gdb/remote-st.c

   1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
   2
   3    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000,
   4    2001, 2002 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., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, 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       supply_register (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 {
 234   int entry_pt;
 235
 236   if (args && *args)
 237     error ("Can't pass arguments to remote STDEBUG process");
 238
 239   if (execfile == 0 || exec_bfd == 0)
 240     error ("No executable file specified");
 241
 242   entry_pt = (int) bfd_get_start_address (exec_bfd);
 243
 244 /* The "process" (board) is already stopped awaiting our commands, and
 245    the program is already downloaded.  We just set its PC and go.  */
 246
 247   clear_proceed_status ();
 248
 249   /* Tell wait_for_inferior that we've started a new process.  */
 250   init_wait_for_inferior ();
 251
 252   /* Set up the "saved terminal modes" of the inferior
 253      based on what modes we are starting it with.  */
 254   target_terminal_init ();
 255
 256   /* Install inferior's terminal modes.  */
 257   target_terminal_inferior ();
 258
 259   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 260   /* Let 'er rip... */
 261   proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 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 (CORE_ADDR addr, char *shadow)
 603 {
 604   int i;
 605   CORE_ADDR bp_addr = addr;
 606   int bp_size = 0;
 607
 608   BREAKPOINT_FROM_PC (&bp_addr, &bp_size);
 609
 610   for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
 611     if (breakaddr[i] == 0)
 612       {
 613         breakaddr[i] = addr;
 614
 615         st2000_read_inferior_memory (bp_addr, shadow, bp_size);
 616         printf_stdebug ("BR %x H\r", addr);
 617         expect_prompt (1);
 618         return 0;
 619       }
 620
 621   fprintf_unfiltered (gdb_stderr, "Too many breakpoints (> 16) for STDBUG\n");
 622   return 1;
 623 }
 624
 625 static int
 626 st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)
 627 {
 628   int i;
 629
 630   for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
 631     if (breakaddr[i] == addr)
 632       {
 633         breakaddr[i] = 0;
 634
 635         printf_stdebug ("CB %d\r", i);
 636         expect_prompt (1);
 637         return 0;
 638       }
 639
 640   fprintf_unfiltered (gdb_stderr,
 641                       "Can't find breakpoint associated with 0x%x\n", addr);
 642   return 1;
 643 }
 644
 645
 646 /* Put a command string, in args, out to STDBUG.  Output from STDBUG is placed
 647    on the users terminal until the prompt is seen. */
 648
 649 static void
 650 st2000_command (char *args, int fromtty)
 651 {
 652   if (!st2000_desc)
 653     error ("st2000 target not open.");
 654
 655   if (!args)
 656     error ("Missing command.");
 657
 658   printf_stdebug ("%s\r", args);
 659   expect_prompt (0);
 660 }
 661
 662 /* Connect the user directly to STDBUG.  This command acts just like the
 663    'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 664
 665 /*static struct ttystate ttystate; */
 666
 667 static void
 668 cleanup_tty (void)
 669 {
 670   printf ("\r\n[Exiting connect mode]\r\n");
 671 /*  serial_restore(0, &ttystate); */
 672 }
 673
 674 #if 0
 675 /* This all should now be in serial.c */
 676
 677 static void
 678 connect_command (char *args, int fromtty)
 679 {
 680   fd_set readfds;
 681   int numfds;
 682   int c;
 683   char cur_esc = 0;
 684
 685   dont_repeat ();
 686
 687   if (st2000_desc < 0)
 688     error ("st2000 target not open.");
 689
 690   if (args)
 691     fprintf ("This command takes no args.  They have been ignored.\n");
 692
 693   printf ("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 694
 695   serial_raw (0, &ttystate);
 696
 697   make_cleanup (cleanup_tty, 0);
 698
 699   FD_ZERO (&readfds);
 700
 701   while (1)
 702     {
 703       do
 704         {
 705           FD_SET (0, &readfds);
 706           FD_SET (deprecated_serial_fd (st2000_desc), &readfds);
 707           numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
 708         }
 709       while (numfds == 0);
 710
 711       if (numfds < 0)
 712         perror_with_name ("select");
 713
 714       if (FD_ISSET (0, &readfds))
 715         {                       /* tty input, send to stdebug */
 716           c = getchar ();
 717           if (c < 0)
 718             perror_with_name ("connect");
 719
 720           printf_stdebug ("%c", c);
 721           switch (cur_esc)
 722             {
 723             case 0:
 724               if (c == '\r')
 725                 cur_esc = c;
 726               break;
 727             case '\r':
 728               if (c == '~')
 729                 cur_esc = c;
 730               else
 731                 cur_esc = 0;
 732               break;
 733             case '~':
 734               if (c == '.' || c == '\004')
 735                 return;
 736               else
 737                 cur_esc = 0;
 738             }
 739         }
 740
 741       if (FD_ISSET (deprecated_serial_fd (st2000_desc), &readfds))
 742         {
 743           while (1)
 744             {
 745               c = readchar (0);
 746               if (c < 0)
 747                 break;
 748               putchar (c);
 749             }
 750           fflush (stdout);
 751         }
 752     }
 753 }
 754 #endif /* 0 */
 755
 756 /* Define the target subroutine names */
 757
 758 struct target_ops st2000_ops;
 759
 760 static void
 761 init_st2000_ops (void)
 762 {
 763   st2000_ops.to_shortname = "st2000";
 764   st2000_ops.to_longname = "Remote serial Tandem ST2000 target";
 765   st2000_ops.to_doc = "Use a remote computer running STDEBUG connected by a serial line;\n\
 766 or a network connection.\n\
 767 Arguments are the name of the device for the serial line,\n\
 768 the speed to connect at in bits per second.";
 769   st2000_ops.to_open = st2000_open;
 770   st2000_ops.to_close = st2000_close;
 771   st2000_ops.to_detach = st2000_detach;
 772   st2000_ops.to_resume = st2000_resume;
 773   st2000_ops.to_wait = st2000_wait;
 774   st2000_ops.to_fetch_registers = st2000_fetch_register;
 775   st2000_ops.to_store_registers = st2000_store_register;
 776   st2000_ops.to_prepare_to_store = st2000_prepare_to_store;
 777   st2000_ops.to_xfer_memory = st2000_xfer_inferior_memory;
 778   st2000_ops.to_files_info = st2000_files_info;
 779   st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint;
 780   st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint;   /* Breakpoints */
 781   st2000_ops.to_kill = st2000_kill;
 782   st2000_ops.to_create_inferior = st2000_create_inferior;
 783   st2000_ops.to_mourn_inferior = st2000_mourn_inferior;
 784   st2000_ops.to_stratum = process_stratum;
 785   st2000_ops.to_has_all_memory = 1;
 786   st2000_ops.to_has_memory = 1;
 787   st2000_ops.to_has_stack = 1;
 788   st2000_ops.to_has_registers = 1;
 789   st2000_ops.to_has_execution = 1;      /* all mem, mem, stack, regs, exec */
 790   st2000_ops.to_magic = OPS_MAGIC;      /* Always the last thing */
 791 };
 792
 793 void
 794 _initialize_remote_st2000 (void)
 795 {
 796   init_st2000_ops ();
 797   add_target (&st2000_ops);
 798   add_com ("st2000 <command>", class_obscure, st2000_command,
 799            "Send a command to the STDBUG monitor.");
 800   add_com ("connect", class_obscure, connect_command,
 801            "Connect the terminal directly up to the STDBUG command monitor.\n\
 802 Use <CR>~. or <CR>~^D to break out.");
 803 }