gdb/remote-st.c

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