1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1995 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This file was derived from various remote-* modules. It is a collection
22 of generic support functions so GDB can talk directly to a ROM based
23 monitor. This saves use from having to hack an exception based handler
24 into existance, and makes for quick porting.
26 This module talks to a debug monitor called 'MONITOR', which
27 We communicate with MONITOR via either a direct serial line, or a TCP
28 (or possibly TELNET) stream to a terminal multiplexor,
29 which in turn talks to the target board. */
42 #include <sys/types.h>
50 static int readchar
PARAMS ((int timeout
));
52 static void monitor_command
PARAMS ((char *args
, int fromtty
));
53 static void monitor_load_srec
PARAMS ((char *args
));
55 static int monitor_make_srec
PARAMS ((char *buffer
, int type
,
57 unsigned char *myaddr
, int len
));
59 static void monitor_fetch_register
PARAMS ((int regno
));
60 static void monitor_store_register
PARAMS ((int regno
));
62 static void monitor_close
PARAMS ((int quitting
));
63 static void monitor_detach
PARAMS ((char *args
, int from_tty
));
64 static void monitor_resume
PARAMS ((int pid
, int step
, enum target_signal sig
));
65 static void monitor_interrupt
PARAMS ((int signo
));
66 static void monitor_interrupt_twice
PARAMS ((int signo
));
67 static void monitor_interrupt_query
PARAMS ((void));
68 static void monitor_wait_cleanup
PARAMS ((int old_timeout
));
70 static int monitor_wait
PARAMS ((int pid
, struct target_waitstatus
*status
));
71 static void monitor_fetch_registers
PARAMS ((int regno
));
72 static void monitor_store_registers
PARAMS ((int regno
));
73 static void monitor_prepare_to_store
PARAMS ((void));
74 static int monitor_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
, int write
, struct target_ops
*target
));
75 static void monitor_files_info
PARAMS ((struct target_ops
*ops
));
76 static int monitor_insert_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
77 static int monitor_remove_breakpoint
PARAMS ((CORE_ADDR addr
, char *shadow
));
78 static void monitor_kill
PARAMS ((void));
79 static void monitor_load
PARAMS ((char *file
, int from_tty
));
80 static void monitor_mourn_inferior
PARAMS ((void));
81 static void monitor_stop
PARAMS ((void));
83 static int from_hex
PARAMS ((int a
));
84 static unsigned long get_hex_word
PARAMS ((void));
86 static struct monitor_ops
*current_monitor
;
88 static int hashmark
; /* flag set by "set hash" */
90 static int timeout
= 30;
92 static void (*ofunc
)(); /* Old SIGINT signal handler */
94 /* Descriptor for I/O to remote machine. Initialize it to NULL so
95 that monitor_open knows that we don't have a file open when the
98 static serial_t monitor_desc
= NULL
;
100 /* Pointer to regexp pattern matching data */
102 static struct re_pattern_buffer register_pattern
;
104 /* Element 0 points to start of register name, and element 1 points to the
105 start of the register value. */
107 static struct re_registers register_strings
;
109 static char fastmap
[256];
111 static int dump_reg_flag
; /* Non-zero means do a dump_registers cmd when
112 monitor_wait wakes up. */
114 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
115 Works just like printf. */
119 monitor_printf_noecho (char *pattern
, ...)
121 monitor_printf_noecho (va_alist
)
130 va_start (args
, pattern
);
134 pattern
= va_arg (args
, char *);
137 vsprintf (sndbuf
, pattern
, args
);
139 if (remote_debug
> 0)
140 fputs_unfiltered (sndbuf
, gdb_stderr
);
142 len
= strlen (sndbuf
);
144 if (len
+ 1 > sizeof sndbuf
)
147 if (SERIAL_WRITE(monitor_desc
, sndbuf
, len
))
148 fprintf_unfiltered (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
151 /* monitor_printf -- Send data to monitor and check the echo. Works just like
156 monitor_printf (char *pattern
, ...)
158 monitor_printf (va_alist
)
168 va_start (args
, pattern
);
172 pattern
= va_arg (args
, char *);
175 vsprintf (sndbuf
, pattern
, args
);
177 if (remote_debug
> 0)
178 fputs_unfiltered (sndbuf
, gdb_stderr
);
180 len
= strlen (sndbuf
);
182 if (len
+ 1 > sizeof sndbuf
)
185 if (SERIAL_WRITE(monitor_desc
, sndbuf
, len
))
186 fprintf_unfiltered (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
188 for (i
= 0; i
< len
; i
++)
191 c
= readchar (timeout
);
196 if (sndbuf
[i
] == '\r'
200 error ("monitor_printf: Bad echo. Sent: \"%s\", Got: \"%.*s%c\".",
201 sndbuf
, i
, sndbuf
, c
);
206 /* Read a character from the remote system, doing all the fancy
215 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
217 if (remote_debug
> 0)
218 fputc_unfiltered (c
, gdb_stderr
);
223 if (c
== SERIAL_TIMEOUT
)
224 error ("Timeout reading from remote system.");
226 perror_with_name ("remote-monitor");
229 /* Scan input from the remote system, until STRING is found. If BUF is non-
230 zero, then collect input until we have collected either STRING or BUFLEN-1
231 chars. In either case we terminate BUF with a 0. If input overflows BUF
232 because STRING can't be found, return -1, else return number of chars in BUF
233 (minus the terminating NUL). Note that in the non-overflow case, STRING
234 will be at the end of BUF. */
237 monitor_expect (string
, buf
, buflen
)
243 int obuflen
= buflen
;
258 c
= readchar (timeout
);
263 c
= readchar (timeout
);
274 return obuflen
- buflen
;
289 /* Keep discarding input until we see the MONITOR prompt.
291 The convention for dealing with the prompt is that you
293 o *then* wait for the prompt.
295 Thus the last thing that a procedure does with the serial line
296 will be an monitor_expect_prompt(). Exception: monitor_resume does not
297 wait for the prompt, because the terminal is being handed over
298 to the inferior. However, the next thing which happens after that
299 is a monitor_wait which does wait for the prompt.
300 Note that this includes abnormal exit, e.g. error(). This is
301 necessary to prevent getting into states from which we can't
305 monitor_expect_prompt (buf
, buflen
)
309 return monitor_expect (PROMPT
, buf
, buflen
);
312 /* Get N 32-bit words from remote, each preceded by a space, and put
313 them in registers starting at REGNO. */
323 ch
= readchar (timeout
);
328 for (i
= 7; i
>= 1; i
--)
330 ch
= readchar (timeout
);
333 val
= (val
<< 4) | from_hex (ch
);
339 /* Open a connection to a remote debugger. NAME is the filename used
340 for communication. */
342 static char *dev_name
;
343 static struct target_ops
*targ_ops
;
346 monitor_open (args
, mon_ops
, from_tty
)
348 struct monitor_ops
*mon_ops
;
355 if (mon_ops
->magic
!= MONITOR_OPS_MAGIC
)
356 error ("Magic number of monitor_ops struct wrong.");
358 targ_ops
= mon_ops
->target
;
359 name
= targ_ops
->to_shortname
;
362 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
363 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
365 target_preopen (from_tty
);
367 /* Setup pattern for register dump */
369 if (mon_ops
->register_pattern
)
374 register_pattern
.fastmap
= fastmap
;
375 tmp
= re_set_syntax (RE_SYNTAX_EMACS
);
376 val
= re_compile_pattern (mon_ops
->register_pattern
,
377 strlen (mon_ops
->register_pattern
),
381 error ("Can't compiler register pattern string: %s!", val
);
382 re_compile_fastmap (®ister_pattern
);
385 unpush_target (targ_ops
);
389 dev_name
= strsave (args
);
391 monitor_desc
= SERIAL_OPEN (dev_name
);
394 perror_with_name (dev_name
);
398 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
400 SERIAL_CLOSE (monitor_desc
);
401 perror_with_name (dev_name
);
405 SERIAL_RAW (monitor_desc
);
407 SERIAL_FLUSH_INPUT (monitor_desc
);
409 /* some systems only work with 2 stop bits */
411 SERIAL_SETSTOPBITS (monitor_desc
, mon_ops
->stopbits
);
413 current_monitor
= mon_ops
;
415 /* See if we can wake up the monitor. First, try sending a stop sequence,
416 then send the init strings. Last, remove all breakpoints. */
418 if (current_monitor
->stop
)
421 monitor_expect_prompt (NULL
, 0);
424 /* wake up the monitor and see if it's alive */
425 for (p
= mon_ops
->init
; *p
!= NULL
; p
++)
428 monitor_expect_prompt (NULL
, 0);
431 SERIAL_FLUSH_INPUT (monitor_desc
);
433 /* Remove all breakpoints */
435 if (mon_ops
->clr_all_break
)
437 monitor_printf (mon_ops
->clr_all_break
);
438 monitor_expect_prompt (NULL
, 0);
442 printf_unfiltered ("Remote target %s connected to %s\n", name
, dev_name
);
444 push_target (targ_ops
);
446 inferior_pid
= 42000; /* Make run command think we are busy... */
448 /* Give monitor_wait something to read */
450 monitor_printf (current_monitor
->line_term
);
455 /* Close out all files and local state before this target loses
459 monitor_close (quitting
)
463 SERIAL_CLOSE (monitor_desc
);
467 /* Terminate the open connection to the remote debugger. Use this
468 when you want to detach and do something else with your gdb. */
471 monitor_detach (args
, from_tty
)
475 pop_target (); /* calls monitor_close to do the real work */
477 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
480 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
483 monitor_supply_register (regno
, valstr
)
487 unsigned LONGEST val
;
488 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
491 val
= strtoul (valstr
, &p
, 16);
493 if (val
== 0 && valstr
== p
)
494 error ("monitor_supply_register (%d): bad value from monitor: %s.",
497 /* supply register stores in target byte order, so swap here */
499 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
501 supply_register (regno
, regbuf
);
506 /* Tell the remote machine to resume. */
509 monitor_resume (pid
, step
, sig
)
511 enum target_signal sig
;
514 monitor_printf (STEP_CMD
);
517 monitor_printf (CONT_CMD
);
518 if (current_monitor
->flags
& MO_NEED_REGDUMP_AFTER_CONT
)
523 /* Parse the output of a register dump command. A monitor specific regexp is
524 used to extract individual register descriptions of the form REG=VAL. Each
525 description is split up into a name and a value string which are passed down
526 to monitor specific code. */
529 parse_register_dump (buf
, len
)
535 int regnamelen
, vallen
;
538 if (re_search (®ister_pattern
, buf
, len
, 0, len
,
539 ®ister_strings
) == -1)
542 regnamelen
= register_strings
.end
[1] - register_strings
.start
[1];
543 regname
= buf
+ register_strings
.start
[1];
544 vallen
= register_strings
.end
[2] - register_strings
.start
[2];
545 val
= buf
+ register_strings
.start
[2];
547 current_monitor
->supply_register (regname
, regnamelen
, val
, vallen
);
549 buf
+= register_strings
.end
[0];
550 len
-= register_strings
.end
[0];
554 /* Send ^C to target to halt it. Target will respond, and send us a
558 monitor_interrupt (signo
)
561 /* If this doesn't work, try more severe steps. */
562 signal (signo
, monitor_interrupt_twice
);
565 printf_unfiltered ("monitor_interrupt called\n");
570 /* The user typed ^C twice. */
573 monitor_interrupt_twice (signo
)
576 signal (signo
, ofunc
);
578 monitor_interrupt_query ();
580 signal (signo
, monitor_interrupt
);
583 /* Ask the user what to do when an interrupt is received. */
586 monitor_interrupt_query ()
588 target_terminal_ours ();
590 if (query ("Interrupted while waiting for the program.\n\
591 Give up (and stop debugging it)? "))
593 target_mourn_inferior ();
594 return_to_top_level (RETURN_QUIT
);
597 target_terminal_inferior ();
601 monitor_wait_cleanup (old_timeout
)
604 timeout
= old_timeout
;
605 signal (SIGINT
, ofunc
);
608 /* Wait until the remote machine stops, then return, storing status in
609 status just as `wait' would. */
612 monitor_wait (pid
, status
)
614 struct target_waitstatus
*status
;
616 int old_timeout
= timeout
;
619 struct cleanup
*old_chain
;
621 status
->kind
= TARGET_WAITKIND_EXITED
;
622 status
->value
.integer
= 0;
624 old_chain
= make_cleanup (monitor_wait_cleanup
, old_timeout
);
626 timeout
= -1; /* Don't time out -- user program is running. */
628 ofunc
= (void (*)()) signal (SIGINT
, monitor_interrupt
);
632 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
635 fprintf_unfiltered (gdb_stderr
, "monitor_wait: excessive response from monitor: %s.", buf
);
637 while (resp_len
< 0);
639 signal (SIGINT
, ofunc
);
641 timeout
= old_timeout
;
643 if (dump_reg_flag
&& current_monitor
->dump_registers
)
647 monitor_printf (current_monitor
->dump_registers
);
648 resp_len
= monitor_expect_prompt (buf
, sizeof (buf
));
651 if (current_monitor
->register_pattern
)
652 parse_register_dump (buf
, resp_len
);
654 status
->kind
= TARGET_WAITKIND_STOPPED
;
655 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
657 discard_cleanups (old_chain
);
662 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
666 monitor_fetch_register (regno
)
670 static char zerobuf
[MAX_REGISTER_RAW_SIZE
] = {0};
671 char regbuf
[MAX_REGISTER_RAW_SIZE
* 2 + 1];
674 name
= REGNAMES (regno
);
678 supply_register (regno
, zerobuf
);
682 /* send the register examine command */
684 monitor_printf (current_monitor
->getreg
.cmd
, name
);
686 /* If RESP_DELIM is specified, we search for that as a leading delimiter for
687 the register value. Otherwise, we just start searching from the start of
690 if (current_monitor
->getreg
.resp_delim
)
691 monitor_expect (current_monitor
->getreg
.resp_delim
, NULL
, 0);
693 /* Now, read the appropriate number of hex digits for this register, skipping
696 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
) * 2; i
++)
702 c
= readchar (timeout
);
708 error ("monitor_fetch_register (%d): bad response from monitor: %.*s%c.",
709 regno
, i
, regbuf
, c
);
715 regbuf
[i
] = '\000'; /* terminate the number */
717 /* If TERM is present, we wait for that to show up. Also, (if TERM is
718 present), we will send TERM_CMD if that is present. In any case, we collect
719 all of the output into buf, and then wait for the normal prompt. */
721 if (current_monitor
->getreg
.term
)
723 monitor_expect (current_monitor
->getreg
.term
, NULL
, 0); /* get response */
725 if (current_monitor
->getreg
.term_cmd
)
727 monitor_printf (current_monitor
->getreg
.term_cmd
);
728 monitor_expect_prompt (NULL
, 0);
732 monitor_expect_prompt (NULL
, 0); /* get response */
734 monitor_supply_register (regno
, regbuf
);
737 /* Read the remote registers into the block regs. */
740 monitor_fetch_registers (regno
)
745 monitor_fetch_register (regno
);
749 for (regno
= 0; regno
< NUM_REGS
; regno
++)
750 monitor_fetch_register (regno
);
753 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
756 monitor_store_register (regno
)
760 unsigned LONGEST val
;
762 name
= REGNAMES (regno
);
766 val
= read_register (regno
);
768 /* send the register deposit command */
770 monitor_printf (current_monitor
->setreg
.cmd
, name
, val
);
772 /* It's possible that there are actually some monitors out there that will
773 prompt you when you set a register. In that case, you may need to add some
774 code here to deal with TERM and TERM_CMD (see monitor_fetch_register to get
775 an idea of what's needed...) */
777 monitor_expect_prompt (NULL
, 0);
780 /* Store the remote registers. */
783 monitor_store_registers (regno
)
788 monitor_store_register (regno
);
792 for (regno
= 0; regno
< NUM_REGS
; regno
++)
793 monitor_store_register (regno
);
796 /* Get ready to modify the registers array. On machines which store
797 individual registers, this doesn't need to do anything. On machines
798 which store all the registers in one fell swoop, this makes sure
799 that registers contains all the registers from the program being
803 monitor_prepare_to_store ()
805 /* Do nothing, since we can store individual regs */
809 monitor_files_info (ops
)
810 struct target_ops
*ops
;
812 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baud_rate
);
816 monitor_write_memory (memaddr
, myaddr
, len
)
818 unsigned char *myaddr
;
821 unsigned LONGEST val
;
825 /* Use memory fill command for leading 0 bytes. */
827 if (current_monitor
->fill
)
829 for (i
= 0; i
< len
; i
++)
833 if (i
> 4) /* More than 4 zeros is worth doing */
835 if (current_monitor
->flags
& MO_FILL_USES_ADDR
)
836 monitor_printf (current_monitor
->fill
, memaddr
, memaddr
+ i
, 0);
838 monitor_printf (current_monitor
->fill
, memaddr
, i
, 0);
840 monitor_expect_prompt (NULL
, 0);
846 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->setmem
.cmdll
)
849 cmd
= current_monitor
->setmem
.cmdll
;
851 else if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->setmem
.cmdl
)
854 cmd
= current_monitor
->setmem
.cmdl
;
856 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->setmem
.cmdw
)
859 cmd
= current_monitor
->setmem
.cmdw
;
864 cmd
= current_monitor
->setmem
.cmdb
;
867 val
= extract_unsigned_integer (myaddr
, len
);
869 monitor_printf (cmd
, memaddr
, val
);
871 monitor_expect_prompt (NULL
, 0);
876 /* This is an alternate form of monitor_read_memory which is used for monitors
877 which can only read a single byte/word/etc. at a time. */
880 monitor_read_memory_single (memaddr
, myaddr
, len
)
882 unsigned char *myaddr
;
885 unsigned LONGEST val
;
886 char membuf
[sizeof(LONGEST
) * 2 + 1];
891 if ((memaddr
& 0x7) == 0 && len
>= 8 && current_monitor
->getmem
.cmdll
)
894 cmd
= current_monitor
->getmem
.cmdll
;
896 else if ((memaddr
& 0x3) == 0 && len
>= 4 && current_monitor
->getmem
.cmdl
)
899 cmd
= current_monitor
->getmem
.cmdl
;
901 else if ((memaddr
& 0x1) == 0 && len
>= 2 && current_monitor
->getmem
.cmdw
)
904 cmd
= current_monitor
->getmem
.cmdw
;
909 cmd
= current_monitor
->getmem
.cmdb
;
912 /* Send the examine command. */
914 monitor_printf (cmd
, memaddr
);
916 /* If RESP_DELIM is specified, we search for that as a leading delimiter for
917 the register value. Otherwise, we just start searching from the start of
920 if (current_monitor
->getmem
.resp_delim
)
921 monitor_expect (current_monitor
->getmem
.resp_delim
, NULL
, 0);
923 /* Now, read the appropriate number of hex digits for this loc, skipping
926 for (i
= 0; i
< len
* 2; i
++)
932 c
= readchar (timeout
);
938 error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
939 memaddr
, i
, membuf
, c
);
945 membuf
[i
] = '\000'; /* terminate the number */
947 /* If TERM is present, we wait for that to show up. Also, (if TERM is
948 present), we will send TERM_CMD if that is present. In any case, we collect
949 all of the output into buf, and then wait for the normal prompt. */
951 if (current_monitor
->getmem
.term
)
953 monitor_expect (current_monitor
->getmem
.term
, NULL
, 0); /* get response */
955 if (current_monitor
->getmem
.term_cmd
)
957 monitor_printf (current_monitor
->getmem
.term_cmd
);
958 monitor_expect_prompt (NULL
, 0);
962 monitor_expect_prompt (NULL
, 0); /* get response */
965 val
= strtoul (membuf
, &p
, 16);
967 if (val
== 0 && membuf
== p
)
968 error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
971 /* supply register stores in target byte order, so swap here */
973 store_unsigned_integer (myaddr
, len
, val
);
978 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's memory
979 at MEMADDR. Returns length moved. Currently, we only do one byte at a
983 monitor_read_memory (memaddr
, myaddr
, len
)
988 unsigned LONGEST val
;
989 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
996 if (current_monitor
->flags
& MO_GETMEM_READ_SINGLE
)
997 return monitor_read_memory_single (memaddr
, myaddr
, len
);
1001 /* See if xfer would cross a 16 byte boundary. If so, clip it. */
1002 if (((memaddr
^ (memaddr
+ len
- 1)) & ~0xf) != 0)
1003 len
= ((memaddr
+ len
) & ~0xf) - memaddr
;
1005 /* send the memory examine command */
1007 if (current_monitor
->flags
& MO_GETMEM_NEEDS_RANGE
)
1008 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, memaddr
+ len
- 1);
1010 monitor_printf (current_monitor
->getmem
.cmdb
, memaddr
, len
);
1012 /* If TERM is present, we wait for that to show up. Also, (if TERM is
1013 present), we will send TERM_CMD if that is present. In any case, we collect
1014 all of the output into buf, and then wait for the normal prompt. */
1016 if (current_monitor
->getmem
.term
)
1018 resp_len
= monitor_expect (current_monitor
->getmem
.term
, buf
, sizeof buf
); /* get response */
1021 error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
1022 memaddr
, resp_len
, buf
);
1024 if (current_monitor
->getmem
.term_cmd
)
1026 SERIAL_WRITE (monitor_desc
, current_monitor
->getmem
.term_cmd
,
1027 strlen (current_monitor
->getmem
.term_cmd
));
1028 monitor_expect_prompt (NULL
, 0);
1032 resp_len
= monitor_expect_prompt (buf
, sizeof buf
); /* get response */
1036 /* If RESP_DELIM is specified, we search for that as a leading delimiter for
1037 the values. Otherwise, we just start searching from the start of the buf.
1040 if (current_monitor
->getmem
.resp_delim
)
1042 p
= strstr (p
, current_monitor
->getmem
.resp_delim
);
1044 error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
1045 memaddr
, resp_len
, buf
);
1046 p
+= strlen (current_monitor
->getmem
.resp_delim
);
1049 for (i
= len
; i
> 0; i
--)
1051 /* Skip non-hex chars, but bomb on end of string and newlines */
1057 if (*p
== '\000' || *p
== '\n' || *p
== '\r')
1058 error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s", memaddr
, resp_len
, buf
);
1062 val
= strtoul (p
, &p1
, 16);
1064 if (val
== 0 && p
== p1
)
1065 error ("monitor_read_memory (0x%x): bad value from monitor: %.*s.", memaddr
,
1080 monitor_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1085 struct target_ops
*target
; /* ignored */
1088 return monitor_write_memory (memaddr
, myaddr
, len
);
1090 return monitor_read_memory (memaddr
, myaddr
, len
);
1096 return; /* ignore attempts to kill target system */
1099 /* All we actually do is set the PC to the start address of exec_bfd, and start
1100 the program at that point. */
1103 monitor_create_inferior (exec_file
, args
, env
)
1108 if (args
&& (*args
!= '\000'))
1109 error ("Args are not supported by the monitor.");
1111 clear_proceed_status ();
1112 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1115 /* Clean up when a program exits.
1116 The program actually lives on in the remote processor's RAM, and may be
1117 run again without a download. Don't leave it full of breakpoint
1121 monitor_mourn_inferior ()
1123 unpush_target (targ_ops
);
1124 generic_mourn_inferior (); /* Do all the proper things now */
1127 #define NUM_MONITOR_BREAKPOINTS 8
1129 static CORE_ADDR breakaddr
[NUM_MONITOR_BREAKPOINTS
] = {0};
1131 /* Tell the monitor to add a breakpoint. */
1134 monitor_insert_breakpoint (addr
, shadow
)
1139 static unsigned char break_insn
[] = BREAKPOINT
;
1141 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1143 if (breakaddr
[i
] == 0)
1145 breakaddr
[i
] = addr
;
1146 monitor_read_memory (addr
, shadow
, sizeof (break_insn
));
1147 monitor_printf (SET_BREAK_CMD
, addr
);
1148 monitor_expect_prompt (NULL
, 0);
1153 error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS
);
1156 /* Tell the monitor to remove a breakpoint. */
1159 monitor_remove_breakpoint (addr
, shadow
)
1165 for (i
= 0; i
< NUM_MONITOR_BREAKPOINTS
; i
++)
1167 if (breakaddr
[i
] == addr
)
1170 /* some monitors remove breakpoints based on the address */
1171 if (current_monitor
->flags
& MO_CLR_BREAK_USES_ADDR
)
1172 monitor_printf (CLR_BREAK_CMD
, addr
);
1174 monitor_printf (CLR_BREAK_CMD
, i
);
1175 monitor_expect_prompt (NULL
, 0);
1179 fprintf_unfiltered (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1183 /* monitor_load -- download a file. */
1186 monitor_load (file
, from_tty
)
1190 if (current_monitor
->load_routine
)
1191 current_monitor
->load_routine (monitor_desc
, file
, hashmark
);
1193 monitor_load_srec (file
);
1195 /* Finally, make the PC point at the start address */
1197 write_pc (bfd_get_start_address (exec_bfd
));
1199 inferior_pid
= 0; /* No process now */
1201 /* This is necessary because many things were based on the PC at the time that
1202 we attached to the monitor, which is no longer valid now that we have loaded
1203 new code (and just changed the PC). Another way to do this might be to call
1204 normal_stop, except that the stack may not be valid, and things would get
1205 horribly confused... */
1207 clear_symtab_users ();
1213 if (current_monitor
->stop
)
1214 monitor_printf_noecho (current_monitor
->stop
);
1217 /* Put a command string, in args, out to MONITOR. Output from MONITOR
1218 is placed on the users terminal until the prompt is seen. FIXME: We
1219 read the characters ourseleves here cause of a nasty echo. */
1222 monitor_command (args
, from_tty
)
1230 if (monitor_desc
== NULL
)
1231 error ("monitor target not open.");
1235 /* Send the command. Note that if no args were supplied, then we're
1236 just sending the monitor a newline, which is sometimes useful. */
1238 monitor_printf ("%s\r", (args
? args
: ""));
1240 resp_len
= monitor_expect_prompt (buf
, sizeof buf
);
1242 fputs_unfiltered (buf
, gdb_stdout
); /* Output the response */
1245 /* Download a binary file by converting it to S records. */
1248 monitor_load_srec (args
)
1253 char *buffer
, srec
[1024];
1255 int srec_frame
= 32;
1258 buffer
= alloca (srec_frame
* 2 + 256);
1260 abfd
= bfd_openr (args
, 0);
1263 printf_filtered ("Unable to open file %s\n", args
);
1267 if (bfd_check_format (abfd
, bfd_object
) == 0)
1269 printf_filtered ("File is not an object file\n");
1273 monitor_printf (LOAD_CMD
); /* tell the monitor to load */
1274 if (current_monitor
->loadresp
)
1275 monitor_expect (current_monitor
->loadresp
, NULL
, 0);
1277 for (s
= abfd
->sections
; s
; s
= s
->next
)
1278 if (s
->flags
& SEC_LOAD
)
1280 printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s
->name
, s
->vma
,
1281 s
->vma
+ s
->_raw_size
);
1282 gdb_flush (gdb_stdout
);
1284 for (i
= 0; i
< s
->_raw_size
; i
+= srec_frame
)
1288 numbytes
= min (srec_frame
, s
->_raw_size
- i
);
1290 bfd_get_section_contents (abfd
, s
, buffer
, i
, numbytes
);
1292 reclen
= monitor_make_srec (srec
, 3, s
->vma
+ i
, buffer
, numbytes
);
1294 monitor_printf_noecho ("%.*s\r", reclen
, srec
);
1298 putchar_unfiltered ('#');
1299 gdb_flush (gdb_stdout
);
1301 } /* Per-packet (or S-record) loop */
1303 putchar_unfiltered ('\n');
1304 } /* Loadable sections */
1307 putchar_unfiltered ('\n');
1309 /* Write a type 7 terminator record. no data for a type 7, and there
1310 is no data, so len is 0. */
1312 reclen
= monitor_make_srec (srec
, 7, abfd
->start_address
, NULL
, 0);
1314 monitor_printf_noecho ("%.*s\r", reclen
, srec
);
1316 monitor_printf_noecho ("\r\r"); /* Some monitors need these to wake up */
1318 monitor_expect_prompt (NULL
, 0);
1320 SERIAL_FLUSH_INPUT (monitor_desc
);
1324 * monitor_make_srec -- make an srecord. This writes each line, one at a
1325 * time, each with it's own header and trailer line.
1326 * An srecord looks like this:
1328 * byte count-+ address
1329 * start ---+ | | data +- checksum
1331 * S01000006F6B692D746573742E73726563E4
1332 * S315000448600000000000000000FC00005900000000E9
1333 * S31A0004000023C1400037DE00F023604000377B009020825000348D
1334 * S30B0004485A0000000000004E
1337 * S<type><length><address><data><checksum>
1341 * is the number of bytes following upto the checksum. Note that
1342 * this is not the number of chars following, since it takes two
1343 * chars to represent a byte.
1347 * 1) two byte address data record
1348 * 2) three byte address data record
1349 * 3) four byte address data record
1350 * 7) four byte address termination record
1351 * 8) three byte address termination record
1352 * 9) two byte address termination record
1355 * is the start address of the data following, or in the case of
1356 * a termination record, the start address of the image
1360 * is the sum of all the raw byte data in the record, from the length
1361 * upwards, modulo 256 and subtracted from 255.
1363 * This routine returns the length of the S-record.
1368 monitor_make_srec (buffer
, type
, memaddr
, myaddr
, len
)
1372 unsigned char *myaddr
;
1375 unsigned char checksum
;
1378 static char hextab
[] = "0123456789ABCDEF";
1384 /* Create the header for the srec. 4 is the number of bytes in the address,
1385 and 1 is the number of bytes in the count. */
1387 sprintf (buf
, "S%d%02X%08X", type
, len
+ 4 + 1, memaddr
);
1390 /* Note that the checksum is calculated on the raw data, not the hexified
1391 data. It includes the length, address and the data portions of the
1394 checksum
+= (len
+ 4 + 1 /* Packet length */
1395 + (memaddr
& 0xff) /* Address... */
1396 + ((memaddr
>> 8) & 0xff)
1397 + ((memaddr
>> 16) & 0xff)
1398 + ((memaddr
>> 24) & 0xff));
1400 /* build the srecord */
1401 for (i
= 0; i
< len
; i
++)
1403 *buf
++ = hextab
[myaddr
[i
] >> 4];
1404 *buf
++ = hextab
[myaddr
[i
] & 0xf];
1405 checksum
+= myaddr
[i
];
1408 checksum
= ~checksum
;
1410 *buf
++ = hextab
[checksum
>> 4];
1411 *buf
++ = hextab
[checksum
& 0xf];
1413 return buf
- buffer
;
1416 /* Convert hex digit A to a number. */
1422 if (a
>= '0' && a
<= '9')
1424 if (a
>= 'a' && a
<= 'f')
1425 return a
- 'a' + 10;
1426 if (a
>= 'A' && a
<= 'F')
1427 return a
- 'A' + 10;
1429 error ("Reply contains invalid hex digit 0x%x", a
);
1432 static struct target_ops monitor_ops
=
1434 NULL
, /* to_shortname */
1435 NULL
, /* to_longname */
1438 monitor_close
, /* to_close */
1439 NULL
, /* to_attach */
1440 monitor_detach
, /* to_detach */
1441 monitor_resume
, /* to_resume */
1442 monitor_wait
, /* to_wait */
1443 monitor_fetch_registers
, /* to_fetch_registers */
1444 monitor_store_registers
, /* to_store_registers */
1445 monitor_prepare_to_store
, /* to_prepare_to_store */
1446 monitor_xfer_memory
, /* to_xfer_memory */
1447 monitor_files_info
, /* to_files_info */
1448 monitor_insert_breakpoint
, /* to_insert_breakpoint */
1449 monitor_remove_breakpoint
, /* to_remove_breakpoint */
1450 0, /* to_terminal_init */
1451 0, /* to_terminal_inferior */
1452 0, /* to_terminal_ours_for_output */
1453 0, /* to_terminal_ours */
1454 0, /* to_terminal_info */
1455 monitor_kill
, /* to_kill */
1456 monitor_load
, /* to_load */
1457 0, /* to_lookup_symbol */
1458 monitor_create_inferior
, /* to_create_inferior */
1459 monitor_mourn_inferior
, /* to_mourn_inferior */
1461 0, /* to_notice_signals */
1462 monitor_stop
, /* to_stop */
1463 process_stratum
, /* to_stratum */
1465 1, /* to_has_all_memory */
1466 1, /* to_has_memory */
1467 1, /* to_has_stack */
1468 1, /* to_has_registers */
1469 1, /* to_has_execution */
1471 0, /* sections_end */
1472 OPS_MAGIC
/* to_magic */
1475 /* Init the target_ops structure pointed at by OPS */
1478 init_monitor_ops (ops
)
1479 struct target_ops
*ops
;
1481 memcpy (ops
, &monitor_ops
, sizeof monitor_ops
);
1484 /* Define additional commands that are usually only used by monitors. */
1487 _initialize_remote_monitors ()
1489 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
1491 "Set display of activity while downloading a file.\n\
1492 When enabled, a hashmark \'#\' is displayed.",
1496 add_com ("monitor", class_obscure
, monitor_command
,
1497 "Send a command to the debug monitor.");