1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001 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 existence, 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 */
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 (char *sndbuf
, char *pattern
, va_list args
);
62 static int readchar (int timeout
);
64 static void monitor_fetch_register (int regno
);
65 static void monitor_store_register (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 (char *args
, int from_tty
);
70 static void monitor_resume (ptid_t ptid
, int step
, enum target_signal sig
);
71 static void monitor_interrupt (int signo
);
72 static void monitor_interrupt_twice (int signo
);
73 static void monitor_interrupt_query (void);
74 static void monitor_wait_cleanup (void *old_timeout
);
76 static ptid_t
monitor_wait (ptid_t ptid
, struct target_waitstatus
*status
);
77 static void monitor_fetch_registers (int regno
);
78 static void monitor_store_registers (int regno
);
79 static void monitor_prepare_to_store (void);
80 static int monitor_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
82 struct mem_attrib
*attrib
,
83 struct target_ops
*target
);
84 static void monitor_files_info (struct target_ops
*ops
);
85 static int monitor_insert_breakpoint (CORE_ADDR addr
, char *shadow
);
86 static int monitor_remove_breakpoint (CORE_ADDR addr
, char *shadow
);
87 static void monitor_kill (void);
88 static void monitor_load (char *file
, int from_tty
);
89 static void monitor_mourn_inferior (void);
90 static void monitor_stop (void);
92 static int monitor_read_memory (CORE_ADDR addr
, char *myaddr
, int len
);
93 static int monitor_write_memory (CORE_ADDR addr
, char *myaddr
, int len
);
94 static int monitor_write_memory_bytes (CORE_ADDR addr
, char *myaddr
, int len
);
95 static int monitor_write_memory_block (CORE_ADDR memaddr
,
96 char *myaddr
, int len
);
97 static int monitor_expect_regexp (struct re_pattern_buffer
*pat
,
98 char *buf
, int buflen
);
99 static void monitor_dump_regs (void);
101 static int from_hex (int a
);
102 static unsigned long get_hex_word (void);
104 static void parse_register_dump (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 int first_time
= 0; /* is this the first time we're executing after
136 gaving created the child proccess? */
138 #define TARGET_BUF_SIZE 2048
140 /* Monitor specific debugging information. Typically only useful to
141 the developer of a new monitor interface. */
143 static void monitor_debug (const char *fmt
, ...) ATTR_FORMAT(printf
, 1, 2);
145 static int monitor_debug_p
= 0;
147 /* NOTE: This file alternates between monitor_debug_p and remote_debug
148 when determining if debug information is printed. Perhaphs this
149 could be simplified. */
152 monitor_debug (const char *fmt
, ...)
157 va_start (args
, fmt
);
158 vfprintf_filtered (gdb_stdlog
, fmt
, args
);
164 /* Convert a string into a printable representation, Return # byte in
165 the new string. When LEN is >0 it specifies the size of the
166 string. Otherwize strlen(oldstr) is used. */
169 monitor_printable_string (char *newstr
, char *oldstr
, int len
)
175 len
= strlen (oldstr
);
177 for (i
= 0; i
< len
; i
++)
188 sprintf (newstr
, "\\x%02x", ch
& 0xff);
227 /* Print monitor errors with a string, converting the string to printable
231 monitor_error (char *function
, char *message
,
232 CORE_ADDR memaddr
, int len
, char *string
, int final_char
)
234 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
235 char *safe_string
= alloca ((real_len
* 4) + 1);
236 monitor_printable_string (safe_string
, string
, real_len
);
239 error ("%s (0x%s): %s: %s%c", function
, paddr_nz (memaddr
), message
, safe_string
, final_char
);
241 error ("%s (0x%s): %s: %s", function
, paddr_nz (memaddr
), message
, safe_string
);
244 /* Convert hex digit A to a number. */
249 if (a
>= '0' && a
<= '9')
251 else if (a
>= 'a' && a
<= 'f')
253 else if (a
>= 'A' && a
<= 'F')
256 error ("Invalid hex digit %d", a
);
259 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
261 This function exists to get around the problem that many host platforms
262 don't have a printf that can print 64-bit addresses. The %A format
263 specification is recognized as a special case, and causes the argument
264 to be printed as a 64-bit hexadecimal address.
266 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
267 If it is a '%s' format, the argument is a string; otherwise the
268 argument is assumed to be a long integer.
270 %% is also turned into a single %.
274 monitor_vsprintf (char *sndbuf
, char *pattern
, va_list args
)
284 for (p
= pattern
; *p
; p
++)
288 /* Copy the format specifier to a separate buffer. */
290 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
293 format
[i
] = fmt
= *p
;
294 format
[i
+ 1] = '\0';
296 /* Fetch the next argument and print it. */
300 strcpy (sndbuf
, "%");
303 arg_addr
= va_arg (args
, CORE_ADDR
);
304 strcpy (sndbuf
, paddr_nz (arg_addr
));
307 arg_string
= va_arg (args
, char *);
308 sprintf (sndbuf
, format
, arg_string
);
311 arg_int
= va_arg (args
, long);
312 sprintf (sndbuf
, format
, arg_int
);
315 sndbuf
+= strlen (sndbuf
);
324 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
325 Works just like printf. */
328 monitor_printf_noecho (char *pattern
,...)
334 va_start (args
, pattern
);
336 monitor_vsprintf (sndbuf
, pattern
, args
);
338 len
= strlen (sndbuf
);
339 if (len
+ 1 > sizeof sndbuf
)
340 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
344 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
345 monitor_printable_string (safe_string
, sndbuf
, 0);
346 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
349 monitor_write (sndbuf
, len
);
352 /* monitor_printf -- Send data to monitor and check the echo. Works just like
356 monitor_printf (char *pattern
,...)
362 va_start (args
, pattern
);
364 monitor_vsprintf (sndbuf
, pattern
, args
);
366 len
= strlen (sndbuf
);
367 if (len
+ 1 > sizeof sndbuf
)
368 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
372 char *safe_string
= (char *) alloca ((len
* 4) + 1);
373 monitor_printable_string (safe_string
, sndbuf
, 0);
374 fprintf_unfiltered (gdb_stdlog
, "sent[%s]\n", safe_string
);
377 monitor_write (sndbuf
, len
);
379 /* We used to expect that the next immediate output was the characters we
380 just output, but sometimes some extra junk appeared before the characters
381 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
382 So, just start searching for what we sent, and skip anything unknown. */
383 monitor_debug ("ExpectEcho\n");
384 monitor_expect (sndbuf
, (char *) 0, 0);
388 /* Write characters to the remote system. */
391 monitor_write (char *buf
, int buflen
)
393 if (SERIAL_WRITE (monitor_desc
, buf
, buflen
))
394 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n",
395 safe_strerror (errno
));
399 /* Read a binary character from the remote system, doing all the fancy
400 timeout stuff, but without interpreting the character in any way,
401 and without printing remote debug information. */
404 monitor_readchar (void)
412 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
415 c
&= 0xff; /* don't lose bit 7 */
422 if (c
== SERIAL_TIMEOUT
)
423 error ("Timeout reading from remote system.");
425 perror_with_name ("remote-monitor");
429 /* Read a character from the remote system, doing all the fancy
433 readchar (int timeout
)
438 last_random
, last_nl
, last_cr
, last_crnl
446 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
451 /* This seems to interfere with proper function of the
453 if (monitor_debug_p
|| remote_debug
)
458 puts_debug ("read -->", buf
, "<--");
463 /* Canonicialize \n\r combinations into one \r */
464 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
466 if ((c
== '\r' && state
== last_nl
)
467 || (c
== '\n' && state
== last_cr
))
488 if (c
== SERIAL_TIMEOUT
)
490 /* I fail to see how detaching here can be useful */
491 if (in_monitor_wait
) /* Watchdog went off */
493 target_mourn_inferior ();
494 error ("GDB serial timeout has expired. Target detached.\n");
498 error ("Timeout reading from remote system.");
500 perror_with_name ("remote-monitor");
503 /* Scan input from the remote system, until STRING is found. If BUF is non-
504 zero, then collect input until we have collected either STRING or BUFLEN-1
505 chars. In either case we terminate BUF with a 0. If input overflows BUF
506 because STRING can't be found, return -1, else return number of chars in BUF
507 (minus the terminating NUL). Note that in the non-overflow case, STRING
508 will be at the end of BUF. */
511 monitor_expect (char *string
, char *buf
, int buflen
)
514 int obuflen
= buflen
;
516 extern struct target_ops
*targ_ops
;
520 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
521 monitor_printable_string (safe_string
, string
, 0);
522 fprintf_unfiltered (gdb_stdlog
, "MON Expecting '%s'\n", safe_string
);
537 c
= readchar (timeout
);
544 c
= readchar (timeout
);
546 /* Don't expect any ^C sent to be echoed */
548 if (*p
== '\003' || c
== *p
)
558 return obuflen
- buflen
;
564 else if ((c
== '\021' || c
== '\023') &&
565 (STREQ (targ_ops
->to_shortname
, "m32r")
566 || STREQ (targ_ops
->to_shortname
, "mon2000")))
567 { /* m32r monitor emits random DC1/DC3 chars */
572 /* We got a character that doesn't match the string. We need to
573 back up p, but how far? If we're looking for "..howdy" and the
574 monitor sends "...howdy"? There's certainly a match in there,
575 but when we receive the third ".", we won't find it if we just
576 restart the matching at the beginning of the string.
578 This is a Boyer-Moore kind of situation. We want to reset P to
579 the end of the longest prefix of STRING that is a suffix of
580 what we've read so far. In the example above, that would be
581 ".." --- the longest prefix of "..howdy" that is a suffix of
582 "...". This longest prefix could be the empty string, if C
583 is nowhere to be found in STRING.
585 If this longest prefix is not the empty string, it must contain
586 C, so let's search from the end of STRING for instances of C,
587 and see if the portion of STRING before that is a suffix of
588 what we read before C. Actually, we can search backwards from
589 p, since we know no prefix can be longer than that.
591 Note that we can use STRING itself, along with C, as a record
592 of what we've received so far. :) */
595 for (i
= (p
- string
) - 1; i
>= 0; i
--)
598 /* Is this prefix a suffix of what we've read so far?
600 string[0 .. i-1] == string[p - i, p - 1]? */
601 if (! memcmp (string
, p
- i
, i
))
613 /* Search for a regexp. */
616 monitor_expect_regexp (struct re_pattern_buffer
*pat
, char *buf
, int buflen
)
620 monitor_debug ("MON Expecting regexp\n");
625 mybuf
= alloca (TARGET_BUF_SIZE
);
626 buflen
= TARGET_BUF_SIZE
;
634 if (p
- mybuf
>= buflen
)
635 { /* Buffer about to overflow */
637 /* On overflow, we copy the upper half of the buffer to the lower half. Not
638 great, but it usually works... */
640 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
641 p
= mybuf
+ buflen
/ 2;
644 *p
++ = readchar (timeout
);
646 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
652 /* Keep discarding input until we see the MONITOR prompt.
654 The convention for dealing with the prompt is that you
656 o *then* wait for the prompt.
658 Thus the last thing that a procedure does with the serial line will
659 be an monitor_expect_prompt(). Exception: monitor_resume does not
660 wait for the prompt, because the terminal is being handed over to
661 the inferior. However, the next thing which happens after that is
662 a monitor_wait which does wait for the prompt. Note that this
663 includes abnormal exit, e.g. error(). This is necessary to prevent
664 getting into states from which we can't recover. */
667 monitor_expect_prompt (char *buf
, int buflen
)
669 monitor_debug ("MON Expecting prompt\n");
670 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
673 /* Get N 32-bit words from remote, each preceded by a space, and put
674 them in registers starting at REGNO. */
685 ch
= readchar (timeout
);
686 while (isspace (ch
));
690 for (i
= 7; i
>= 1; i
--)
692 ch
= readchar (timeout
);
695 val
= (val
<< 4) | from_hex (ch
);
703 compile_pattern (char *pattern
, struct re_pattern_buffer
*compiled_pattern
,
709 compiled_pattern
->fastmap
= fastmap
;
711 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
712 val
= re_compile_pattern (pattern
,
718 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
721 re_compile_fastmap (compiled_pattern
);
724 /* Open a connection to a remote debugger. NAME is the filename used
725 for communication. */
728 monitor_open (char *args
, struct monitor_ops
*mon_ops
, int from_tty
)
733 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
734 error ("Magic number of monitor_ops struct wrong.");
736 targ_ops
= mon_ops
->target
;
737 name
= targ_ops
->to_shortname
;
740 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
741 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
743 target_preopen (from_tty
);
745 /* Setup pattern for register dump */
747 if (mon_ops
->register_pattern
)
748 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
751 if (mon_ops
->getmem
.resp_delim
)
752 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
753 getmem_resp_delim_fastmap
);
755 unpush_target (targ_ops
);
759 dev_name
= xstrdup (args
);
761 monitor_desc
= SERIAL_OPEN (dev_name
);
764 perror_with_name (dev_name
);
768 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
770 SERIAL_CLOSE (monitor_desc
);
771 perror_with_name (dev_name
);
775 SERIAL_RAW (monitor_desc
);
777 SERIAL_FLUSH_INPUT (monitor_desc
);
779 /* some systems only work with 2 stop bits */
781 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
783 current_monitor
= mon_ops
;
785 /* See if we can wake up the monitor. First, try sending a stop sequence,
786 then send the init strings. Last, remove all breakpoints. */
788 if (current_monitor
->stop
)
791 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
793 monitor_debug ("EXP Open echo\n");
794 monitor_expect_prompt (NULL
, 0);
798 /* wake up the monitor and see if it's alive */
799 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
801 /* Some of the characters we send may not be echoed,
802 but we hope to get a prompt at the end of it all. */
804 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
807 monitor_printf_noecho (*p
);
808 monitor_expect_prompt (NULL
, 0);
811 SERIAL_FLUSH_INPUT (monitor_desc
);
813 /* Alloc breakpoints */
814 if (mon_ops
->set_break
!= NULL
)
816 if (mon_ops
->num_breakpoints
== 0)
817 mon_ops
->num_breakpoints
= 8;
819 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
820 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
823 /* Remove all breakpoints */
825 if (mon_ops
->clr_all_break
)
827 monitor_printf (mon_ops
->clr_all_break
);
828 monitor_expect_prompt (NULL
, 0);
832 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
834 push_target (targ_ops
);
836 inferior_ptid
= pid_to_ptid (42000); /* Make run command think we are busy... */
838 /* Give monitor_wait something to read */
840 monitor_printf (current_monitor
->line_term
);
845 /* Close out all files and local state before this target loses
849 monitor_close (int quitting
)
852 SERIAL_CLOSE (monitor_desc
);
854 /* Free breakpoint memory */
855 if (breakaddr
!= NULL
)
864 /* Terminate the open connection to the remote debugger. Use this
865 when you want to detach and do something else with your gdb. */
868 monitor_detach (char *args
, int from_tty
)
870 pop_target (); /* calls monitor_close to do the real work */
872 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
875 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
878 monitor_supply_register (int regno
, char *valstr
)
881 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
886 while (p
&& *p
!= '\0')
888 if (*p
== '\r' || *p
== '\n')
899 if (!isxdigit (*p
) && *p
!= 'x')
905 val
+= fromhex (*p
++);
907 monitor_debug ("Supplying Register %d %s\n", regno
, valstr
);
909 if (val
== 0 && valstr
== p
)
910 error ("monitor_supply_register (%d): bad value from monitor: %s.",
913 /* supply register stores in target byte order, so swap here */
915 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
917 supply_register (regno
, regbuf
);
922 /* Tell the remote machine to resume. */
925 monitor_resume (ptid_t ptid
, int step
, enum target_signal sig
)
927 /* Some monitors require a different command when starting a program */
928 monitor_debug ("MON resume\n");
929 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
932 monitor_printf ("run\r");
933 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
938 monitor_printf (current_monitor
->step
);
941 if (current_monitor
->continue_hook
)
942 (*current_monitor
->continue_hook
) ();
944 monitor_printf (current_monitor
->cont
);
945 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
950 /* Parse the output of a register dump command. A monitor specific
951 regexp is used to extract individual register descriptions of the
952 form REG=VAL. Each description is split up into a name and a value
953 string which are passed down to monitor specific code. */
956 parse_register_dump (char *buf
, int len
)
958 monitor_debug ("MON Parsing register dump\n");
961 int regnamelen
, vallen
;
963 /* Element 0 points to start of register name, and element 1
964 points to the start of the register value. */
965 struct re_registers register_strings
;
967 memset (®ister_strings
, 0, sizeof (struct re_registers
));
969 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
970 ®ister_strings
) == -1)
973 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
974 regname
= buf
+ register_strings
.start
[1];
975 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
976 val
= buf
+ register_strings
.start
[2];
978 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
980 buf
+= register_strings
.end
[0];
981 len
-= register_strings
.end
[0];
985 /* Send ^C to target to halt it. Target will respond, and send us a
989 monitor_interrupt (int signo
)
991 /* If this doesn't work, try more severe steps. */
992 signal (signo
, monitor_interrupt_twice
);
994 if (monitor_debug_p
|| remote_debug
)
995 fprintf_unfiltered (gdb_stdlog
, "monitor_interrupt called\n");
1000 /* The user typed ^C twice. */
1003 monitor_interrupt_twice (int signo
)
1005 signal (signo
, ofunc
);
1007 monitor_interrupt_query ();
1009 signal (signo
, monitor_interrupt
);
1012 /* Ask the user what to do when an interrupt is received. */
1015 monitor_interrupt_query (void)
1017 target_terminal_ours ();
1019 if (query ("Interrupted while waiting for the program.\n\
1020 Give up (and stop debugging it)? "))
1022 target_mourn_inferior ();
1023 return_to_top_level (RETURN_QUIT
);
1026 target_terminal_inferior ();
1030 monitor_wait_cleanup (void *old_timeout
)
1032 timeout
= *(int *) old_timeout
;
1033 signal (SIGINT
, ofunc
);
1034 in_monitor_wait
= 0;
1040 monitor_wait_filter (char *buf
,
1043 struct target_waitstatus
*status
1049 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1050 *ext_resp_len
= resp_len
;
1053 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1055 while (resp_len
< 0);
1057 /* Print any output characters that were preceded by ^O. */
1058 /* FIXME - This would be great as a user settabgle flag */
1059 if (monitor_debug_p
|| remote_debug
1060 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1064 for (i
= 0; i
< resp_len
- 1; i
++)
1066 putchar_unfiltered (buf
[++i
]);
1072 /* Wait until the remote machine stops, then return, storing status in
1073 status just as `wait' would. */
1076 monitor_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1078 int old_timeout
= timeout
;
1079 char buf
[TARGET_BUF_SIZE
];
1081 struct cleanup
*old_chain
;
1083 status
->kind
= TARGET_WAITKIND_EXITED
;
1084 status
->value
.integer
= 0;
1086 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1087 monitor_debug ("MON wait\n");
1090 /* This is somthing other than a maintenance command */
1091 in_monitor_wait
= 1;
1092 timeout
= watchdog
> 0 ? watchdog
: -1;
1094 timeout
= -1; /* Don't time out -- user program is running. */
1097 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1099 if (current_monitor
->wait_filter
)
1100 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1102 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1104 #if 0 /* Transferred to monitor wait filter */
1107 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1110 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1112 while (resp_len
< 0);
1114 /* Print any output characters that were preceded by ^O. */
1115 /* FIXME - This would be great as a user settabgle flag */
1116 if (monitor_debug_p
|| remote_debug
1117 || current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1121 for (i
= 0; i
< resp_len
- 1; i
++)
1123 putchar_unfiltered (buf
[++i
]);
1127 signal (SIGINT
, ofunc
);
1129 timeout
= old_timeout
;
1131 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1134 monitor_printf (current_monitor
->dump_registers
);
1135 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1138 if (current_monitor
->register_pattern
)
1139 parse_register_dump (buf
, resp_len
);
1141 monitor_debug ("Wait fetching registers after stop\n");
1142 monitor_dump_regs ();
1145 status
->kind
= TARGET_WAITKIND_STOPPED
;
1146 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1148 discard_cleanups (old_chain
);
1150 in_monitor_wait
= 0;
1152 return inferior_ptid
;
1155 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1159 monitor_fetch_register (int regno
)
1166 regbuf
= alloca (MAX_REGISTER_RAW_SIZE
* 2 + 1);
1167 zerobuf
= alloca (MAX_REGISTER_RAW_SIZE
);
1168 memset (zerobuf
, 0, MAX_REGISTER_RAW_SIZE
);
1170 name
= current_monitor
->regnames
[regno
];
1171 monitor_debug ("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)");
1173 if (!name
|| (*name
== '\0'))
1175 monitor_debug ("No register known for %d\n", regno
);
1176 supply_register (regno
, zerobuf
);
1180 /* send the register examine command */
1182 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1184 /* If RESP_DELIM is specified, we search for that as a leading
1185 delimiter for the register value. Otherwise, we just start
1186 searching from the start of the buf. */
1188 if (current_monitor
->getreg
.resp_delim
)
1190 monitor_debug ("EXP getreg.resp_delim\n");
1191 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1192 /* Handle case of first 32 registers listed in pairs. */
1193 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1194 && (regno
& 1) != 0 && regno
< 32)
1196 monitor_debug ("EXP getreg.resp_delim\n");
1197 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1201 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1202 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1205 c
= readchar (timeout
);
1207 c
= readchar (timeout
);
1208 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1211 error ("Bad value returned from monitor while fetching register %x.",
1215 /* Read upto the maximum number of hex digits for this register, skipping
1216 spaces, but stop reading if something else is seen. Some monitors
1217 like to drop leading zeros. */
1219 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1222 c
= readchar (timeout
);
1224 c
= readchar (timeout
);
1232 regbuf
[i
] = '\000'; /* terminate the number */
1233 monitor_debug ("REGVAL '%s'\n", regbuf
);
1235 /* If TERM is present, we wait for that to show up. Also, (if TERM
1236 is present), we will send TERM_CMD if that is present. In any
1237 case, we collect all of the output into buf, and then wait for
1238 the normal prompt. */
1240 if (current_monitor
->getreg
.term
)
1242 monitor_debug ("EXP getreg.term\n");
1243 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1246 if (current_monitor
->getreg
.term_cmd
)
1248 monitor_debug ("EMIT getreg.term.cmd\n");
1249 monitor_printf (current_monitor
->getreg
.term_cmd
);
1251 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1252 current_monitor
->getreg
.term_cmd
) /* ack expected */
1253 monitor_expect_prompt (NULL
, 0); /* get response */
1255 monitor_supply_register (regno
, regbuf
);
1258 /* Sometimes, it takes several commands to dump the registers */
1259 /* This is a primitive for use by variations of monitor interfaces in
1260 case they need to compose the operation.
1263 monitor_dump_reg_block (char *block_cmd
)
1265 char buf
[TARGET_BUF_SIZE
];
1267 monitor_printf (block_cmd
);
1268 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1269 parse_register_dump (buf
, resp_len
);
1274 /* Read the remote registers into the block regs. */
1275 /* Call the specific function if it has been provided */
1278 monitor_dump_regs (void)
1280 char buf
[TARGET_BUF_SIZE
];
1282 if (current_monitor
->dumpregs
)
1283 (*(current_monitor
->dumpregs
)) (); /* call supplied function */
1284 else if (current_monitor
->dump_registers
) /* default version */
1286 monitor_printf (current_monitor
->dump_registers
);
1287 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1288 parse_register_dump (buf
, resp_len
);
1291 internal_error (__FILE__
, __LINE__
, "failed internal consistency check"); /* Need some way to read registers */
1295 monitor_fetch_registers (int regno
)
1297 monitor_debug ("MON fetchregs\n");
1298 if (current_monitor
->getreg
.cmd
)
1302 monitor_fetch_register (regno
);
1306 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1307 monitor_fetch_register (regno
);
1311 monitor_dump_regs ();
1315 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1318 monitor_store_register (int regno
)
1323 name
= current_monitor
->regnames
[regno
];
1324 if (!name
|| (*name
== '\0'))
1326 monitor_debug ("MON Cannot store unknown register\n");
1330 val
= read_register (regno
);
1331 monitor_debug ("MON storeg %d %s\n", regno
,
1332 phex (val
, REGISTER_RAW_SIZE (regno
)));
1334 /* send the register deposit command */
1336 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1337 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1338 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1339 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1341 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1343 if (current_monitor
->setreg
.term
)
1345 monitor_debug ("EXP setreg.term\n");
1346 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1347 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1348 monitor_printf ("%s\r", paddr_nz (val
));
1349 monitor_expect_prompt (NULL
, 0);
1352 monitor_expect_prompt (NULL
, 0);
1353 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1355 monitor_debug ("EXP setreg_termcmd\n");
1356 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1357 monitor_expect_prompt (NULL
, 0);
1359 } /* monitor_store_register */
1361 /* Store the remote registers. */
1364 monitor_store_registers (int regno
)
1368 monitor_store_register (regno
);
1372 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1373 monitor_store_register (regno
);
1376 /* Get ready to modify the registers array. On machines which store
1377 individual registers, this doesn't need to do anything. On machines
1378 which store all the registers in one fell swoop, this makes sure
1379 that registers contains all the registers from the program being
1383 monitor_prepare_to_store (void)
1385 /* Do nothing, since we can store individual regs */
1389 monitor_files_info (struct target_ops
*ops
)
1391 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1395 monitor_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1397 unsigned int val
, hostval
;
1401 monitor_debug ("MON write %d %s\n", len
, paddr (memaddr
));
1403 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1404 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1406 /* Use memory fill command for leading 0 bytes. */
1408 if (current_monitor
->fill
)
1410 for (i
= 0; i
< len
; i
++)
1414 if (i
> 4) /* More than 4 zeros is worth doing */
1416 monitor_debug ("MON FILL %d\n", i
);
1417 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1418 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1420 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1422 monitor_expect_prompt (NULL
, 0);
1429 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1430 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1433 cmd
= current_monitor
->setmem
.cmdll
;
1437 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1440 cmd
= current_monitor
->setmem
.cmdl
;
1442 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1445 cmd
= current_monitor
->setmem
.cmdw
;
1450 cmd
= current_monitor
->setmem
.cmdb
;
1453 val
= extract_unsigned_integer (myaddr
, len
);
1457 hostval
= *(unsigned int *) myaddr
;
1458 monitor_debug ("Hostval(%08x) val(%08x)\n", hostval
, val
);
1462 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1463 monitor_printf_noecho (cmd
, memaddr
, val
);
1464 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1467 monitor_printf_noecho (cmd
, memaddr
);
1469 if (current_monitor
->setmem
.term
)
1471 monitor_debug ("EXP setmem.term");
1472 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1473 monitor_printf ("%x\r", val
);
1475 if (current_monitor
->setmem
.term_cmd
)
1476 { /* Emit this to get out of the memory editing state */
1477 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1478 /* Drop through to expecting a prompt */
1482 monitor_printf (cmd
, memaddr
, val
);
1484 monitor_expect_prompt (NULL
, 0);
1491 monitor_write_even_block (CORE_ADDR memaddr
, char *myaddr
, int len
)
1495 /* Enter the sub mode */
1496 monitor_printf (current_monitor
->setmem
.cmdl
, memaddr
);
1497 monitor_expect_prompt (NULL
, 0);
1501 val
= extract_unsigned_integer (myaddr
, 4); /* REALLY */
1502 monitor_printf ("%x\r", val
);
1506 monitor_debug (" @ %s\n", paddr (memaddr
));
1507 /* If we wanted to, here we could validate the address */
1508 monitor_expect_prompt (NULL
, 0);
1510 /* Now exit the sub mode */
1511 monitor_printf (current_monitor
->getreg
.term_cmd
);
1512 monitor_expect_prompt (NULL
, 0);
1518 monitor_write_memory_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1524 /* Enter the sub mode */
1525 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1526 monitor_expect_prompt (NULL
, 0);
1530 monitor_printf ("%x\r", val
);
1534 /* If we wanted to, here we could validate the address */
1535 monitor_expect_prompt (NULL
, 0);
1538 /* Now exit the sub mode */
1539 monitor_printf (current_monitor
->getreg
.term_cmd
);
1540 monitor_expect_prompt (NULL
, 0);
1546 longlongendswap (unsigned char *a
)
1555 *(a
+ i
) = *(a
+ j
);
1560 /* Format 32 chars of long long value, advance the pointer */
1561 static char *hexlate
= "0123456789abcdef";
1563 longlong_hexchars (unsigned long long value
,
1573 static unsigned char disbuf
[8]; /* disassembly buffer */
1574 unsigned char *scan
, *limit
; /* loop controls */
1575 unsigned char c
, nib
;
1580 unsigned long long *dp
;
1581 dp
= (unsigned long long *) scan
;
1584 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1585 while (scan
< limit
)
1587 c
= *scan
++; /* a byte of our long long value */
1593 leadzero
= 0; /* henceforth we print even zeroes */
1595 nib
= c
>> 4; /* high nibble bits */
1596 *outbuff
++ = hexlate
[nib
];
1597 nib
= c
& 0x0f; /* low nibble bits */
1598 *outbuff
++ = hexlate
[nib
];
1602 } /* longlong_hexchars */
1606 /* I am only going to call this when writing virtual byte streams.
1607 Which possably entails endian conversions
1610 monitor_write_memory_longlongs (CORE_ADDR memaddr
, char *myaddr
, int len
)
1612 static char hexstage
[20]; /* At least 16 digits required, plus null */
1617 llptr
= (unsigned long long *) myaddr
;
1620 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1621 monitor_expect_prompt (NULL
, 0);
1625 endstring
= longlong_hexchars (*llptr
, hexstage
);
1626 *endstring
= '\0'; /* NUll terminate for printf */
1627 monitor_printf ("%s\r", hexstage
);
1631 /* If we wanted to, here we could validate the address */
1632 monitor_expect_prompt (NULL
, 0);
1635 /* Now exit the sub mode */
1636 monitor_printf (current_monitor
->getreg
.term_cmd
);
1637 monitor_expect_prompt (NULL
, 0);
1643 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1644 /* This is for the large blocks of memory which may occur in downloading.
1645 And for monitors which use interactive entry,
1646 And for monitors which do not have other downloading methods.
1647 Without this, we will end up calling monitor_write_memory many times
1648 and do the entry and exit of the sub mode many times
1649 This currently assumes...
1650 MO_SETMEM_INTERACTIVE
1651 ! MO_NO_ECHO_ON_SETMEM
1652 To use this, the you have to patch the monitor_cmds block with
1653 this function. Otherwise, its not tuned up for use by all
1658 monitor_write_memory_block (CORE_ADDR memaddr
, char *myaddr
, int len
)
1662 /* FIXME: This would be a good place to put the zero test */
1664 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1666 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1673 written
= monitor_write_even_block (memaddr
, myaddr
, len
);
1674 /* Adjust calling parameters by written amount */
1680 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1684 /* This is an alternate form of monitor_read_memory which is used for monitors
1685 which can only read a single byte/word/etc. at a time. */
1688 monitor_read_memory_single (CORE_ADDR memaddr
, char *myaddr
, int len
)
1691 char membuf
[sizeof (int) * 2 + 1];
1695 monitor_debug ("MON read single\n");
1697 /* Can't actually use long longs (nice idea, though). In fact, the
1698 call to strtoul below will fail if it tries to convert a value
1699 that's too big to fit in a long. */
1700 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1703 cmd
= current_monitor
->getmem
.cmdll
;
1707 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1710 cmd
= current_monitor
->getmem
.cmdl
;
1712 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1715 cmd
= current_monitor
->getmem
.cmdw
;
1720 cmd
= current_monitor
->getmem
.cmdb
;
1723 /* Send the examine command. */
1725 monitor_printf (cmd
, memaddr
);
1727 /* If RESP_DELIM is specified, we search for that as a leading
1728 delimiter for the memory value. Otherwise, we just start
1729 searching from the start of the buf. */
1731 if (current_monitor
->getmem
.resp_delim
)
1733 monitor_debug ("EXP getmem.resp_delim\n");
1734 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1737 /* Now, read the appropriate number of hex digits for this loc,
1740 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1741 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1745 c
= readchar (timeout
);
1747 c
= readchar (timeout
);
1748 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1751 monitor_error ("monitor_read_memory_single",
1752 "bad response from monitor",
1753 memaddr
, 0, NULL
, 0);
1758 for (i
= 0; i
< len
* 2; i
++)
1764 c
= readchar (timeout
);
1770 monitor_error ("monitor_read_memory_single",
1771 "bad response from monitor",
1772 memaddr
, i
, membuf
, 0);
1776 membuf
[i
] = '\000'; /* terminate the number */
1779 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1780 present), we will send TERM_CMD if that is present. In any case, we collect
1781 all of the output into buf, and then wait for the normal prompt. */
1783 if (current_monitor
->getmem
.term
)
1785 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1787 if (current_monitor
->getmem
.term_cmd
)
1789 monitor_printf (current_monitor
->getmem
.term_cmd
);
1790 monitor_expect_prompt (NULL
, 0);
1794 monitor_expect_prompt (NULL
, 0); /* get response */
1797 val
= strtoul (membuf
, &p
, 16);
1799 if (val
== 0 && membuf
== p
)
1800 monitor_error ("monitor_read_memory_single",
1801 "bad value from monitor",
1802 memaddr
, 0, membuf
, 0);
1804 /* supply register stores in target byte order, so swap here */
1806 store_unsigned_integer (myaddr
, len
, val
);
1811 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1812 memory at MEMADDR. Returns length moved. Currently, we do no more
1813 than 16 bytes at a time. */
1816 monitor_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1827 monitor_debug ("Zero length call to monitor_read_memory\n");
1831 monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1832 paddr_nz (memaddr
), (long) myaddr
, len
);
1834 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1835 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1837 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1838 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1840 len
= min (len
, 16);
1842 /* Some dumpers align the first data with the preceeding 16
1843 byte boundary. Some print blanks and start at the
1844 requested boundary. EXACT_DUMPADDR
1847 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1848 ? memaddr
: memaddr
& ~0x0f;
1850 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1851 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1852 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1854 /* send the memory examine command */
1856 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1857 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1858 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1859 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1861 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1863 /* If TERM is present, we wait for that to show up. Also, (if TERM
1864 is present), we will send TERM_CMD if that is present. In any
1865 case, we collect all of the output into buf, and then wait for
1866 the normal prompt. */
1868 if (current_monitor
->getmem
.term
)
1870 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1873 monitor_error ("monitor_read_memory",
1874 "excessive response from monitor",
1875 memaddr
, resp_len
, buf
, 0);
1877 if (current_monitor
->getmem
.term_cmd
)
1879 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1880 strlen (current_monitor
->getmem
.term_cmd
));
1881 monitor_expect_prompt (NULL
, 0);
1885 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1889 /* If RESP_DELIM is specified, we search for that as a leading
1890 delimiter for the values. Otherwise, we just start searching
1891 from the start of the buf. */
1893 if (current_monitor
->getmem
.resp_delim
)
1896 struct re_registers resp_strings
;
1897 monitor_debug ("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
);
1899 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1901 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1905 monitor_error ("monitor_read_memory",
1906 "bad response from monitor",
1907 memaddr
, resp_len
, buf
, 0);
1909 p
+= resp_strings
.end
[0];
1911 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1913 monitor_error ("monitor_read_memory",
1914 "bad response from monitor",
1915 memaddr
, resp_len
, buf
, 0);
1916 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1919 monitor_debug ("MON scanning %d ,%lx '%s'\n", len
, (long) p
, p
);
1920 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1928 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1932 if ((dumpaddr
>= memaddr
) && (i
> 0))
1934 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
1936 if (monitor_debug_p
|| remote_debug
)
1937 fprintf_unfiltered (gdb_stdlog
, "[%02x]", val
);
1944 ++p
; /* skip a blank or other non hex char */
1948 error ("Failed to read via monitor");
1949 if (monitor_debug_p
|| remote_debug
)
1950 fprintf_unfiltered (gdb_stdlog
, "\n");
1951 return fetched
; /* Return the number of bytes actually read */
1953 monitor_debug ("MON scanning bytes\n");
1955 for (i
= len
; i
> 0; i
--)
1957 /* Skip non-hex chars, but bomb on end of string and newlines */
1964 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1965 monitor_error ("monitor_read_memory",
1966 "badly terminated response from monitor",
1967 memaddr
, resp_len
, buf
, 0);
1971 val
= strtoul (p
, &p1
, 16);
1973 if (val
== 0 && p
== p1
)
1974 monitor_error ("monitor_read_memory",
1975 "bad value from monitor",
1976 memaddr
, resp_len
, buf
, 0);
1989 /* Transfer LEN bytes between target address MEMADDR and GDB address
1990 MYADDR. Returns 0 for success, errno code for failure. TARGET is
1994 monitor_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1995 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
1996 struct target_ops
*target ATTRIBUTE_UNUSED
)
2002 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
2003 res
= monitor_write_memory_block(memaddr
, myaddr
, len
);
2005 res
= monitor_write_memory(memaddr
, myaddr
, len
);
2009 res
= monitor_read_memory(memaddr
, myaddr
, len
);
2018 return; /* ignore attempts to kill target system */
2021 /* All we actually do is set the PC to the start address of exec_bfd, and start
2022 the program at that point. */
2025 monitor_create_inferior (char *exec_file
, char *args
, char **env
)
2027 if (args
&& (*args
!= '\000'))
2028 error ("Args are not supported by the monitor.");
2031 clear_proceed_status ();
2032 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
2035 /* Clean up when a program exits.
2036 The program actually lives on in the remote processor's RAM, and may be
2037 run again without a download. Don't leave it full of breakpoint
2041 monitor_mourn_inferior (void)
2043 unpush_target (targ_ops
);
2044 generic_mourn_inferior (); /* Do all the proper things now */
2047 /* Tell the monitor to add a breakpoint. */
2050 monitor_insert_breakpoint (CORE_ADDR addr
, char *shadow
)
2056 monitor_debug ("MON inst bkpt %s\n", paddr (addr
));
2057 if (current_monitor
->set_break
== NULL
)
2058 error ("No set_break defined for this monitor");
2060 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2061 addr
= ADDR_BITS_REMOVE (addr
);
2063 /* Determine appropriate breakpoint size for this address. */
2064 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2066 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2068 if (breakaddr
[i
] == 0)
2070 breakaddr
[i
] = addr
;
2071 monitor_read_memory (addr
, shadow
, bplen
);
2072 monitor_printf (current_monitor
->set_break
, addr
);
2073 monitor_expect_prompt (NULL
, 0);
2078 error ("Too many breakpoints (> %d) for monitor.", current_monitor
->num_breakpoints
);
2081 /* Tell the monitor to remove a breakpoint. */
2084 monitor_remove_breakpoint (CORE_ADDR addr
, char *shadow
)
2088 monitor_debug ("MON rmbkpt %s\n", paddr (addr
));
2089 if (current_monitor
->clr_break
== NULL
)
2090 error ("No clr_break defined for this monitor");
2092 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2093 addr
= ADDR_BITS_REMOVE (addr
);
2095 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2097 if (breakaddr
[i
] == addr
)
2100 /* some monitors remove breakpoints based on the address */
2101 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2102 monitor_printf (current_monitor
->clr_break
, addr
);
2103 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2104 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2106 monitor_printf (current_monitor
->clr_break
, i
);
2107 monitor_expect_prompt (NULL
, 0);
2111 fprintf_unfiltered (gdb_stderr
,
2112 "Can't find breakpoint associated with 0x%s\n",
2117 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2118 an S-record. Return non-zero if the ACK is received properly. */
2121 monitor_wait_srec_ack (void)
2125 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2127 return (readchar (timeout
) == '+');
2129 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2131 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2132 if ((ch
= readchar (1)) < 0)
2134 if ((ch
= readchar (1)) < 0)
2136 if ((ch
= readchar (1)) < 0)
2138 if ((ch
= readchar (1)) < 0)
2144 /* monitor_load -- download a file. */
2147 monitor_load (char *file
, int from_tty
)
2149 monitor_debug ("MON load\n");
2151 if (current_monitor
->load_routine
)
2152 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2154 { /* The default is ascii S-records */
2156 unsigned long load_offset
;
2159 /* enable user to specify address for downloading as 2nd arg to load */
2160 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2166 monitor_printf (current_monitor
->load
);
2167 if (current_monitor
->loadresp
)
2168 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2170 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2171 32, SREC_ALL
, hashmark
,
2172 current_monitor
->flags
& MO_SREC_ACK
?
2173 monitor_wait_srec_ack
: NULL
);
2175 monitor_expect_prompt (NULL
, 0);
2178 /* Finally, make the PC point at the start address */
2181 write_pc (bfd_get_start_address (exec_bfd
));
2183 inferior_ptid
= null_ptid
; /* No process now */
2185 /* This is necessary because many things were based on the PC at the time that
2186 we attached to the monitor, which is no longer valid now that we have loaded
2187 new code (and just changed the PC). Another way to do this might be to call
2188 normal_stop, except that the stack may not be valid, and things would get
2189 horribly confused... */
2191 clear_symtab_users ();
2197 monitor_debug ("MON stop\n");
2198 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2199 SERIAL_SEND_BREAK (monitor_desc
);
2200 if (current_monitor
->stop
)
2201 monitor_printf_noecho (current_monitor
->stop
);
2204 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2205 in OUTPUT until the prompt is seen. FIXME: We read the characters
2206 ourseleves here cause of a nasty echo. */
2209 monitor_rcmd (char *command
,
2210 struct ui_file
*outbuf
)
2216 if (monitor_desc
== NULL
)
2217 error ("monitor target not open.");
2219 p
= current_monitor
->prompt
;
2221 /* Send the command. Note that if no args were supplied, then we're
2222 just sending the monitor a newline, which is sometimes useful. */
2224 monitor_printf ("%s\r", (command
? command
: ""));
2226 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2228 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2231 /* Convert hex digit A to a number. */
2237 if (a
>= '0' && a
<= '9')
2239 if (a
>= 'a' && a
<= 'f')
2240 return a
- 'a' + 10;
2241 if (a
>= 'A' && a
<= 'F')
2242 return a
- 'A' + 10;
2244 error ("Reply contains invalid hex digit 0x%x", a
);
2249 monitor_get_dev_name (void)
2254 static struct target_ops monitor_ops
;
2257 init_base_monitor_ops (void)
2259 monitor_ops
.to_shortname
= NULL
;
2260 monitor_ops
.to_longname
= NULL
;
2261 monitor_ops
.to_doc
= NULL
;
2262 monitor_ops
.to_open
= NULL
;
2263 monitor_ops
.to_close
= monitor_close
;
2264 monitor_ops
.to_attach
= NULL
;
2265 monitor_ops
.to_post_attach
= NULL
;
2266 monitor_ops
.to_require_attach
= NULL
;
2267 monitor_ops
.to_detach
= monitor_detach
;
2268 monitor_ops
.to_require_detach
= NULL
;
2269 monitor_ops
.to_resume
= monitor_resume
;
2270 monitor_ops
.to_wait
= monitor_wait
;
2271 monitor_ops
.to_post_wait
= NULL
;
2272 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2273 monitor_ops
.to_store_registers
= monitor_store_registers
;
2274 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2275 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2276 monitor_ops
.to_files_info
= monitor_files_info
;
2277 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2278 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2279 monitor_ops
.to_terminal_init
= 0;
2280 monitor_ops
.to_terminal_inferior
= 0;
2281 monitor_ops
.to_terminal_ours_for_output
= 0;
2282 monitor_ops
.to_terminal_ours
= 0;
2283 monitor_ops
.to_terminal_info
= 0;
2284 monitor_ops
.to_kill
= monitor_kill
;
2285 monitor_ops
.to_load
= monitor_load
;
2286 monitor_ops
.to_lookup_symbol
= 0;
2287 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2288 monitor_ops
.to_post_startup_inferior
= NULL
;
2289 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2290 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2291 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2292 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2293 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2294 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2295 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2296 monitor_ops
.to_has_forked
= NULL
;
2297 monitor_ops
.to_has_vforked
= NULL
;
2298 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2299 monitor_ops
.to_post_follow_vfork
= NULL
;
2300 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2301 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2302 monitor_ops
.to_has_execd
= NULL
;
2303 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2304 monitor_ops
.to_has_exited
= NULL
;
2305 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2306 monitor_ops
.to_can_run
= 0;
2307 monitor_ops
.to_notice_signals
= 0;
2308 monitor_ops
.to_thread_alive
= 0;
2309 monitor_ops
.to_stop
= monitor_stop
;
2310 monitor_ops
.to_rcmd
= monitor_rcmd
;
2311 monitor_ops
.to_pid_to_exec_file
= NULL
;
2312 monitor_ops
.to_stratum
= process_stratum
;
2313 monitor_ops
.DONT_USE
= 0;
2314 monitor_ops
.to_has_all_memory
= 1;
2315 monitor_ops
.to_has_memory
= 1;
2316 monitor_ops
.to_has_stack
= 1;
2317 monitor_ops
.to_has_registers
= 1;
2318 monitor_ops
.to_has_execution
= 1;
2319 monitor_ops
.to_sections
= 0;
2320 monitor_ops
.to_sections_end
= 0;
2321 monitor_ops
.to_magic
= OPS_MAGIC
;
2322 } /* init_base_monitor_ops */
2324 /* Init the target_ops structure pointed at by OPS */
2327 init_monitor_ops (struct target_ops
*ops
)
2329 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2330 init_base_monitor_ops ();
2332 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2335 /* Define additional commands that are usually only used by monitors. */
2338 _initialize_remote_monitors (void)
2340 init_base_monitor_ops ();
2341 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2343 "Set display of activity while downloading a file.\n\
2344 When enabled, a hashmark \'#\' is displayed.",
2349 (add_set_cmd ("monitor", no_class
, var_zinteger
,
2350 (char *) &monitor_debug_p
,
2351 "Set debugging of remote monitor communication.\n\
2352 When enabled, communication between GDB and the remote monitor\n\
2353 is displayed.", &setdebuglist
),