1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993 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.
39 #include <sys/types.h>
43 #include "remote-utils.h"
46 # define TERMINAL struct termios
48 # define TERMINAL struct sgttyb
51 struct monitor_ops
*current_monitor
;
52 extern struct cmd_list_element
*setlist
;
53 extern struct cmd_list_element
*unsetlist
;
54 struct cmd_list_element
*showlist
;
56 static int hashmark
; /* flag set by "set hash" */
58 /* FIXME: Replace with sr_get_debug (). */
59 #define LOG_FILE "monitor.log"
60 #if defined (LOG_FILE)
64 static int timeout
= 24;
66 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
67 monitor_open knows that we don't have a file open when the program starts.
69 static serial_t monitor_desc
= NULL
;
71 /* sets the download protocol, choices are srec, generic, boot */
73 static char *loadtype_str
;
74 static void set_loadtype_command();
77 * set_loadtype_command -- set the type for downloading. Check to make
78 * sure you have a support protocol for this target.
81 set_loadtype_command (ignore
, from_tty
, c
)
84 struct cmd_list_element
*c
;
88 if (strcmp (LOADTYPES
, "")) {
89 error ("No loadtype set");
93 type
= strtok(LOADTYPES
, ",");
94 if (STREQ (type
, (*(char **) c
->var
))) {
95 loadtype_str
= savestring (*(char **) c
->var
, strlen (*(char **) c
->var
));
99 while (type
= strtok (NULL
, ",") != (char *)NULL
)
100 if (STREQ (type
, (*(char **) c
->var
)))
101 loadtype_str
= savestring (*(char **) c
->var
, strlen (*(char **) c
->var
));
103 loadtype_str
= savestring (*(char **) c
->var
, strlen (*(char **) c
->var
));
107 * printf_monitor -- send data to monitor. Works just like printf.
110 printf_monitor(va_alist
)
120 pattern
= va_arg(args
, char *);
122 vsprintf(buf
, pattern
, args
);
124 if (sr_get_debug() > 3)
125 printf ("Sending to monitor,\r\n\t\"%s\".\r\n", buf
);
127 if (SERIAL_WRITE(monitor_desc
, buf
, strlen(buf
)))
128 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
131 /* readchar -- read a character from the remote system, doing all the fancy
140 c
= SERIAL_READCHAR(monitor_desc
, timeout
);
142 if (sr_get_debug() > 5)
147 putc(c
& 0x7f, log_file
);
153 if (c
== SERIAL_TIMEOUT
) {
155 return c
; /* Polls shouldn't generate timeout errors */
156 error("Timeout reading from remote system.");
158 perror_with_name("remote-monitor");
162 * expect -- scan input from the remote system, until STRING is found.
163 * If DISCARD is non-zero, then discard non-matching input, else print
164 * it out. Let the user break out immediately.
167 expect (string
, discard
)
176 printf ("Expecting \"%s\".\n", string
);
180 c
= readchar(timeout
);
187 printf ("\nMatched\n");
192 fwrite(string
, 1, (p
- 1) - string
, stdout
);
201 /* Keep discarding input until we see the MONITOR prompt.
203 The convention for dealing with the prompt is that you
205 o *then* wait for the prompt.
207 Thus the last thing that a procedure does with the serial line
208 will be an expect_prompt(). Exception: monitor_resume does not
209 wait for the prompt, because the terminal is being handed over
210 to the inferior. However, the next thing which happens after that
211 is a monitor_wait which does wait for the prompt.
212 Note that this includes abnormal exit, e.g. error(). This is
213 necessary to prevent getting into states from which we can't
216 expect_prompt(discard
)
219 #if defined (LOG_FILE)
220 /* This is a convenient place to do this. The idea is to do it often
221 enough that we never lose much data if we terminate abnormally. */
224 expect (PROMPT
, discard
);
228 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
240 if (sr_get_debug() > 5)
241 printf ("Ignoring \'%c\'.\n", ch
);
244 if (sr_get_debug() > 5)
245 printf ("Accepting \'%c\'.\n", ch
);
251 * get_hex_digit -- Get a hex digit from the remote system & return its value.
252 * If ignore is nonzero, ignore spaces, newline & tabs.
255 get_hex_digit(ignore
)
260 ch
= readchar(timeout
);
263 if (sr_get_debug() > 4)
264 printf ("get_hex_digit() got a 0x%x(%c)\n", ch
, ch
);
266 if (ch
>= '0' && ch
<= '9')
268 else if (ch
>= 'A' && ch
<= 'F')
269 return ch
- 'A' + 10;
270 else if (ch
>= 'a' && ch
<= 'f')
271 return ch
- 'a' + 10;
272 else if (ch
== ' ' && ignore
)
276 error("Invalid hex digit from remote system.");
281 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
282 * Accept any number leading spaces.
290 val
= get_hex_digit (1) << 4;
291 if (sr_get_debug() > 3)
292 printf ("\nget_hex_digit() -- Read first nibble 0x%x\n", val
);
294 val
|= get_hex_digit (0);
295 if (sr_get_debug() > 3)
296 printf ("\nget_hex_digit() -- Read second nibble 0x%x\n", val
);
299 if (sr_get_debug() > 3)
300 printf ("\nget_hex_digit() -- Read a 0x%x\n", val
);
304 * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
305 * and put them in registers starting at REGNO.
314 for (i
= 0; i
< 8; i
++)
315 val
= (val
<< 4) + get_hex_digit (i
== 0);
317 if (sr_get_debug() > 3)
318 printf ("\nget_hex_word() got a 0x%x.\n", val
);
323 /* This is called not only when we first attach, but also when the
324 user types "run" after having attached. */
326 monitor_create_inferior (execfile
, args
, env
)
334 error("Can't pass arguments to remote MONITOR process");
336 if (execfile
== 0 || exec_bfd
== 0)
337 error("No exec file specified");
339 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
342 fputs ("\nIn Create_inferior()", log_file
);
345 /* The "process" (board) is already stopped awaiting our commands, and
346 the program is already downloaded. We just set its PC and go. */
348 clear_proceed_status ();
350 /* Tell wait_for_inferior that we've started a new process. */
351 init_wait_for_inferior ();
353 /* Set up the "saved terminal modes" of the inferior
354 based on what modes we are starting it with. */
355 target_terminal_init ();
357 /* Install inferior's terminal modes. */
358 target_terminal_inferior ();
360 /* insert_step_breakpoint (); FIXME, do we need this? */
363 proceed ((CORE_ADDR
)entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
367 * monitor_open -- open a connection to a remote debugger.
368 * NAME is the filename used for communication.
370 static int baudrate
= 9600;
371 static char dev_name
[100];
374 monitor_open(args
, name
, from_tty
)
381 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
382 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
387 strcpy(dev_name
, args
);
388 monitor_desc
= SERIAL_OPEN(dev_name
);
390 if (monitor_desc
== NULL
)
391 perror_with_name(dev_name
);
395 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
397 SERIAL_CLOSE (monitor_desc
);
398 perror_with_name (name
);
402 SERIAL_RAW(monitor_desc
);
404 #if defined (LOG_FILE)
405 log_file
= fopen (LOG_FILE
, "w");
406 if (log_file
== NULL
)
407 perror_with_name (LOG_FILE
);
410 /* wake up the monitor and see if it's alive */
411 printf_monitor(INIT_CMD
);
412 expect_prompt(1); /* See if we get a prompt */
414 /* try again to be sure */
415 printf_monitor(INIT_CMD
);
416 expect_prompt(1); /* See if we get a prompt */
419 printf("Remote target %s connected to %s\n", TARGET_NAME
, dev_name
);
425 * monitor_close -- Close out all files and local state before this
426 * target loses control.
430 monitor_close (quitting
)
433 SERIAL_CLOSE(monitor_desc
);
436 if (sr_get_debug() > 4)
437 puts ("\nmonitor_close ()");
439 #if defined (LOG_FILE)
441 if (ferror(log_file
))
442 fprintf(stderr
, "Error writing log file.\n");
443 if (fclose(log_file
) != 0)
444 fprintf(stderr
, "Error closing log file.\n");
450 * monitor_detach -- terminate the open connection to the remote
451 * debugger. Use this when you want to detach and do something
452 * else with your gdb.
455 monitor_detach (from_tty
)
459 fprintf (log_file
, "\nmonitor_detach ()\n");
462 pop_target(); /* calls monitor_close to do the real work */
464 printf ("Ending remote %s debugging\n", target_shortname
);
468 * monitor_attach -- attach GDB to the target.
471 monitor_attach (args
, from_tty
)
476 printf ("Starting remote %s debugging\n", target_shortname
);
479 fprintf (log_file
, "\nmonitor_attach (args=%s)\n", args
);
482 if (sr_get_debug() > 4)
483 printf ("\nmonitor_attach (args=%s)\n", args
);
485 printf_monitor (GO_CMD
);
486 /* swallow the echo. */
491 * monitor_resume -- Tell the remote machine to resume.
494 monitor_resume (pid
, step
, sig
)
496 enum target_signal sig
;
499 fprintf (log_file
, "\nmonitor_resume (step=%d, sig=%d)\n", step
, sig
);
502 if (sr_get_debug() > 4)
503 printf ("\nmonitor_resume (step=%d, sig=%d)\n", step
, sig
);
506 printf_monitor (STEP_CMD
);
507 /* wait for the echo. */
508 expect (STEP_CMD
, 1);
510 printf_monitor (CONT_CMD
);
511 /* swallow the echo. */
512 expect (CONT_CMD
, 1);
517 * _wait -- Wait until the remote machine stops, then return,
518 * storing status in status just as `wait' would.
522 monitor_wait (pid
, status
)
524 struct target_waitstatus
*status
;
526 int old_timeout
= timeout
;
528 fputs ("\nIn wait ()", log_file
);
531 status
->kind
= TARGET_WAITKIND_EXITED
;
532 status
->value
.integer
= 0;
534 timeout
= 0; /* Don't time out -- user program is running. */
536 expect_prompt(0); /* Wait for prompt, outputting extraneous text */
538 status
->kind
= TARGET_WAITKIND_STOPPED
;
539 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
541 timeout
= old_timeout
;
546 /* Return the name of register number regno in the form input and output by
547 monitor. Currently, register_names just happens to contain exactly what
548 monitor wants. Lets take advantage of that just as long as possible! */
563 for (p
= REGNAMES(regno
); *p
; p
++)
568 if (sr_get_debug() > 5)
569 printf ("Got name \"%s\" from regno #%d.\n", buf
, regno
);
572 fprintf (log_file
, "Got name \"%s\" from regno #%d.\n", buf
, regno
);
579 /* read the remote registers into the block regs. */
582 monitor_fetch_registers ()
586 /* yeah yeah, i know this is horribly inefficient. but it isn't done
587 very often... i'll clean it up later. */
589 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
590 monitor_fetch_register(regno
);
594 * monitor_fetch_register -- fetch register REGNO, or all registers if REGNO
595 * is -1. Returns errno value.
598 monitor_fetch_register (regno
)
604 fprintf (log_file
, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno
));
609 monitor_fetch_registers ();
611 char *name
= get_reg_name (regno
);
614 printf_monitor (ROMCMD(GET_REG
), name
); /* send the command */
615 expect (name
, 1); /* then strip the leading garbage */
616 if (*ROMDELIM(GET_REG
) != 0) { /* if there's a delimiter */
617 expect (ROMDELIM(GET_REG
), 1);
620 val
= get_hex_word(); /* get the value, ignore junk */
621 supply_register (regno
, (char *) &val
);
623 if (*ROMDELIM(GET_REG
) != 0) {
624 /*** expect (ROMRES(GET_REG)); ***/
625 printf_monitor (CMD_END
);
632 /* Store the remote registers from the contents of the block REGS. */
635 monitor_store_registers ()
640 fprintf (log_file
, "\nIn Fetch Registers\n");
643 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
644 monitor_store_register(regno
);
646 registers_changed ();
650 * monitor_store_register -- store register REGNO, or all if REGNO == 0.
651 * return errno value.
654 monitor_store_register (regno
)
660 i
= read_register(regno
);
663 fprintf (log_file
, "\nIn Store_register (regno=%d)\n", regno
);
667 monitor_store_registers ();
669 if (sr_get_debug() > 3)
670 printf ("Setting register %s to 0x%x\n", get_reg_name (regno
), read_register (regno
));
672 name
= get_reg_name (regno
);
675 printf_monitor (ROMCMD(SET_REG
), name
, read_register(regno
));
676 expect (name
, 1); /* strip the leading garbage */
677 if (*ROMDELIM(SET_REG
) != 0) { /* if there's a delimiter */
678 expect (ROMDELIM(SET_REG
), 1);
680 printf_monitor ("%d%s\n", i
, CMD_END
);
687 printf_monitor (SET_REG
, get_reg_name (regno
),
688 read_register (regno
));
694 /* Get ready to modify the registers array. On machines which store
695 individual registers, this doesn't need to do anything. On machines
696 which store all the registers in one fell swoop, this makes sure
697 that registers contains all the registers from the program being
701 monitor_prepare_to_store ()
703 /* Do nothing, since we can store individual regs */
707 monitor_files_info ()
709 printf ("\tAttached to %s at %d baud.\n",
714 * monitor_write_inferior_memory -- Copy LEN bytes of data from debugger
715 * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
718 monitor_write_inferior_memory (memaddr
, myaddr
, len
)
720 unsigned char *myaddr
;
727 fprintf (log_file
, "\nIn Write_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
730 if (sr_get_debug() > 0)
731 printf ("\nTrying to set 0x%x to 0x%x\n", memaddr
, myaddr
);
733 for (i
= 0; i
< len
; i
++) {
734 printf_monitor (ROMCMD(SET_MEM
), memaddr
+ i
, myaddr
[i
] );
735 if (*ROMDELIM(SET_MEM
) != 0) { /* if there's a delimiter */
736 expect (ROMDELIM(SET_MEM
), 1);
738 printf_monitor ("%x", myaddr
[i
]);
740 /*** printf_monitor ("%x", myaddr[i]); ***/
741 if (sr_get_debug() > 1)
742 printf ("\nSet 0x%x to 0x%x\n", memaddr
+ i
, myaddr
[i
]);
743 if (*ROMDELIM(SET_MEM
) != 0) {
745 printf_monitor (CMD_END
);
753 * monitor_read_inferior_memory -- read LEN bytes from inferior memory
754 * at MEMADDR. Put the result at debugger address MYADDR. Returns
758 monitor_read_inferior_memory(memaddr
, myaddr
, len
)
766 /* Number of bytes read so far. */
769 /* Starting address of this pass. */
770 unsigned long startaddr
;
772 /* Number of bytes to read in this pass. */
776 fprintf (log_file
, "\nIn Read_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
779 /* Note that this code works correctly if startaddr is just less
780 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
781 thing). That is, something like
782 monitor_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
783 works--it never adds len To memaddr and gets 0. */
784 /* However, something like
785 monitor_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
786 doesn't need to work. Detect it and give up if there's an attempt
788 if (((memaddr
- 1) + len
) < memaddr
) {
795 while (count
< len
) {
797 if ((startaddr
% 16) != 0)
798 len_this_pass
-= startaddr
% 16;
799 if (len_this_pass
> (len
- count
))
800 len_this_pass
= (len
- count
);
802 printf ("\nDisplay %d bytes at %x\n", len_this_pass
, startaddr
);
804 for (i
= 0; i
< len_this_pass
; i
++) {
805 printf_monitor (ROMCMD(GET_MEM
), startaddr
, startaddr
);
806 sprintf (buf
, ROMCMD(GET_MEM
), startaddr
, startaddr
);
808 expect (buf
,1); /* get the command echo */
809 get_hex_word(1); /* strip away the address */
811 if (*ROMDELIM(GET_MEM
) != 0) { /* if there's a delimiter */
812 expect (ROMDELIM(GET_MEM
), 1);
814 sprintf (buf
, ROMCMD(GET_MEM
), startaddr
, startaddr
);
815 expect (buf
,1); /* get the command echo */
816 get_hex_word(1); /* strip away the address */
818 get_hex_byte (&myaddr
[count
++]); /* get the value at this address */
820 if (*ROMDELIM(GET_MEM
) != 0) {
821 printf_monitor (CMD_END
);
830 /* FIXME-someday! merge these two. */
832 monitor_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
837 struct target_ops
*target
; /* ignored */
840 return monitor_write_inferior_memory (memaddr
, myaddr
, len
);
842 return monitor_read_inferior_memory (memaddr
, myaddr
, len
);
846 monitor_kill (args
, from_tty
)
850 return; /* ignore attempts to kill target system */
853 /* Clean up when a program exits.
854 The program actually lives on in the remote processor's RAM, and may be
855 run again without a download. Don't leave it full of breakpoint
859 monitor_mourn_inferior ()
861 remove_breakpoints ();
862 generic_mourn_inferior (); /* Do all the proper things now */
865 #define MAX_MONITOR_BREAKPOINTS 16
867 extern int memory_breakpoint_size
;
868 static CORE_ADDR breakaddr
[MAX_MONITOR_BREAKPOINTS
] = {0};
871 * monitor_insert_breakpoint -- add a breakpoint
874 monitor_insert_breakpoint (addr
, shadow
)
881 fprintf (log_file
, "\nIn Insert_breakpoint (addr=%x)\n", addr
);
884 if (sr_get_debug() > 4)
885 printf ("insert_breakpoint() addr = 0x%x\n", addr
);
887 for (i
= 0; i
<= MAX_MONITOR_BREAKPOINTS
; i
++) {
888 if (breakaddr
[i
] == 0) {
890 if (sr_get_debug() > 4)
891 printf ("Breakpoint at %x\n", addr
);
892 monitor_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
893 printf_monitor(SET_BREAK_CMD
, addr
);
899 fprintf(stderr
, "Too many breakpoints (> 16) for monitor\n");
904 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
907 monitor_remove_breakpoint (addr
, shadow
)
914 fprintf (log_file
, "\nIn Remove_breakpoint (addr=%x)\n", addr
);
917 if (sr_get_debug() > 4)
918 printf ("remove_breakpoint (addr=%x)\n", addr
);
920 for (i
= 0; i
< MAX_MONITOR_BREAKPOINTS
; i
++) {
921 if (breakaddr
[i
] == addr
) {
923 /* some monitors remove breakpoints based on the address */
925 printf_monitor(CLR_BREAK_CMD
, addr
);
927 printf_monitor(CLR_BREAK_CMD
, i
);
932 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
936 /* Load a file. This is usually an srecord, which is ascii. No
937 protocol, just sent line by line. */
939 #define DOWNLOAD_LINE_SIZE 100
945 char buf
[DOWNLOAD_LINE_SIZE
];
949 printf ("Loading %s to monitor\n", arg
);
951 download
= fopen (arg
, "r");
952 if (download
== NULL
)
954 error (sprintf (buf
, "%s Does not exist", arg
));
958 printf_monitor (LOAD_CMD
);
959 /* expect ("Waiting for S-records from host... ", 1); */
961 while (!feof (download
))
963 bytes_read
= fread (buf
, sizeof (char), DOWNLOAD_LINE_SIZE
, download
);
970 if (SERIAL_WRITE(monitor_desc
, buf
, bytes_read
)) {
971 fprintf(stderr
, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror(errno
));
975 while (i
++ <=200000) {} ; /* Ugly HACK, probably needs flow control */
976 if (bytes_read
< DOWNLOAD_LINE_SIZE
)
978 if (!feof (download
))
979 error ("Only read %d bytes\n", bytes_read
);
988 if (!feof (download
))
989 error ("Never got EOF while downloading");
994 * monitor_command -- put a command string, in args, out to MONITOR.
995 * Output from MONITOR is placed on the users terminal until the
996 * prompt is seen. FIXME: We read the charcters ourseleves here
997 * cause of a nasty echo.
1000 monitor_command (args
, fromtty
)
1010 fprintf (log_file
, "\nmonitor_command (args=%s)\n", args
);
1012 if (monitor_desc
== NULL
)
1013 error("monitor target not open.");
1016 error("Missing command.");
1018 if (sr_get_debug() > 4)
1019 printf ("monitor_command (args=%s)\n", args
);
1021 printf_monitor ("%s\n", args
);
1027 * _initialize_remote_monitors -- setup a few addtitional commands that
1028 * are usually only used by monitors.
1031 _initialize_remote_monitors ()
1033 struct cmd_list_element
*c
;
1035 /* this sets the type of download protocol */
1036 c
= add_set_cmd ("loadtype", no_class
, var_string
, (char *)&loadtype_str
,
1037 "Set the type of the remote load protocol.\n", &setlist
);
1038 c
->function
.sfunc
= set_loadtype_command
;
1039 add_show_from_set (c
, &showlist
);
1040 loadtype_str
= savestring ("generic", 8);
1042 add_show_from_set (add_set_cmd ("hash", no_class
, var_boolean
,
1044 "Set display of activity while downloading a file.\n\
1045 When enabled, a period \'.\' is displayed.",
1049 /* generic monitor command */
1050 add_com ("monitor", class_obscure
, monitor_command
,
1051 "Send a command to the debug monitor.");
This page took 0.067368 seconds and 5 git commands to generate.