1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
5 Resurrected from the ashes by Stu Grossman.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* This file was derived from various remote-* modules. It is a collection
25 of generic support functions so GDB can talk directly to a ROM based
26 monitor. This saves use from having to hack an exception based handler
27 into existance, and makes for quick porting.
29 This module talks to a debug monitor called 'MONITOR', which
30 We communicate with MONITOR via either a direct serial line, or a TCP
31 (or possibly TELNET) stream to a terminal multiplexor,
32 which in turn talks to the target board. */
34 /* FIXME 32x64: This code assumes that registers and addresses are at
35 most 32 bits long. If they can be larger, you will need to declare
36 values as LONGEST and use %llx or some such to print values when
37 building commands to send to the monitor. Since we don't know of
38 any actual 64-bit targets with ROM monitors that use this code,
39 it's not an issue right now. -sts 4/18/96 */
47 #include "gdb_string.h"
48 #include <sys/types.h>
54 #include "gnu-regex.h"
58 static char *dev_name
;
59 static struct target_ops
*targ_ops
;
61 static void monitor_vsprintf
PARAMS ((char *sndbuf
, char *pattern
, va_list args
));
63 static int readchar
PARAMS ((int timeout
));
65 static void monitor_fetch_register
PARAMS ((int regno
));
66 static void monitor_store_register
PARAMS ((int regno
));
68 static int monitor_printable_string
PARAMS ((char *newstr
, char *oldstr
));
69 static void monitor_error
PARAMS ((char *format
, CORE_ADDR memaddr
, int len
, char *string
, int final_char
));
70 static void monitor_detach
PARAMS ((char *args
, int from_tty
));
71 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
72 static void monitor_interrupt
PARAMS ((int signo
));
73 static void monitor_interrupt_twice
PARAMS ((int signo
));
74 static void monitor_interrupt_query
PARAMS ((void));
75 static void monitor_wait_cleanup
PARAMS ((void *old_timeout
));
77 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
* status
));
78 static void monitor_fetch_registers
PARAMS ((int regno
));
79 static void monitor_store_registers
PARAMS ((int regno
));
80 static void monitor_prepare_to_store
PARAMS ((void));
81 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
* target
));
82 static void monitor_files_info
PARAMS ((struct target_ops
* ops
));
83 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
84 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
85 static void monitor_kill
PARAMS ((void));
86 static void monitor_load
PARAMS ((char *file
, int from_tty
));
87 static void monitor_mourn_inferior
PARAMS ((void));
88 static void monitor_stop
PARAMS ((void));
90 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
91 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
, int len
));
92 static int monitor_write_memory_bytes
PARAMS ((CORE_ADDR addr
,
93 char *myaddr
, int len
));
94 static int monitor_write_memory_block
PARAMS ((
98 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
* pat
,
99 char *buf
, int buflen
));
100 static void monitor_dump_regs
PARAMS ((void));
102 static int from_hex
PARAMS ((int a
));
103 static unsigned long get_hex_word
PARAMS ((void));
105 static void parse_register_dump
PARAMS ((char *, int));
107 static struct monitor_ops
*current_monitor
;
109 static int hashmark
; /* flag set by "set hash" */
111 static int timeout
= 30;
113 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
115 static void (*ofunc
) (); /* Old SIGINT signal handler */
117 static CORE_ADDR
*breakaddr
;
119 /* Extra remote debugging for developing a new rom monitor variation */
120 #if ! defined(EXTRA_RDEBUG)
121 #define EXTRA_RDEBUG 0
123 #define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; }
125 /* Descriptor for I/O to remote machine. Initialize it to NULL so
126 that monitor_open knows that we don't have a file open when the
129 static serial_t monitor_desc
= NULL
;
131 /* Pointer to regexp pattern matching data */
133 static struct re_pattern_buffer register_pattern
;
134 static char register_fastmap
[256];
136 static struct re_pattern_buffer getmem_resp_delim_pattern
;
137 static char getmem_resp_delim_fastmap
[256];
139 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
140 monitor_wait wakes up. */
142 static DCACHE
*remote_dcache
;
143 static int first_time
= 0; /* is this the first time we're executing after
144 gaving created the child proccess? */
146 #define TARGET_BUF_SIZE 2048
148 /* Convert a string into a printable representation, Return # byte in the
152 monitor_printable_string (newstr
, oldstr
)
159 while ((ch
= *oldstr
++) != '\0')
169 sprintf (newstr
, "\\x%02x", ch
& 0xff);
206 return newstr
- save
;
209 /* Print monitor errors with a string, converting the string to printable
213 monitor_error (format
, memaddr
, len
, string
, final_char
)
220 int real_len
= (len
== 0 && string
!= (char *) 0) ? strlen (string
) : len
;
221 char *safe_string
= alloca ((real_len
* 4) + 1);
223 int safe_len
= monitor_printable_string (safe_string
, string
);
226 error (format
, (int) memaddr
, p
- safe_string
, safe_string
, final_char
);
228 error (format
, (int) memaddr
, p
- safe_string
, safe_string
);
231 /* Convert hex digit A to a number. */
237 if (a
>= '0' && a
<= '9')
239 else if (a
>= 'a' && a
<= 'f')
241 else if (a
>= 'A' && a
<= 'F')
244 error ("Invalid hex digit %d", a
);
247 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
249 This function exists to get around the problem that many host platforms
250 don't have a printf that can print 64-bit addresses. The %A format
251 specification is recognized as a special case, and causes the argument
252 to be printed as a 64-bit hexadecimal address.
254 Only format specifiers of the form "[0-9]*[a-z]" are recognized.
255 If it is a '%s' format, the argument is a string; otherwise the
256 argument is assumed to be a long integer.
258 %% is also turned into a single %.
262 monitor_vsprintf (sndbuf
, pattern
, args
)
275 for (p
= pattern
; *p
; p
++)
279 /* Copy the format specifier to a separate buffer. */
281 for (i
= 1; *p
>= '0' && *p
<= '9' && i
< (int) sizeof (format
) - 2;
284 format
[i
] = fmt
= *p
;
285 format
[i
+ 1] = '\0';
287 /* Fetch the next argument and print it. */
291 strcpy (sndbuf
, "%");
294 arg_addr
= va_arg (args
, CORE_ADDR
);
295 strcpy (sndbuf
, paddr_nz (arg_addr
));
298 arg_string
= va_arg (args
, char *);
299 sprintf (sndbuf
, format
, arg_string
);
302 arg_int
= va_arg (args
, long);
303 sprintf (sndbuf
, format
, arg_int
);
306 sndbuf
+= strlen (sndbuf
);
315 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
316 Works just like printf. */
319 monitor_printf_noecho (char *pattern
,...)
325 va_start (args
, pattern
);
327 monitor_vsprintf (sndbuf
, pattern
, args
);
329 len
= strlen (sndbuf
);
330 if (len
+ 1 > sizeof sndbuf
)
334 if (remote_debug
> 0)
335 puts_debug ("sent -->", sndbuf
, "<--");
340 char *safe_string
= (char *) alloca ((strlen (sndbuf
) * 4) + 1);
341 monitor_printable_string (safe_string
, sndbuf
);
342 printf ("sent[%s]\n", safe_string
);
345 monitor_write (sndbuf
, len
);
348 /* monitor_printf -- Send data to monitor and check the echo. Works just like
352 monitor_printf (char *pattern
,...)
358 va_start (args
, pattern
);
360 monitor_vsprintf (sndbuf
, pattern
, args
);
362 len
= strlen (sndbuf
);
363 if (len
+ 1 > sizeof sndbuf
)
367 if (remote_debug
> 0)
368 puts_debug ("sent -->", sndbuf
, "<--");
373 char *safe_string
= (char *) alloca ((len
* 4) + 1);
374 monitor_printable_string (safe_string
, sndbuf
);
375 printf ("sent[%s]\n", safe_string
);
378 monitor_write (sndbuf
, len
);
380 /* We used to expect that the next immediate output was the characters we
381 just output, but sometimes some extra junk appeared before the characters
382 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
383 So, just start searching for what we sent, and skip anything unknown. */
384 RDEBUG (("ExpectEcho\n"))
385 monitor_expect (sndbuf
, (char *) 0, 0);
389 /* Write characters to the remote system. */
392 monitor_write (buf
, buflen
)
396 if (SERIAL_WRITE (monitor_desc
, buf
, buflen
))
397 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n",
398 safe_strerror (errno
));
402 /* Read a binary character from the remote system, doing all the fancy
403 timeout stuff, but without interpreting the character in any way,
404 and without printing remote debug information. */
415 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
418 c
&= 0xff; /* don't lose bit 7 */
425 if (c
== SERIAL_TIMEOUT
)
426 error ("Timeout reading from remote system.");
428 perror_with_name ("remote-monitor");
432 /* Read a character from the remote system, doing all the fancy
442 last_random
, last_nl
, last_cr
, last_crnl
450 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
455 /* This seems to interfere with proper function of the
457 if (remote_debug
> 0)
462 puts_debug ("read -->", buf
, "<--");
467 /* Canonicialize \n\r combinations into one \r */
468 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
470 if ((c
== '\r' && state
== last_nl
)
471 || (c
== '\n' && state
== last_cr
))
492 if (c
== SERIAL_TIMEOUT
)
494 /* I fail to see how detaching here can be useful */
495 if (in_monitor_wait
) /* Watchdog went off */
497 target_mourn_inferior ();
498 error ("GDB serial timeout has expired. Target detached.\n");
502 error ("Timeout reading from remote system.");
504 perror_with_name ("remote-monitor");
507 /* Scan input from the remote system, until STRING is found. If BUF is non-
508 zero, then collect input until we have collected either STRING or BUFLEN-1
509 chars. In either case we terminate BUF with a 0. If input overflows BUF
510 because STRING can't be found, return -1, else return number of chars in BUF
511 (minus the terminating NUL). Note that in the non-overflow case, STRING
512 will be at the end of BUF. */
515 monitor_expect (string
, buf
, buflen
)
521 int obuflen
= buflen
;
523 extern struct target_ops
*targ_ops
;
528 char *safe_string
= (char *) alloca ((strlen (string
) * 4) + 1);
529 monitor_printable_string (safe_string
, string
);
530 printf ("MON Expecting '%s'\n", safe_string
);
545 c
= readchar (timeout
);
552 c
= readchar (timeout
);
554 /* Don't expect any ^C sent to be echoed */
556 if (*p
== '\003' || c
== *p
)
566 return obuflen
- buflen
;
572 else if ((c
== '\021' || c
== '\023') &&
573 (STREQ (targ_ops
->to_shortname
, "m32r")
574 || STREQ (targ_ops
->to_shortname
, "mon2000")))
575 { /* m32r monitor emits random DC1/DC3 chars */
580 /* We got a character that doesn't match the string. We need to
581 back up p, but how far? If we're looking for "..howdy" and the
582 monitor sends "...howdy"? There's certainly a match in there,
583 but when we receive the third ".", we won't find it if we just
584 restart the matching at the beginning of the string.
586 This is a Boyer-Moore kind of situation. We want to reset P to
587 the end of the longest prefix of STRING that is a suffix of
588 what we've read so far. In the example above, that would be
589 ".." --- the longest prefix of "..howdy" that is a suffix of
590 "...". This longest prefix could be the empty string, if C
591 is nowhere to be found in STRING.
593 If this longest prefix is not the empty string, it must contain
594 C, so let's search from the end of STRING for instances of C,
595 and see if the portion of STRING before that is a suffix of
596 what we read before C. Actually, we can search backwards from
597 p, since we know no prefix can be longer than that.
599 Note that we can use STRING itself, along with C, as a record
600 of what we've received so far. :) */
603 for (i
= (p
- string
) - 1; i
>= 0; i
--)
606 /* Is this prefix a suffix of what we've read so far?
608 string[0 .. i-1] == string[p - i, p - 1]? */
609 if (! memcmp (string
, p
- i
, i
))
621 /* Search for a regexp. */
624 monitor_expect_regexp (pat
, buf
, buflen
)
625 struct re_pattern_buffer
*pat
;
631 RDEBUG (("MON Expecting regexp\n"));
636 mybuf
= alloca (TARGET_BUF_SIZE
);
637 buflen
= TARGET_BUF_SIZE
;
645 if (p
- mybuf
>= buflen
)
646 { /* Buffer about to overflow */
648 /* On overflow, we copy the upper half of the buffer to the lower half. Not
649 great, but it usually works... */
651 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
652 p
= mybuf
+ buflen
/ 2;
655 *p
++ = readchar (timeout
);
657 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
663 /* Keep discarding input until we see the MONITOR prompt.
665 The convention for dealing with the prompt is that you
667 o *then* wait for the prompt.
669 Thus the last thing that a procedure does with the serial line will
670 be an monitor_expect_prompt(). Exception: monitor_resume does not
671 wait for the prompt, because the terminal is being handed over to
672 the inferior. However, the next thing which happens after that is
673 a monitor_wait which does wait for the prompt. Note that this
674 includes abnormal exit, e.g. error(). This is necessary to prevent
675 getting into states from which we can't recover. */
678 monitor_expect_prompt (buf
, buflen
)
682 RDEBUG (("MON Expecting prompt\n"))
683 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
686 /* Get N 32-bit words from remote, each preceded by a space, and put
687 them in registers starting at REGNO. */
698 ch
= readchar (timeout
);
699 while (isspace (ch
));
703 for (i
= 7; i
>= 1; i
--)
705 ch
= readchar (timeout
);
708 val
= (val
<< 4) | from_hex (ch
);
716 compile_pattern (pattern
, compiled_pattern
, fastmap
)
718 struct re_pattern_buffer
*compiled_pattern
;
724 compiled_pattern
->fastmap
= fastmap
;
726 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
727 val
= re_compile_pattern (pattern
,
733 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
736 re_compile_fastmap (compiled_pattern
);
739 /* Open a connection to a remote debugger. NAME is the filename used
740 for communication. */
743 monitor_open (args
, mon_ops
, from_tty
)
745 struct monitor_ops
*mon_ops
;
751 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
752 error ("Magic number of monitor_ops struct wrong.");
754 targ_ops
= mon_ops
->target
;
755 name
= targ_ops
->to_shortname
;
758 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
759 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
761 target_preopen (from_tty
);
763 /* Setup pattern for register dump */
765 if (mon_ops
->register_pattern
)
766 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
769 if (mon_ops
->getmem
.resp_delim
)
770 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
771 getmem_resp_delim_fastmap
);
773 unpush_target (targ_ops
);
777 dev_name
= strsave (args
);
779 monitor_desc
= SERIAL_OPEN (dev_name
);
782 perror_with_name (dev_name
);
786 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
788 SERIAL_CLOSE (monitor_desc
);
789 perror_with_name (dev_name
);
793 SERIAL_RAW (monitor_desc
);
795 SERIAL_FLUSH_INPUT (monitor_desc
);
797 /* some systems only work with 2 stop bits */
799 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
801 current_monitor
= mon_ops
;
803 /* See if we can wake up the monitor. First, try sending a stop sequence,
804 then send the init strings. Last, remove all breakpoints. */
806 if (current_monitor
->stop
)
809 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
811 RDEBUG (("EXP Open echo\n"));
812 monitor_expect_prompt (NULL
, 0);
816 /* wake up the monitor and see if it's alive */
817 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
819 /* Some of the characters we send may not be echoed,
820 but we hope to get a prompt at the end of it all. */
822 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
825 monitor_printf_noecho (*p
);
826 monitor_expect_prompt (NULL
, 0);
829 SERIAL_FLUSH_INPUT (monitor_desc
);
831 /* Alloc breakpoints */
832 if (mon_ops
->set_break
!= NULL
)
834 if (mon_ops
->num_breakpoints
== 0)
835 mon_ops
->num_breakpoints
= 8;
837 breakaddr
= (CORE_ADDR
*) xmalloc (mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
838 memset (breakaddr
, 0, mon_ops
->num_breakpoints
* sizeof (CORE_ADDR
));
841 /* Remove all breakpoints */
843 if (mon_ops
->clr_all_break
)
845 monitor_printf (mon_ops
->clr_all_break
);
846 monitor_expect_prompt (NULL
, 0);
850 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
852 push_target (targ_ops
);
854 inferior_pid
= 42000; /* Make run command think we are busy... */
856 /* Give monitor_wait something to read */
858 monitor_printf (current_monitor
->line_term
);
860 if (current_monitor
->flags
& MO_HAS_BLOCKWRITES
)
861 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory_block
);
863 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
867 /* Close out all files and local state before this target loses
871 monitor_close (quitting
)
875 SERIAL_CLOSE (monitor_desc
);
877 /* Free breakpoint memory */
878 if (breakaddr
!= NULL
)
887 /* Terminate the open connection to the remote debugger. Use this
888 when you want to detach and do something else with your gdb. */
891 monitor_detach (args
, from_tty
)
895 pop_target (); /* calls monitor_close to do the real work */
897 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
900 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
903 monitor_supply_register (regno
, valstr
)
908 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
912 while (p
&& *p
!= '\0')
914 if (*p
== '\r' || *p
== '\n')
925 if (!isxdigit (*p
) && *p
!= 'x')
931 val
+= fromhex (*p
++);
933 RDEBUG (("Supplying Register %d %s\n", regno
, valstr
));
936 error ("monitor_supply_register (%d): bad value from monitor: %s.",
939 /* supply register stores in target byte order, so swap here */
941 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
943 supply_register (regno
, regbuf
);
948 /* Tell the remote machine to resume. */
951 flush_monitor_dcache ()
953 dcache_flush (remote_dcache
);
957 monitor_resume (pid
, step
, sig
)
959 enum target_signal sig
;
961 /* Some monitors require a different command when starting a program */
962 RDEBUG (("MON resume\n"));
963 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
966 monitor_printf ("run\r");
967 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
971 dcache_flush (remote_dcache
);
973 monitor_printf (current_monitor
->step
);
976 if (current_monitor
->continue_hook
)
977 (*current_monitor
->continue_hook
) ();
979 monitor_printf (current_monitor
->cont
);
980 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
985 /* Parse the output of a register dump command. A monitor specific
986 regexp is used to extract individual register descriptions of the
987 form REG=VAL. Each description is split up into a name and a value
988 string which are passed down to monitor specific code. */
991 parse_register_dump (buf
, len
)
995 RDEBUG (("MON Parsing register dump\n"))
998 int regnamelen
, vallen
;
1000 /* Element 0 points to start of register name, and element 1
1001 points to the start of the register value. */
1002 struct re_registers register_strings
;
1004 memset (®ister_strings
, 0, sizeof (struct re_registers
));
1006 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
1007 ®ister_strings
) == -1)
1010 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
1011 regname
= buf
+ register_strings
.start
[1];
1012 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
1013 val
= buf
+ register_strings
.start
[2];
1015 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
1017 buf
+= register_strings
.end
[0];
1018 len
-= register_strings
.end
[0];
1022 /* Send ^C to target to halt it. Target will respond, and send us a
1026 monitor_interrupt (signo
)
1029 /* If this doesn't work, try more severe steps. */
1030 signal (signo
, monitor_interrupt_twice
);
1033 printf_unfiltered ("monitor_interrupt called\n");
1038 /* The user typed ^C twice. */
1041 monitor_interrupt_twice (signo
)
1044 signal (signo
, ofunc
);
1046 monitor_interrupt_query ();
1048 signal (signo
, monitor_interrupt
);
1051 /* Ask the user what to do when an interrupt is received. */
1054 monitor_interrupt_query ()
1056 target_terminal_ours ();
1058 if (query ("Interrupted while waiting for the program.\n\
1059 Give up (and stop debugging it)? "))
1061 target_mourn_inferior ();
1062 return_to_top_level (RETURN_QUIT
);
1065 target_terminal_inferior ();
1069 monitor_wait_cleanup (old_timeout
)
1072 timeout
= *(int *) old_timeout
;
1073 signal (SIGINT
, ofunc
);
1074 in_monitor_wait
= 0;
1080 monitor_wait_filter (char *buf
,
1083 struct target_waitstatus
*status
1089 resp_len
= monitor_expect_prompt (buf
, bufmax
);
1090 *ext_resp_len
= resp_len
;
1093 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1095 while (resp_len
< 0);
1097 /* Print any output characters that were preceded by ^O. */
1098 /* FIXME - This would be great as a user settabgle flag */
1100 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1104 for (i
= 0; i
< resp_len
- 1; i
++)
1106 putchar_unfiltered (buf
[++i
]);
1112 /* Wait until the remote machine stops, then return, storing status in
1113 status just as `wait' would. */
1116 monitor_wait (pid
, status
)
1118 struct target_waitstatus
*status
;
1120 int old_timeout
= timeout
;
1121 char buf
[TARGET_BUF_SIZE
];
1123 struct cleanup
*old_chain
;
1125 status
->kind
= TARGET_WAITKIND_EXITED
;
1126 status
->value
.integer
= 0;
1128 old_chain
= make_cleanup (monitor_wait_cleanup
, &old_timeout
);
1129 RDEBUG (("MON wait\n"))
1132 /* This is somthing other than a maintenance command */
1133 in_monitor_wait
= 1;
1134 timeout
= watchdog
> 0 ? watchdog
: -1;
1136 timeout
= -1; /* Don't time out -- user program is running. */
1139 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
1141 if (current_monitor
->wait_filter
)
1142 (*current_monitor
->wait_filter
) (buf
, sizeof (buf
), &resp_len
, status
);
1144 monitor_wait_filter (buf
, sizeof (buf
), &resp_len
, status
);
1146 #if 0 /* Transferred to monitor wait filter */
1149 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1152 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
1154 while (resp_len
< 0);
1156 /* Print any output characters that were preceded by ^O. */
1157 /* FIXME - This would be great as a user settabgle flag */
1159 current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
1163 for (i
= 0; i
< resp_len
- 1; i
++)
1165 putchar_unfiltered (buf
[++i
]);
1169 signal (SIGINT
, ofunc
);
1171 timeout
= old_timeout
;
1173 if (dump_reg_flag
&& current_monitor
->dump_registers
)
1176 monitor_printf (current_monitor
->dump_registers
);
1177 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1180 if (current_monitor
->register_pattern
)
1181 parse_register_dump (buf
, resp_len
);
1183 RDEBUG (("Wait fetching registers after stop\n"));
1184 monitor_dump_regs ();
1187 status
->kind
= TARGET_WAITKIND_STOPPED
;
1188 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
1190 discard_cleanups (old_chain
);
1192 in_monitor_wait
= 0;
1194 return inferior_pid
;
1197 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1201 monitor_fetch_register (regno
)
1205 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] =
1207 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
1210 name
= current_monitor
->regnames
[regno
];
1211 RDEBUG (("MON fetchreg %d '%s'\n", regno
, name
? name
: "(null name)"))
1213 if (!name
|| (*name
== '\0'))
1215 RDEBUG (("No register known for %d\n", regno
))
1216 supply_register (regno
, zerobuf
);
1220 /* send the register examine command */
1222 monitor_printf (current_monitor
->getreg
.cmd
, name
);
1224 /* If RESP_DELIM is specified, we search for that as a leading
1225 delimiter for the register value. Otherwise, we just start
1226 searching from the start of the buf. */
1228 if (current_monitor
->getreg
.resp_delim
)
1230 RDEBUG (("EXP getreg.resp_delim\n"))
1231 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1232 /* Handle case of first 32 registers listed in pairs. */
1233 if (current_monitor
->flags
& MO_32_REGS_PAIRED
1234 && (regno
& 1) != 0 && regno
< 32)
1236 RDEBUG (("EXP getreg.resp_delim\n"));
1237 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
1241 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1242 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1245 c
= readchar (timeout
);
1247 c
= readchar (timeout
);
1248 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1251 error ("Bad value returned from monitor while fetching register %x.",
1255 /* Read upto the maximum number of hex digits for this register, skipping
1256 spaces, but stop reading if something else is seen. Some monitors
1257 like to drop leading zeros. */
1259 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
1262 c
= readchar (timeout
);
1264 c
= readchar (timeout
);
1272 regbuf
[i
] = '\000'; /* terminate the number */
1273 RDEBUG (("REGVAL '%s'\n", regbuf
));
1275 /* If TERM is present, we wait for that to show up. Also, (if TERM
1276 is present), we will send TERM_CMD if that is present. In any
1277 case, we collect all of the output into buf, and then wait for
1278 the normal prompt. */
1280 if (current_monitor
->getreg
.term
)
1282 RDEBUG (("EXP getreg.term\n"))
1283 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
1286 if (current_monitor
->getreg
.term_cmd
)
1288 RDEBUG (("EMIT getreg.term.cmd\n"))
1289 monitor_printf (current_monitor
->getreg
.term_cmd
);
1291 if (!current_monitor
->getreg
.term
|| /* Already expected or */
1292 current_monitor
->getreg
.term_cmd
) /* ack expected */
1293 monitor_expect_prompt (NULL
, 0); /* get response */
1295 monitor_supply_register (regno
, regbuf
);
1298 /* Sometimes, it takes several commands to dump the registers */
1299 /* This is a primitive for use by variations of monitor interfaces in
1300 case they need to compose the operation.
1303 monitor_dump_reg_block (char *block_cmd
)
1305 char buf
[TARGET_BUF_SIZE
];
1307 monitor_printf (block_cmd
);
1308 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1309 parse_register_dump (buf
, resp_len
);
1314 /* Read the remote registers into the block regs. */
1315 /* Call the specific function if it has been provided */
1318 monitor_dump_regs ()
1320 char buf
[TARGET_BUF_SIZE
];
1322 if (current_monitor
->dumpregs
)
1323 (*(current_monitor
->dumpregs
)) (); /* call supplied function */
1324 else if (current_monitor
->dump_registers
) /* default version */
1326 monitor_printf (current_monitor
->dump_registers
);
1327 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
1328 parse_register_dump (buf
, resp_len
);
1331 abort (); /* Need some way to read registers */
1335 monitor_fetch_registers (regno
)
1338 RDEBUG (("MON fetchregs\n"));
1339 if (current_monitor
->getreg
.cmd
)
1343 monitor_fetch_register (regno
);
1347 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1348 monitor_fetch_register (regno
);
1352 monitor_dump_regs ();
1356 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1359 monitor_store_register (regno
)
1365 name
= current_monitor
->regnames
[regno
];
1366 if (!name
|| (*name
== '\0'))
1368 RDEBUG (("MON Cannot store unknown register\n"))
1372 val
= read_register (regno
);
1373 RDEBUG (("MON storeg %d %08lx\n", regno
, (ULONGEST
) val
))
1375 /* send the register deposit command */
1377 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
1378 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
1379 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1380 monitor_printf (current_monitor
->setreg
.cmd
, name
);
1382 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
1384 if (current_monitor
->setreg
.term
)
1386 RDEBUG (("EXP setreg.term\n"))
1387 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
1388 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
1389 monitor_printf ("%A\r", val
);
1390 monitor_expect_prompt (NULL
, 0);
1393 monitor_expect_prompt (NULL
, 0);
1394 if (current_monitor
->setreg
.term_cmd
) /* Mode exit required */
1396 RDEBUG (("EXP setreg_termcmd\n"));
1397 monitor_printf ("%s", current_monitor
->setreg
.term_cmd
);
1398 monitor_expect_prompt (NULL
, 0);
1400 } /* monitor_store_register */
1402 /* Store the remote registers. */
1405 monitor_store_registers (regno
)
1410 monitor_store_register (regno
);
1414 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1415 monitor_store_register (regno
);
1418 /* Get ready to modify the registers array. On machines which store
1419 individual registers, this doesn't need to do anything. On machines
1420 which store all the registers in one fell swoop, this makes sure
1421 that registers contains all the registers from the program being
1425 monitor_prepare_to_store ()
1427 /* Do nothing, since we can store individual regs */
1431 monitor_files_info (ops
)
1432 struct target_ops
*ops
;
1434 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1438 monitor_write_memory (memaddr
, myaddr
, len
)
1443 unsigned int val
, hostval
;
1447 RDEBUG (("MON write %d %08x\n", len
, (unsigned long) memaddr
))
1449 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1450 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1452 /* Use memory fill command for leading 0 bytes. */
1454 if (current_monitor
->fill
)
1456 for (i
= 0; i
< len
; i
++)
1460 if (i
> 4) /* More than 4 zeros is worth doing */
1462 RDEBUG (("MON FILL %d\n", i
))
1463 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1464 monitor_printf (current_monitor
->fill
, memaddr
, (memaddr
+ i
) - 1, 0);
1466 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1468 monitor_expect_prompt (NULL
, 0);
1475 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1476 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1479 cmd
= current_monitor
->setmem
.cmdll
;
1483 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1486 cmd
= current_monitor
->setmem
.cmdl
;
1488 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1491 cmd
= current_monitor
->setmem
.cmdw
;
1496 cmd
= current_monitor
->setmem
.cmdb
;
1499 val
= extract_unsigned_integer (myaddr
, len
);
1503 hostval
= *(unsigned int *) myaddr
;
1504 RDEBUG (("Hostval(%08x) val(%08x)\n", hostval
, val
));
1508 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1509 monitor_printf_noecho (cmd
, memaddr
, val
);
1510 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1513 monitor_printf_noecho (cmd
, memaddr
);
1515 if (current_monitor
->setmem
.term
)
1517 RDEBUG (("EXP setmem.term"));
1518 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1519 monitor_printf ("%x\r", val
);
1521 if (current_monitor
->setmem
.term_cmd
)
1522 { /* Emit this to get out of the memory editing state */
1523 monitor_printf ("%s", current_monitor
->setmem
.term_cmd
);
1524 /* Drop through to expecting a prompt */
1528 monitor_printf (cmd
, memaddr
, val
);
1530 monitor_expect_prompt (NULL
, 0);
1537 monitor_write_even_block (memaddr
, myaddr
, len
)
1544 /* Enter the sub mode */
1545 monitor_printf (current_monitor
->setmem
.cmdl
, memaddr
);
1546 monitor_expect_prompt (NULL
, 0);
1550 val
= extract_unsigned_integer (myaddr
, 4); /* REALLY */
1551 monitor_printf ("%x\r", val
);
1555 RDEBUG ((" @ %08x\n", memaddr
))
1556 /* If we wanted to, here we could validate the address */
1557 monitor_expect_prompt (NULL
, 0);
1559 /* Now exit the sub mode */
1560 monitor_printf (current_monitor
->getreg
.term_cmd
);
1561 monitor_expect_prompt (NULL
, 0);
1567 monitor_write_memory_bytes (memaddr
, myaddr
, len
)
1576 /* Enter the sub mode */
1577 monitor_printf (current_monitor
->setmem
.cmdb
, memaddr
);
1578 monitor_expect_prompt (NULL
, 0);
1582 monitor_printf ("%x\r", val
);
1586 /* If we wanted to, here we could validate the address */
1587 monitor_expect_prompt (NULL
, 0);
1590 /* Now exit the sub mode */
1591 monitor_printf (current_monitor
->getreg
.term_cmd
);
1592 monitor_expect_prompt (NULL
, 0);
1598 longlongendswap (unsigned char *a
)
1607 *(a
+ i
) = *(a
+ j
);
1612 /* Format 32 chars of long long value, advance the pointer */
1613 static char *hexlate
= "0123456789abcdef";
1615 longlong_hexchars (unsigned long long value
,
1625 static unsigned char disbuf
[8]; /* disassembly buffer */
1626 unsigned char *scan
, *limit
; /* loop controls */
1627 unsigned char c
, nib
;
1632 unsigned long long *dp
;
1633 dp
= (unsigned long long *) scan
;
1636 longlongendswap (disbuf
); /* FIXME: ONly on big endian hosts */
1637 while (scan
< limit
)
1639 c
= *scan
++; /* a byte of our long long value */
1645 leadzero
= 0; /* henceforth we print even zeroes */
1647 nib
= c
>> 4; /* high nibble bits */
1648 *outbuff
++ = hexlate
[nib
];
1649 nib
= c
& 0x0f; /* low nibble bits */
1650 *outbuff
++ = hexlate
[nib
];
1654 } /* longlong_hexchars */
1658 /* I am only going to call this when writing virtual byte streams.
1659 Which possably entails endian conversions
1662 monitor_write_memory_longlongs (memaddr
, myaddr
, len
)
1667 static char hexstage
[20]; /* At least 16 digits required, plus null */
1672 llptr
= (unsigned long long *) myaddr
;
1675 monitor_printf (current_monitor
->setmem
.cmdll
, memaddr
);
1676 monitor_expect_prompt (NULL
, 0);
1680 endstring
= longlong_hexchars (*llptr
, hexstage
);
1681 *endstring
= '\0'; /* NUll terminate for printf */
1682 monitor_printf ("%s\r", hexstage
);
1686 /* If we wanted to, here we could validate the address */
1687 monitor_expect_prompt (NULL
, 0);
1690 /* Now exit the sub mode */
1691 monitor_printf (current_monitor
->getreg
.term_cmd
);
1692 monitor_expect_prompt (NULL
, 0);
1698 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1699 /* This is for the large blocks of memory which may occur in downloading.
1700 And for monitors which use interactive entry,
1701 And for monitors which do not have other downloading methods.
1702 Without this, we will end up calling monitor_write_memory many times
1703 and do the entry and exit of the sub mode many times
1704 This currently assumes...
1705 MO_SETMEM_INTERACTIVE
1706 ! MO_NO_ECHO_ON_SETMEM
1707 To use this, the you have to patch the monitor_cmds block with
1708 this function. Otherwise, its not tuned up for use by all
1713 monitor_write_memory_block (memaddr
, myaddr
, len
)
1720 /* FIXME: This would be a good place to put the zero test */
1722 if ((len
> 8) && (((len
& 0x07)) == 0) && current_monitor
->setmem
.cmdll
)
1724 return monitor_write_memory_longlongs (memaddr
, myaddr
, len
);
1731 written
= monitor_write_even_block (memaddr
, myaddr
, len
);
1732 /* Adjust calling parameters by written amount */
1738 written
= monitor_write_memory_bytes (memaddr
, myaddr
, len
);
1742 /* This is an alternate form of monitor_read_memory which is used for monitors
1743 which can only read a single byte/word/etc. at a time. */
1746 monitor_read_memory_single (memaddr
, myaddr
, len
)
1752 char membuf
[sizeof (int) * 2 + 1];
1757 RDEBUG (("MON read single\n"));
1759 /* Can't actually use long longs (nice idea, though). In fact, the
1760 call to strtoul below will fail if it tries to convert a value
1761 that's too big to fit in a long. */
1762 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1765 cmd
= current_monitor
->getmem
.cmdll
;
1769 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1772 cmd
= current_monitor
->getmem
.cmdl
;
1774 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1777 cmd
= current_monitor
->getmem
.cmdw
;
1782 cmd
= current_monitor
->getmem
.cmdb
;
1785 /* Send the examine command. */
1787 monitor_printf (cmd
, memaddr
);
1789 /* If RESP_DELIM is specified, we search for that as a leading
1790 delimiter for the memory value. Otherwise, we just start
1791 searching from the start of the buf. */
1793 if (current_monitor
->getmem
.resp_delim
)
1795 RDEBUG (("EXP getmem.resp_delim\n"));
1796 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1799 /* Now, read the appropriate number of hex digits for this loc,
1802 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1803 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1807 c
= readchar (timeout
);
1809 c
= readchar (timeout
);
1810 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1813 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1814 memaddr
, i
, membuf
, c
);
1816 for (i
= 0; i
< len
* 2; i
++)
1822 c
= readchar (timeout
);
1828 monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1829 memaddr
, i
, membuf
, c
);
1835 membuf
[i
] = '\000'; /* terminate the number */
1837 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1838 present), we will send TERM_CMD if that is present. In any case, we collect
1839 all of the output into buf, and then wait for the normal prompt. */
1841 if (current_monitor
->getmem
.term
)
1843 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1845 if (current_monitor
->getmem
.term_cmd
)
1847 monitor_printf (current_monitor
->getmem
.term_cmd
);
1848 monitor_expect_prompt (NULL
, 0);
1852 monitor_expect_prompt (NULL
, 0); /* get response */
1855 val
= strtoul (membuf
, &p
, 16);
1857 if (val
== 0 && membuf
== p
)
1858 monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1859 memaddr
, 0, membuf
, 0);
1861 /* supply register stores in target byte order, so swap here */
1863 store_unsigned_integer (myaddr
, len
, val
);
1868 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1869 memory at MEMADDR. Returns length moved. Currently, we do no more
1870 than 16 bytes at a time. */
1873 monitor_read_memory (memaddr
, myaddr
, len
)
1887 RDEBUG (("Zero length call to monitor_read_memory\n"));
1892 printf ("MON read block ta(%08x) ha(%08x) %d\n",
1893 (unsigned long) memaddr
, (unsigned long) myaddr
, len
);
1895 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1896 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1898 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1899 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1901 len
= min (len
, 16);
1903 /* Some dumpers align the first data with the preceeding 16
1904 byte boundary. Some print blanks and start at the
1905 requested boundary. EXACT_DUMPADDR
1908 dumpaddr
= (current_monitor
->flags
& MO_EXACT_DUMPADDR
)
1909 ? memaddr
: memaddr
& ~0x0f;
1911 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1912 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1913 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1915 /* send the memory examine command */
1917 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1918 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
);
1919 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1920 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1922 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1924 /* If TERM is present, we wait for that to show up. Also, (if TERM
1925 is present), we will send TERM_CMD if that is present. In any
1926 case, we collect all of the output into buf, and then wait for
1927 the normal prompt. */
1929 if (current_monitor
->getmem
.term
)
1931 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1934 monitor_error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1935 memaddr
, resp_len
, buf
, 0);
1937 if (current_monitor
->getmem
.term_cmd
)
1939 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1940 strlen (current_monitor
->getmem
.term_cmd
));
1941 monitor_expect_prompt (NULL
, 0);
1945 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1949 /* If RESP_DELIM is specified, we search for that as a leading
1950 delimiter for the values. Otherwise, we just start searching
1951 from the start of the buf. */
1953 if (current_monitor
->getmem
.resp_delim
)
1956 struct re_registers resp_strings
;
1957 RDEBUG (("MON getmem.resp_delim %s\n", current_monitor
->getmem
.resp_delim
));
1959 memset (&resp_strings
, 0, sizeof (struct re_registers
));
1961 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1965 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1966 memaddr
, resp_len
, buf
, 0);
1968 p
+= resp_strings
.end
[0];
1970 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1972 monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1973 memaddr
, resp_len
, buf
, 0);
1974 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1978 printf ("MON scanning %d ,%08x '%s'\n", len
, p
, p
);
1979 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1987 while (!(c
== '\000' || c
== '\n' || c
== '\r') && i
> 0)
1991 if ((dumpaddr
>= memaddr
) && (i
> 0))
1993 val
= fromhex (c
) * 16 + fromhex (*(p
+ 1));
1996 printf ("[%02x]", val
);
2003 ++p
; /* skip a blank or other non hex char */
2007 error ("Failed to read via monitor");
2010 return fetched
; /* Return the number of bytes actually read */
2012 RDEBUG (("MON scanning bytes\n"));
2014 for (i
= len
; i
> 0; i
--)
2016 /* Skip non-hex chars, but bomb on end of string and newlines */
2023 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
2024 monitor_error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s",
2025 memaddr
, resp_len
, buf
, 0);
2029 val
= strtoul (p
, &p1
, 16);
2031 if (val
== 0 && p
== p1
)
2032 monitor_error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.",
2033 memaddr
, resp_len
, buf
, 0);
2047 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
2052 struct target_ops
*target
; /* ignored */
2054 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
2060 return; /* ignore attempts to kill target system */
2063 /* All we actually do is set the PC to the start address of exec_bfd, and start
2064 the program at that point. */
2067 monitor_create_inferior (exec_file
, args
, env
)
2072 if (args
&& (*args
!= '\000'))
2073 error ("Args are not supported by the monitor.");
2076 clear_proceed_status ();
2077 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
2080 /* Clean up when a program exits.
2081 The program actually lives on in the remote processor's RAM, and may be
2082 run again without a download. Don't leave it full of breakpoint
2086 monitor_mourn_inferior ()
2088 unpush_target (targ_ops
);
2089 generic_mourn_inferior (); /* Do all the proper things now */
2092 /* Tell the monitor to add a breakpoint. */
2095 monitor_insert_breakpoint (addr
, shadow
)
2103 RDEBUG (("MON inst bkpt %08x\n", addr
))
2104 if (current_monitor
->set_break
== NULL
)
2105 error ("No set_break defined for this monitor");
2107 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2108 addr
= ADDR_BITS_REMOVE (addr
);
2110 /* Determine appropriate breakpoint size for this address. */
2111 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
2113 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2115 if (breakaddr
[i
] == 0)
2117 breakaddr
[i
] = addr
;
2118 monitor_read_memory (addr
, shadow
, bplen
);
2119 monitor_printf (current_monitor
->set_break
, addr
);
2120 monitor_expect_prompt (NULL
, 0);
2125 error ("Too many breakpoints (> %d) for monitor.", current_monitor
->num_breakpoints
);
2128 /* Tell the monitor to remove a breakpoint. */
2131 monitor_remove_breakpoint (addr
, shadow
)
2137 RDEBUG (("MON rmbkpt %08x\n", addr
))
2138 if (current_monitor
->clr_break
== NULL
)
2139 error ("No clr_break defined for this monitor");
2141 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
2142 addr
= ADDR_BITS_REMOVE (addr
);
2144 for (i
= 0; i
< current_monitor
->num_breakpoints
; i
++)
2146 if (breakaddr
[i
] == addr
)
2149 /* some monitors remove breakpoints based on the address */
2150 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
2151 monitor_printf (current_monitor
->clr_break
, addr
);
2152 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
2153 monitor_printf (current_monitor
->clr_break
, i
+ 1);
2155 monitor_printf (current_monitor
->clr_break
, i
);
2156 monitor_expect_prompt (NULL
, 0);
2160 fprintf_unfiltered (gdb_stderr
,
2161 "Can't find breakpoint associated with 0x%x\n", addr
);
2165 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2166 an S-record. Return non-zero if the ACK is received properly. */
2169 monitor_wait_srec_ack ()
2173 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
2175 return (readchar (timeout
) == '+');
2177 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
2179 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
2180 if ((ch
= readchar (1)) < 0)
2182 if ((ch
= readchar (1)) < 0)
2184 if ((ch
= readchar (1)) < 0)
2186 if ((ch
= readchar (1)) < 0)
2192 /* monitor_load -- download a file. */
2195 monitor_load (file
, from_tty
)
2199 dcache_flush (remote_dcache
);
2200 RDEBUG (("MON load\n"))
2202 if (current_monitor
->load_routine
)
2203 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
2205 { /* The default is ascii S-records */
2207 unsigned long load_offset
;
2210 /* enable user to specify address for downloading as 2nd arg to load */
2211 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
2217 monitor_printf (current_monitor
->load
);
2218 if (current_monitor
->loadresp
)
2219 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
2221 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
2222 32, SREC_ALL
, hashmark
,
2223 current_monitor
->flags
& MO_SREC_ACK
?
2224 monitor_wait_srec_ack
: NULL
);
2226 monitor_expect_prompt (NULL
, 0);
2229 /* Finally, make the PC point at the start address */
2232 write_pc (bfd_get_start_address (exec_bfd
));
2234 inferior_pid
= 0; /* No process now */
2236 /* This is necessary because many things were based on the PC at the time that
2237 we attached to the monitor, which is no longer valid now that we have loaded
2238 new code (and just changed the PC). Another way to do this might be to call
2239 normal_stop, except that the stack may not be valid, and things would get
2240 horribly confused... */
2242 clear_symtab_users ();
2248 RDEBUG (("MON stop\n"));
2249 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
2250 SERIAL_SEND_BREAK (monitor_desc
);
2251 if (current_monitor
->stop
)
2252 monitor_printf_noecho (current_monitor
->stop
);
2255 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2256 in OUTPUT until the prompt is seen. FIXME: We read the characters
2257 ourseleves here cause of a nasty echo. */
2260 monitor_rcmd (char *command
,
2261 struct gdb_file
*outbuf
)
2267 if (monitor_desc
== NULL
)
2268 error ("monitor target not open.");
2270 p
= current_monitor
->prompt
;
2272 /* Send the command. Note that if no args were supplied, then we're
2273 just sending the monitor a newline, which is sometimes useful. */
2275 monitor_printf ("%s\r", (command
? command
: ""));
2277 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
2279 fputs_unfiltered (buf
, outbuf
); /* Output the response */
2282 /* Convert hex digit A to a number. */
2289 if (a
>= '0' && a
<= '9')
2291 if (a
>= 'a' && a
<= 'f')
2292 return a
- 'a' + 10;
2293 if (a
>= 'A' && a
<= 'F')
2294 return a
- 'A' + 10;
2296 error ("Reply contains invalid hex digit 0x%x", a
);
2301 monitor_get_dev_name ()
2306 static struct target_ops monitor_ops
;
2309 init_base_monitor_ops (void)
2311 monitor_ops
.to_shortname
= NULL
;
2312 monitor_ops
.to_longname
= NULL
;
2313 monitor_ops
.to_doc
= NULL
;
2314 monitor_ops
.to_open
= NULL
;
2315 monitor_ops
.to_close
= monitor_close
;
2316 monitor_ops
.to_attach
= NULL
;
2317 monitor_ops
.to_post_attach
= NULL
;
2318 monitor_ops
.to_require_attach
= NULL
;
2319 monitor_ops
.to_detach
= monitor_detach
;
2320 monitor_ops
.to_require_detach
= NULL
;
2321 monitor_ops
.to_resume
= monitor_resume
;
2322 monitor_ops
.to_wait
= monitor_wait
;
2323 monitor_ops
.to_post_wait
= NULL
;
2324 monitor_ops
.to_fetch_registers
= monitor_fetch_registers
;
2325 monitor_ops
.to_store_registers
= monitor_store_registers
;
2326 monitor_ops
.to_prepare_to_store
= monitor_prepare_to_store
;
2327 monitor_ops
.to_xfer_memory
= monitor_xfer_memory
;
2328 monitor_ops
.to_files_info
= monitor_files_info
;
2329 monitor_ops
.to_insert_breakpoint
= monitor_insert_breakpoint
;
2330 monitor_ops
.to_remove_breakpoint
= monitor_remove_breakpoint
;
2331 monitor_ops
.to_terminal_init
= 0;
2332 monitor_ops
.to_terminal_inferior
= 0;
2333 monitor_ops
.to_terminal_ours_for_output
= 0;
2334 monitor_ops
.to_terminal_ours
= 0;
2335 monitor_ops
.to_terminal_info
= 0;
2336 monitor_ops
.to_kill
= monitor_kill
;
2337 monitor_ops
.to_load
= monitor_load
;
2338 monitor_ops
.to_lookup_symbol
= 0;
2339 monitor_ops
.to_create_inferior
= monitor_create_inferior
;
2340 monitor_ops
.to_post_startup_inferior
= NULL
;
2341 monitor_ops
.to_acknowledge_created_inferior
= NULL
;
2342 monitor_ops
.to_clone_and_follow_inferior
= NULL
;
2343 monitor_ops
.to_post_follow_inferior_by_clone
= NULL
;
2344 monitor_ops
.to_insert_fork_catchpoint
= NULL
;
2345 monitor_ops
.to_remove_fork_catchpoint
= NULL
;
2346 monitor_ops
.to_insert_vfork_catchpoint
= NULL
;
2347 monitor_ops
.to_remove_vfork_catchpoint
= NULL
;
2348 monitor_ops
.to_has_forked
= NULL
;
2349 monitor_ops
.to_has_vforked
= NULL
;
2350 monitor_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2351 monitor_ops
.to_post_follow_vfork
= NULL
;
2352 monitor_ops
.to_insert_exec_catchpoint
= NULL
;
2353 monitor_ops
.to_remove_exec_catchpoint
= NULL
;
2354 monitor_ops
.to_has_execd
= NULL
;
2355 monitor_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2356 monitor_ops
.to_has_exited
= NULL
;
2357 monitor_ops
.to_mourn_inferior
= monitor_mourn_inferior
;
2358 monitor_ops
.to_can_run
= 0;
2359 monitor_ops
.to_notice_signals
= 0;
2360 monitor_ops
.to_thread_alive
= 0;
2361 monitor_ops
.to_stop
= monitor_stop
;
2362 monitor_ops
.to_rcmd
= monitor_rcmd
;
2363 monitor_ops
.to_pid_to_exec_file
= NULL
;
2364 monitor_ops
.to_core_file_to_sym_file
= NULL
;
2365 monitor_ops
.to_stratum
= process_stratum
;
2366 monitor_ops
.DONT_USE
= 0;
2367 monitor_ops
.to_has_all_memory
= 1;
2368 monitor_ops
.to_has_memory
= 1;
2369 monitor_ops
.to_has_stack
= 1;
2370 monitor_ops
.to_has_registers
= 1;
2371 monitor_ops
.to_has_execution
= 1;
2372 monitor_ops
.to_sections
= 0;
2373 monitor_ops
.to_sections_end
= 0;
2374 monitor_ops
.to_magic
= OPS_MAGIC
;
2375 } /* init_base_monitor_ops */
2377 /* Init the target_ops structure pointed at by OPS */
2380 init_monitor_ops (ops
)
2381 struct target_ops
*ops
;
2383 if (monitor_ops
.to_magic
!= OPS_MAGIC
)
2384 init_base_monitor_ops ();
2386 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
2389 /* Define additional commands that are usually only used by monitors. */
2392 _initialize_remote_monitors ()
2394 init_base_monitor_ops ();
2395 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
2397 "Set display of activity while downloading a file.\n\
2398 When enabled, a hashmark \'#\' is displayed.",