* ppc-bdm.c (#include <signal.h>): Removed.
[external/binutils.git] / gdb / remote-st.c
1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
2    Copyright 1990, 1991, 1992, 2001 Free Software Foundation, Inc.
3    Contributed by Cygnus Support.  Written by Jim Kingdon for Cygnus.
4
5    This file is part of GDB.
6
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.
11
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.
16
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., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22 /* This file was derived from remote-eb.c, which did a similar job, but for
23    an AMD-29K running EBMON.  That file was in turn derived from remote.c
24    as mentioned in the following comment (left in for comic relief):
25
26    "This is like remote.c but is for an esoteric situation--
27    having an a29k board in a PC hooked up to a unix machine with
28    a serial line, and running ctty com1 on the PC, through which
29    the unix machine can run ebmon.  Not to mention that the PC
30    has PC/NFS, so it can access the same executables that gdb can,
31    over the net in real time."
32
33    In reality, this module talks to a debug monitor called 'STDEBUG', which
34    runs in a phone switch.  We communicate with STDEBUG via either a direct
35    serial line, or a TCP (or possibly TELNET) stream to a terminal multiplexor,
36    which in turn talks to the phone switch. */
37
38 #include "defs.h"
39 #include "gdbcore.h"
40 #include "target.h"
41 #include "gdb_string.h"
42 #include <sys/types.h>
43 #include "serial.h"
44
45 extern struct target_ops st2000_ops;    /* Forward declaration */
46
47 static void st2000_close ();
48 static void st2000_fetch_register ();
49 static void st2000_store_register ();
50
51 #define LOG_FILE "st2000.log"
52 #if defined (LOG_FILE)
53 FILE *log_file;
54 #endif
55
56 static int timeout = 24;
57
58 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
59    st2000_open knows that we don't have a file open when the program
60    starts.  */
61
62 static serial_t st2000_desc;
63
64 /* Send data to stdebug.  Works just like printf. */
65
66 static void
67 printf_stdebug (char *pattern,...)
68 {
69   va_list args;
70   char buf[200];
71
72   va_start (args, pattern);
73
74   vsprintf (buf, pattern, args);
75   va_end (args);
76
77   if (SERIAL_WRITE (st2000_desc, buf, strlen (buf)))
78     fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
79 }
80
81 /* Read a character from the remote system, doing all the fancy timeout
82    stuff.  */
83
84 static int
85 readchar (int timeout)
86 {
87   int c;
88
89   c = SERIAL_READCHAR (st2000_desc, timeout);
90
91 #ifdef LOG_FILE
92   putc (c & 0x7f, log_file);
93 #endif
94
95   if (c >= 0)
96     return c & 0x7f;
97
98   if (c == SERIAL_TIMEOUT)
99     {
100       if (timeout == 0)
101         return c;               /* Polls shouldn't generate timeout errors */
102
103       error ("Timeout reading from remote system.");
104     }
105
106   perror_with_name ("remote-st2000");
107 }
108
109 /* Scan input from the remote system, until STRING is found.  If DISCARD is
110    non-zero, then discard non-matching input, else print it out.
111    Let the user break out immediately.  */
112 static void
113 expect (char *string, int discard)
114 {
115   char *p = string;
116   int c;
117
118   immediate_quit++;
119   while (1)
120     {
121       c = readchar (timeout);
122       if (c == *p++)
123         {
124           if (*p == '\0')
125             {
126               immediate_quit--;
127               return;
128             }
129         }
130       else
131         {
132           if (!discard)
133             {
134               fwrite (string, 1, (p - 1) - string, stdout);
135               putchar ((char) c);
136               fflush (stdout);
137             }
138           p = string;
139         }
140     }
141 }
142
143 /* Keep discarding input until we see the STDEBUG prompt.
144
145    The convention for dealing with the prompt is that you
146    o give your command
147    o *then* wait for the prompt.
148
149    Thus the last thing that a procedure does with the serial line
150    will be an expect_prompt().  Exception:  st2000_resume does not
151    wait for the prompt, because the terminal is being handed over
152    to the inferior.  However, the next thing which happens after that
153    is a st2000_wait which does wait for the prompt.
154    Note that this includes abnormal exit, e.g. error().  This is
155    necessary to prevent getting into states from which we can't
156    recover.  */
157 static void
158 expect_prompt (int discard)
159 {
160 #if defined (LOG_FILE)
161   /* This is a convenient place to do this.  The idea is to do it often
162      enough that we never lose much data if we terminate abnormally.  */
163   fflush (log_file);
164 #endif
165   expect ("dbug> ", discard);
166 }
167
168 /* Get a hex digit from the remote system & return its value.
169    If ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
170 static int
171 get_hex_digit (int ignore_space)
172 {
173   int ch;
174   while (1)
175     {
176       ch = readchar (timeout);
177       if (ch >= '0' && ch <= '9')
178         return ch - '0';
179       else if (ch >= 'A' && ch <= 'F')
180         return ch - 'A' + 10;
181       else if (ch >= 'a' && ch <= 'f')
182         return ch - 'a' + 10;
183       else if (ch == ' ' && ignore_space)
184         ;
185       else
186         {
187           expect_prompt (1);
188           error ("Invalid hex digit from remote system.");
189         }
190     }
191 }
192
193 /* Get a byte from stdebug and put it in *BYT.  Accept any number
194    leading spaces.  */
195 static void
196 get_hex_byte (char *byt)
197 {
198   int val;
199
200   val = get_hex_digit (1) << 4;
201   val |= get_hex_digit (0);
202   *byt = val;
203 }
204
205 /* Get N 32-bit words from remote, each preceded by a space,
206    and put them in registers starting at REGNO.  */
207 static void
208 get_hex_regs (int n, int regno)
209 {
210   long val;
211   int i;
212
213   for (i = 0; i < n; i++)
214     {
215       int j;
216
217       val = 0;
218       for (j = 0; j < 8; j++)
219         val = (val << 4) + get_hex_digit (j == 0);
220       supply_register (regno++, (char *) &val);
221     }
222 }
223
224 /* This is called not only when we first attach, but also when the
225    user types "run" after having attached.  */
226 static void
227 st2000_create_inferior (char *execfile, char *args, char **env)
228 {
229   int entry_pt;
230
231   if (args && *args)
232     error ("Can't pass arguments to remote STDEBUG process");
233
234   if (execfile == 0 || exec_bfd == 0)
235     error ("No executable file specified");
236
237   entry_pt = (int) bfd_get_start_address (exec_bfd);
238
239 /* The "process" (board) is already stopped awaiting our commands, and
240    the program is already downloaded.  We just set its PC and go.  */
241
242   clear_proceed_status ();
243
244   /* Tell wait_for_inferior that we've started a new process.  */
245   init_wait_for_inferior ();
246
247   /* Set up the "saved terminal modes" of the inferior
248      based on what modes we are starting it with.  */
249   target_terminal_init ();
250
251   /* Install inferior's terminal modes.  */
252   target_terminal_inferior ();
253
254   /* insert_step_breakpoint ();  FIXME, do we need this?  */
255   /* Let 'er rip... */
256   proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
257 }
258
259 /* Open a connection to a remote debugger.
260    NAME is the filename used for communication.  */
261
262 static int baudrate = 9600;
263 static char dev_name[100];
264
265 static void
266 st2000_open (char *args, int from_tty)
267 {
268   int n;
269   char junk[100];
270
271   target_preopen (from_tty);
272
273   n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk);
274
275   if (n != 2)
276     error ("Bad arguments.  Usage: target st2000 <device> <speed>\n\
277 or target st2000 <host> <port>\n");
278
279   st2000_close (0);
280
281   st2000_desc = SERIAL_OPEN (dev_name);
282
283   if (!st2000_desc)
284     perror_with_name (dev_name);
285
286   SERIAL_SETBAUDRATE (st2000_desc, baudrate);
287
288   SERIAL_RAW (st2000_desc);
289
290   push_target (&st2000_ops);
291
292 #if defined (LOG_FILE)
293   log_file = fopen (LOG_FILE, "w");
294   if (log_file == NULL)
295     perror_with_name (LOG_FILE);
296 #endif
297
298   /* Hello?  Are you there?  */
299   printf_stdebug ("\003");      /* ^C wakes up dbug */
300
301   expect_prompt (1);
302
303   if (from_tty)
304     printf ("Remote %s connected to %s\n", target_shortname,
305             dev_name);
306 }
307
308 /* Close out all files and local state before this target loses control. */
309
310 static void
311 st2000_close (int quitting)
312 {
313   SERIAL_CLOSE (st2000_desc);
314
315 #if defined (LOG_FILE)
316   if (log_file)
317     {
318       if (ferror (log_file))
319         fprintf (stderr, "Error writing log file.\n");
320       if (fclose (log_file) != 0)
321         fprintf (stderr, "Error closing log file.\n");
322     }
323 #endif
324 }
325
326 /* Terminate the open connection to the remote debugger.
327    Use this when you want to detach and do something else
328    with your gdb.  */
329 static void
330 st2000_detach (int from_tty)
331 {
332   pop_target ();                /* calls st2000_close to do the real work */
333   if (from_tty)
334     printf ("Ending remote %s debugging\n", target_shortname);
335 }
336
337 /* Tell the remote machine to resume.  */
338
339 static void
340 st2000_resume (int pid, int step, enum target_signal sig)
341 {
342   if (step)
343     {
344       printf_stdebug ("ST\r");
345       /* Wait for the echo.  */
346       expect ("ST\r", 1);
347     }
348   else
349     {
350       printf_stdebug ("GO\r");
351       /* Swallow the echo.  */
352       expect ("GO\r", 1);
353     }
354 }
355
356 /* Wait until the remote machine stops, then return,
357    storing status in STATUS just as `wait' would.  */
358
359 static int
360 st2000_wait (struct target_waitstatus *status)
361 {
362   int old_timeout = timeout;
363
364   status->kind = TARGET_WAITKIND_EXITED;
365   status->value.integer = 0;
366
367   timeout = 0;                  /* Don't time out -- user program is running. */
368
369   expect_prompt (0);            /* Wait for prompt, outputting extraneous text */
370
371   status->kind = TARGET_WAITKIND_STOPPED;
372   status->value.sig = TARGET_SIGNAL_TRAP;
373
374   timeout = old_timeout;
375
376   return 0;
377 }
378
379 /* Return the name of register number REGNO in the form input and output by
380    STDEBUG.  Currently, REGISTER_NAMES just happens to contain exactly what
381    STDEBUG wants.  Lets take advantage of that just as long as possible! */
382
383 static char *
384 get_reg_name (int regno)
385 {
386   static char buf[50];
387   const char *p;
388   char *b;
389
390   b = buf;
391
392   for (p = REGISTER_NAME (regno); *p; p++)
393     *b++ = toupper (*p);
394   *b = '\000';
395
396   return buf;
397 }
398
399 /* Read the remote registers into the block REGS.  */
400
401 static void
402 st2000_fetch_registers (void)
403 {
404   int regno;
405
406   /* Yeah yeah, I know this is horribly inefficient.  But it isn't done
407      very often...  I'll clean it up later.  */
408
409   for (regno = 0; regno <= PC_REGNUM; regno++)
410     st2000_fetch_register (regno);
411 }
412
413 /* Fetch register REGNO, or all registers if REGNO is -1.
414    Returns errno value.  */
415 static void
416 st2000_fetch_register (int regno)
417 {
418   if (regno == -1)
419     st2000_fetch_registers ();
420   else
421     {
422       char *name = get_reg_name (regno);
423       printf_stdebug ("DR %s\r", name);
424       expect (name, 1);
425       expect (" : ", 1);
426       get_hex_regs (1, regno);
427       expect_prompt (1);
428     }
429   return;
430 }
431
432 /* Store the remote registers from the contents of the block REGS.  */
433
434 static void
435 st2000_store_registers (void)
436 {
437   int regno;
438
439   for (regno = 0; regno <= PC_REGNUM; regno++)
440     st2000_store_register (regno);
441
442   registers_changed ();
443 }
444
445 /* Store register REGNO, or all if REGNO == 0.
446    Return errno value.  */
447 static void
448 st2000_store_register (int regno)
449 {
450   if (regno == -1)
451     st2000_store_registers ();
452   else
453     {
454       printf_stdebug ("PR %s %x\r", get_reg_name (regno),
455                       read_register (regno));
456
457       expect_prompt (1);
458     }
459 }
460
461 /* Get ready to modify the registers array.  On machines which store
462    individual registers, this doesn't need to do anything.  On machines
463    which store all the registers in one fell swoop, this makes sure
464    that registers contains all the registers from the program being
465    debugged.  */
466
467 static void
468 st2000_prepare_to_store (void)
469 {
470   /* Do nothing, since we can store individual regs */
471 }
472
473 static void
474 st2000_files_info (void)
475 {
476   printf ("\tAttached to %s at %d baud.\n",
477           dev_name, baudrate);
478 }
479
480 /* Copy LEN bytes of data from debugger memory at MYADDR
481    to inferior's memory at MEMADDR.  Returns length moved.  */
482 static int
483 st2000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
484 {
485   int i;
486
487   for (i = 0; i < len; i++)
488     {
489       printf_stdebug ("PM.B %x %x\r", memaddr + i, myaddr[i]);
490       expect_prompt (1);
491     }
492   return len;
493 }
494
495 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
496    at debugger address MYADDR.  Returns length moved.  */
497 static int
498 st2000_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
499 {
500   int i;
501
502   /* Number of bytes read so far.  */
503   int count;
504
505   /* Starting address of this pass.  */
506   unsigned long startaddr;
507
508   /* Number of bytes to read in this pass.  */
509   int len_this_pass;
510
511   /* Note that this code works correctly if startaddr is just less
512      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
513      thing).  That is, something like
514      st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
515      works--it never adds len to memaddr and gets 0.  */
516   /* However, something like
517      st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
518      doesn't need to work.  Detect it and give up if there's an attempt
519      to do that.  */
520   if (((memaddr - 1) + len) < memaddr)
521     {
522       errno = EIO;
523       return 0;
524     }
525
526   startaddr = memaddr;
527   count = 0;
528   while (count < len)
529     {
530       len_this_pass = 16;
531       if ((startaddr % 16) != 0)
532         len_this_pass -= startaddr % 16;
533       if (len_this_pass > (len - count))
534         len_this_pass = (len - count);
535
536       printf_stdebug ("DI.L %x %x\r", startaddr, len_this_pass);
537       expect (":  ", 1);
538
539       for (i = 0; i < len_this_pass; i++)
540         get_hex_byte (&myaddr[count++]);
541
542       expect_prompt (1);
543
544       startaddr += len_this_pass;
545     }
546   return len;
547 }
548
549 /* Transfer LEN bytes between GDB address MYADDR and target address
550    MEMADDR.  If WRITE is non-zero, transfer them to the target,
551    otherwise transfer them from the target.  TARGET is unused.
552
553    Returns the number of bytes transferred. */
554
555 static int
556 st2000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
557                              int write, 
558                              struct mem_attrib *attrib ATTRIBUTE_UNUSED,
559                              struct target_ops *target ATTRIBUTE_UNUSED)
560 {
561   if (write)
562     return st2000_write_inferior_memory (memaddr, myaddr, len);
563   else
564     return st2000_read_inferior_memory (memaddr, myaddr, len);
565 }
566
567 static void
568 st2000_kill (char *args, int from_tty)
569 {
570   return;                       /* Ignore attempts to kill target system */
571 }
572
573 /* Clean up when a program exits.
574
575    The program actually lives on in the remote processor's RAM, and may be
576    run again without a download.  Don't leave it full of breakpoint
577    instructions.  */
578
579 static void
580 st2000_mourn_inferior (void)
581 {
582   remove_breakpoints ();
583   unpush_target (&st2000_ops);
584   generic_mourn_inferior ();    /* Do all the proper things now */
585 }
586
587 #define MAX_STDEBUG_BREAKPOINTS 16
588
589 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] =
590 {0};
591
592 static int
593 st2000_insert_breakpoint (CORE_ADDR addr, char *shadow)
594 {
595   int i;
596   CORE_ADDR bp_addr = addr;
597   int bp_size = 0;
598
599   BREAKPOINT_FROM_PC (&bp_addr, &bp_size);
600
601   for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
602     if (breakaddr[i] == 0)
603       {
604         breakaddr[i] = addr;
605
606         st2000_read_inferior_memory (bp_addr, shadow, bp_size);
607         printf_stdebug ("BR %x H\r", addr);
608         expect_prompt (1);
609         return 0;
610       }
611
612   fprintf (stderr, "Too many breakpoints (> 16) for STDBUG\n");
613   return 1;
614 }
615
616 static int
617 st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)
618 {
619   int i;
620
621   for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
622     if (breakaddr[i] == addr)
623       {
624         breakaddr[i] = 0;
625
626         printf_stdebug ("CB %d\r", i);
627         expect_prompt (1);
628         return 0;
629       }
630
631   fprintf (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
632   return 1;
633 }
634
635
636 /* Put a command string, in args, out to STDBUG.  Output from STDBUG is placed
637    on the users terminal until the prompt is seen. */
638
639 static void
640 st2000_command (char *args, int fromtty)
641 {
642   if (!st2000_desc)
643     error ("st2000 target not open.");
644
645   if (!args)
646     error ("Missing command.");
647
648   printf_stdebug ("%s\r", args);
649   expect_prompt (0);
650 }
651
652 /* Connect the user directly to STDBUG.  This command acts just like the
653    'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
654
655 /*static struct ttystate ttystate; */
656
657 static void
658 cleanup_tty (void)
659 {
660   printf ("\r\n[Exiting connect mode]\r\n");
661 /*  SERIAL_RESTORE(0, &ttystate); */
662 }
663
664 #if 0
665 /* This all should now be in serial.c */
666
667 static void
668 connect_command (char *args, int fromtty)
669 {
670   fd_set readfds;
671   int numfds;
672   int c;
673   char cur_esc = 0;
674
675   dont_repeat ();
676
677   if (st2000_desc < 0)
678     error ("st2000 target not open.");
679
680   if (args)
681     fprintf ("This command takes no args.  They have been ignored.\n");
682
683   printf ("[Entering connect mode.  Use ~. or ~^D to escape]\n");
684
685   serial_raw (0, &ttystate);
686
687   make_cleanup (cleanup_tty, 0);
688
689   FD_ZERO (&readfds);
690
691   while (1)
692     {
693       do
694         {
695           FD_SET (0, &readfds);
696           FD_SET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds);
697           numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
698         }
699       while (numfds == 0);
700
701       if (numfds < 0)
702         perror_with_name ("select");
703
704       if (FD_ISSET (0, &readfds))
705         {                       /* tty input, send to stdebug */
706           c = getchar ();
707           if (c < 0)
708             perror_with_name ("connect");
709
710           printf_stdebug ("%c", c);
711           switch (cur_esc)
712             {
713             case 0:
714               if (c == '\r')
715                 cur_esc = c;
716               break;
717             case '\r':
718               if (c == '~')
719                 cur_esc = c;
720               else
721                 cur_esc = 0;
722               break;
723             case '~':
724               if (c == '.' || c == '\004')
725                 return;
726               else
727                 cur_esc = 0;
728             }
729         }
730
731       if (FD_ISSET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds))
732         {
733           while (1)
734             {
735               c = readchar (0);
736               if (c < 0)
737                 break;
738               putchar (c);
739             }
740           fflush (stdout);
741         }
742     }
743 }
744 #endif /* 0 */
745
746 /* Define the target subroutine names */
747
748 struct target_ops st2000_ops;
749
750 static void
751 init_st2000_ops (void)
752 {
753   st2000_ops.to_shortname = "st2000";
754   st2000_ops.to_longname = "Remote serial Tandem ST2000 target";
755   st2000_ops.to_doc = "Use a remote computer running STDEBUG connected by a serial line;\n\
756 or a network connection.\n\
757 Arguments are the name of the device for the serial line,\n\
758 the speed to connect at in bits per second.";
759   st2000_ops.to_open = st2000_open;
760   st2000_ops.to_close = st2000_close;
761   st2000_ops.to_attach = 0;
762   st2000_run_ops.to_post_attach = NULL;
763   st2000_ops.to_require_attach = NULL;
764   st2000_ops.to_detach = st2000_detach;
765   st2000_ops.to_require_detach = NULL;
766   st2000_ops.to_resume = st2000_resume;
767   st2000_ops.to_wait = st2000_wait;
768   st2000_ops.to_post_wait = NULL;
769   st2000_ops.to_fetch_registers = st2000_fetch_register;
770   st2000_ops.to_store_registers = st2000_store_register;
771   st2000_ops.to_prepare_to_store = st2000_prepare_to_store;
772   st2000_ops.to_xfer_memory = st2000_xfer_inferior_memory;
773   st2000_ops.to_files_info = st2000_files_info;
774   st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint;
775   st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint;   /* Breakpoints */
776   st2000_ops.to_terminal_init = 0;
777   st2000_ops.to_terminal_inferior = 0;
778   st2000_ops.to_terminal_ours_for_output = 0;
779   st2000_ops.to_terminal_ours = 0;
780   st2000_ops.to_terminal_info = 0;      /* Terminal handling */
781   st2000_ops.to_kill = st2000_kill;
782   st2000_ops.to_load = 0;       /* load */
783   st2000_ops.to_lookup_symbol = 0;      /* lookup_symbol */
784   st2000_ops.to_create_inferior = st2000_create_inferior;
785   st2000_ops.to_post_startup_inferior = NULL;
786   st2000_ops.to_acknowledge_created_inferior = NULL;
787   st2000_ops.to_clone_and_follow_inferior = NULL;
788   st2000_ops.to_post_follow_inferior_by_clone = NULL;
789   st2000_run_ops.to_insert_fork_catchpoint = NULL;
790   st2000_run_ops.to_remove_fork_catchpoint = NULL;
791   st2000_run_ops.to_insert_vfork_catchpoint = NULL;
792   st2000_run_ops.to_remove_vfork_catchpoint = NULL;
793   st2000_ops.to_has_forked = NULL;
794   st2000_ops.to_has_vforked = NULL;
795   st2000_run_ops.to_can_follow_vfork_prior_to_exec = NULL;
796   st2000_ops.to_post_follow_vfork = NULL;
797   st2000_run_ops.to_insert_exec_catchpoint = NULL;
798   st2000_run_ops.to_remove_exec_catchpoint = NULL;
799   st2000_run_ops.to_has_execd = NULL;
800   st2000_run_ops.to_reported_exec_events_per_exec_call = NULL;
801   st2000_run_ops.to_has_exited = NULL;
802   st2000_ops.to_mourn_inferior = st2000_mourn_inferior;
803   st2000_ops.to_can_run = 0;    /* can_run */
804   st2000_ops.to_notice_signals = 0;     /* notice_signals */
805   st2000_ops.to_thread_alive = 0;       /* thread alive */
806   st2000_ops.to_stop = 0;       /* to_stop */
807   st2000_ops.to_pid_to_exec_file = NULL;
808   st2000_run_ops.to_core_file_to_sym_file = NULL;
809   st2000_ops.to_stratum = process_stratum;
810   st2000_ops.DONT_USE = 0;      /* next */
811   st2000_ops.to_has_all_memory = 1;
812   st2000_ops.to_has_memory = 1;
813   st2000_ops.to_has_stack = 1;
814   st2000_ops.to_has_registers = 1;
815   st2000_ops.to_has_execution = 1;      /* all mem, mem, stack, regs, exec */
816   st2000_ops.to_sections = 0;
817   st2000_ops.to_sections_end = 0;       /* Section pointers */
818   st2000_ops.to_magic = OPS_MAGIC;      /* Always the last thing */
819 };
820
821 void
822 _initialize_remote_st2000 (void)
823 {
824   init_st2000_ops ();
825   add_target (&st2000_ops);
826   add_com ("st2000 <command>", class_obscure, st2000_command,
827            "Send a command to the STDBUG monitor.");
828   add_com ("connect", class_obscure, connect_command,
829            "Connect the terminal directly up to the STDBUG command monitor.\n\
830 Use <CR>~. or <CR>~^D to break out.");
831 }