gdb/remote-st.c

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