1 /* Remote debugging interface for boot monitors, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 2001 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., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, 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 a different situation--
26 having a PC running os9000 hook up with a unix machine with
27 a serial line, and running ctty com2 on the PC. os9000 has a debug
28 monitor called ROMBUG running. 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 'ROMBUG', which
33 We communicate with ROMBUG via a direct serial line, the network version
34 of ROMBUG is not available yet.
37 /* FIXME This file needs to be rewritten if it's to work again, either
38 to self-contained or to use the new monitor interface. */
43 #include "gdb_string.h"
44 #include <sys/types.h>
48 #include "remote-utils.h"
52 #include "gdb-stabs.h"
54 struct cmd_list_element
*showlist
;
55 extern struct target_ops rombug_ops
; /* Forward declaration */
56 extern struct monitor_ops rombug_cmds
; /* Forward declaration */
57 extern struct cmd_list_element
*setlist
;
58 extern struct cmd_list_element
*unsetlist
;
59 extern int attach_flag
;
61 static void rombug_close ();
62 static void rombug_fetch_register ();
63 static void rombug_fetch_registers ();
64 static void rombug_store_register ();
66 static int sr_get_debug (); /* flag set by "set remotedebug" */
68 static int hashmark
; /* flag set by "set hash" */
69 static int rombug_is_open
= 0;
71 /* FIXME: Replace with sr_get_debug (). */
72 #define LOG_FILE "monitor.log"
74 static int monitor_log
= 0;
75 static int tty_xon
= 0;
76 static int tty_xoff
= 0;
78 static int timeout
= 10;
79 static int is_trace_mode
= 0;
80 /* Descriptor for I/O to remote machine. Initialize it to NULL */
81 static serial_t monitor_desc
= NULL
;
83 static CORE_ADDR bufaddr
= 0;
84 static int buflen
= 0;
85 static char readbuf
[16];
87 /* Send data to monitor. Works just like printf. */
89 printf_monitor (char *pattern
,...)
95 va_start (args
, pattern
);
97 vsprintf (buf
, pattern
, args
);
100 if (SERIAL_WRITE (monitor_desc
, buf
, strlen (buf
)))
101 fprintf (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
104 /* Read a character from the remote system, doing all the fancy timeout stuff */
106 readchar (int timeout
)
110 c
= SERIAL_READCHAR (monitor_desc
, timeout
);
115 if (monitor_log
&& isascii (c
))
116 putc (c
& 0x7f, log_file
);
121 if (c
== SERIAL_TIMEOUT
)
124 return c
; /* Polls shouldn't generate timeout errors */
126 error ("Timeout reading from remote system.");
129 perror_with_name ("remote-monitor");
132 /* Scan input from the remote system, until STRING is found. If DISCARD is
133 non-zero, then discard non-matching input, else print it out.
134 Let the user break out immediately. */
136 expect (char *string
, int discard
)
142 printf ("Expecting \"%s\"\n", string
);
147 c
= readchar (timeout
);
156 printf ("\nMatched\n");
164 fwrite (string
, 1, (p
- 1) - string
, stdout
);
173 /* Keep discarding input until we see the ROMBUG prompt.
175 The convention for dealing with the prompt is that you
177 o *then* wait for the prompt.
179 Thus the last thing that a procedure does with the serial line
180 will be an expect_prompt(). Exception: rombug_resume does not
181 wait for the prompt, because the terminal is being handed over
182 to the inferior. However, the next thing which happens after that
183 is a rombug_wait which does wait for the prompt.
184 Note that this includes abnormal exit, e.g. error(). This is
185 necessary to prevent getting into states from which we can't
188 expect_prompt (int discard
)
191 /* This is a convenient place to do this. The idea is to do it often
192 enough that we never lose much data if we terminate abnormally. */
197 expect ("trace", discard
);
201 expect (PROMPT
, discard
);
205 /* Get a hex digit from the remote system & return its value.
206 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
208 get_hex_digit (int ignore_space
)
213 ch
= readchar (timeout
);
214 if (ch
>= '0' && ch
<= '9')
216 else if (ch
>= 'A' && ch
<= 'F')
217 return ch
- 'A' + 10;
218 else if (ch
>= 'a' && ch
<= 'f')
219 return ch
- 'a' + 10;
220 else if (ch
== ' ' && ignore_space
)
225 error ("Invalid hex digit from remote system.");
230 /* Get a byte from monitor and put it in *BYT. Accept any number
233 get_hex_byte (char *byt
)
237 val
= get_hex_digit (1) << 4;
238 val
|= get_hex_digit (0);
242 /* Get N 32-bit words from remote, each preceded by a space,
243 and put them in registers starting at REGNO. */
245 get_hex_regs (int n
, int regno
)
251 for (i
= 0; i
< n
; i
++)
256 for (j
= 0; j
< 4; j
++)
259 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
260 val
= (val
<< 8) + b
;
262 val
= val
+ (b
<< (j
* 8));
264 supply_register (regno
++, (char *) &val
);
268 /* This is called not only when we first attach, but also when the
269 user types "run" after having attached. */
271 rombug_create_inferior (char *execfile
, char *args
, char **env
)
276 error ("Can't pass arguments to remote ROMBUG process");
278 if (execfile
== 0 || exec_bfd
== 0)
279 error ("No executable file specified");
281 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
284 fputs ("\nIn Create_inferior()", log_file
);
287 /* The "process" (board) is already stopped awaiting our commands, and
288 the program is already downloaded. We just set its PC and go. */
290 init_wait_for_inferior ();
291 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
294 /* Open a connection to a remote debugger.
295 NAME is the filename used for communication. */
297 static char dev_name
[100];
300 rombug_open (char *args
, int from_tty
)
303 error ("Use `target RomBug DEVICE-NAME' to use a serial port, or \n\
304 `target RomBug HOST-NAME:PORT-NUMBER' to use a network connection.");
306 target_preopen (from_tty
);
309 unpush_target (&rombug_ops
);
311 strcpy (dev_name
, args
);
312 monitor_desc
= SERIAL_OPEN (dev_name
);
313 if (monitor_desc
== NULL
)
314 perror_with_name (dev_name
);
316 /* if baud rate is set by 'set remotebaud' */
317 if (SERIAL_SETBAUDRATE (monitor_desc
, sr_get_baud_rate ()))
319 SERIAL_CLOSE (monitor_desc
);
320 perror_with_name ("RomBug");
322 SERIAL_RAW (monitor_desc
);
323 if (tty_xon
|| tty_xoff
)
325 struct hardware_ttystate
331 tty_s
= (struct hardware_ttystate
*) SERIAL_GET_TTY_STATE (monitor_desc
);
333 tty_s
->t
.c_iflag
|= IXON
;
335 tty_s
->t
.c_iflag
|= IXOFF
;
336 SERIAL_SET_TTY_STATE (monitor_desc
, (serial_ttystate
) tty_s
);
341 log_file
= fopen (LOG_FILE
, "w");
342 if (log_file
== NULL
)
343 perror_with_name (LOG_FILE
);
345 push_monitor (&rombug_cmds
);
346 printf_monitor ("\r"); /* CR wakes up monitor */
348 push_target (&rombug_ops
);
352 printf ("Remote %s connected to %s\n", target_shortname
,
355 rombug_fetch_registers ();
357 printf_monitor ("ov e \r");
364 * Close out all files and local state before this target loses control.
368 rombug_close (int quitting
)
372 SERIAL_CLOSE (monitor_desc
);
379 if (ferror (log_file
))
380 fprintf (stderr
, "Error writing log file.\n");
381 if (fclose (log_file
) != 0)
382 fprintf (stderr
, "Error closing log file.\n");
388 rombug_link (char *mod_name
, CORE_ADDR
*text_reloc
)
394 printf_monitor ("l %s \r", mod_name
);
396 printf_monitor (".r \r");
397 expect (REG_DELIM
, 1);
398 for (i
= 0; i
<= 7; i
++)
401 for (j
= 0; j
< 4; j
++)
404 val
= (val
<< 8) + b
;
412 /* Terminate the open connection to the remote debugger.
413 Use this when you want to detach and do something else
416 rombug_detach (int from_tty
)
420 printf_monitor (GO_CMD
);
423 pop_target (); /* calls rombug_close to do the real work */
425 printf ("Ending remote %s debugging\n", target_shortname
);
429 * Tell the remote machine to resume.
432 rombug_resume (int pid
, int step
, enum target_signal sig
)
435 fprintf (log_file
, "\nIn Resume (step=%d, sig=%d)\n", step
, sig
);
440 printf_monitor (STEP_CMD
);
441 /* wait for the echo. **
442 expect (STEP_CMD, 1);
447 printf_monitor (GO_CMD
);
448 /* swallow the echo. **
457 * Wait until the remote machine stops, then return,
458 * storing status in status just as `wait' would.
462 rombug_wait (int pid
, struct target_waitstatus
*status
)
464 int old_timeout
= timeout
;
465 struct section_offsets
*offs
;
467 struct obj_section
*obj_sec
;
470 fputs ("\nIn wait ()", log_file
);
472 status
->kind
= TARGET_WAITKIND_EXITED
;
473 status
->value
.integer
= 0;
475 timeout
= -1; /* Don't time out -- user program is running. */
476 expect ("eax:", 0); /* output any message before register display */
477 expect_prompt (1); /* Wait for prompt, outputting extraneous text */
479 status
->kind
= TARGET_WAITKIND_STOPPED
;
480 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
481 timeout
= old_timeout
;
482 rombug_fetch_registers ();
485 pc
= read_register (PC_REGNUM
);
486 addr
= read_register (DATABASE_REG
);
487 obj_sec
= find_pc_section (pc
);
490 if (obj_sec
->objfile
!= symfile_objfile
)
491 new_symfile_objfile (obj_sec
->objfile
, 1, 0);
492 offs
= (struct section_offsets
*) alloca (SIZEOF_SECTION_OFFSETS
);
493 memcpy (offs
, symfile_objfile
->section_offsets
, SIZEOF_SECTION_OFFSETS
);
494 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = addr
;
495 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = addr
;
497 objfile_relocate (symfile_objfile
, offs
);
503 /* Return the name of register number regno in the form input and output by
504 monitor. Currently, register_names just happens to contain exactly what
505 monitor wants. Lets take advantage of that just as long as possible! */
508 get_reg_name (int regno
)
519 for (p = REGISTER_NAME (regno); *p; p++)
523 p
= (char *) REGISTER_NAME (regno
);
530 /* read the remote registers into the block regs. */
533 rombug_fetch_registers (void)
539 printf_monitor (GET_REG
);
550 for (regno
= 8; regno
<= 15; regno
++)
552 expect (REG_DELIM
, 1);
553 if (regno
>= 8 && regno
<= 13)
556 for (j
= 0; j
< 2; j
++)
559 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
560 val
= (val
<< 8) + b
;
562 val
= val
+ (b
<< (j
* 8));
567 if (regno
>= 9 && regno
<= 12)
571 supply_register (i
, (char *) &val
);
573 else if (regno
== 14)
575 get_hex_regs (1, PC_REGNUM
);
577 else if (regno
== 15)
584 supply_register (regno
, (char *) &val
);
591 /* Fetch register REGNO, or all registers if REGNO is -1.
592 Returns errno value. */
594 rombug_fetch_register (int regno
)
601 fprintf (log_file
, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno
));
607 rombug_fetch_registers ();
611 char *name
= get_reg_name (regno
);
612 printf_monitor (GET_REG
);
613 if (regno
>= 10 && regno
<= 15)
618 expect (REG_DELIM
, 1);
620 for (j
= 0; j
< 2; j
++)
623 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
624 val
= (val
<< 8) + b
;
626 val
= val
+ (b
<< (j
* 8));
628 supply_register (regno
, (char *) &val
);
630 else if (regno
== 8 || regno
== 9)
636 expect (REG_DELIM
, 1);
637 get_hex_regs (1, regno
);
642 expect (REG_DELIM
, 1);
658 /* Store the remote registers from the contents of the block REGS. */
661 rombug_store_registers (void)
665 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
666 rombug_store_register (regno
);
668 registers_changed ();
671 /* Store register REGNO, or all if REGNO == 0.
672 return errno value. */
674 rombug_store_register (int regno
)
679 fprintf (log_file
, "\nIn Store_register (regno=%d)\n", regno
);
682 rombug_store_registers ();
686 printf ("Setting register %s to 0x%x\n", get_reg_name (regno
), read_register (regno
));
688 name
= get_reg_name (regno
);
691 printf_monitor (SET_REG
, name
, read_register (regno
));
698 /* Get ready to modify the registers array. On machines which store
699 individual registers, this doesn't need to do anything. On machines
700 which store all the registers in one fell swoop, this makes sure
701 that registers contains all the registers from the program being
705 rombug_prepare_to_store (void)
707 /* Do nothing, since we can store individual regs */
711 rombug_files_info (void)
713 printf ("\tAttached to %s at %d baud.\n",
714 dev_name
, sr_get_baud_rate ());
717 /* Copy LEN bytes of data from debugger memory at MYADDR
718 to inferior's memory at MEMADDR. Returns length moved. */
720 rombug_write_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
726 fprintf (log_file
, "\nIn Write_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
728 printf_monitor (MEM_SET_CMD
, memaddr
);
729 for (i
= 0; i
< len
; i
++)
731 expect (CMD_DELIM
, 1);
732 printf_monitor ("%x \r", myaddr
[i
]);
734 printf ("\nSet 0x%x to 0x%x\n", memaddr
+ i
, myaddr
[i
]);
736 expect (CMD_DELIM
, 1);
738 printf_monitor (CMD_END
);
747 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
748 at debugger address MYADDR. Returns length moved. */
750 rombug_read_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
754 /* Number of bytes read so far. */
757 /* Starting address of this pass. */
758 unsigned long startaddr
;
760 /* Number of bytes to read in this pass. */
764 fprintf (log_file
, "\nIn Read_inferior_memory (memaddr=%x, len=%d)\n", memaddr
, len
);
766 /* Note that this code works correctly if startaddr is just less
767 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
768 thing). That is, something like
769 rombug_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
770 works--it never adds len To memaddr and gets 0. */
771 /* However, something like
772 rombug_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
773 doesn't need to work. Detect it and give up if there's an attempt
775 if (((memaddr
- 1) + len
) < memaddr
)
780 if (bufaddr
<= memaddr
&& (memaddr
+ len
) <= (bufaddr
+ buflen
))
782 memcpy (myaddr
, &readbuf
[memaddr
- bufaddr
], len
);
791 if ((startaddr
% 16) != 0)
792 len_this_pass
-= startaddr
% 16;
793 if (len_this_pass
> (len
- count
))
794 len_this_pass
= (len
- count
);
796 printf ("\nDisplay %d bytes at %x\n", len_this_pass
, startaddr
);
798 printf_monitor (MEM_DIS_CMD
, startaddr
, 8);
800 for (i
= 0; i
< 16; i
++)
802 get_hex_byte (&readbuf
[i
]);
806 memcpy (&myaddr
[count
], readbuf
, len_this_pass
);
807 count
+= len_this_pass
;
808 startaddr
+= len_this_pass
;
809 expect (CMD_DELIM
, 1);
812 printf_monitor (CMD_END
);
819 /* Transfer LEN bytes between GDB address MYADDR and target address
820 MEMADDR. If WRITE is non-zero, transfer them to the target,
821 otherwise transfer them from the target. TARGET is unused.
823 Returns the number of bytes transferred. */
826 rombug_xfer_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
828 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
829 struct target_ops
*target ATTRIBUTE_UNUSED
)
832 return rombug_write_inferior_memory (memaddr
, myaddr
, len
);
834 return rombug_read_inferior_memory (memaddr
, myaddr
, len
);
838 rombug_kill (char *args
, int from_tty
)
840 return; /* ignore attempts to kill target system */
843 /* Clean up when a program exits.
844 The program actually lives on in the remote processor's RAM, and may be
845 run again without a download. Don't leave it full of breakpoint
849 rombug_mourn_inferior (void)
851 remove_breakpoints ();
852 generic_mourn_inferior (); /* Do all the proper things now */
855 #define MAX_MONITOR_BREAKPOINTS 16
857 static CORE_ADDR breakaddr
[MAX_MONITOR_BREAKPOINTS
] =
861 rombug_insert_breakpoint (CORE_ADDR addr
, char *shadow
)
864 CORE_ADDR bp_addr
= addr
;
868 fprintf (log_file
, "\nIn Insert_breakpoint (addr=%x)\n", addr
);
869 BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
);
871 for (i
= 0; i
<= MAX_MONITOR_BREAKPOINTS
; i
++)
872 if (breakaddr
[i
] == 0)
876 printf ("Breakpoint at %x\n", addr
);
877 rombug_read_inferior_memory (bp_addr
, shadow
, bp_size
);
878 printf_monitor (SET_BREAK_CMD
, addr
);
884 fprintf (stderr
, "Too many breakpoints (> 16) for monitor\n");
889 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
892 rombug_remove_breakpoint (CORE_ADDR addr
, char *shadow
)
897 fprintf (log_file
, "\nIn Remove_breakpoint (addr=%x)\n", addr
);
899 for (i
= 0; i
< MAX_MONITOR_BREAKPOINTS
; i
++)
900 if (breakaddr
[i
] == addr
)
903 printf_monitor (CLR_BREAK_CMD
, addr
);
909 fprintf (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
913 /* Load a file. This is usually an srecord, which is ascii. No
914 protocol, just sent line by line. */
916 #define DOWNLOAD_LINE_SIZE 100
918 rombug_load (char *arg
)
920 /* this part comment out for os9* */
923 char buf
[DOWNLOAD_LINE_SIZE
];
927 printf ("Loading %s to monitor\n", arg
);
929 download
= fopen (arg
, "r");
930 if (download
== NULL
)
932 error (sprintf (buf
, "%s Does not exist", arg
));
936 printf_monitor (LOAD_CMD
);
937 /* expect ("Waiting for S-records from host... ", 1); */
939 while (!feof (download
))
941 bytes_read
= fread (buf
, sizeof (char), DOWNLOAD_LINE_SIZE
, download
);
948 if (SERIAL_WRITE (monitor_desc
, buf
, bytes_read
))
950 fprintf (stderr
, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror (errno
));
954 while (i
++ <= 200000)
956 }; /* Ugly HACK, probably needs flow control */
957 if (bytes_read
< DOWNLOAD_LINE_SIZE
)
959 if (!feof (download
))
960 error ("Only read %d bytes\n", bytes_read
);
969 if (!feof (download
))
970 error ("Never got EOF while downloading");
975 /* Put a command string, in args, out to MONITOR.
976 Output from MONITOR is placed on the users terminal until the prompt
980 rombug_command (char *args
, int fromtty
)
982 if (monitor_desc
== NULL
)
983 error ("monitor target not open.");
986 fprintf (log_file
, "\nIn command (args=%s)\n", args
);
989 error ("Missing command.");
991 printf_monitor ("%s\r", args
);
996 /* Connect the user directly to MONITOR. This command acts just like the
997 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
999 static struct ttystate ttystate
;
1004 printf ("\r\n[Exiting connect mode]\r\n");
1005 /*SERIAL_RESTORE(0, &ttystate); */
1009 connect_command (char *args
, int fromtty
)
1018 if (monitor_desc
== NULL
)
1019 error ("monitor target not open.");
1022 fprintf ("This command takes no args. They have been ignored.\n");
1024 printf ("[Entering connect mode. Use ~. or ~^D to escape]\n");
1026 serial_raw (0, &ttystate
);
1028 make_cleanup (cleanup_tty
, 0);
1036 FD_SET (0, &readfds
);
1037 FD_SET (DEPRECATED_SERIAL_FD (monitor_desc
), &readfds
);
1038 numfds
= select (sizeof (readfds
) * 8, &readfds
, 0, 0, 0);
1040 while (numfds
== 0);
1043 perror_with_name ("select");
1045 if (FD_ISSET (0, &readfds
))
1046 { /* tty input, send to monitor */
1049 perror_with_name ("connect");
1051 printf_monitor ("%c", c
);
1065 if (c
== '.' || c
== '\004')
1072 if (FD_ISSET (DEPRECATED_SERIAL_FD (monitor_desc
), &readfds
))
1088 * Define the monitor command strings. Since these are passed directly
1089 * through to a printf style function, we need can include formatting
1090 * strings. We also need a CR or LF on the end.
1092 #warning FIXME: monitor interface pattern strings, stale struct decl
1093 struct monitor_ops rombug_cmds
=
1095 "g \r", /* execute or usually GO command */
1096 "g \r", /* continue command */
1097 "t \r", /* single step */
1098 "b %x\r", /* set a breakpoint */
1099 "k %x\r", /* clear a breakpoint */
1100 "c %x\r", /* set memory to a value */
1101 "d %x %d\r", /* display memory */
1102 "$%08X", /* prompt memory commands use */
1103 ".%s %x\r", /* set a register */
1104 ":", /* delimiter between registers */
1105 ". \r", /* read a register */
1106 "mf \r", /* download command */
1107 "RomBug: ", /* monitor command prompt */
1108 ": ", /* end-of-command delimitor */
1109 ".\r" /* optional command terminator */
1112 struct target_ops rombug_ops
;
1115 init_rombug_ops (void)
1117 rombug_ops
.to_shortname
= "rombug";
1118 rombug_ops
.to_longname
= "Microware's ROMBUG debug monitor";
1119 rombug_ops
.to_doc
= "Use a remote computer running the ROMBUG debug monitor.\n\
1120 Specify the serial device it is connected to (e.g. /dev/ttya).",
1121 rombug_ops
.to_open
= rombug_open
;
1122 rombug_ops
.to_close
= rombug_close
;
1123 rombug_ops
.to_attach
= 0;
1124 rombug_ops
.to_post_attach
= NULL
;
1125 rombug_ops
.to_require_attach
= NULL
;
1126 rombug_ops
.to_detach
= rombug_detach
;
1127 rombug_ops
.to_require_detach
= NULL
;
1128 rombug_ops
.to_resume
= rombug_resume
;
1129 rombug_ops
.to_wait
= rombug_wait
;
1130 rombug_ops
.to_post_wait
= NULL
;
1131 rombug_ops
.to_fetch_registers
= rombug_fetch_register
;
1132 rombug_ops
.to_store_registers
= rombug_store_register
;
1133 rombug_ops
.to_prepare_to_store
= rombug_prepare_to_store
;
1134 rombug_ops
.to_xfer_memory
= rombug_xfer_inferior_memory
;
1135 rombug_ops
.to_files_info
= rombug_files_info
;
1136 rombug_ops
.to_insert_breakpoint
= rombug_insert_breakpoint
;
1137 rombug_ops
.to_remove_breakpoint
= rombug_remove_breakpoint
; /* Breakpoints */
1138 rombug_ops
.to_terminal_init
= 0;
1139 rombug_ops
.to_terminal_inferior
= 0;
1140 rombug_ops
.to_terminal_ours_for_output
= 0;
1141 rombug_ops
.to_terminal_ours
= 0;
1142 rombug_ops
.to_terminal_info
= 0; /* Terminal handling */
1143 rombug_ops
.to_kill
= rombug_kill
;
1144 rombug_ops
.to_load
= rombug_load
; /* load */
1145 rombug_ops
.to_lookup_symbol
= rombug_link
; /* lookup_symbol */
1146 rombug_ops
.to_create_inferior
= rombug_create_inferior
;
1147 rombug_ops
.to_post_startup_inferior
= NULL
;
1148 rombug_ops
.to_acknowledge_created_inferior
= NULL
;
1149 rombug_ops
.to_clone_and_follow_inferior
= NULL
;
1150 rombug_ops
.to_post_follow_inferior_by_clone
= NULL
;
1151 rombug_ops
.to_insert_fork_catchpoint
= NULL
;
1152 rombug_ops
.to_remove_fork_catchpoint
= NULL
;
1153 rombug_ops
.to_insert_vfork_catchpoint
= NULL
;
1154 rombug_ops
.to_remove_vfork_catchpoint
= NULL
;
1155 rombug_ops
.to_has_forked
= NULL
;
1156 rombug_ops
.to_has_vforked
= NULL
;
1157 rombug_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
1158 rombug_ops
.to_post_follow_vfork
= NULL
;
1159 rombug_ops
.to_insert_exec_catchpoint
= NULL
;
1160 rombug_ops
.to_remove_exec_catchpoint
= NULL
;
1161 rombug_ops
.to_has_execd
= NULL
;
1162 rombug_ops
.to_reported_exec_events_per_exec_call
= NULL
;
1163 rombug_ops
.to_has_exited
= NULL
;
1164 rombug_ops
.to_mourn_inferior
= rombug_mourn_inferior
;
1165 rombug_ops
.to_can_run
= 0; /* can_run */
1166 rombug_ops
.to_notice_signals
= 0; /* notice_signals */
1167 rombug_ops
.to_thread_alive
= 0;
1168 rombug_ops
.to_stop
= 0; /* to_stop */
1169 rombug_ops
.to_pid_to_exec_file
= NULL
;
1170 rombug_ops
.to_core_file_to_sym_file
= NULL
;
1171 rombug_ops
.to_stratum
= process_stratum
;
1172 rombug_ops
.DONT_USE
= 0; /* next */
1173 rombug_ops
.to_has_all_memory
= 1;
1174 rombug_ops
.to_has_memory
= 1;
1175 rombug_ops
.to_has_stack
= 1;
1176 rombug_ops
.to_has_registers
= 1;
1177 rombug_ops
.to_has_execution
= 1; /* has execution */
1178 rombug_ops
.to_sections
= 0;
1179 rombug_ops
.to_sections_end
= 0; /* Section pointers */
1180 rombug_ops
.to_magic
= OPS_MAGIC
; /* Always the last thing */
1184 _initialize_remote_os9k (void)
1187 add_target (&rombug_ops
);
1190 add_set_cmd ("hash", no_class
, var_boolean
, (char *) &hashmark
,
1191 "Set display of activity while downloading a file.\nWhen enabled, a period \'.\' is displayed.",
1196 add_set_cmd ("timeout", no_class
, var_zinteger
,
1198 "Set timeout in seconds for remote MIPS serial I/O.",
1203 add_set_cmd ("remotelog", no_class
, var_zinteger
,
1204 (char *) &monitor_log
,
1205 "Set monitor activity log on(=1) or off(=0).",
1210 add_set_cmd ("remotexon", no_class
, var_zinteger
,
1212 "Set remote tty line XON control",
1217 add_set_cmd ("remotexoff", no_class
, var_zinteger
,
1219 "Set remote tty line XOFF control",
1223 add_com ("rombug <command>", class_obscure
, rombug_command
,
1224 "Send a command to the debug monitor.");
1226 add_com ("connect", class_obscure
, connect_command
,
1227 "Connect the terminal directly up to a serial based command monitor.\nUse <CR>~. or <CR>~^D to break out.");