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? */
314 proceed ((CORE_ADDR
)entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
317 /* Open a connection to a remote debugger.
318 NAME is the filename used for communication. */
320 static int baudrate
= 9600;
321 static char dev_name
[100];
324 general_open(args
, name
, from_tty
)
330 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
331 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
333 target_preopen(from_tty
);
338 strcpy(dev_name
, args
);
339 monitor_desc
= SERIAL_OPEN(dev_name
);
341 if (monitor_desc
== NULL
)
342 perror_with_name(dev_name
);
346 if (SERIAL_SETBAUDRATE (monitor_desc
, baud_rate
))
348 SERIAL_CLOSE (monitor_desc
);
349 perror_with_name (name
);
353 SERIAL_RAW(monitor_desc
);
355 #if defined (LOG_FILE)
356 log_file
= fopen (LOG_FILE
, "w");
357 if (log_file
== NULL
)
358 perror_with_name (LOG_FILE
);
361 /* Hello? Are you there? */
362 printf_monitor("\r"); /* CR wakes up monitor */
367 printf("Remote %s connected to %s\n", target_shortname
,
372 rom68k_open(args
, from_tty
)
376 push_target(&rom68k_ops
);
377 push_monitor (&rom68k_cmds
);
379 general_open (args
, "rom68k", from_tty
);
383 mon68_open(args
, from_tty
)
387 push_target(&mon68_ops
);
388 push_monitor (&mon68_cmds
);
390 general_open (args
, "mon68", from_tty
);
394 bug_open(args
, from_tty
)
398 push_target(&monitor_bug_ops
);
399 push_monitor (&bug_cmds
);
401 general_open (args
, "bug", from_tty
);
405 * _close -- Close out all files and local state before this target loses control.
409 monitor_close (quitting
)
412 SERIAL_CLOSE(monitor_desc
);
415 #if defined (LOG_FILE)
417 if (ferror(log_file
))
418 fprintf(stderr
, "Error writing log file.\n");
419 if (fclose(log_file
) != 0)
420 fprintf(stderr
, "Error closing log file.\n");
425 /* Terminate the open connection to the remote debugger.
426 Use this when you want to detach and do something else
429 monitor_detach (from_tty
)
432 pop_target(); /* calls monitor_close to do the real work */
434 printf ("Ending remote %s debugging\n", target_shortname
);
438 * _resume -- Tell the remote machine to resume.
441 monitor_resume (pid
, step
, sig
)
443 enum target_signal sig
;
446 fprintf (log_file
, "\nIn Resume (step=%d, sig=%d)\n", step
, sig
);
451 printf_monitor (STEP_CMD
);
452 /* wait for the echo. */
453 expect (STEP_CMD
, 1);
457 printf_monitor (GO_CMD
);
458 /* swallow the echo. */
464 * _wait -- Wait until the remote machine stops, then return,
465 * storing status in status just as `wait' would.
469 monitor_wait (pid
, status
)
471 struct target_waitstatus
*status
;
473 int old_timeout
= timeout
;
475 fputs ("\nIn wait ()", log_file
);
478 status
->kind
= TARGET_WAITKIND_EXITED
;
479 status
->value
.integer
= 0;
481 timeout
= 0; /* Don't time out -- user program is running. */
483 expect_prompt(0); /* Wait for prompt, outputting extraneous text */
485 status
->kind
= TARGET_WAITKIND_STOPPED
;
486 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
488 timeout
= old_timeout
;
493 /* Return the name of register number regno in the form input and output by
494 monitor. Currently, register_names just happens to contain exactly what
495 monitor wants. Lets take advantage of that just as long as possible! */
509 for (p
= reg_names
[regno
]; *p
; p
++)
516 /* read the remote registers into the block regs. */
519 monitor_fetch_registers ()
523 /* yeah yeah, i know this is horribly inefficient. but it isn't done
524 very often... i'll clean it up later. */
526 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
527 monitor_fetch_register(regno
);
530 /* Fetch register REGNO, or all registers if REGNO is -1.
531 Returns errno value. */
533 monitor_fetch_register (regno
)
539 fprintf (log_file
, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno
));
545 monitor_fetch_registers ();
549 char *name
= get_reg_name (regno
);
550 printf_monitor (GET_REG
, name
);
552 expect (REG_DELIM
, 1);
553 if (strcasecmp (name
, "SR") == 0)
556 for (j
= 0; j
< 4; j
++)
557 val
= (val
<< 4) + get_hex_digit (j
== 0);
558 supply_register (regno
, (char *) &val
);
562 get_hex_regs (1, regno
);
567 printf_monitor (CMD_END
);
574 /* Store the remote registers from the contents of the block REGS. */
577 monitor_store_registers ()
581 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
582 monitor_store_register(regno
);
584 registers_changed ();
587 /* Store register REGNO, or all if REGNO == 0.
588 return errno value. */
590 monitor_store_register (regno
)
594 fprintf (log_file
, "\nIn Store_register (regno=%d)\n", regno
);
597 monitor_store_registers ();
601 printf ("Setting register %s to 0x%x\n", get_reg_name (regno
), read_register (regno
));
603 printf_monitor (SET_REG
, get_reg_name (regno
),
604 read_register (regno
));
610 /* Get ready to modify the registers array. On machines which store
611 individual registers, this doesn't need to do anything. On machines
612 which store all the registers in one fell swoop, this makes sure
613 that registers contains all the registers from the program being
617 monitor_prepare_to_store ()
619 /* Do nothing, since we can store individual regs */
623 monitor_files_info ()
625 printf ("\tAttached to %s at %d baud.\n",
629 /* Copy LEN bytes of data from debugger memory at MYADDR
630 to inferior's memory at MEMADDR. Returns length moved. */
632 monitor_write_inferior_memory (memaddr
, myaddr
, len
)
634 unsigned char *myaddr
;
641 fprintf (log_file
, "\nIn Write_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
643 for (i
= 0; i
< len
; i
++)
645 printf_monitor (MEM_SET_CMD
, memaddr
+ i
);
646 expect (sprintf (buf
, MEM_PROMPT
, memaddr
+ i
), 1);
648 printf_monitor ("%x", myaddr
[i
]);
650 printf ("\nSet 0x%x to 0x%x\n", memaddr
+ i
, myaddr
[i
]);
653 /*** expect (sprintf (buf, MEM_PROMPT, memaddr + i +1), 1);
654 expect (CMD_DELIM); ***/
655 printf_monitor (CMD_END
);
662 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
663 at debugger address MYADDR. Returns length moved. */
665 monitor_read_inferior_memory(memaddr
, myaddr
, len
)
673 /* Number of bytes read so far. */
676 /* Starting address of this pass. */
677 unsigned long startaddr
;
679 /* Number of bytes to read in this pass. */
683 fprintf (log_file
, "\nIn Read_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
686 /* Note that this code works correctly if startaddr is just less
687 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
688 thing). That is, something like
689 monitor_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
690 works--it never adds len To memaddr and gets 0. */
691 /* However, something like
692 monitor_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
693 doesn't need to work. Detect it and give up if there's an attempt
695 if (((memaddr
- 1) + len
) < memaddr
) {
705 if ((startaddr
% 16) != 0)
706 len_this_pass
-= startaddr
% 16;
707 if (len_this_pass
> (len
- count
))
708 len_this_pass
= (len
- count
);
710 printf ("\nDisplay %d bytes at %x\n", len_this_pass
, startaddr
);
712 for (i
= 0; i
< len_this_pass
; i
++)
714 printf_monitor (MEM_DIS_CMD
, startaddr
);
715 expect (sprintf(buf
, MEM_PROMPT
, startaddr
), 1);
716 get_hex_byte (&myaddr
[count
++]);
718 printf ("\nRead a 0x%x from 0x%x\n", myaddr
[count
-1], startaddr
);
722 printf_monitor (CMD_END
);
731 /* FIXME-someday! merge these two. */
733 monitor_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
738 struct target_ops
*target
; /* ignored */
741 return monitor_write_inferior_memory (memaddr
, myaddr
, len
);
743 return monitor_read_inferior_memory (memaddr
, myaddr
, len
);
747 monitor_kill (args
, from_tty
)
751 return; /* ignore attempts to kill target system */
754 /* Clean up when a program exits.
755 The program actually lives on in the remote processor's RAM, and may be
756 run again without a download. Don't leave it full of breakpoint
760 monitor_mourn_inferior ()
762 remove_breakpoints ();
763 generic_mourn_inferior (); /* Do all the proper things now */
766 #define MAX_MONITOR_BREAKPOINTS 16
768 extern int memory_breakpoint_size
;
769 static CORE_ADDR breakaddr
[MAX_MONITOR_BREAKPOINTS
] = {0};
772 monitor_insert_breakpoint (addr
, shadow
)
779 fprintf (log_file
, "\nIn Insert_breakpoint (addr=%x)\n", addr
);
781 for (i
= 0; i
<= MAX_MONITOR_BREAKPOINTS
; i
++)
782 if (breakaddr
[i
] == 0)
786 printf ("Breakpoint at %x\n", addr
);
787 monitor_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
788 printf_monitor(SET_BREAK_CMD
, addr
);
793 fprintf(stderr
, "Too many breakpoints (> 16) for monitor\n");
798 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
801 monitor_remove_breakpoint (addr
, shadow
)
808 fprintf (log_file
, "\nIn Remove_breakpoint (addr=%x)\n", addr
);
810 for (i
= 0; i
< MAX_MONITOR_BREAKPOINTS
; i
++)
811 if (breakaddr
[i
] == addr
)
814 /* some monitors remove breakpoints based on the address */
815 if (strcasecmp (target_shortname
, "bug") == 0)
816 printf_monitor(CLR_BREAK_CMD
, addr
);
818 printf_monitor(CLR_BREAK_CMD
, i
);
823 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
827 /* Load a file. This is usually an srecord, which is ascii. No
828 protocol, just sent line by line. */
830 #define DOWNLOAD_LINE_SIZE 100
836 char buf
[DOWNLOAD_LINE_SIZE
];
840 printf ("Loading %s to monitor\n", arg
);
842 download
= fopen (arg
, "r");
843 if (download
== NULL
)
845 error (sprintf (buf
, "%s Does not exist", arg
));
849 printf_monitor (LOAD_CMD
);
850 /* expect ("Waiting for S-records from host... ", 1); */
852 while (!feof (download
))
854 bytes_read
= fread (buf
, sizeof (char), DOWNLOAD_LINE_SIZE
, download
);
861 if (SERIAL_WRITE(monitor_desc
, buf
, bytes_read
)) {
862 fprintf(stderr
, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror(errno
));
866 while (i
++ <=200000) {} ; /* Ugly HACK, probably needs flow control */
867 if (bytes_read
< DOWNLOAD_LINE_SIZE
)
869 if (!feof (download
))
870 error ("Only read %d bytes\n", bytes_read
);
879 if (!feof (download
))
880 error ("Never got EOF while downloading");
884 /* Put a command string, in args, out to MONITOR. Output from MONITOR is placed
885 on the users terminal until the prompt is seen. */
888 monitor_command (args
, fromtty
)
893 fprintf (log_file
, "\nIn command (args=%s)\n", args
);
895 if (monitor_desc
== NULL
)
896 error("monitor target not open.");
899 error("Missing command.");
901 printf_monitor("%s\r", args
);
907 /* Connect the user directly to MONITOR. This command acts just like the
908 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
910 static struct ttystate ttystate
;
914 { printf("\r\n[Exiting connect mode]\r\n");
915 /*SERIAL_RESTORE(0, &ttystate);*/
919 connect_command (args
, fromtty
)
930 if (monitor_desc
== NULL
)
931 error("monitor target not open.");
934 fprintf("This command takes no args. They have been ignored.\n");
936 printf("[Entering connect mode. Use ~. or ~^D to escape]\n");
938 serial_raw(0, &ttystate
);
940 make_cleanup(cleanup_tty
, 0);
949 FD_SET(monitor_desc
, &readfds
);
950 numfds
= select(sizeof(readfds
)*8, &readfds
, 0, 0, 0);
955 perror_with_name("select");
957 if (FD_ISSET(0, &readfds
))
958 { /* tty input, send to monitor */
961 perror_with_name("connect");
963 printf_monitor("%c", c
);
977 if (c
== '.' || c
== '\004')
984 if (FD_ISSET(monitor_desc
, &readfds
))
1000 * Define the monitor command strings. Since these are passed directly
1001 * through to a printf style function, we need can include formatting
1002 * strings. We also need a CR or LF on the end.
1004 struct monitor_ops rom68k_cmds
= {
1005 "go \r", /* execute or usually GO command */
1006 "go \r", /* continue command */
1007 "st \r", /* single step */
1008 "db %x\r", /* set a breakpoint */
1009 "cb %x\r", /* clear a breakpoint */
1010 "pm %x\r", /* set memory to a value */
1011 "pm %x\r", /* display memory */
1012 "-%08X ", /* prompt memory commands use */
1013 "pr %s %x\r", /* set a register */
1014 ": ", /* delimiter between registers */
1015 "pr %s\r", /* read a register */
1016 "dc \r", /* download command */
1017 "ROM68K :->", /* monitor command prompt */
1018 "=", /* end-of-command delimitor */
1019 ".\r" /* optional command terminator */
1022 struct monitor_ops bug_cmds
= {
1023 "go \r", /* execute or usually GO command */
1024 "go \r", /* continue command */
1025 "gn \r", /* single step */
1026 "br %x\r", /* set a breakpoint */
1027 "nobr %x\r", /* clear a breakpoint */
1028 "mm %x\r", /* set memory to a value */
1029 "mm %x\r", /* display memory */
1030 "%08X", /* prompt memory commands use */
1031 "rs %s %x\r", /* set a register */
1032 "=", /* delimiter between registers */
1033 "rm %s\r", /* read a register */
1034 "lo 0\r", /* download command */
1035 "Bug>", /* monitor command prompt */
1036 "? ", /* end-of-command delimitor */
1037 ".\r" /* optional command terminator */
1040 /* Define the target subroutine names */
1041 struct monitor_ops mon68_cmds
= {
1042 "", /* execute or usually GO command */
1043 "", /* continue command */
1044 "", /* single step */
1045 "", /* set a breakpoint */
1046 "", /* clear a breakpoint */
1047 "", /* set memory to a value */
1048 "", /* display memory */
1049 "", /* set a register */
1050 "", /* delimiter between registers */
1051 "", /* read a register */
1052 "", /* download command */
1053 ">", /* monitor command prompt */
1054 "", /* end-of-command delimitor */
1055 "" /* optional command terminator */
1058 struct target_ops rom68k_ops
= {
1060 "Integrated System's ROM68K remote debug monitor",
1061 "Use a remote computer running the ROM68K debug monitor.\n\
1062 Specify the serial device it is connected to (e.g. /dev/ttya).",
1069 monitor_fetch_register
,
1070 monitor_store_register
,
1071 monitor_prepare_to_store
,
1072 monitor_xfer_inferior_memory
,
1074 monitor_insert_breakpoint
,
1075 monitor_remove_breakpoint
, /* Breakpoints */
1080 0, /* Terminal handling */
1082 monitor_load
, /* load */
1083 0, /* lookup_symbol */
1084 monitor_create_inferior
,
1085 monitor_mourn_inferior
,
1087 0, /* notice_signals */
1094 1, /* all mem, mem, stack, regs, exec */
1096 0, /* Section pointers */
1097 OPS_MAGIC
, /* Always the last thing */
1100 struct target_ops monitor_bug_ops
= {
1102 "Motorola's BUG remote serial debug monitor",
1103 "Use a remote computer running Motorola's BUG debug monitor.\n\
1104 Specify the serial device it is connected to (e.g. /dev/ttya).",
1111 monitor_fetch_register
,
1112 monitor_store_register
,
1113 monitor_prepare_to_store
,
1114 monitor_xfer_inferior_memory
,
1116 monitor_insert_breakpoint
,
1117 monitor_remove_breakpoint
, /* Breakpoints */
1122 0, /* Terminal handling */
1124 monitor_load
, /* load */
1125 0, /* lookup_symbol */
1126 monitor_create_inferior
,
1127 monitor_mourn_inferior
,
1129 0, /* notice_signals */
1136 1, /* all mem, mem, stack, regs, exec */
1138 0, /* Section pointers */
1139 OPS_MAGIC
, /* Always the last thing */
1142 struct target_ops mon68_ops
= {
1144 "Intermetric's MON68 remote serial debug monitor",
1145 "Use a remote computer running the MON68 debug monitor.\n\
1146 Specify the serial device it is connected to (e.g. /dev/ttya).",
1153 monitor_fetch_register
,
1154 monitor_store_register
,
1155 monitor_prepare_to_store
,
1156 monitor_xfer_inferior_memory
,
1158 monitor_insert_breakpoint
,
1159 monitor_remove_breakpoint
, /* Breakpoints */
1164 0, /* Terminal handling */
1166 monitor_load
, /* load */
1167 0, /* lookup_symbol */
1168 monitor_create_inferior
,
1169 monitor_mourn_inferior
,
1171 0, /* notice_signals */
1178 1, /* all mem, mem, stack, regs, exec */
1180 0, /* Section pointers */
1181 OPS_MAGIC
, /* Always the last thing */
1185 _initialize_remote_monitors ()
1188 add_set_cmd ("hash", no_class
, var_boolean
,
1190 "Set display of activity while downloading a file.\n\
1191 When enabled, a period \'.\' is displayed.",
1195 /* generic monitor command */
1196 add_com ("monitor <command>", class_obscure
, monitor_command
,
1197 "Send a command to the debug monitor.");
1199 add_com ("connect", class_obscure
, connect_command
,
1200 "Connect the terminal directly up to a serial based command monitor.\n\
1201 Use <CR>~. or <CR>~^D to break out.");
1204 add_target (&rom68k_ops
);
1205 /* add_target (&mon68_ops); */
1206 add_target (&monitor_bug_ops
);