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 remote-eb.c, which did a similar job, but for
22 an AMD-29K running EBMON. That file was in turn derived from remote.c
23 as mentioned in the following comment (left in for comic relief):
25 "This is like remote.c but is for an esoteric situation--
26 having an a29k board in a PC hooked up to a unix machine with
27 a serial line, and running ctty com1 on the PC, through which
28 the unix machine can run ebmon. Not to mention that the PC
29 has PC/NFS, so it can access the same executables that gdb can,
30 over the net in real time."
32 In reality, this module talks to a debug monitor called 'MONITOR', which
33 We communicate with MONITOR via either a direct serial line, or a TCP
34 (or possibly TELNET) stream to a terminal multiplexor,
35 which in turn talks to the target board.
37 This is based on remote-st2000.c. I left in the above note here for histerical
48 #include <sys/types.h>
52 #include "remote-utils.h"
55 # define TERMINAL struct termios
57 # define TERMINAL struct sgttyb
60 struct monitor_ops
*current_monitor
;
61 extern struct target_ops rom68k_ops
; /* Forward declaration */
62 extern struct target_ops mon68_ops
; /* Forward declaration */
63 extern struct target_ops monitor_bug_ops
; /* Forward declaration */
64 extern struct monitor_ops rom68k_cmds
; /* Forward declaration */
65 extern struct monitor_ops mon68_cmds
; /* Forward declaration */
66 extern struct monitor_ops bug_cmds
; /* Forward declaration */
67 extern struct cmd_list_element
*setlist
;
68 extern struct cmd_list_element
*unsetlist
;
69 struct cmd_list_element
*showlist
;
71 static void monitor_close();
72 static void monitor_fetch_register();
73 static void monitor_store_register();
75 static int sr_get_debug(); /* flag set by "set remotedebug" */
77 static int hashmark
; /* flag set by "set hash" */
79 /* FIXME: Replace with sr_get_debug (). */
80 #define LOG_FILE "monitor.log"
81 #if defined (LOG_FILE)
85 static int timeout
= 24;
87 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
88 monitor_open knows that we don't have a file open when the program starts.
90 static serial_t monitor_desc
= NULL
;
92 /* Send data to monitor. Works just like printf. */
95 printf_monitor(va_alist
)
105 pattern
= va_arg(args
, char *);
107 vsprintf(buf
, pattern
, args
);
109 if (SERIAL_WRITE(monitor_desc
, buf
, strlen(buf
)))
110 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
113 /* Read a character from the remote system, doing all the fancy
121 c
= SERIAL_READCHAR(monitor_desc
, timeout
);
128 putc(c
& 0x7f, log_file
);
134 if (c
== SERIAL_TIMEOUT
)
137 return c
; /* Polls shouldn't generate timeout errors */
139 error("Timeout reading from remote system.");
142 perror_with_name("remote-monitor");
145 /* Scan input from the remote system, until STRING is found. If DISCARD is
146 non-zero, then discard non-matching input, else print it out.
147 Let the user break out immediately. */
149 expect(string
, discard
)
157 printf ("Expecting \"%s\"\n", string
);
162 c
= readchar(timeout
);
171 printf ("\nMatched\n");
179 fwrite(string
, 1, (p
- 1) - string
, stdout
);
188 /* Keep discarding input until we see the MONITOR prompt.
190 The convention for dealing with the prompt is that you
192 o *then* wait for the prompt.
194 Thus the last thing that a procedure does with the serial line
195 will be an expect_prompt(). Exception: monitor_resume does not
196 wait for the prompt, because the terminal is being handed over
197 to the inferior. However, the next thing which happens after that
198 is a monitor_wait which does wait for the prompt.
199 Note that this includes abnormal exit, e.g. error(). This is
200 necessary to prevent getting into states from which we can't
203 expect_prompt(discard
)
206 #if defined (LOG_FILE)
207 /* This is a convenient place to do this. The idea is to do it often
208 enough that we never lose much data if we terminate abnormally. */
211 expect (PROMPT
, discard
);
214 /* Get a hex digit from the remote system & return its value.
215 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
217 get_hex_digit(ignore_space
)
223 ch
= readchar(timeout
);
224 if (ch
>= '0' && ch
<= '9')
226 else if (ch
>= 'A' && ch
<= 'F')
227 return ch
- 'A' + 10;
228 else if (ch
>= 'a' && ch
<= 'f')
229 return ch
- 'a' + 10;
230 else if (ch
== ' ' && ignore_space
)
235 error("Invalid hex digit from remote system.");
240 /* Get a byte from monitor and put it in *BYT. Accept any number
248 val
= get_hex_digit (1) << 4;
249 val
|= get_hex_digit (0);
253 /* Get N 32-bit words from remote, each preceded by a space,
254 and put them in registers starting at REGNO. */
256 get_hex_regs (n
, regno
)
263 for (i
= 0; i
< n
; i
++)
268 for (j
= 0; j
< 8; j
++)
269 val
= (val
<< 4) + get_hex_digit (j
== 0);
270 supply_register (regno
++, (char *) &val
);
274 /* This is called not only when we first attach, but also when the
275 user types "run" after having attached. */
277 monitor_create_inferior (execfile
, args
, env
)
285 error("Can't pass arguments to remote MONITOR process");
287 if (execfile
== 0 || exec_bfd
== 0)
288 error("No exec file specified");
290 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
293 fputs ("\nIn Create_inferior()", log_file
);
296 /* The "process" (board) is already stopped awaiting our commands, and
297 the program is already downloaded. We just set its PC and go. */
299 clear_proceed_status ();
301 /* Tell wait_for_inferior that we've started a new process. */
302 init_wait_for_inferior ();
304 /* Set up the "saved terminal modes" of the inferior
305 based on what modes we are starting it with. */
306 target_terminal_init ();
308 /* Install inferior's terminal modes. */
309 target_terminal_inferior ();
311 /* insert_step_breakpoint (); FIXME, do we need this? */
312 proceed ((CORE_ADDR
)entry_pt
, -1, 0); /* Let 'er rip... */
315 /* Open a connection to a remote debugger.
316 NAME is the filename used for communication. */
318 static int baudrate
= 9600;
319 static char dev_name
[100];
322 general_open(args
, name
, from_tty
)
328 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
329 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
331 target_preopen(from_tty
);
336 strcpy(dev_name
, args
);
337 monitor_desc
= SERIAL_OPEN(dev_name
);
339 if (monitor_desc
== NULL
)
340 perror_with_name(dev_name
);
342 /* The baud rate was specified when GDB was started. */
343 if (SERIAL_SETBAUDRATE (monitor_desc
, sr_get_baud_rate()))
345 SERIAL_CLOSE (monitor_desc
);
346 perror_with_name (name
);
349 SERIAL_RAW(monitor_desc
);
351 #if defined (LOG_FILE)
352 log_file
= fopen (LOG_FILE
, "w");
353 if (log_file
== NULL
)
354 perror_with_name (LOG_FILE
);
357 /* Hello? Are you there? */
358 printf_monitor("\r"); /* CR wakes up monitor */
363 printf("Remote %s connected to %s\n", target_shortname
,
368 rom68k_open(args
, from_tty
)
372 push_target(&rom68k_ops
);
373 push_monitor (&rom68k_cmds
);
375 general_open (args
, "rom68k", from_tty
);
379 mon68_open(args
, from_tty
)
383 push_target(&mon68_ops
);
384 push_monitor (&mon68_cmds
);
386 general_open (args
, "mon68", from_tty
);
390 bug_open(args
, from_tty
)
394 push_target(&monitor_bug_ops
);
395 push_monitor (&bug_cmds
);
397 general_open (args
, "bug", from_tty
);
401 * _close -- Close out all files and local state before this target loses control.
405 monitor_close (quitting
)
408 SERIAL_CLOSE(monitor_desc
);
411 #if defined (LOG_FILE)
413 if (ferror(log_file
))
414 fprintf(stderr
, "Error writing log file.\n");
415 if (fclose(log_file
) != 0)
416 fprintf(stderr
, "Error closing log file.\n");
421 /* Terminate the open connection to the remote debugger.
422 Use this when you want to detach and do something else
425 monitor_detach (from_tty
)
428 pop_target(); /* calls monitor_close to do the real work */
430 printf ("Ending remote %s debugging\n", target_shortname
);
434 * _resume -- Tell the remote machine to resume.
437 monitor_resume (pid
, step
, sig
)
439 enum target_signal sig
;
442 fprintf (log_file
, "\nIn Resume (step=%d, sig=%d)\n", step
, sig
);
447 printf_monitor (STEP_CMD
);
448 /* wait for the echo. */
449 expect (STEP_CMD
, 1);
453 printf_monitor (GO_CMD
);
454 /* swallow the echo. */
460 * _wait -- Wait until the remote machine stops, then return,
461 * storing status in status just as `wait' would.
465 monitor_wait (pid
, status
)
467 struct target_waitstatus
*status
;
469 int old_timeout
= timeout
;
471 fputs ("\nIn wait ()", log_file
);
474 status
->kind
= TARGET_WAITKIND_EXITED
;
475 status
->value
.integer
= 0;
477 timeout
= 0; /* Don't time out -- user program is running. */
479 expect_prompt(0); /* Wait for prompt, outputting extraneous text */
481 status
->kind
= TARGET_WAITKIND_STOPPED
;
482 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
484 timeout
= old_timeout
;
489 /* Return the name of register number regno in the form input and output by
490 monitor. Currently, register_names just happens to contain exactly what
491 monitor wants. Lets take advantage of that just as long as possible! */
505 for (p
= reg_names
[regno
]; *p
; p
++)
512 /* read the remote registers into the block regs. */
515 monitor_fetch_registers ()
519 /* yeah yeah, i know this is horribly inefficient. but it isn't done
520 very often... i'll clean it up later. */
522 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
523 monitor_fetch_register(regno
);
526 /* Fetch register REGNO, or all registers if REGNO is -1.
527 Returns errno value. */
529 monitor_fetch_register (regno
)
535 fprintf (log_file
, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno
));
541 monitor_fetch_registers ();
545 char *name
= get_reg_name (regno
);
546 printf_monitor (GET_REG
, name
);
548 expect (REG_DELIM
, 1);
549 if (strcasecmp (name
, "SR") == 0)
552 for (j
= 0; j
< 4; j
++)
553 val
= (val
<< 4) + get_hex_digit (j
== 0);
554 supply_register (regno
, (char *) &val
);
558 get_hex_regs (1, regno
);
563 printf_monitor (CMD_END
);
570 /* Store the remote registers from the contents of the block REGS. */
573 monitor_store_registers ()
577 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
578 monitor_store_register(regno
);
580 registers_changed ();
583 /* Store register REGNO, or all if REGNO == 0.
584 return errno value. */
586 monitor_store_register (regno
)
590 fprintf (log_file
, "\nIn Store_register (regno=%d)\n", regno
);
593 monitor_store_registers ();
597 printf ("Setting register %s to 0x%x\n", get_reg_name (regno
), read_register (regno
));
599 printf_monitor (SET_REG
, get_reg_name (regno
),
600 read_register (regno
));
606 /* Get ready to modify the registers array. On machines which store
607 individual registers, this doesn't need to do anything. On machines
608 which store all the registers in one fell swoop, this makes sure
609 that registers contains all the registers from the program being
613 monitor_prepare_to_store ()
615 /* Do nothing, since we can store individual regs */
619 monitor_files_info ()
621 printf ("\tAttached to %s at %d baud.\n",
625 /* Copy LEN bytes of data from debugger memory at MYADDR
626 to inferior's memory at MEMADDR. Returns length moved. */
628 monitor_write_inferior_memory (memaddr
, myaddr
, len
)
630 unsigned char *myaddr
;
637 fprintf (log_file
, "\nIn Write_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
639 for (i
= 0; i
< len
; i
++)
641 printf_monitor (MEM_SET_CMD
, memaddr
+ i
);
642 expect (sprintf (buf
, MEM_PROMPT
, memaddr
+ i
), 1);
644 printf_monitor ("%x", myaddr
[i
]);
646 printf ("\nSet 0x%x to 0x%x\n", memaddr
+ i
, myaddr
[i
]);
649 /*** expect (sprintf (buf, MEM_PROMPT, memaddr + i +1), 1);
650 expect (CMD_DELIM); ***/
651 printf_monitor (CMD_END
);
658 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
659 at debugger address MYADDR. Returns length moved. */
661 monitor_read_inferior_memory(memaddr
, myaddr
, len
)
669 /* Number of bytes read so far. */
672 /* Starting address of this pass. */
673 unsigned long startaddr
;
675 /* Number of bytes to read in this pass. */
679 fprintf (log_file
, "\nIn Read_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
682 /* Note that this code works correctly if startaddr is just less
683 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
684 thing). That is, something like
685 monitor_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
686 works--it never adds len To memaddr and gets 0. */
687 /* However, something like
688 monitor_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
689 doesn't need to work. Detect it and give up if there's an attempt
691 if (((memaddr
- 1) + len
) < memaddr
) {
701 if ((startaddr
% 16) != 0)
702 len_this_pass
-= startaddr
% 16;
703 if (len_this_pass
> (len
- count
))
704 len_this_pass
= (len
- count
);
706 printf ("\nDisplay %d bytes at %x\n", len_this_pass
, startaddr
);
708 for (i
= 0; i
< len_this_pass
; i
++)
710 printf_monitor (MEM_DIS_CMD
, startaddr
);
711 expect (sprintf(buf
, MEM_PROMPT
, startaddr
), 1);
712 get_hex_byte (&myaddr
[count
++]);
714 printf ("\nRead a 0x%x from 0x%x\n", myaddr
[count
-1], startaddr
);
718 printf_monitor (CMD_END
);
727 /* FIXME-someday! merge these two. */
729 monitor_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
734 struct target_ops
*target
; /* ignored */
737 return monitor_write_inferior_memory (memaddr
, myaddr
, len
);
739 return monitor_read_inferior_memory (memaddr
, myaddr
, len
);
743 monitor_kill (args
, from_tty
)
747 return; /* ignore attempts to kill target system */
750 /* Clean up when a program exits.
751 The program actually lives on in the remote processor's RAM, and may be
752 run again without a download. Don't leave it full of breakpoint
756 monitor_mourn_inferior ()
758 remove_breakpoints ();
759 generic_mourn_inferior (); /* Do all the proper things now */
762 #define MAX_MONITOR_BREAKPOINTS 16
764 extern int memory_breakpoint_size
;
765 static CORE_ADDR breakaddr
[MAX_MONITOR_BREAKPOINTS
] = {0};
768 monitor_insert_breakpoint (addr
, shadow
)
775 fprintf (log_file
, "\nIn Insert_breakpoint (addr=%x)\n", addr
);
777 for (i
= 0; i
<= MAX_MONITOR_BREAKPOINTS
; i
++)
778 if (breakaddr
[i
] == 0)
782 printf ("Breakpoint at %x\n", addr
);
783 monitor_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
784 printf_monitor(SET_BREAK_CMD
, addr
);
789 fprintf(stderr
, "Too many breakpoints (> 16) for monitor\n");
794 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
797 monitor_remove_breakpoint (addr
, shadow
)
804 fprintf (log_file
, "\nIn Remove_breakpoint (addr=%x)\n", addr
);
806 for (i
= 0; i
< MAX_MONITOR_BREAKPOINTS
; i
++)
807 if (breakaddr
[i
] == addr
)
810 /* some monitors remove breakpoints based on the address */
811 if (strcasecmp (target_shortname
, "bug") == 0)
812 printf_monitor(CLR_BREAK_CMD
, addr
);
814 printf_monitor(CLR_BREAK_CMD
, i
);
819 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
823 /* Load a file. This is usually an srecord, which is ascii. No
824 protocol, just sent line by line. */
826 #define DOWNLOAD_LINE_SIZE 100
832 char buf
[DOWNLOAD_LINE_SIZE
];
836 printf ("Loading %s to monitor\n", arg
);
838 download
= fopen (arg
, "r");
839 if (download
== NULL
)
841 error (sprintf (buf
, "%s Does not exist", arg
));
845 printf_monitor (LOAD_CMD
);
846 /* expect ("Waiting for S-records from host... ", 1); */
848 while (!feof (download
))
850 bytes_read
= fread (buf
, sizeof (char), DOWNLOAD_LINE_SIZE
, download
);
857 if (SERIAL_WRITE(monitor_desc
, buf
, bytes_read
)) {
858 fprintf(stderr
, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror(errno
));
862 while (i
++ <=200000) {} ; /* Ugly HACK, probably needs flow control */
863 if (bytes_read
< DOWNLOAD_LINE_SIZE
)
865 if (!feof (download
))
866 error ("Only read %d bytes\n", bytes_read
);
875 if (!feof (download
))
876 error ("Never got EOF while downloading");
880 /* Put a command string, in args, out to MONITOR. Output from MONITOR is placed
881 on the users terminal until the prompt is seen. */
884 monitor_command (args
, fromtty
)
889 fprintf (log_file
, "\nIn command (args=%s)\n", args
);
891 if (monitor_desc
== NULL
)
892 error("monitor target not open.");
895 error("Missing command.");
897 printf_monitor("%s\r", args
);
903 /* Connect the user directly to MONITOR. This command acts just like the
904 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
906 static struct ttystate ttystate
;
910 { printf("\r\n[Exiting connect mode]\r\n");
911 /*SERIAL_RESTORE(0, &ttystate);*/
915 connect_command (args
, fromtty
)
926 if (monitor_desc
== NULL
)
927 error("monitor target not open.");
930 fprintf("This command takes no args. They have been ignored.\n");
932 printf("[Entering connect mode. Use ~. or ~^D to escape]\n");
934 serial_raw(0, &ttystate
);
936 make_cleanup(cleanup_tty
, 0);
945 FD_SET(monitor_desc
, &readfds
);
946 numfds
= select(sizeof(readfds
)*8, &readfds
, 0, 0, 0);
951 perror_with_name("select");
953 if (FD_ISSET(0, &readfds
))
954 { /* tty input, send to monitor */
957 perror_with_name("connect");
959 printf_monitor("%c", c
);
973 if (c
== '.' || c
== '\004')
980 if (FD_ISSET(monitor_desc
, &readfds
))
996 * Define the monitor command strings. Since these are passed directly
997 * through to a printf style function, we need can include formatting
998 * strings. We also need a CR or LF on the end.
1000 struct monitor_ops rom68k_cmds
= {
1001 "go \r", /* execute or usually GO command */
1002 "go \r", /* continue command */
1003 "st \r", /* single step */
1004 "db %x\r", /* set a breakpoint */
1005 "cb %x\r", /* clear a breakpoint */
1006 "pm %x\r", /* set memory to a value */
1007 "pm %x\r", /* display memory */
1008 "-%08X ", /* prompt memory commands use */
1009 "pr %s %x\r", /* set a register */
1010 ": ", /* delimiter between registers */
1011 "pr %s\r", /* read a register */
1012 "dc \r", /* download command */
1013 "ROM68K :->", /* monitor command prompt */
1014 "=", /* end-of-command delimitor */
1015 ".\r" /* optional command terminator */
1018 struct monitor_ops bug_cmds
= {
1019 "go \r", /* execute or usually GO command */
1020 "go \r", /* continue command */
1021 "gn \r", /* single step */
1022 "br %x\r", /* set a breakpoint */
1023 "nobr %x\r", /* clear a breakpoint */
1024 "mm %x\r", /* set memory to a value */
1025 "mm %x\r", /* display memory */
1026 "%08X", /* prompt memory commands use */
1027 "rs %s %x\r", /* set a register */
1028 "=", /* delimiter between registers */
1029 "rm %s\r", /* read a register */
1030 "lo 0\r", /* download command */
1031 "Bug>", /* monitor command prompt */
1032 "? ", /* end-of-command delimitor */
1033 ".\r" /* optional command terminator */
1036 /* Define the target subroutine names */
1037 struct monitor_ops mon68_cmds
= {
1038 "", /* execute or usually GO command */
1039 "", /* continue command */
1040 "", /* single step */
1041 "", /* set a breakpoint */
1042 "", /* clear a breakpoint */
1043 "", /* set memory to a value */
1044 "", /* display memory */
1045 "", /* set a register */
1046 "", /* delimiter between registers */
1047 "", /* read a register */
1048 "", /* download command */
1049 ">", /* monitor command prompt */
1050 "", /* end-of-command delimitor */
1051 "" /* optional command terminator */
1054 struct target_ops rom68k_ops
= {
1056 "Integrated System's ROM68K remote debug monitor",
1057 "Use a remote computer running the ROM68K debug monitor.\n\
1058 Specify the serial device it is connected to (e.g. /dev/ttya).",
1065 monitor_fetch_register
,
1066 monitor_store_register
,
1067 monitor_prepare_to_store
,
1068 monitor_xfer_inferior_memory
,
1070 monitor_insert_breakpoint
,
1071 monitor_remove_breakpoint
, /* Breakpoints */
1076 0, /* Terminal handling */
1078 monitor_load
, /* load */
1079 0, /* lookup_symbol */
1080 monitor_create_inferior
,
1081 monitor_mourn_inferior
,
1083 0, /* notice_signals */
1090 1, /* all mem, mem, stack, regs, exec */
1092 0, /* Section pointers */
1093 OPS_MAGIC
, /* Always the last thing */
1096 struct target_ops monitor_bug_ops
= {
1098 "Motorola's BUG remote serial debug monitor",
1099 "Use a remote computer running Motorola's BUG debug monitor.\n\
1100 Specify the serial device it is connected to (e.g. /dev/ttya).",
1107 monitor_fetch_register
,
1108 monitor_store_register
,
1109 monitor_prepare_to_store
,
1110 monitor_xfer_inferior_memory
,
1112 monitor_insert_breakpoint
,
1113 monitor_remove_breakpoint
, /* Breakpoints */
1118 0, /* Terminal handling */
1120 monitor_load
, /* load */
1121 0, /* lookup_symbol */
1122 monitor_create_inferior
,
1123 monitor_mourn_inferior
,
1125 0, /* notice_signals */
1132 1, /* all mem, mem, stack, regs, exec */
1134 0, /* Section pointers */
1135 OPS_MAGIC
, /* Always the last thing */
1138 struct target_ops mon68_ops
= {
1140 "Intermetric's MON68 remote serial debug monitor",
1141 "Use a remote computer running the MON68 debug monitor.\n\
1142 Specify the serial device it is connected to (e.g. /dev/ttya).",
1149 monitor_fetch_register
,
1150 monitor_store_register
,
1151 monitor_prepare_to_store
,
1152 monitor_xfer_inferior_memory
,
1154 monitor_insert_breakpoint
,
1155 monitor_remove_breakpoint
, /* Breakpoints */
1160 0, /* Terminal handling */
1162 monitor_load
, /* load */
1163 0, /* lookup_symbol */
1164 monitor_create_inferior
,
1165 monitor_mourn_inferior
,
1167 0, /* notice_signals */
1174 1, /* all mem, mem, stack, regs, exec */
1176 0, /* Section pointers */
1177 OPS_MAGIC
, /* Always the last thing */
1181 _initialize_remote_monitors ()
1184 add_set_cmd ("hash", no_class
, var_boolean
,
1186 "Set display of activity while downloading a file.\n\
1187 When enabled, a period \'.\' is displayed.",
1191 /* generic monitor command */
1192 add_com ("monitor <command>", class_obscure
, monitor_command
,
1193 "Send a command to the debug monitor.");
1195 add_com ("connect", class_obscure
, connect_command
,
1196 "Connect the terminal directly up to a serial based command monitor.\n\
1197 Use <CR>~. or <CR>~^D to break out.");
1200 add_target (&rom68k_ops
);
1201 /* add_target (&mon68_ops); */
1202 add_target (&monitor_bug_ops
);