1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
5 Resurrected from the ashes by Stu Grossman.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 /* This file was derived from various remote-* modules. It is a collection
24 of generic support functions so GDB can talk directly to a ROM based
25 monitor. This saves use from having to hack an exception based handler
26 into existance, and makes for quick porting.
28 This module talks to a debug monitor called 'MONITOR', which
29 We communicate with MONITOR via either a direct serial line, or a TCP
30 (or possibly TELNET) stream to a terminal multiplexor,
31 which in turn talks to the target board. */
33 /* FIXME 32x64: This code assumes that registers and addresses are at
34 most 32 bits long. If they can be larger, you will need to declare
35 values as LONGEST and use %llx or some such to print values when
36 building commands to send to the monitor. Since we don't know of
37 any actual 64-bit targets with ROM monitors that use this code,
38 it's not an issue right now. -sts 4/18/96 */
44 #ifdef ANSI_PROTOTYPES
51 #include "gdb_string.h"
52 #include <sys/types.h>
58 #include "gnu-regex.h"
62 static char *dev_name
;
63 static struct target_ops
*targ_ops
;
65 static int readchar
PARAMS ((int timeout
));
67 static void monitor_command
PARAMS ((char *args
, int fromtty
));
69 static void monitor_fetch_register
PARAMS ((int regno
));
70 static void monitor_store_register
PARAMS ((int regno
));
72 static void monitor_detach
PARAMS ((char *args
, int from_tty
));
73 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
74 static void monitor_interrupt
PARAMS ((int signo
));
75 static void monitor_interrupt_twice
PARAMS ((int signo
));
76 static void monitor_interrupt_query
PARAMS ((void));
77 static void monitor_wait_cleanup
PARAMS ((int old_timeout
));
79 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
*status
));
80 static void monitor_fetch_registers
PARAMS ((int regno
));
81 static void monitor_store_registers
PARAMS ((int regno
));
82 static void monitor_prepare_to_store
PARAMS ((void));
83 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
*target
));
84 static void monitor_files_info
PARAMS ((struct target_ops
*ops
));
85 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
86 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
87 static void monitor_kill
PARAMS ((void));
88 static void monitor_load
PARAMS ((char *file
, int from_tty
));
89 static void monitor_mourn_inferior
PARAMS ((void));
90 static void monitor_stop
PARAMS ((void));
92 static int monitor_read_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
93 static int monitor_write_memory
PARAMS ((CORE_ADDR addr
, char *myaddr
,int len
));
95 static int monitor_expect_regexp
PARAMS ((struct re_pattern_buffer
*pat
,
96 char *buf
, int buflen
));
98 static int from_hex
PARAMS ((int a
));
99 static unsigned long get_hex_word
PARAMS ((void));
101 static void parse_register_dump
PARAMS ((char *, int));
103 static struct monitor_ops
*current_monitor
;
105 static int hashmark
; /* flag set by "set hash" */
107 static int timeout
= 30;
109 static int in_monitor_wait
= 0; /* Non-zero means we are in monitor_wait() */
111 static void (*ofunc
)(); /* Old SIGINT signal handler */
113 /* Descriptor for I/O to remote machine. Initialize it to NULL so
114 that monitor_open knows that we don't have a file open when the
117 static serial_t monitor_desc
= NULL
;
119 /* Pointer to regexp pattern matching data */
121 static struct re_pattern_buffer register_pattern
;
122 static char register_fastmap
[256];
124 static struct re_pattern_buffer getmem_resp_delim_pattern
;
125 static char getmem_resp_delim_fastmap
[256];
127 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
128 monitor_wait wakes up. */
130 static DCACHE
*remote_dcache
;
131 static int first_time
=0; /* is this the first time we're executing after
132 gaving created the child proccess? */
134 /* Convert hex digit A to a number. */
140 if (a
>= '0' && a
<= '9')
142 else if (a
>= 'a' && a
<= 'f')
145 error ("Invalid hex digit %d", a
);
148 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
149 Works just like printf. */
152 #ifdef ANSI_PROTOTYPES
153 monitor_printf_noecho (char *pattern
, ...)
155 monitor_printf_noecho (va_alist
)
164 va_start (args
, pattern
);
168 pattern
= va_arg (args
, char *);
171 vsprintf (sndbuf
, pattern
, args
);
173 if (remote_debug
> 0)
174 puts_debug ("sent -->", sndbuf
, "<--");
176 len
= strlen (sndbuf
);
178 if (len
+ 1 > sizeof sndbuf
)
181 if (SERIAL_WRITE(monitor_desc
, sndbuf
, len
))
182 fprintf_unfiltered (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
185 /* monitor_printf -- Send data to monitor and check the echo. Works just like
189 #ifdef ANSI_PROTOTYPES
190 monitor_printf (char *pattern
, ...)
192 monitor_printf (va_alist
)
200 #ifdef ANSI_PROTOTYPES
201 va_start (args
, pattern
);
205 pattern
= va_arg (args
, char *);
208 vsprintf (sndbuf
, pattern
, args
);
210 if (remote_debug
> 0)
211 puts_debug ("sent -->", sndbuf
, "<--");
213 len
= strlen (sndbuf
);
215 if (len
+ 1 > sizeof sndbuf
)
218 if (SERIAL_WRITE(monitor_desc
, sndbuf
, len
))
219 fprintf_unfiltered (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
221 /* We used to expect that the next immediate output was the characters we
222 just output, but sometimes some extra junk appeared before the characters
223 we expected, like an extra prompt, or a portmaster sending telnet negotiations.
224 So, just start searching for what we sent, and skip anything unknown. */
225 monitor_expect (sndbuf
, (char *)0, 0);
228 /* Read a character from the remote system, doing all the fancy
236 static enum { last_random
, last_nl
, last_cr
, last_crnl
} state
= last_random
;
242 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
247 if (remote_debug
> 0)
252 puts_debug ("read -->", buf
, "<--");
256 /* Canonicialize \n\r combinations into one \r */
257 if ((current_monitor
->flags
& MO_HANDLE_NL
) != 0)
259 if ((c
== '\r' && state
== last_nl
)
260 || (c
== '\n' && state
== last_cr
))
281 if (c
== SERIAL_TIMEOUT
)
282 #ifdef MAINTENANCE_CMDS
283 if (in_monitor_wait
) /* Watchdog went off */
285 target_mourn_inferior ();
286 error ("Watchdog has expired. Target detached.\n");
290 error ("Timeout reading from remote system.");
292 perror_with_name ("remote-monitor");
295 /* Scan input from the remote system, until STRING is found. If BUF is non-
296 zero, then collect input until we have collected either STRING or BUFLEN-1
297 chars. In either case we terminate BUF with a 0. If input overflows BUF
298 because STRING can't be found, return -1, else return number of chars in BUF
299 (minus the terminating NUL). Note that in the non-overflow case, STRING
300 will be at the end of BUF. */
303 monitor_expect (string
, buf
, buflen
)
309 int obuflen
= buflen
;
311 extern struct target_ops
*targ_ops
;
325 c
= readchar (timeout
);
332 c
= readchar (timeout
);
334 /* Don't expect any ^C sent to be echoed */
336 if (*p
== '\003' || c
== *p
)
346 return obuflen
- buflen
;
352 else if ((c
== '\021' || c
== '\023') &&
353 (strcmp(targ_ops
->to_shortname
, "m32r") == 0))
354 { /* m32r monitor emits random DC1/DC3 chars */
366 /* Search for a regexp. */
369 monitor_expect_regexp (pat
, buf
, buflen
)
370 struct re_pattern_buffer
*pat
;
381 mybuf
= alloca (1024);
390 if (p
- mybuf
>= buflen
)
391 { /* Buffer about to overflow */
393 /* On overflow, we copy the upper half of the buffer to the lower half. Not
394 great, but it usually works... */
396 memcpy (mybuf
, mybuf
+ buflen
/ 2, buflen
/ 2);
397 p
= mybuf
+ buflen
/ 2;
400 *p
++ = readchar (timeout
);
402 retval
= re_search (pat
, mybuf
, p
- mybuf
, 0, p
- mybuf
, NULL
);
408 /* Keep discarding input until we see the MONITOR prompt.
410 The convention for dealing with the prompt is that you
412 o *then* wait for the prompt.
414 Thus the last thing that a procedure does with the serial line will
415 be an monitor_expect_prompt(). Exception: monitor_resume does not
416 wait for the prompt, because the terminal is being handed over to
417 the inferior. However, the next thing which happens after that is
418 a monitor_wait which does wait for the prompt. Note that this
419 includes abnormal exit, e.g. error(). This is necessary to prevent
420 getting into states from which we can't recover. */
423 monitor_expect_prompt (buf
, buflen
)
427 return monitor_expect (current_monitor
->prompt
, buf
, buflen
);
430 /* Get N 32-bit words from remote, each preceded by a space, and put
431 them in registers starting at REGNO. */
442 ch
= readchar (timeout
);
447 for (i
= 7; i
>= 1; i
--)
449 ch
= readchar (timeout
);
452 val
= (val
<< 4) | from_hex (ch
);
460 compile_pattern (pattern
, compiled_pattern
, fastmap
)
462 struct re_pattern_buffer
*compiled_pattern
;
468 compiled_pattern
->fastmap
= fastmap
;
470 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
471 val
= re_compile_pattern (pattern
,
477 error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern
, val
);
480 re_compile_fastmap (compiled_pattern
);
483 /* Open a connection to a remote debugger. NAME is the filename used
484 for communication. */
487 monitor_open (args
, mon_ops
, from_tty
)
489 struct monitor_ops
*mon_ops
;
495 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
496 error ("Magic number of monitor_ops struct wrong.");
498 targ_ops
= mon_ops
->target
;
499 name
= targ_ops
->to_shortname
;
502 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
503 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
505 target_preopen (from_tty
);
507 /* Setup pattern for register dump */
509 if (mon_ops
->register_pattern
)
510 compile_pattern (mon_ops
->register_pattern
, ®ister_pattern
,
513 if (mon_ops
->getmem
.resp_delim
)
514 compile_pattern (mon_ops
->getmem
.resp_delim
, &getmem_resp_delim_pattern
,
515 getmem_resp_delim_fastmap
);
517 unpush_target (targ_ops
);
521 dev_name
= strsave (args
);
523 monitor_desc
= SERIAL_OPEN (dev_name
);
526 perror_with_name (dev_name
);
530 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
532 SERIAL_CLOSE (monitor_desc
);
533 perror_with_name (dev_name
);
537 SERIAL_RAW (monitor_desc
);
539 SERIAL_FLUSH_INPUT (monitor_desc
);
541 /* some systems only work with 2 stop bits */
543 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
545 current_monitor
= mon_ops
;
547 /* See if we can wake up the monitor. First, try sending a stop sequence,
548 then send the init strings. Last, remove all breakpoints. */
550 if (current_monitor
->stop
)
553 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
555 monitor_expect_prompt (NULL
, 0);
559 /* wake up the monitor and see if it's alive */
560 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
562 /* Some of the characters we send may not be echoed,
563 but we hope to get a prompt at the end of it all. */
565 if ((current_monitor
->flags
& MO_NO_ECHO_ON_OPEN
) == 0)
568 monitor_printf_noecho (*p
);
569 monitor_expect_prompt (NULL
, 0);
572 SERIAL_FLUSH_INPUT (monitor_desc
);
574 /* Remove all breakpoints */
576 if (mon_ops
->clr_all_break
)
578 monitor_printf (mon_ops
->clr_all_break
);
579 monitor_expect_prompt (NULL
, 0);
583 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
585 push_target (targ_ops
);
587 inferior_pid
= 42000; /* Make run command think we are busy... */
589 /* Give monitor_wait something to read */
591 monitor_printf (current_monitor
->line_term
);
593 remote_dcache
= dcache_init (monitor_read_memory
, monitor_write_memory
);
598 /* Close out all files and local state before this target loses
602 monitor_close (quitting
)
606 SERIAL_CLOSE (monitor_desc
);
610 /* Terminate the open connection to the remote debugger. Use this
611 when you want to detach and do something else with your gdb. */
614 monitor_detach (args
, from_tty
)
618 pop_target (); /* calls monitor_close to do the real work */
620 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
623 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
626 monitor_supply_register (regno
, valstr
)
631 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
634 val
= strtoul (valstr
, &p
, 16);
636 if (val
== 0 && valstr
== p
)
637 error ("monitor_supply_register (%d): bad value from monitor: %s.",
640 /* supply register stores in target byte order, so swap here */
642 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
644 supply_register (regno
, regbuf
);
649 /* Tell the remote machine to resume. */
652 monitor_resume (pid
, step
, sig
)
654 enum target_signal sig
;
656 /* Some monitors require a different command when starting a program */
657 if (current_monitor
->flags
& MO_RUN_FIRST_TIME
&& first_time
== 1)
660 monitor_printf ("run\r");
661 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
665 dcache_flush (remote_dcache
);
667 monitor_printf (current_monitor
->step
);
670 monitor_printf (current_monitor
->cont
);
671 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
676 /* Parse the output of a register dump command. A monitor specific
677 regexp is used to extract individual register descriptions of the
678 form REG=VAL. Each description is split up into a name and a value
679 string which are passed down to monitor specific code. */
682 parse_register_dump (buf
, len
)
688 int regnamelen
, vallen
;
690 /* Element 0 points to start of register name, and element 1
691 points to the start of the register value. */
692 struct re_registers register_strings
;
694 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
695 ®ister_strings
) == -1)
698 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
699 regname
= buf
+ register_strings
.start
[1];
700 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
701 val
= buf
+ register_strings
.start
[2];
703 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
705 buf
+= register_strings
.end
[0];
706 len
-= register_strings
.end
[0];
710 /* Send ^C to target to halt it. Target will respond, and send us a
714 monitor_interrupt (signo
)
717 /* If this doesn't work, try more severe steps. */
718 signal (signo
, monitor_interrupt_twice
);
721 printf_unfiltered ("monitor_interrupt called\n");
726 /* The user typed ^C twice. */
729 monitor_interrupt_twice (signo
)
732 signal (signo
, ofunc
);
734 monitor_interrupt_query ();
736 signal (signo
, monitor_interrupt
);
739 /* Ask the user what to do when an interrupt is received. */
742 monitor_interrupt_query ()
744 target_terminal_ours ();
746 if (query ("Interrupted while waiting for the program.\n\
747 Give up (and stop debugging it)? "))
749 target_mourn_inferior ();
750 return_to_top_level (RETURN_QUIT
);
753 target_terminal_inferior ();
757 monitor_wait_cleanup (old_timeout
)
760 timeout
= old_timeout
;
761 signal (SIGINT
, ofunc
);
765 /* Wait until the remote machine stops, then return, storing status in
766 status just as `wait' would. */
769 monitor_wait (pid
, status
)
771 struct target_waitstatus
*status
;
773 int old_timeout
= timeout
;
776 struct cleanup
*old_chain
;
778 status
->kind
= TARGET_WAITKIND_EXITED
;
779 status
->value
.integer
= 0;
781 old_chain
= make_cleanup (monitor_wait_cleanup
, old_timeout
);
783 #ifdef MAINTENANCE_CMDS
785 timeout
= watchdog
> 0 ? watchdog
: -1;
787 timeout
= -1; /* Don't time out -- user program is running. */
790 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
794 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
797 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
799 while (resp_len
< 0);
801 /* Print any output characters that were preceded by ^O. */
802 if (current_monitor
->flags
& MO_PRINT_PROGRAM_OUTPUT
)
806 for (i
= 0; i
< resp_len
- 1; i
++)
808 putchar_unfiltered (buf
[++i
]);
811 signal (SIGINT
, ofunc
);
813 timeout
= old_timeout
;
815 if (dump_reg_flag
&& current_monitor
->dump_registers
)
819 monitor_printf (current_monitor
->dump_registers
);
820 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
823 if (current_monitor
->register_pattern
)
824 parse_register_dump (buf
, resp_len
);
826 status
->kind
= TARGET_WAITKIND_STOPPED
;
827 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
829 discard_cleanups (old_chain
);
836 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
840 monitor_fetch_register (regno
)
844 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
845 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
848 name
= current_monitor
->regnames
[regno
];
852 supply_register (regno
, zerobuf
);
856 /* send the register examine command */
858 monitor_printf (current_monitor
->getreg
.cmd
, name
);
860 /* If RESP_DELIM is specified, we search for that as a leading
861 delimiter for the register value. Otherwise, we just start
862 searching from the start of the buf. */
864 if (current_monitor
->getreg
.resp_delim
)
866 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
867 /* Handle case of first 32 registers listed in pairs. */
868 if (current_monitor
->flags
& MO_32_REGS_PAIRED
869 && regno
& 1 == 1 && regno
< 32)
870 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
873 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
874 if (current_monitor
->flags
& MO_HEX_PREFIX
)
877 c
= readchar (timeout
);
879 c
= readchar (timeout
);
880 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
883 error ("Bad value returned from monitor while fetching register %x.",
887 /* Read upto the maximum number of hex digits for this register, skipping
888 spaces, but stop reading if something else is seen. Some monitors
889 like to drop leading zeros. */
891 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
894 c
= readchar (timeout
);
896 c
= readchar (timeout
);
904 regbuf
[i
] = '\000'; /* terminate the number */
906 /* If TERM is present, we wait for that to show up. Also, (if TERM
907 is present), we will send TERM_CMD if that is present. In any
908 case, we collect all of the output into buf, and then wait for
909 the normal prompt. */
911 if (current_monitor
->getreg
.term
)
913 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
915 if (current_monitor
->getreg
.term_cmd
)
917 monitor_printf (current_monitor
->getreg
.term_cmd
);
918 monitor_expect_prompt (NULL
, 0);
922 monitor_expect_prompt (NULL
, 0); /* get response */
924 monitor_supply_register (regno
, regbuf
);
927 /* Read the remote registers into the block regs. */
935 if (current_monitor
->dump_registers
)
937 monitor_printf (current_monitor
->dump_registers
);
938 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
939 parse_register_dump (buf
, resp_len
);
942 abort(); /* Need some way to read registers */
946 monitor_fetch_registers (regno
)
949 if (current_monitor
->getreg
.cmd
)
953 monitor_fetch_register (regno
);
957 for (regno
= 0; regno
< NUM_REGS
; regno
++)
958 monitor_fetch_register (regno
);
961 monitor_dump_regs ();
965 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
968 monitor_store_register (regno
)
974 name
= current_monitor
->regnames
[regno
];
978 val
= read_register (regno
);
980 /* send the register deposit command */
982 if (current_monitor
->flags
& MO_REGISTER_VALUE_FIRST
)
983 monitor_printf (current_monitor
->setreg
.cmd
, val
, name
);
984 else if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
985 monitor_printf (current_monitor
->setreg
.cmd
, name
);
987 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
989 if (current_monitor
->setreg
.term
)
991 monitor_expect (current_monitor
->setreg
.term
, NULL
, 0);
993 if (current_monitor
->flags
& MO_SETREG_INTERACTIVE
)
994 monitor_printf ("%x\r", val
);
996 monitor_expect_prompt (NULL
, 0);
999 monitor_expect_prompt (NULL
, 0);
1002 /* Store the remote registers. */
1005 monitor_store_registers (regno
)
1010 monitor_store_register (regno
);
1014 for (regno
= 0; regno
< NUM_REGS
; regno
++)
1015 monitor_store_register (regno
);
1018 /* Get ready to modify the registers array. On machines which store
1019 individual registers, this doesn't need to do anything. On machines
1020 which store all the registers in one fell swoop, this makes sure
1021 that registers contains all the registers from the program being
1025 monitor_prepare_to_store ()
1027 /* Do nothing, since we can store individual regs */
1031 monitor_files_info (ops
)
1032 struct target_ops
*ops
;
1034 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
1038 monitor_write_memory (memaddr
, myaddr
, len
)
1047 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1048 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1050 /* Use memory fill command for leading 0 bytes. */
1052 if (current_monitor
->fill
)
1054 for (i
= 0; i
< len
; i
++)
1058 if (i
> 4) /* More than 4 zeros is worth doing */
1060 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
1061 monitor_printf (current_monitor
->fill
, memaddr
, memaddr
+ i
, 0);
1063 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
1065 monitor_expect_prompt (NULL
, 0);
1072 /* Can't actually use long longs if VAL is an int (nice idea, though). */
1073 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
1076 cmd
= current_monitor
->setmem
.cmdll
;
1080 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
1083 cmd
= current_monitor
->setmem
.cmdl
;
1085 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
1088 cmd
= current_monitor
->setmem
.cmdw
;
1093 cmd
= current_monitor
->setmem
.cmdb
;
1096 val
= extract_unsigned_integer (myaddr
, len
);
1098 if (current_monitor
->flags
& MO_NO_ECHO_ON_SETMEM
)
1099 monitor_printf_noecho (cmd
, memaddr
, val
);
1100 else if (current_monitor
->flags
& MO_SETMEM_INTERACTIVE
)
1103 monitor_printf_noecho (cmd
, memaddr
);
1105 if (current_monitor
->setmem
.term
)
1107 monitor_expect (current_monitor
->setmem
.term
, NULL
, 0);
1109 monitor_printf ("%x\r", val
);
1114 monitor_printf (cmd
, memaddr
, val
);
1116 monitor_expect_prompt (NULL
, 0);
1121 /* This is an alternate form of monitor_read_memory which is used for monitors
1122 which can only read a single byte/word/etc. at a time. */
1125 monitor_read_memory_single (memaddr
, myaddr
, len
)
1131 char membuf
[sizeof(int) * 2 + 1];
1137 /* Can't actually use long longs (nice idea, though). In fact, the
1138 call to strtoul below will fail if it tries to convert a value
1139 that's too big to fit in a long. */
1140 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
1143 cmd
= current_monitor
->getmem
.cmdll
;
1147 if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
1150 cmd
= current_monitor
->getmem
.cmdl
;
1152 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
1155 cmd
= current_monitor
->getmem
.cmdw
;
1160 cmd
= current_monitor
->getmem
.cmdb
;
1163 /* Send the examine command. */
1165 monitor_printf (cmd
, memaddr
);
1167 /* If RESP_DELIM is specified, we search for that as a leading
1168 delimiter for the memory value. Otherwise, we just start
1169 searching from the start of the buf. */
1171 if (current_monitor
->getmem
.resp_delim
)
1172 monitor_expect_regexp (&getmem_resp_delim_pattern
, NULL
, 0);
1174 /* Now, read the appropriate number of hex digits for this loc,
1177 /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1178 if (current_monitor
->flags
& MO_HEX_PREFIX
)
1182 c
= readchar (timeout
);
1184 c
= readchar (timeout
);
1185 if ((c
== '0') && ((c
= readchar (timeout
)) == 'x'))
1188 error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1189 memaddr
, i
, membuf
, c
);
1191 for (i
= 0; i
< len
* 2; i
++)
1197 c
= readchar (timeout
);
1203 error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
1204 memaddr
, i
, membuf
, c
);
1210 membuf
[i
] = '\000'; /* terminate the number */
1212 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1213 present), we will send TERM_CMD if that is present. In any case, we collect
1214 all of the output into buf, and then wait for the normal prompt. */
1216 if (current_monitor
->getmem
.term
)
1218 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
1220 if (current_monitor
->getmem
.term_cmd
)
1222 monitor_printf (current_monitor
->getmem
.term_cmd
);
1223 monitor_expect_prompt (NULL
, 0);
1227 monitor_expect_prompt (NULL
, 0); /* get response */
1230 val
= strtoul (membuf
, &p
, 16);
1232 if (val
== 0 && membuf
== p
)
1233 error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
1236 /* supply register stores in target byte order, so swap here */
1238 store_unsigned_integer (myaddr
, len
, val
);
1243 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1244 memory at MEMADDR. Returns length moved. Currently, we do no more
1245 than 16 bytes at a time. */
1248 monitor_read_memory (memaddr
, myaddr
, len
)
1260 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1261 memaddr
= ADDR_BITS_REMOVE (memaddr
);
1263 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
1264 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1266 len
= min (len
, 16);
1268 dumpaddr
= memaddr
& ~0xf;
1270 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1271 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1272 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1274 /* send the memory examine command */
1276 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1277 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
- 1);
1278 else if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1279 monitor_printf (current_monitor
->getmem
.cmdb
, dumpaddr
);
1281 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1283 /* If TERM is present, we wait for that to show up. Also, (if TERM
1284 is present), we will send TERM_CMD if that is present. In any
1285 case, we collect all of the output into buf, and then wait for
1286 the normal prompt. */
1288 if (current_monitor
->getmem
.term
)
1290 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1293 error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1294 memaddr
, resp_len
, buf
);
1296 if (current_monitor
->getmem
.term_cmd
)
1298 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1299 strlen (current_monitor
->getmem
.term_cmd
));
1300 monitor_expect_prompt (NULL
, 0);
1304 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1308 /* If RESP_DELIM is specified, we search for that as a leading
1309 delimiter for the values. Otherwise, we just start searching
1310 from the start of the buf. */
1312 if (current_monitor
->getmem
.resp_delim
)
1315 struct re_registers resp_strings
;
1318 retval
= re_search (&getmem_resp_delim_pattern
, p
, tmp
, 0, tmp
,
1322 error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1323 memaddr
, resp_len
, buf
);
1325 p
+= resp_strings
.end
[0];
1327 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1329 error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1330 memaddr
, resp_len
, buf
);
1331 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1335 if (current_monitor
->flags
& MO_GETMEM_16_BOUNDARY
)
1338 while (!(*p
== '\000' || *p
== '\n' || *p
== '\r') && i
> 0)
1342 if (dumpaddr
>= memaddr
&& i
> 0)
1344 val
= fromhex (*p
) * 16 + fromhex (*(p
+1));
1356 for (i
= len
; i
> 0; i
--)
1358 /* Skip non-hex chars, but bomb on end of string and newlines */
1365 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1366 error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s", memaddr
, resp_len
, buf
);
1370 val
= strtoul (p
, &p1
, 16);
1372 if (val
== 0 && p
== p1
)
1373 error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.", memaddr
,
1388 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1393 struct target_ops
*target
; /* ignored */
1395 return dcache_xfer_memory (remote_dcache
, memaddr
, myaddr
, len
, write
);
1401 return; /* ignore attempts to kill target system */
1404 /* All we actually do is set the PC to the start address of exec_bfd, and start
1405 the program at that point. */
1408 monitor_create_inferior (exec_file
, args
, env
)
1413 if (args
&& (*args
!= '\000'))
1414 error ("Args are not supported by the monitor.");
1417 clear_proceed_status ();
1418 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1421 /* Clean up when a program exits.
1422 The program actually lives on in the remote processor's RAM, and may be
1423 run again without a download. Don't leave it full of breakpoint
1427 monitor_mourn_inferior ()
1429 unpush_target (targ_ops
);
1430 generic_mourn_inferior (); /* Do all the proper things now */
1433 #define NUM_MONITOR_BREAKPOINTS 8
1435 static CORE_ADDR breakaddr
[NUM_MONITOR_BREAKPOINTS
] = {0};
1437 /* Tell the monitor to add a breakpoint. */
1440 monitor_insert_breakpoint (addr
, shadow
)
1448 if (current_monitor
->set_break
== NULL
)
1449 error ("No set_break defined for this monitor");
1451 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1452 addr
= ADDR_BITS_REMOVE (addr
);
1454 /* Determine appropriate breakpoint size for this address. */
1455 bp
= memory_breakpoint_from_pc (&addr
, &bplen
);
1457 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1459 if (breakaddr
[i
] == 0)
1461 breakaddr
[i
] = addr
;
1462 monitor_read_memory (addr
, shadow
, bplen
);
1463 monitor_printf (current_monitor
->set_break
, addr
);
1464 monitor_expect_prompt (NULL
, 0);
1469 error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS
);
1472 /* Tell the monitor to remove a breakpoint. */
1475 monitor_remove_breakpoint (addr
, shadow
)
1481 if (current_monitor
->clr_break
== NULL
)
1482 error ("No clr_break defined for this monitor");
1484 if (current_monitor
->flags
& MO_ADDR_BITS_REMOVE
)
1485 addr
= ADDR_BITS_REMOVE (addr
);
1487 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1489 if (breakaddr
[i
] == addr
)
1492 /* some monitors remove breakpoints based on the address */
1493 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
1494 monitor_printf (current_monitor
->clr_break
, addr
);
1495 else if (current_monitor
->flags
& MO_CLR_BREAK_1_BASED
)
1496 monitor_printf (current_monitor
->clr_break
, i
+ 1);
1498 monitor_printf (current_monitor
->clr_break
, i
);
1499 monitor_expect_prompt (NULL
, 0);
1503 fprintf_unfiltered (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1507 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
1508 an S-record. Return non-zero if the ACK is received properly. */
1511 monitor_wait_srec_ack ()
1515 if (current_monitor
->flags
& MO_SREC_ACK_PLUS
)
1517 return (readchar (timeout
) == '+');
1519 else if (current_monitor
->flags
& MO_SREC_ACK_ROTATE
)
1521 /* Eat two backspaces, a "rotating" char (|/-\), and a space. */
1522 if ((ch
= readchar (1)) < 0)
1524 if ((ch
= readchar (1)) < 0)
1526 if ((ch
= readchar (1)) < 0)
1528 if ((ch
= readchar (1)) < 0)
1534 /* monitor_load -- download a file. */
1537 monitor_load (file
, from_tty
)
1541 dcache_flush (remote_dcache
);
1543 if (current_monitor
->load_routine
)
1544 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
1546 { /* The default is ascii S-records */
1548 unsigned long load_offset
;
1551 /* enable user to specify address for downloading as 2nd arg to load */
1552 n
= sscanf (file
, "%s 0x%lx", buf
, &load_offset
);
1558 monitor_printf (current_monitor
->load
);
1559 if (current_monitor
->loadresp
)
1560 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
1562 load_srec (monitor_desc
, file
, (bfd_vma
) load_offset
,
1563 32, SREC_ALL
, hashmark
,
1564 current_monitor
->flags
& MO_SREC_ACK
?
1565 monitor_wait_srec_ack
: NULL
);
1567 monitor_expect_prompt (NULL
, 0);
1570 /* Finally, make the PC point at the start address */
1573 write_pc (bfd_get_start_address (exec_bfd
));
1575 inferior_pid
= 0; /* No process now */
1577 /* This is necessary because many things were based on the PC at the time that
1578 we attached to the monitor, which is no longer valid now that we have loaded
1579 new code (and just changed the PC). Another way to do this might be to call
1580 normal_stop, except that the stack may not be valid, and things would get
1581 horribly confused... */
1583 clear_symtab_users ();
1589 if ((current_monitor
->flags
& MO_SEND_BREAK_ON_STOP
) != 0)
1590 SERIAL_SEND_BREAK (monitor_desc
);
1591 if (current_monitor
->stop
)
1592 monitor_printf_noecho (current_monitor
->stop
);
1595 /* Put a command string, in args, out to MONITOR. Output from MONITOR
1596 is placed on the users terminal until the prompt is seen. FIXME: We
1597 read the characters ourseleves here cause of a nasty echo. */
1600 monitor_command (args
, from_tty
)
1608 if (monitor_desc
== NULL
)
1609 error ("monitor target not open.");
1611 p
= current_monitor
->prompt
;
1613 /* Send the command. Note that if no args were supplied, then we're
1614 just sending the monitor a newline, which is sometimes useful. */
1616 monitor_printf ("%s\r", (args
? args
: ""));
1618 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
1620 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
1623 /* Convert hex digit A to a number. */
1630 if (a
>= '0' && a
<= '9')
1632 if (a
>= 'a' && a
<= 'f')
1633 return a
- 'a' + 10;
1634 if (a
>= 'A' && a
<= 'F')
1635 return a
- 'A' + 10;
1637 error ("Reply contains invalid hex digit 0x%x", a
);
1642 monitor_get_dev_name ()
1647 static struct target_ops monitor_ops
=
1649 NULL
, /* to_shortname */
1650 NULL
, /* to_longname */
1653 monitor_close
, /* to_close */
1654 NULL
, /* to_attach */
1655 monitor_detach
, /* to_detach */
1656 monitor_resume
, /* to_resume */
1657 monitor_wait
, /* to_wait */
1658 monitor_fetch_registers
, /* to_fetch_registers */
1659 monitor_store_registers
, /* to_store_registers */
1660 monitor_prepare_to_store
, /* to_prepare_to_store */
1661 monitor_xfer_memory
, /* to_xfer_memory */
1662 monitor_files_info
, /* to_files_info */
1663 monitor_insert_breakpoint
, /* to_insert_breakpoint */
1664 monitor_remove_breakpoint
, /* to_remove_breakpoint */
1665 0, /* to_terminal_init */
1666 0, /* to_terminal_inferior */
1667 0, /* to_terminal_ours_for_output */
1668 0, /* to_terminal_ours */
1669 0, /* to_terminal_info */
1670 monitor_kill
, /* to_kill */
1671 monitor_load
, /* to_load */
1672 0, /* to_lookup_symbol */
1673 monitor_create_inferior
, /* to_create_inferior */
1674 monitor_mourn_inferior
, /* to_mourn_inferior */
1676 0, /* to_notice_signals */
1677 0, /* to_thread_alive */
1678 monitor_stop
, /* to_stop */
1679 process_stratum
, /* to_stratum */
1681 1, /* to_has_all_memory */
1682 1, /* to_has_memory */
1683 1, /* to_has_stack */
1684 1, /* to_has_registers */
1685 1, /* to_has_execution */
1687 0, /* sections_end */
1688 OPS_MAGIC
/* to_magic */
1691 /* Init the target_ops structure pointed at by OPS */
1694 init_monitor_ops (ops
)
1695 struct target_ops
*ops
;
1697 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
1700 /* Define additional commands that are usually only used by monitors. */
1703 _initialize_remote_monitors ()
1705 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
1707 "Set display of activity while downloading a file.\n\
1708 When enabled, a hashmark \'#\' is displayed.",
1712 add_com ("monitor", class_obscure
, monitor_command
,
1713 "Send a command to the debug monitor.");