1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990-1993, 1995-1997, 1999-2000 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
4 Resurrected from the ashes by Stu Grossman.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 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 */
46 #include "gdb_string.h"
47 #include <sys/types.h>
53 #include "gdb_regex.h"
57 static char *dev_name
;
58 static struct target_ops
*targ_ops
;
60 static void monitor_vsprintf
PARAMS ((char *sndbuf
, char *pattern
, va_list args
));
62 static int readchar
PARAMS ((int timeout
));
64 static void monitor_fetch_register
PARAMS ((int regno
));
65 static void monitor_store_register
PARAMS ((int regno
));
67 static void monitor_printable_string (char *newstr
, char *oldstr
, int len
);
68 static void monitor_error (char *function
, char *message
, CORE_ADDR memaddr
, int len
, char *string
, int final_char
);
69 static void monitor_detach
PARAMS ((char *args
, int from_tty
));
70 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
71 static void monitor_interrupt
PARAMS ((int signo
));
72 static void monitor_interrupt_twice
PARAMS ((int signo
));
73 static void monitor_interrupt_query
PARAMS ((void));
74 static void monitor_wait_cleanup
PARAMS ((void *old_timeout
));
76 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
* status
));
77 static void monitor_fetch_registers
PARAMS ((int regno
));
78 static void monitor_store_registers
PARAMS ((int regno
));
79 static void monitor_prepare_to_store
PARAMS ((void));
80 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
* target
));
81 static void monitor_files_info
PARAMS ((struct target_ops
* ops
));
82 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
83 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
84 static void monitor_kill
PARAMS ((void));
85 static void monitor_load
PARAMS ((char *file
, int from_tty
));
86 static void monitor_mourn_inferior
PARAMS ((void));
87 static void monitor_stop
PARAMS ((void));
89 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
90 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
91 static int monitor_write_memory_bytes
PARAMS ((CORE_ADDR addr
,
92 char *myaddr
, int len
));
93 static int monitor_write_memory_block
PARAMS ((
97 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
* pat
,
98 char *buf
, int buflen
));
99 static void monitor_dump_regs
PARAMS ((void));
101 static int from_hex
PARAMS ((int a
));
102 static unsigned long get_hex_word
PARAMS ((void));
104 static void parse_register_dump
PARAMS ((char *, int));
106 static struct monitor_ops
*current_monitor
;
108 static int hashmark
; /* flag set by "set hash" */
110 static int timeout
= 30;
112 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
114 static void (*ofunc
) (); /* Old SIGINT signal handler */
116 static CORE_ADDR
*breakaddr
;
118 /* Descriptor for I/O to remote machine. Initialize it to NULL so
119 that monitor_open knows that we don't have a file open when the
122 static serial_t monitor_desc
= NULL
;
124 /* Pointer to regexp pattern matching data */
126 static struct re_pattern_buffer register_pattern
;
127 static char register_fastmap
[256];
129 static struct re_pattern_buffer getmem_resp_delim_pattern
;
130 static char getmem_resp_delim_fastmap
[256];
132 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
133 monitor_wait wakes up. */
135 static DCACHE
*remote_dcache
;
136 static int first_time
= 0; /* is this the first time we're executing after
137 gaving created the child proccess? */
139 #define TARGET_BUF_SIZE 2048
141 /* Monitor specific debugging information. Typically only useful to
142 the developer of a new monitor interface. */
144 static void monitor_debug (const char *fmt
, ...) ATTR_FORMAT(printf
, 1, 2);
146 static int monitor_debug_p
= 0;
148 /* NOTE: This file alternates between monitor_debug_p and remote_debug
149 when determining if debug information is printed. Perhaphs this
150 could be simplified. */
153 monitor_debug (const char *fmt
, ...)
158 va_start (args
, fmt
);
159 vfprintf_filtered (gdb_stdlog
, fmt
, args
);
165 /* Convert a string into a printable representation, Return # byte in
166 the new string. When LEN is >0 it specifies the size of the
167 string. Otherwize strlen(oldstr) is used. */
170 monitor_printable_string (char *newstr
, char *oldstr
, int len
)
176 len
= strlen (oldstr
);
178 for (i
= 0; i
< len
; i
++)
189 sprintf (newstr
, "\\x%02x", ch
& 0xff);
228 /* Print monitor errors with a string, converting the string to printable
232 monitor_error (char *function
, char *message
,
233 CORE_ADDR memaddr
, int len
, char *string
, int final_char
)
235 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
236 char *safe_string
= alloca ((real_len
* 4) + 1);
237 monitor_printable_string (safe_string
, string
, real_len
);
240 error ("%s (0x%s): %s: %s%c", function
, paddr_nz (memaddr
), message
, safe_string
, final_char
);
242 error ("%s (0x%s): %s: %s", function
, paddr_nz (memaddr
), message
, safe_string
);
245 /* Convert hex digit A to a number. */
251 if (a
>= '0' && a
<= '9')
253 else if (a
>= 'a' && a
<= 'f')
255 else if (a
>= 'A' && a
<= 'F')
258 error ("Invalid hex digit %d", a
);
261 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
263 This function exists to get around the problem that many host platforms
264 don't have a printf that can print 64-bit addresses. The %A format
265 specification is recognized as a special case, and causes the argument
266 to be printed as a 64-bit hexadecimal address.
268 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
269 If it is a '%s' format, the argument is a string; otherwise the
270 argument is assumed to be a long integer.
272 %% is also turned into a single %.
276 monitor_vsprintf (sndbuf
, pattern
, args
)
289 for (p
= pattern
; *p
; p
++)
293 /* Copy the format specifier to a separate buffer. */
295 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
298 format
[i
] = fmt
= *p
;
299 format
[i
+ 1] = '\0';
301 /* Fetch the next argument and print it. */
305 strcpy (sndbuf
, "%");
308 arg_addr
= va_arg (args
, CORE_ADDR
);
309 strcpy (sndbuf
, paddr_nz (arg_addr
));
312 arg_string
= va_arg (args
, char *);
313 sprintf (sndbuf
, format
, arg_string
);
316 arg_int
= va_arg (args
, long);
317 sprintf (sndbuf
, format
, arg_int
);
320 sndbuf
+= strlen (sndbuf
);
329 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
330 Works just like printf. */
333 monitor_printf_noecho (char *pattern
,...)
339 va_start (args
, pattern
);
341 monitor_vsprintf (sndbuf
, pattern
, args
);
343 len
= strlen (sndbuf
);
344 if (len
+ 1 > sizeof sndbuf
)
349 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
350 monitor_printable_string (safe_string
, sndbuf
, 0);
351 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
354 monitor_write (sndbuf
, len
);
357 /* monitor_printf -- Send data to monitor and check the echo. Works just like
361 monitor_printf (char *pattern
,...)
367 va_start (args
, pattern
);
369 monitor_vsprintf (sndbuf
, pattern
, args
);
371 len
= strlen (sndbuf
);
372 if (len
+ 1 > sizeof sndbuf
)
377 char *safe_string
= (char *) alloca ((len
* 4) + 1);
378 monitor_printable_string (safe_string
, sndbuf
, 0);
379 fprintf_unfiltered (gdb_stdlog
, "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 monitor_debug ("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
446 last_random
, last_nl
, last_cr
, last_crnl
454 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
459 /* This seems to interfere with proper function of the
461 if (monitor_debug_p
|| remote_debug
)
466 puts_debug ("read -->", buf
, "<--");
471 /* Canonicialize \n\r combinations into one \r */
472 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
474 if ((c
== '\r' && state
== last_nl
)
475 || (c
== '\n' && state
== last_cr
))
496 if (c
== SERIAL_TIMEOUT
)
498 /* I fail to see how detaching here can be useful */
499 if (in_monitor_wait
) /* Watchdog went off */
501 target_mourn_inferior ();
502 error ("GDB serial timeout has expired. Target detached.\n");
506 error ("Timeout reading from remote system.");
508 perror_with_name ("remote-monitor");
511 /* Scan input from the remote system, until STRING is found. If BUF is non-
512 zero, then collect input until we have collected either STRING or BUFLEN-1
513 chars. In either case we terminate BUF with a 0. If input overflows BUF
514 because STRING can't be found, return -1, else return number of chars in BUF
515 (minus the terminating NUL). Note that in the non-overflow case, STRING
516 will be at the end of BUF. */
519 monitor_expect (string
, buf
, buflen
)
525 int obuflen
= buflen
;
527 extern struct target_ops
*targ_ops
;
531 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
532 monitor_printable_string (safe_string
, string
, 0);
533 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
548 c
= readchar (timeout
);
555 c
= readchar (timeout
);
557 /* Don't expect any ^C sent to be echoed */
559 if (*p
== '\003' || c
== *p
)
569 return obuflen
- buflen
;
575 else if ((c
== '\021' || c
== '\023') &&
576 (STREQ (targ_ops
->to_shortname
, "m32r")
577 || STREQ (targ_ops
->to_shortname
, "mon2000")))
578 { /* m32r monitor emits random DC1/DC3 chars */
583 /* We got a character that doesn't match the string. We need to
584 back up p, but how far? If we're looking for "..howdy" and the
585 monitor sends "...howdy"? There's certainly a match in there,
586 but when we receive the third ".", we won't find it if we just
587 restart the matching at the beginning of the string.
589 This is a Boyer-Moore kind of situation. We want to reset P to
590 the end of the longest prefix of STRING that is a suffix of
591 what we've read so far. In the example above, that would be
592 ".." --- the longest prefix of "..howdy" that is a suffix of
593 "...". This longest prefix could be the empty string, if C
594 is nowhere to be found in STRING.
596 If this longest prefix is not the empty string, it must contain
597 C, so let's search from the end of STRING for instances of C,
598 and see if the portion of STRING before that is a suffix of
599 what we read before C. Actually, we can search backwards from
600 p, since we know no prefix can be longer than that.
602 Note that we can use STRING itself, along with C, as a record
603 of what we've received so far. :) */
606 for (i
= (p
- string
) - 1; i
>= 0; i
--)
609 /* Is this prefix a suffix of what we've read so far?
611 string[0 .. i-1] == string[p - i, p - 1]? */
612 if (! memcmp (string
, p
- i
, i
))
624 /* Search for a regexp. */
627 monitor_expect_regexp (pat
, buf
, buflen
)
628 struct re_pattern_buffer
*pat
;
634 monitor_debug ("MON Expecting regexp\n");
639 mybuf
= alloca (TARGET_BUF_SIZE
);
640 buflen
= TARGET_BUF_SIZE
;
648 if (p
- mybuf
>= buflen
)
649 { /* Buffer about to overflow */
651 /* On overflow, we copy the upper half of the buffer to the lower half. Not
652 great, but it usually works... */
654 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
655 p
= mybuf
+ buflen
/ 2;
658 *p
++ = readchar (timeout
);
660 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
666 /* Keep discarding input until we see the MONITOR prompt.
668 The convention for dealing with the prompt is that you
670 o *then* wait for the prompt.
672 Thus the last thing that a procedure does with the serial line will
673 be an monitor_expect_prompt(). Exception: monitor_resume does not
674 wait for the prompt, because the terminal is being handed over to
675 the inferior. However, the next thing which happens after that is
676 a monitor_wait which does wait for the prompt. Note that this
677 includes abnormal exit, e.g. error(). This is necessary to prevent
678 getting into states from which we can't recover. */
681 monitor_expect_prompt (buf
, buflen
)
685 monitor_debug ("MON Expecting prompt\n");
686 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
689 /* Get N 32-bit words from remote, each preceded by a space, and put
690 them in registers starting at REGNO. */
701 ch
= readchar (timeout
);
702 while (isspace (ch
));
706 for (i
= 7; i
>= 1; i
--)
708 ch
= readchar (timeout
);
711 val
= (val
<< 4) | from_hex (ch
);
719 compile_pattern (pattern
, compiled_pattern
, fastmap
)
721 struct re_pattern_buffer
*compiled_pattern
;
727 compiled_pattern
->fastmap
= fastmap
;
729 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
730 val
= re_compile_pattern (pattern
,
736 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
739 re_compile_fastmap (compiled_pattern
);
742 /* Open a connection to a remote debugger. NAME is the filename used
743 for communication. */
746 monitor_open (args
, mon_ops
, from_tty
)
748 struct monitor_ops
*mon_ops
;
754 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
755 error ("Magic number of monitor_ops struct wrong.");
757 targ_ops
= mon_ops
->target
;
758 name
= targ_ops
->to_shortname
;
761 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
762 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
764 target_preopen (from_tty
);
766 /* Setup pattern for register dump */
768 if (mon_ops
->register_pattern
)
769 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
772 if (mon_ops
->getmem
.resp_delim
)
773 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
774 getmem_resp_delim_fastmap
);
776 unpush_target (targ_ops
);
780 dev_name
= strsave (args
);
782 monitor_desc
= SERIAL_OPEN (dev_name
);
785 perror_with_name (dev_name
);
789 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
791 SERIAL_CLOSE (monitor_desc
);
792 perror_with_name (dev_name
);
796 SERIAL_RAW (monitor_desc
);
798 SERIAL_FLUSH_INPUT (monitor_desc
);
800 /* some systems only work with 2 stop bits */
802 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
804 current_monitor
= mon_ops
;
806 /* See if we can wake up the monitor. First, try sending a stop sequence,
807 then send the init strings. Last, remove all breakpoints. */
809 if (current_monitor
->stop
)
812 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
814 monitor_debug ("EXP Open echo\n");
815 monitor_expect_prompt (NULL
, 0);
819 /* wake up the monitor and see if it's alive */
820 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
822 /* Some of the characters we send may not be echoed,
823 but we hope to get a prompt at the end of it all. */
825 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
828 monitor_printf_noecho (*p
);
829 monitor_expect_prompt (NULL
, 0);
832 SERIAL_FLUSH_INPUT (monitor_desc
);
834 /* Alloc breakpoints */
835 if (mon_ops
->set_break
!= NULL
)
837 if (mon_ops
->num_breakpoints
== 0)
838 mon_ops
->num_breakpoints
= 8;
840 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
841 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
844 /* Remove all breakpoints */
846 if (mon_ops
->clr_all_break
)
848 monitor_printf (mon_ops
->clr_all_break
);
849 monitor_expect_prompt (NULL
, 0);
853 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
855 push_target (targ_ops
);
857 inferior_pid
= 42000; /* Make run command think we are busy... */
859 /* Give monitor_wait something to read */
861 monitor_printf (current_monitor
->line_term
);
863 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
864 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
866 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
870 /* Close out all files and local state before this target loses
874 monitor_close (quitting
)
878 SERIAL_CLOSE (monitor_desc
);
880 /* Free breakpoint memory */
881 if (breakaddr
!= NULL
)
890 /* Terminate the open connection to the remote debugger. Use this
891 when you want to detach and do something else with your gdb. */
894 monitor_detach (args
, from_tty
)
898 pop_target (); /* calls monitor_close to do the real work */
900 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
903 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
906 monitor_supply_register (regno
, valstr
)
911 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
916 while (p
&& *p
!= '\0')
918 if (*p
== '\r' || *p
== '\n')
929 if (!isxdigit (*p
) && *p
!= 'x')
935 val
+= fromhex (*p
++);
937 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
940 error ("monitor_supply_register (%d): bad value from monitor: %s.",
943 /* supply register stores in target byte order, so swap here */
945 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
947 supply_register (regno
, regbuf
);
952 /* Tell the remote machine to resume. */
955 flush_monitor_dcache ()
957 dcache_flush (remote_dcache
);
961 monitor_resume (pid
, step
, sig
)
963 enum target_signal sig
;
965 /* Some monitors require a different command when starting a program */
966 monitor_debug ("MON resume\n");
967 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
970 monitor_printf ("run\r");
971 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
975 dcache_flush (remote_dcache
);
977 monitor_printf (current_monitor
->step
);
980 if (current_monitor
->continue_hook
)
981 (*current_monitor
->continue_hook
) ();
983 monitor_printf (current_monitor
->cont
);
984 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
989 /* Parse the output of a register dump command. A monitor specific
990 regexp is used to extract individual register descriptions of the
991 form REG=VAL. Each description is split up into a name and a value
992 string which are passed down to monitor specific code. */
995 parse_register_dump (buf
, len
)
999 monitor_debug ("MON Parsing register dump\n");
1002 int regnamelen
, vallen
;
1003 char *regname
, *val
;
1004 /* Element 0 points to start of register name, and element 1
1005 points to the start of the register value. */
1006 struct re_registers register_strings
;
1008 memset (®ister_strings
, 0, sizeof (struct re_registers
));
1010 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
1011 ®ister_strings
) == -1)
1014 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
1015 regname
= buf
+ register_strings
.start
[1];
1016 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
1017 val
= buf
+ register_strings
.start
[2];
1019 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
1021 buf
+= register_strings
.end
[0];
1022 len
-= register_strings
.end
[0];
1026 /* Send ^C to target to halt it. Target will respond, and send us a
1030 monitor_interrupt (signo
)
1033 /* If this doesn't work, try more severe steps. */
1034 signal (signo
, monitor_interrupt_twice
);
1036 if (monitor_debug_p
|| remote_debug
)
1037 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
1042 /* The user typed ^C twice. */
1045 monitor_interrupt_twice (signo
)
1048 signal (signo
, ofunc
);
1050 monitor_interrupt_query ();
1052 signal (signo
, monitor_interrupt
);
1055 /* Ask the user what to do when an interrupt is received. */
1058 monitor_interrupt_query ()
1060 target_terminal_ours ();
1062 if (query ("Interrupted while waiting for the program.\n\
1063 Give up (and stop debugging it)? "))
1065 target_mourn_inferior ();
1066 return_to_top_level (RETURN_QUIT
);
1069 target_terminal_inferior ();
1073 monitor_wait_cleanup (old_timeout
)
1076 timeout
= *(int *) old_timeout
;
1077 signal (SIGINT
, ofunc
);
1078 in_monitor_wait
= 0;
1084 monitor_wait_filter (char *buf
,
1087 struct target_waitstatus
*status
1093 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1094 *ext_resp_len
= resp_len
;
1097 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1099 while (resp_len
< 0);
1101 /* Print any output characters that were preceded by ^O. */
1102 /* FIXME - This would be great as a user settabgle flag */
1103 if (monitor_debug_p
|| remote_debug
1104 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1108 for (i
= 0; i
< resp_len
- 1; i
++)
1110 putchar_unfiltered (buf
[++i
]);
1116 /* Wait until the remote machine stops, then return, storing status in
1117 status just as `wait' would. */
1120 monitor_wait (pid
, status
)
1122 struct target_waitstatus
*status
;
1124 int old_timeout
= timeout
;
1125 char buf
[TARGET_BUF_SIZE
];
1127 struct cleanup
*old_chain
;
1129 status
->kind
= TARGET_WAITKIND_EXITED
;
1130 status
->value
.integer
= 0;
1132 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1133 monitor_debug ("MON wait\n");
1136 /* This is somthing other than a maintenance command */
1137 in_monitor_wait
= 1;
1138 timeout
= watchdog
> 0 ? watchdog
: -1;
1140 timeout
= -1; /* Don't time out -- user program is running. */
1143 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1145 if (current_monitor
->wait_filter
)
1146 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1148 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1150 #if 0 /* Transferred to monitor wait filter */
1153 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1156 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1158 while (resp_len
< 0);
1160 /* Print any output characters that were preceded by ^O. */
1161 /* FIXME - This would be great as a user settabgle flag */
1162 if (monitor_debug_p
|| remote_debug
1163 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1167 for (i
= 0; i
< resp_len
- 1; i
++)
1169 putchar_unfiltered (buf
[++i
]);
1173 signal (SIGINT
, ofunc
);
1175 timeout
= old_timeout
;
1177 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1180 monitor_printf (current_monitor
->dump_registers
);
1181 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1184 if (current_monitor
->register_pattern
)
1185 parse_register_dump (buf
, resp_len
);
1187 monitor_debug ("Wait fetching registers after stop\n");
1188 monitor_dump_regs ();
1191 status
->kind
= TARGET_WAITKIND_STOPPED
;
1192 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1194 discard_cleanups (old_chain
);
1196 in_monitor_wait
= 0;
1198 return inferior_pid
;
1201 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1205 monitor_fetch_register (regno
)
1213 regbuf
= alloca (MAX_REGISTER_RAW_SIZE
* 2 + 1);
1214 zerobuf
= alloca (MAX_REGISTER_RAW_SIZE
);
1215 memset (zerobuf
, 0, MAX_REGISTER_RAW_SIZE
);
1217 name
= current_monitor
->regnames
[regno
];
1218 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1220 if (!name
|| (*name
== '\0'))
1222 monitor_debug ("No register known for %d\n", regno
);
1223 supply_register (regno
, zerobuf
);
1227 /* send the register examine command */
1229 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1231 /* If RESP_DELIM is specified, we search for that as a leading
1232 delimiter for the register value. Otherwise, we just start
1233 searching from the start of the buf. */
1235 if (current_monitor
->getreg
.resp_delim
)
1237 monitor_debug ("EXP getreg.resp_delim\n");
1238 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1239 /* Handle case of first 32 registers listed in pairs. */
1240 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1241 && (regno
& 1) != 0 && regno
< 32)
1243 monitor_debug ("EXP getreg.resp_delim\n");
1244 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1248 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1249 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1252 c
= readchar (timeout
);
1254 c
= readchar (timeout
);
1255 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1258 error ("Bad value returned from monitor while fetching register %x.",
1262 /* Read upto the maximum number of hex digits for this register, skipping
1263 spaces, but stop reading if something else is seen. Some monitors
1264 like to drop leading zeros. */
1266 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1269 c
= readchar (timeout
);
1271 c
= readchar (timeout
);
1279 regbuf
[i
] = '\000'; /* terminate the number */
1280 monitor_debug ("REGVAL '%s'\n", regbuf
);
1282 /* If TERM is present, we wait for that to show up. Also, (if TERM
1283 is present), we will send TERM_CMD if that is present. In any
1284 case, we collect all of the output into buf, and then wait for
1285 the normal prompt. */
1287 if (current_monitor
->getreg
.term
)
1289 monitor_debug ("EXP getreg.term\n");
1290 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1293 if (current_monitor
->getreg
.term_cmd
)
1295 monitor_debug ("EMIT getreg.term.cmd\n");
1296 monitor_printf (current_monitor
->getreg
.term_cmd
);
1298 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1299 current_monitor
->getreg
.term_cmd
) /* ack expected */
1300 monitor_expect_prompt (NULL
, 0); /* get response */
1302 monitor_supply_register (regno
, regbuf
);
1305 /* Sometimes, it takes several commands to dump the registers */
1306 /* This is a primitive for use by variations of monitor interfaces in
1307 case they need to compose the operation.
1310 monitor_dump_reg_block (char *block_cmd
)
1312 char buf
[TARGET_BUF_SIZE
];
1314 monitor_printf (block_cmd
);
1315 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1316 parse_register_dump (buf
, resp_len
);
1321 /* Read the remote registers into the block regs. */
1322 /* Call the specific function if it has been provided */
1325 monitor_dump_regs ()
1327 char buf
[TARGET_BUF_SIZE
];
1329 if (current_monitor
->dumpregs
)
1330 (*(current_monitor
->dumpregs
)) (); /* call supplied function */
1331 else if (current_monitor
->dump_registers
) /* default version */
1333 monitor_printf (current_monitor
->dump_registers
);
1334 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1335 parse_register_dump (buf
, resp_len
);
1338 abort (); /* Need some way to read registers */
1342 monitor_fetch_registers (regno
)
1345 monitor_debug ("MON fetchregs\n");
1346 if (current_monitor
->getreg
.cmd
)
1350 monitor_fetch_register (regno
);
1354 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1355 monitor_fetch_register (regno
);
1359 monitor_dump_regs ();
1363 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1366 monitor_store_register (regno
)
1372 name
= current_monitor
->regnames
[regno
];
1373 if (!name
|| (*name
== '\0'))
1375 monitor_debug ("MON Cannot store unknown register\n");
1379 val
= read_register (regno
);
1380 monitor_debug ("MON storeg %d %s\n", regno
, preg (val
));
1382 /* send the register deposit command */
1384 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1385 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1386 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1387 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1389 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1391 if (current_monitor
->setreg
.term
)
1393 monitor_debug ("EXP setreg.term\n");
1394 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1395 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1396 monitor_printf ("%s\r", paddr_nz (val
));
1397 monitor_expect_prompt (NULL
, 0);
1400 monitor_expect_prompt (NULL
, 0);
1401 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1403 monitor_debug ("EXP setreg_termcmd\n");
1404 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1405 monitor_expect_prompt (NULL
, 0);
1407 } /* monitor_store_register */
1409 /* Store the remote registers. */
1412 monitor_store_registers (regno
)
1417 monitor_store_register (regno
);
1421 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1422 monitor_store_register (regno
);
1425 /* Get ready to modify the registers array. On machines which store
1426 individual registers, this doesn't need to do anything. On machines
1427 which store all the registers in one fell swoop, this makes sure
1428 that registers contains all the registers from the program being
1432 monitor_prepare_to_store ()
1434 /* Do nothing, since we can store individual regs */
1438 monitor_files_info (ops
)
1439 struct target_ops
*ops
;
1441 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1445 monitor_write_memory (memaddr
, myaddr
, len
)
1450 unsigned int val
, hostval
;
1454 monitor_debug ("MON write %d %s\n", len
, paddr (memaddr
));
1456 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1457 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1459 /* Use memory fill command for leading 0 bytes. */
1461 if (current_monitor
->fill
)
1463 for (i
= 0; i
< len
; i
++)
1467 if (i
> 4) /* More than 4 zeros is worth doing */
1469 monitor_debug ("MON FILL %d\n", i
);
1470 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1471 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1473 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1475 monitor_expect_prompt (NULL
, 0);
1482 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1483 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1486 cmd
= current_monitor
->setmem
.cmdll
;
1490 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1493 cmd
= current_monitor
->setmem
.cmdl
;
1495 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1498 cmd
= current_monitor
->setmem
.cmdw
;
1503 cmd
= current_monitor
->setmem
.cmdb
;
1506 val
= extract_unsigned_integer (myaddr
, len
);
1510 hostval
= *(unsigned int *) myaddr
;
1511 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1515 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1516 monitor_printf_noecho (cmd
, memaddr
, val
);
1517 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1520 monitor_printf_noecho (cmd
, memaddr
);
1522 if (current_monitor
->setmem
.term
)
1524 monitor_debug ("EXP setmem.term");
1525 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1526 monitor_printf ("%x\r", val
);
1528 if (current_monitor
->setmem
.term_cmd
)
1529 { /* Emit this to get out of the memory editing state */
1530 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1531 /* Drop through to expecting a prompt */
1535 monitor_printf (cmd
, memaddr
, val
);
1537 monitor_expect_prompt (NULL
, 0);
1544 monitor_write_even_block (memaddr
, myaddr
, len
)
1551 /* Enter the sub mode */
1552 monitor_printf (current_monitor
->setmem
.cmdl
, memaddr
);
1553 monitor_expect_prompt (NULL
, 0);
1557 val
= extract_unsigned_integer (myaddr
, 4); /* REALLY */
1558 monitor_printf ("%x\r", val
);
1562 monitor_debug (" @ %s\n", paddr (memaddr
));
1563 /* If we wanted to, here we could validate the address */
1564 monitor_expect_prompt (NULL
, 0);
1566 /* Now exit the sub mode */
1567 monitor_printf (current_monitor
->getreg
.term_cmd
);
1568 monitor_expect_prompt (NULL
, 0);
1574 monitor_write_memory_bytes (memaddr
, myaddr
, len
)
1583 /* Enter the sub mode */
1584 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1585 monitor_expect_prompt (NULL
, 0);
1589 monitor_printf ("%x\r", val
);
1593 /* If we wanted to, here we could validate the address */
1594 monitor_expect_prompt (NULL
, 0);
1597 /* Now exit the sub mode */
1598 monitor_printf (current_monitor
->getreg
.term_cmd
);
1599 monitor_expect_prompt (NULL
, 0);
1605 longlongendswap (unsigned char *a
)
1614 *(a
+ i
) = *(a
+ j
);
1619 /* Format 32 chars of long long value, advance the pointer */
1620 static char *hexlate
= "0123456789abcdef";
1622 longlong_hexchars (unsigned long long value
,
1632 static unsigned char disbuf
[8]; /* disassembly buffer */
1633 unsigned char *scan
, *limit
; /* loop controls */
1634 unsigned char c
, nib
;
1639 unsigned long long *dp
;
1640 dp
= (unsigned long long *) scan
;
1643 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1644 while (scan
< limit
)
1646 c
= *scan
++; /* a byte of our long long value */
1652 leadzero
= 0; /* henceforth we print even zeroes */
1654 nib
= c
>> 4; /* high nibble bits */
1655 *outbuff
++ = hexlate
[nib
];
1656 nib
= c
& 0x0f; /* low nibble bits */
1657 *outbuff
++ = hexlate
[nib
];
1661 } /* longlong_hexchars */
1665 /* I am only going to call this when writing virtual byte streams.
1666 Which possably entails endian conversions
1669 monitor_write_memory_longlongs (memaddr
, myaddr
, len
)
1674 static char hexstage
[20]; /* At least 16 digits required, plus null */
1679 llptr
= (unsigned long long *) myaddr
;
1682 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1683 monitor_expect_prompt (NULL
, 0);
1687 endstring
= longlong_hexchars (*llptr
, hexstage
);
1688 *endstring
= '\0'; /* NUll terminate for printf */
1689 monitor_printf ("%s\r", hexstage
);
1693 /* If we wanted to, here we could validate the address */
1694 monitor_expect_prompt (NULL
, 0);
1697 /* Now exit the sub mode */
1698 monitor_printf (current_monitor
->getreg
.term_cmd
);
1699 monitor_expect_prompt (NULL
, 0);
1705 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1706 /* This is for the large blocks of memory which may occur in downloading.
1707 And for monitors which use interactive entry,
1708 And for monitors which do not have other downloading methods.
1709 Without this, we will end up calling monitor_write_memory many times
1710 and do the entry and exit of the sub mode many times
1711 This currently assumes...
1712 MO_SETMEM_INTERACTIVE
1713 ! MO_NO_ECHO_ON_SETMEM
1714 To use this, the you have to patch the monitor_cmds block with
1715 this function. Otherwise, its not tuned up for use by all
1720 monitor_write_memory_block (memaddr
, myaddr
, len
)
1727 /* FIXME: This would be a good place to put the zero test */
1729 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1731 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1738 written
= monitor_write_even_block (memaddr
, myaddr
, len
);
1739 /* Adjust calling parameters by written amount */
1745 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1749 /* This is an alternate form of monitor_read_memory which is used for monitors
1750 which can only read a single byte/word/etc. at a time. */
1753 monitor_read_memory_single (memaddr
, myaddr
, len
)
1759 char membuf
[sizeof (int) * 2 + 1];
1764 monitor_debug ("MON read single\n");
1766 /* Can't actually use long longs (nice idea, though). In fact, the
1767 call to strtoul below will fail if it tries to convert a value
1768 that's too big to fit in a long. */
1769 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1772 cmd
= current_monitor
->getmem
.cmdll
;
1776 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1779 cmd
= current_monitor
->getmem
.cmdl
;
1781 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1784 cmd
= current_monitor
->getmem
.cmdw
;
1789 cmd
= current_monitor
->getmem
.cmdb
;
1792 /* Send the examine command. */
1794 monitor_printf (cmd
, memaddr
);
1796 /* If RESP_DELIM is specified, we search for that as a leading
1797 delimiter for the memory value. Otherwise, we just start
1798 searching from the start of the buf. */
1800 if (current_monitor
->getmem
.resp_delim
)
1802 monitor_debug ("EXP getmem.resp_delim\n");
1803 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1806 /* Now, read the appropriate number of hex digits for this loc,
1809 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1810 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1814 c
= readchar (timeout
);
1816 c
= readchar (timeout
);
1817 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1820 monitor_error ("monitor_read_memory_single",
1821 "bad response from monitor",
1822 memaddr
, i
, membuf
, c
);
1824 for (i
= 0; i
< len
* 2; i
++)
1830 c
= readchar (timeout
);
1836 monitor_error ("monitor_read_memory_single",
1837 "bad response from monitor",
1838 memaddr
, i
, membuf
, c
);
1844 membuf
[i
] = '\000'; /* terminate the number */
1846 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1847 present), we will send TERM_CMD if that is present. In any case, we collect
1848 all of the output into buf, and then wait for the normal prompt. */
1850 if (current_monitor
->getmem
.term
)
1852 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1854 if (current_monitor
->getmem
.term_cmd
)
1856 monitor_printf (current_monitor
->getmem
.term_cmd
);
1857 monitor_expect_prompt (NULL
, 0);
1861 monitor_expect_prompt (NULL
, 0); /* get response */
1864 val
= strtoul (membuf
, &p
, 16);
1866 if (val
== 0 && membuf
== p
)
1867 monitor_error ("monitor_read_memory_single",
1868 "bad value from monitor",
1869 memaddr
, 0, membuf
, 0);
1871 /* supply register stores in target byte order, so swap here */
1873 store_unsigned_integer (myaddr
, len
, val
);
1878 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1879 memory at MEMADDR. Returns length moved. Currently, we do no more
1880 than 16 bytes at a time. */
1883 monitor_read_memory (memaddr
, myaddr
, len
)
1897 monitor_debug ("Zero length call to monitor_read_memory\n");
1901 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1902 paddr_nz (memaddr
), (long) myaddr
, len
);
1904 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1905 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1907 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1908 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1910 len
= min (len
, 16);
1912 /* Some dumpers align the first data with the preceeding 16
1913 byte boundary. Some print blanks and start at the
1914 requested boundary. EXACT_DUMPADDR
1917 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1918 ? memaddr
: memaddr
& ~0x0f;
1920 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1921 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1922 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1924 /* send the memory examine command */
1926 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1927 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1928 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1929 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1931 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1933 /* If TERM is present, we wait for that to show up. Also, (if TERM
1934 is present), we will send TERM_CMD if that is present. In any
1935 case, we collect all of the output into buf, and then wait for
1936 the normal prompt. */
1938 if (current_monitor
->getmem
.term
)
1940 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1943 monitor_error ("monitor_read_memory",
1944 "excessive response from monitor",
1945 memaddr
, resp_len
, buf
, 0);
1947 if (current_monitor
->getmem
.term_cmd
)
1949 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1950 strlen (current_monitor
->getmem
.term_cmd
));
1951 monitor_expect_prompt (NULL
, 0);
1955 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1959 /* If RESP_DELIM is specified, we search for that as a leading
1960 delimiter for the values. Otherwise, we just start searching
1961 from the start of the buf. */
1963 if (current_monitor
->getmem
.resp_delim
)
1966 struct re_registers resp_strings
;
1967 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
);
1969 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1971 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1975 monitor_error ("monitor_read_memory",
1976 "bad response from monitor",
1977 memaddr
, resp_len
, buf
, 0);
1979 p
+= resp_strings
.end
[0];
1981 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1983 monitor_error ("monitor_read_memory",
1984 "bad response from monitor",
1985 memaddr
, resp_len
, buf
, 0);
1986 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1989 monitor_debug ("MON scanning %d ,%lx '%s'\n", len
, (long) p
, p
);
1990 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1998 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
2002 if ((dumpaddr
>= memaddr
) && (i
> 0))
2004 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
2006 if (monitor_debug_p
|| remote_debug
)
2007 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
2014 ++p
; /* skip a blank or other non hex char */
2018 error ("Failed to read via monitor");
2019 if (monitor_debug_p
|| remote_debug
)
2020 fprintf_unfiltered (gdb_stdlog
, "\n");
2021 return fetched
; /* Return the number of bytes actually read */
2023 monitor_debug ("MON scanning bytes\n");
2025 for (i
= len
; i
> 0; i
--)
2027 /* Skip non-hex chars, but bomb on end of string and newlines */
2034 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
2035 monitor_error ("monitor_read_memory",
2036 "badly terminated response from monitor",
2037 memaddr
, resp_len
, buf
, 0);
2041 val
= strtoul (p
, &p1
, 16);
2043 if (val
== 0 && p
== p1
)
2044 monitor_error ("monitor_read_memory",
2045 "bad value from monitor",
2046 memaddr
, resp_len
, buf
, 0);
2060 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
2065 struct target_ops
*target
; /* ignored */
2067 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
2073 return; /* ignore attempts to kill target system */
2076 /* All we actually do is set the PC to the start address of exec_bfd, and start
2077 the program at that point. */
2080 monitor_create_inferior (exec_file
, args
, env
)
2085 if (args
&& (*args
!= '\000'))
2086 error ("Args are not supported by the monitor.");
2089 clear_proceed_status ();
2090 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
2093 /* Clean up when a program exits.
2094 The program actually lives on in the remote processor's RAM, and may be
2095 run again without a download. Don't leave it full of breakpoint
2099 monitor_mourn_inferior ()
2101 unpush_target (targ_ops
);
2102 generic_mourn_inferior (); /* Do all the proper things now */
2105 /* Tell the monitor to add a breakpoint. */
2108 monitor_insert_breakpoint (addr
, shadow
)
2116 monitor_debug ("MON inst bkpt %s\n", paddr (addr
));
2117 if (current_monitor
->set_break
== NULL
)
2118 error ("No set_break defined for this monitor");
2120 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2121 addr
= ADDR_BITS_REMOVE (addr
);
2123 /* Determine appropriate breakpoint size for this address. */
2124 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2126 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2128 if (breakaddr
[i
] == 0)
2130 breakaddr
[i
] = addr
;
2131 monitor_read_memory (addr
, shadow
, bplen
);
2132 monitor_printf (current_monitor
->set_break
, addr
);
2133 monitor_expect_prompt (NULL
, 0);
2138 error ("Too many breakpoints (> %d) for monitor.", current_monitor
->num_breakpoints
);
2141 /* Tell the monitor to remove a breakpoint. */
2144 monitor_remove_breakpoint (addr
, shadow
)
2150 monitor_debug ("MON rmbkpt %s\n", paddr (addr
));
2151 if (current_monitor
->clr_break
== NULL
)
2152 error ("No clr_break defined for this monitor");
2154 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2155 addr
= ADDR_BITS_REMOVE (addr
);
2157 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2159 if (breakaddr
[i
] == addr
)
2162 /* some monitors remove breakpoints based on the address */
2163 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2164 monitor_printf (current_monitor
->clr_break
, addr
);
2165 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2166 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2168 monitor_printf (current_monitor
->clr_break
, i
);
2169 monitor_expect_prompt (NULL
, 0);
2173 fprintf_unfiltered (gdb_stderr
,
2174 "Can't find breakpoint associated with 0x%s\n",
2179 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2180 an S-record. Return non-zero if the ACK is received properly. */
2183 monitor_wait_srec_ack ()
2187 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2189 return (readchar (timeout
) == '+');
2191 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2193 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2194 if ((ch
= readchar (1)) < 0)
2196 if ((ch
= readchar (1)) < 0)
2198 if ((ch
= readchar (1)) < 0)
2200 if ((ch
= readchar (1)) < 0)
2206 /* monitor_load -- download a file. */
2209 monitor_load (file
, from_tty
)
2213 dcache_flush (remote_dcache
);
2214 monitor_debug ("MON load\n");
2216 if (current_monitor
->load_routine
)
2217 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2219 { /* The default is ascii S-records */
2221 unsigned long load_offset
;
2224 /* enable user to specify address for downloading as 2nd arg to load */
2225 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2231 monitor_printf (current_monitor
->load
);
2232 if (current_monitor
->loadresp
)
2233 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2235 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2236 32, SREC_ALL
, hashmark
,
2237 current_monitor
->flags
& MO_SREC_ACK
?
2238 monitor_wait_srec_ack
: NULL
);
2240 monitor_expect_prompt (NULL
, 0);
2243 /* Finally, make the PC point at the start address */
2246 write_pc (bfd_get_start_address (exec_bfd
));
2248 inferior_pid
= 0; /* No process now */
2250 /* This is necessary because many things were based on the PC at the time that
2251 we attached to the monitor, which is no longer valid now that we have loaded
2252 new code (and just changed the PC). Another way to do this might be to call
2253 normal_stop, except that the stack may not be valid, and things would get
2254 horribly confused... */
2256 clear_symtab_users ();
2262 monitor_debug ("MON stop\n");
2263 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2264 SERIAL_SEND_BREAK (monitor_desc
);
2265 if (current_monitor
->stop
)
2266 monitor_printf_noecho (current_monitor
->stop
);
2269 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2270 in OUTPUT until the prompt is seen. FIXME: We read the characters
2271 ourseleves here cause of a nasty echo. */
2274 monitor_rcmd (char *command
,
2275 struct ui_file
*outbuf
)
2281 if (monitor_desc
== NULL
)
2282 error ("monitor target not open.");
2284 p
= current_monitor
->prompt
;
2286 /* Send the command. Note that if no args were supplied, then we're
2287 just sending the monitor a newline, which is sometimes useful. */
2289 monitor_printf ("%s\r", (command
? command
: ""));
2291 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2293 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2296 /* Convert hex digit A to a number. */
2303 if (a
>= '0' && a
<= '9')
2305 if (a
>= 'a' && a
<= 'f')
2306 return a
- 'a' + 10;
2307 if (a
>= 'A' && a
<= 'F')
2308 return a
- 'A' + 10;
2310 error ("Reply contains invalid hex digit 0x%x", a
);
2315 monitor_get_dev_name ()
2320 static struct target_ops monitor_ops
;
2323 init_base_monitor_ops (void)
2325 monitor_ops
.to_shortname
= NULL
;
2326 monitor_ops
.to_longname
= NULL
;
2327 monitor_ops
.to_doc
= NULL
;
2328 monitor_ops
.to_open
= NULL
;
2329 monitor_ops
.to_close
= monitor_close
;
2330 monitor_ops
.to_attach
= NULL
;
2331 monitor_ops
.to_post_attach
= NULL
;
2332 monitor_ops
.to_require_attach
= NULL
;
2333 monitor_ops
.to_detach
= monitor_detach
;
2334 monitor_ops
.to_require_detach
= NULL
;
2335 monitor_ops
.to_resume
= monitor_resume
;
2336 monitor_ops
.to_wait
= monitor_wait
;
2337 monitor_ops
.to_post_wait
= NULL
;
2338 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2339 monitor_ops
.to_store_registers
= monitor_store_registers
;
2340 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2341 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2342 monitor_ops
.to_files_info
= monitor_files_info
;
2343 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2344 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2345 monitor_ops
.to_terminal_init
= 0;
2346 monitor_ops
.to_terminal_inferior
= 0;
2347 monitor_ops
.to_terminal_ours_for_output
= 0;
2348 monitor_ops
.to_terminal_ours
= 0;
2349 monitor_ops
.to_terminal_info
= 0;
2350 monitor_ops
.to_kill
= monitor_kill
;
2351 monitor_ops
.to_load
= monitor_load
;
2352 monitor_ops
.to_lookup_symbol
= 0;
2353 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2354 monitor_ops
.to_post_startup_inferior
= NULL
;
2355 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2356 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2357 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2358 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2359 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2360 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2361 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2362 monitor_ops
.to_has_forked
= NULL
;
2363 monitor_ops
.to_has_vforked
= NULL
;
2364 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2365 monitor_ops
.to_post_follow_vfork
= NULL
;
2366 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2367 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2368 monitor_ops
.to_has_execd
= NULL
;
2369 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2370 monitor_ops
.to_has_exited
= NULL
;
2371 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2372 monitor_ops
.to_can_run
= 0;
2373 monitor_ops
.to_notice_signals
= 0;
2374 monitor_ops
.to_thread_alive
= 0;
2375 monitor_ops
.to_stop
= monitor_stop
;
2376 monitor_ops
.to_rcmd
= monitor_rcmd
;
2377 monitor_ops
.to_pid_to_exec_file
= NULL
;
2378 monitor_ops
.to_core_file_to_sym_file
= NULL
;
2379 monitor_ops
.to_stratum
= process_stratum
;
2380 monitor_ops
.DONT_USE
= 0;
2381 monitor_ops
.to_has_all_memory
= 1;
2382 monitor_ops
.to_has_memory
= 1;
2383 monitor_ops
.to_has_stack
= 1;
2384 monitor_ops
.to_has_registers
= 1;
2385 monitor_ops
.to_has_execution
= 1;
2386 monitor_ops
.to_sections
= 0;
2387 monitor_ops
.to_sections_end
= 0;
2388 monitor_ops
.to_magic
= OPS_MAGIC
;
2389 } /* init_base_monitor_ops */
2391 /* Init the target_ops structure pointed at by OPS */
2394 init_monitor_ops (ops
)
2395 struct target_ops
*ops
;
2397 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2398 init_base_monitor_ops ();
2400 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2403 /* Define additional commands that are usually only used by monitors. */
2406 _initialize_remote_monitors ()
2408 init_base_monitor_ops ();
2409 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2411 "Set display of activity while downloading a file.\n\
2412 When enabled, a hashmark \'#\' is displayed.",
2417 (add_set_cmd ("monitor", no_class
, var_zinteger
,
2418 (char *) &monitor_debug_p
,
2419 "Set debugging of remote monitor communication.\n\
2420 When enabled, communication between GDB and the remote monitor\n\
2421 is displayed.", &setdebuglist
),