1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This file was derived from remote-eb.c, which did a similar job, but for
21 an AMD-29K running EBMON. That file was in turn derived from remote.c
22 as mentioned in the following comment (left in for comic relief):
24 "This is like remote.c but is for a different situation--
25 having a PC running os9000 hook up with a unix machine with
26 a serial line, and running ctty com2 on the PC. os9000 has a debug
27 monitor called ROMBUG running. Not to mention that the PC
28 has PC/NFS, so it can access the same executables that gdb can,
29 over the net in real time."
31 In reality, this module talks to a debug monitor called 'ROMBUG', which
32 We communicate with ROMBUG via a direct serial line, the network version
33 of ROMBUG is not available yet.
43 #include <sys/types.h>
47 #include "remote-utils.h"
51 #include "gdb-stabs.h"
55 # define TERMINAL struct termios
57 # define TERMINAL struct sgttyb
60 struct monitor_ops
*current_monitor
;
61 struct cmd_list_element
*showlist
;
62 extern struct target_ops rombug_ops
; /* Forward declaration */
63 extern struct monitor_ops rombug_cmds
; /* Forward declaration */
64 extern struct cmd_list_element
*setlist
;
65 extern struct cmd_list_element
*unsetlist
;
66 extern int attach_flag
;
68 static void rombug_close();
69 static void rombug_fetch_register();
70 static void rombug_fetch_registers();
71 static void rombug_store_register();
73 static int sr_get_debug(); /* flag set by "set remotedebug" */
75 static int hashmark
; /* flag set by "set hash" */
76 static int rombug_is_open
= 0;
78 /* FIXME: Replace with sr_get_debug (). */
79 #define LOG_FILE "monitor.log"
81 static int monitor_log
= 0;
82 static int tty_xon
= 0;
83 static int tty_xoff
= 0;
85 static int timeout
= 5;
86 static int is_trace_mode
= 0;
87 /* Descriptor for I/O to remote machine. Initialize it to NULL*/
88 static serial_t monitor_desc
= NULL
;
90 /* Send data to monitor. Works just like printf. */
92 printf_monitor(va_alist
)
102 pattern
= va_arg(args
, char *);
104 vsprintf(buf
, pattern
, args
);
106 if (SERIAL_WRITE(monitor_desc
, buf
, strlen(buf
)))
107 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
110 /* Read a character from the remote system, doing all the fancy timeout stuff*/
117 c
= SERIAL_READCHAR(monitor_desc
, timeout
);
122 if (monitor_log
&& isascii(c
))
123 putc(c
& 0x7f, log_file
);
128 if (c
== SERIAL_TIMEOUT
)
131 return c
; /* Polls shouldn't generate timeout errors */
133 error("Timeout reading from remote system.");
136 perror_with_name("remote-monitor");
139 /* Scan input from the remote system, until STRING is found. If DISCARD is
140 non-zero, then discard non-matching input, else print it out.
141 Let the user break out immediately. */
143 expect(string
, discard
)
151 printf ("Expecting \"%s\"\n", string
);
156 c
= readchar(timeout
);
165 printf ("\nMatched\n");
173 fwrite(string
, 1, (p
- 1) - string
, stdout
);
182 /* Keep discarding input until we see the ROMBUG prompt.
184 The convention for dealing with the prompt is that you
186 o *then* wait for the prompt.
188 Thus the last thing that a procedure does with the serial line
189 will be an expect_prompt(). Exception: rombug_resume does not
190 wait for the prompt, because the terminal is being handed over
191 to the inferior. However, the next thing which happens after that
192 is a rombug_wait which does wait for the prompt.
193 Note that this includes abnormal exit, e.g. error(). This is
194 necessary to prevent getting into states from which we can't
197 expect_prompt(discard
)
201 /* This is a convenient place to do this. The idea is to do it often
202 enough that we never lose much data if we terminate abnormally. */
206 expect("trace", discard
);
209 expect (PROMPT
, discard
);
213 /* Get a hex digit from the remote system & return its value.
214 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
216 get_hex_digit(ignore_space
)
222 ch
= readchar(timeout
);
223 if (ch
>= '0' && ch
<= '9')
225 else if (ch
>= 'A' && ch
<= 'F')
226 return ch
- 'A' + 10;
227 else if (ch
>= 'a' && ch
<= 'f')
228 return ch
- 'a' + 10;
229 else if (ch
== ' ' && ignore_space
)
234 error("Invalid hex digit from remote system.");
239 /* Get a byte from monitor and put it in *BYT. Accept any number
247 val
= get_hex_digit (1) << 4;
248 val
|= get_hex_digit (0);
252 /* Get N 32-bit words from remote, each preceded by a space,
253 and put them in registers starting at REGNO. */
255 get_hex_regs (n
, regno
)
263 for (i
= 0; i
< n
; i
++)
268 for (j
= 0; j
< 4; j
++)
270 #if TARGET_BYTE_ORDER == BIG_ENDIAN
272 val
= (val
<< 8) + b
;
275 val
= val
+ (b
<< (j
*8));
278 supply_register (regno
++, (char *) &val
);
282 /* This is called not only when we first attach, but also when the
283 user types "run" after having attached. */
285 rombug_create_inferior (execfile
, args
, env
)
292 /* Nonzero value indicates that a process really is running. */
296 error("Can't pass arguments to remote ROMBUG process");
298 if (execfile
== 0 || exec_bfd
== 0)
299 error("No exec file specified");
301 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
304 fputs ("\nIn Create_inferior()", log_file
);
307 /* The "process" (board) is already stopped awaiting our commands, and
308 the program is already downloaded. We just set its PC and go. */
310 init_wait_for_inferior ();
311 proceed ((CORE_ADDR
)entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
314 /* Open a connection to a remote debugger.
315 NAME is the filename used for communication. */
317 static char dev_name
[100];
320 rombug_open(args
, from_tty
)
325 error ("Use `target RomBug DEVICE-NAME' to use a serial port, or \n\
326 `target RomBug HOST-NAME:PORT-NUMBER' to use a network connection.");
328 target_preopen(from_tty
);
331 unpush_target(&rombug_ops
);
333 strcpy(dev_name
, args
);
334 monitor_desc
= SERIAL_OPEN(dev_name
);
335 if (monitor_desc
== NULL
)
336 perror_with_name(dev_name
);
338 /* if baud rate is set by 'set remotebaud' */
339 if (SERIAL_SETBAUDRATE (monitor_desc
, sr_get_baud_rate()))
341 SERIAL_CLOSE (monitor_desc
);
342 perror_with_name ("RomBug");
344 SERIAL_RAW(monitor_desc
);
345 if (tty_xon
|| tty_xoff
)
347 struct hardware_ttystate
{ struct termios t
;} *tty_s
;
349 tty_s
=(struct hardware_ttystate
*)SERIAL_GET_TTY_STATE(monitor_desc
);
350 if (tty_xon
) tty_s
->t
.c_iflag
|= IXON
;
351 if (tty_xoff
) tty_s
->t
.c_iflag
|= IXOFF
;
352 SERIAL_SET_TTY_STATE(monitor_desc
, (serial_ttystate
) tty_s
);
357 log_file
= fopen (LOG_FILE
, "w");
358 if (log_file
== NULL
)
359 perror_with_name (LOG_FILE
);
361 push_monitor (&rombug_cmds
);
362 printf_monitor("\r"); /* CR wakes up monitor */
365 push_target (&rombug_ops
);
367 printf("Remote %s connected to %s\n", target_shortname
,
372 rombug_fetch_registers();
376 * Close out all files and local state before this target loses control.
380 rombug_close (quitting
)
383 if (rombug_is_open
) {
384 SERIAL_CLOSE(monitor_desc
);
390 if (ferror(log_file
))
391 fprintf(stderr
, "Error writing log file.\n");
392 if (fclose(log_file
) != 0)
393 fprintf(stderr
, "Error closing log file.\n");
399 rombug_link(mod_name
, text_reloc
)
401 CORE_ADDR
*text_reloc
;
407 printf_monitor("l %s \r", mod_name
);
409 printf_monitor(".r \r");
410 expect(REG_DELIM
, 1);
411 for (i
=0; i
<= 7; i
++)
414 for (j
= 0; j
< 4; j
++)
417 val
= (val
<< 8) + b
;
425 /* Terminate the open connection to the remote debugger.
426 Use this when you want to detach and do something else
429 rombug_detach (from_tty
)
433 printf_monitor (GO_CMD
);
437 pop_target(); /* calls rombug_close to do the real work */
439 printf ("Ending remote %s debugging\n", target_shortname
);
443 * Tell the remote machine to resume.
446 rombug_resume (pid
, step
, sig
)
448 enum target_signal sig
;
451 fprintf (log_file
, "\nIn Resume (step=%d, sig=%d)\n", step
, sig
);
456 printf_monitor (STEP_CMD
);
457 /* wait for the echo. */
458 expect (STEP_CMD
, 1);
462 printf_monitor (GO_CMD
);
463 /* swallow the echo. */
469 * Wait until the remote machine stops, then return,
470 * storing status in status just as `wait' would.
474 rombug_wait (pid
, status
)
476 struct target_waitstatus
*status
;
478 int old_timeout
= timeout
;
479 struct section_offsets
*offs
;
481 struct obj_section
*obj_sec
;
484 fputs ("\nIn wait ()", log_file
);
486 status
->kind
= TARGET_WAITKIND_EXITED
;
487 status
->value
.integer
= 0;
489 timeout
= 0; /* Don't time out -- user program is running. */
490 expect_prompt(1); /* Wait for prompt, outputting extraneous text */
492 status
->kind
= TARGET_WAITKIND_STOPPED
;
493 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
494 timeout
= old_timeout
;
495 rombug_fetch_registers();
496 pc
= read_register(PC_REGNUM
);
497 addr
= read_register(DATABASE_REG
);
498 obj_sec
= find_pc_section (pc
);
501 if (obj_sec
->objfile
!= symfile_objfile
)
502 new_symfile_objfile(obj_sec
->objfile
, 1, 0);
503 offs
= ((struct section_offsets
*)
504 alloca (sizeof (struct section_offsets
)
505 + (symfile_objfile
->num_sections
* sizeof (offs
->offsets
))));
506 memcpy (offs
, symfile_objfile
->section_offsets
,
507 (sizeof (struct section_offsets
) +
508 (symfile_objfile
->num_sections
* sizeof (offs
->offsets
))));
509 ANOFFSET (offs
, SECT_OFF_DATA
) = addr
;
510 ANOFFSET (offs
, SECT_OFF_BSS
) = addr
;
512 objfile_relocate(symfile_objfile
, offs
);
517 /* Return the name of register number regno in the form input and output by
518 monitor. Currently, register_names just happens to contain exactly what
519 monitor wants. Lets take advantage of that just as long as possible! */
534 for (p = reg_names[regno]; *p; p++)
538 p
= (char *)reg_names
[regno
];
545 /* read the remote registers into the block regs. */
548 rombug_fetch_registers ()
554 printf_monitor (GET_REG
);
565 for (regno
= 8; regno
<= 15; regno
++)
567 expect(REG_DELIM
, 1);
568 if (regno
>= 8 && regno
<= 13)
571 for (j
= 0; j
< 2; j
++)
573 #if TARGET_BYTE_ORDER == BIG_ENDIAN
575 val
= (val
<< 8) + b
;
578 val
= val
+ (b
<< (j
*8));
582 if (regno
== 8) i
= 10;
583 if (regno
>= 9 && regno
<= 12) i
= regno
+ 3;
584 if (regno
== 13) i
= 11;
585 supply_register (i
, (char *) &val
);
587 else if (regno
== 14)
589 get_hex_regs(1, PC_REGNUM
);
591 else if (regno
== 15)
598 supply_register(regno
, (char *) &val
);
604 /* Fetch register REGNO, or all registers if REGNO is -1.
605 Returns errno value. */
607 rombug_fetch_register (regno
)
614 fprintf (log_file
, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno
));
620 rombug_fetch_registers ();
624 char *name
= get_reg_name (regno
);
625 printf_monitor (GET_REG
);
626 if (regno
>= 10 && regno
<= 15)
631 expect (REG_DELIM
, 1);
633 for (j
= 0; j
< 2; j
++)
635 #if TARGET_BYTE_ORDER == BIG_ENDIAN
637 val
= (val
<< 8) + b
;
640 val
= val
+ (b
<< (j
*8));
643 supply_register (regno
, (char *) &val
);
645 else if (regno
== 8 || regno
== 9)
651 expect (REG_DELIM
, 1);
652 get_hex_regs (1, regno
);
657 expect (REG_DELIM
, 1);
673 /* Store the remote registers from the contents of the block REGS. */
676 rombug_store_registers ()
680 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
681 rombug_store_register(regno
);
683 registers_changed ();
686 /* Store register REGNO, or all if REGNO == 0.
687 return errno value. */
689 rombug_store_register (regno
)
695 fprintf (log_file
, "\nIn Store_register (regno=%d)\n", regno
);
698 rombug_store_registers ();
702 printf ("Setting register %s to 0x%x\n", get_reg_name (regno
), read_register (regno
));
704 name
= get_reg_name(regno
);
705 if (name
== 0) return;
706 printf_monitor (SET_REG
, name
, read_register (regno
));
712 /* Get ready to modify the registers array. On machines which store
713 individual registers, this doesn't need to do anything. On machines
714 which store all the registers in one fell swoop, this makes sure
715 that registers contains all the registers from the program being
719 rombug_prepare_to_store ()
721 /* Do nothing, since we can store individual regs */
727 printf ("\tAttached to %s at %d baud.\n",
728 dev_name
, sr_get_baud_rate());
731 /* Copy LEN bytes of data from debugger memory at MYADDR
732 to inferior's memory at MEMADDR. Returns length moved. */
734 rombug_write_inferior_memory (memaddr
, myaddr
, len
)
736 unsigned char *myaddr
;
743 fprintf (log_file
, "\nIn Write_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
745 printf_monitor (MEM_SET_CMD
, memaddr
);
746 for (i
= 0; i
< len
; i
++)
748 expect (CMD_DELIM
, 1);
749 printf_monitor ("%x \r", myaddr
[i
]);
751 printf ("\nSet 0x%x to 0x%x\n", memaddr
+ i
, myaddr
[i
]);
753 expect (CMD_DELIM
, 1);
755 printf_monitor (CMD_END
);
761 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
762 at debugger address MYADDR. Returns length moved. */
764 rombug_read_inferior_memory(memaddr
, myaddr
, len
)
772 /* Number of bytes read so far. */
775 /* Starting address of this pass. */
776 unsigned long startaddr
;
778 /* Number of bytes to read in this pass. */
782 fprintf (log_file
, "\nIn Read_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
784 /* Note that this code works correctly if startaddr is just less
785 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
786 thing). That is, something like
787 rombug_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
788 works--it never adds len To memaddr and gets 0. */
789 /* However, something like
790 rombug_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
791 doesn't need to work. Detect it and give up if there's an attempt
793 if (((memaddr
- 1) + len
) < memaddr
) {
803 if ((startaddr
% 16) != 0)
804 len_this_pass
-= startaddr
% 16;
805 if (len_this_pass
> (len
- count
))
806 len_this_pass
= (len
- count
);
808 printf ("\nDisplay %d bytes at %x\n", len_this_pass
, startaddr
);
810 printf_monitor (MEM_DIS_CMD
, startaddr
, 16);
812 for (i
= 0; i
< len_this_pass
; i
++)
814 get_hex_byte (&myaddr
[count
++]);
816 printf ("\nRead a 0x%x from 0x%x\n", myaddr
[count
-1], startaddr
);
819 expect(CMD_DELIM
, 1);
822 printf_monitor (CMD_END
);
828 /* FIXME-someday! merge these two. */
830 rombug_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
835 struct target_ops
*target
; /* ignored */
838 return rombug_write_inferior_memory (memaddr
, myaddr
, len
);
840 return rombug_read_inferior_memory (memaddr
, myaddr
, len
);
844 rombug_kill (args
, from_tty
)
848 return; /* ignore attempts to kill target system */
851 /* Clean up when a program exits.
852 The program actually lives on in the remote processor's RAM, and may be
853 run again without a download. Don't leave it full of breakpoint
857 rombug_mourn_inferior ()
859 remove_breakpoints ();
860 generic_mourn_inferior (); /* Do all the proper things now */
863 #define MAX_MONITOR_BREAKPOINTS 16
865 extern int memory_breakpoint_size
;
866 static CORE_ADDR breakaddr
[MAX_MONITOR_BREAKPOINTS
] = {0};
869 rombug_insert_breakpoint (addr
, shadow
)
876 fprintf (log_file
, "\nIn Insert_breakpoint (addr=%x)\n", addr
);
878 for (i
= 0; i
<= MAX_MONITOR_BREAKPOINTS
; i
++)
879 if (breakaddr
[i
] == 0)
883 printf ("Breakpoint at %x\n", addr
);
884 rombug_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
885 printf_monitor(SET_BREAK_CMD
, addr
);
890 fprintf(stderr
, "Too many breakpoints (> 16) for monitor\n");
895 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
898 rombug_remove_breakpoint (addr
, shadow
)
905 fprintf (log_file
, "\nIn Remove_breakpoint (addr=%x)\n", addr
);
907 for (i
= 0; i
< MAX_MONITOR_BREAKPOINTS
; i
++)
908 if (breakaddr
[i
] == addr
)
911 printf_monitor(CLR_BREAK_CMD
, addr
);
916 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
920 /* Load a file. This is usually an srecord, which is ascii. No
921 protocol, just sent line by line. */
923 #define DOWNLOAD_LINE_SIZE 100
928 /* this part comment out for os9* */
931 char buf
[DOWNLOAD_LINE_SIZE
];
935 printf ("Loading %s to monitor\n", arg
);
937 download
= fopen (arg
, "r");
938 if (download
== NULL
)
940 error (sprintf (buf
, "%s Does not exist", arg
));
944 printf_monitor (LOAD_CMD
);
945 /* expect ("Waiting for S-records from host... ", 1); */
947 while (!feof (download
))
949 bytes_read
= fread (buf
, sizeof (char), DOWNLOAD_LINE_SIZE
, download
);
956 if (SERIAL_WRITE(monitor_desc
, buf
, bytes_read
)) {
957 fprintf(stderr
, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror(errno
));
961 while (i
++ <=200000) {} ; /* Ugly HACK, probably needs flow control */
962 if (bytes_read
< DOWNLOAD_LINE_SIZE
)
964 if (!feof (download
))
965 error ("Only read %d bytes\n", bytes_read
);
974 if (!feof (download
))
975 error ("Never got EOF while downloading");
980 /* Put a command string, in args, out to MONITOR.
981 Output from MONITOR is placed on the users terminal until the prompt
985 rombug_command (args
, fromtty
)
989 if (monitor_desc
== NULL
)
990 error("monitor target not open.");
993 fprintf (log_file
, "\nIn command (args=%s)\n", args
);
996 error("Missing command.");
998 printf_monitor("%s\r", args
);
999 expect(CMD_DELIM
, 0);
1003 /* Connect the user directly to MONITOR. This command acts just like the
1004 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
1006 static struct ttystate ttystate
;
1010 { printf("\r\n[Exiting connect mode]\r\n");
1011 /*SERIAL_RESTORE(0, &ttystate);*/
1015 connect_command (args
, fromtty
)
1026 if (monitor_desc
== NULL
)
1027 error("monitor target not open.");
1030 fprintf("This command takes no args. They have been ignored.\n");
1032 printf("[Entering connect mode. Use ~. or ~^D to escape]\n");
1034 serial_raw(0, &ttystate
);
1036 make_cleanup(cleanup_tty
, 0);
1044 FD_SET(0, &readfds
);
1045 FD_SET(monitor_desc
, &readfds
);
1046 numfds
= select(sizeof(readfds
)*8, &readfds
, 0, 0, 0);
1048 while (numfds
== 0);
1051 perror_with_name("select");
1053 if (FD_ISSET(0, &readfds
))
1054 { /* tty input, send to monitor */
1057 perror_with_name("connect");
1059 printf_monitor("%c", c
);
1073 if (c
== '.' || c
== '\004')
1080 if (FD_ISSET(monitor_desc
, &readfds
))
1096 * Define the monitor command strings. Since these are passed directly
1097 * through to a printf style function, we need can include formatting
1098 * strings. We also need a CR or LF on the end.
1100 struct monitor_ops rombug_cmds
= {
1101 "g \r", /* execute or usually GO command */
1102 "g \r", /* continue command */
1103 "t \r", /* single step */
1104 "b %x\r", /* set a breakpoint */
1105 "k %x\r", /* clear a breakpoint */
1106 "c %x\r", /* set memory to a value */
1107 "d %x %d\r", /* display memory */
1108 "$%08X", /* prompt memory commands use */
1109 ".%s %x\r", /* set a register */
1110 ":", /* delimiter between registers */
1111 ". \r", /* read a register */
1112 "mf \r", /* download command */
1113 "RomBug: ", /* monitor command prompt */
1114 ": ", /* end-of-command delimitor */
1115 ".\r" /* optional command terminator */
1118 struct target_ops rombug_ops
= {
1120 "Microware's ROMBUG debug monitor",
1121 "Use a remote computer running the ROMBUG debug monitor.\n\
1122 Specify the serial device it is connected to (e.g. /dev/ttya).",
1129 rombug_fetch_register
,
1130 rombug_store_register
,
1131 rombug_prepare_to_store
,
1132 rombug_xfer_inferior_memory
,
1134 rombug_insert_breakpoint
,
1135 rombug_remove_breakpoint
, /* Breakpoints */
1140 0, /* Terminal handling */
1142 rombug_load
, /* load */
1143 rombug_link
, /* lookup_symbol */
1144 rombug_create_inferior
,
1145 rombug_mourn_inferior
,
1147 0, /* notice_signals */
1154 1, /* has execution */
1156 0, /* Section pointers */
1157 OPS_MAGIC
, /* Always the last thing */
1161 _initialize_remote_os9k ()
1163 add_target (&rombug_ops
);
1166 add_set_cmd ("hash", no_class
, var_boolean
, (char *)&hashmark
,
1167 "Set display of activity while downloading a file.\nWhen enabled, a period \'.\' is displayed.",
1172 add_set_cmd ("timeout", no_class
, var_zinteger
,
1174 "Set timeout in seconds for remote MIPS serial I/O.",
1179 add_set_cmd ("remotelog", no_class
, var_zinteger
,
1180 (char *) &monitor_log
,
1181 "Set monitor activity log on(=1) or off(=0).",
1186 add_set_cmd ("remotexon", no_class
, var_zinteger
,
1188 "Set remote tty line XON control",
1193 add_set_cmd ("remotexoff", no_class
, var_zinteger
,
1195 "Set remote tty line XOFF control",
1199 add_com ("rombug <command>", class_obscure
, rombug_command
,
1200 "Send a command to the debug monitor.");
1202 add_com ("connect", class_obscure
, connect_command
,
1203 "Connect the terminal directly up to a serial based command monitor.\nUse <CR>~. or <CR>~^D to break out.");