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 output by
 389    STDEBUG.  Currently, REGISTER_NAMES just happens to contain exactly what
 390    STDEBUG wants.  Lets take advantage of that just as long as possible! */
 391
 392 static char *
 393 get_reg_name (int regno)
 394 {
 395   static char buf[50];
 396   const char *p;
 397   char *b;
 398
 399   b = buf;
 400
 401   for (p = REGISTER_NAME (regno); *p; p++)
 402     *b++ = toupper (*p);
 403   *b = '\000';
 404
 405   return buf;
 406 }
 407
 408 /* Read the remote registers into the block REGS.  */
 409
 410 static void
 411 st2000_fetch_registers (void)
 412 {
 413   int regno;
 414
 415   /* Yeah yeah, I know this is horribly inefficient.  But it isn't done
 416      very often...  I'll clean it up later.  */
 417
 418   for (regno = 0; regno <= PC_REGNUM; regno++)
 419     st2000_fetch_register (regno);
 420 }
 421
 422 /* Fetch register REGNO, or all registers if REGNO is -1.
 423    Returns errno value.  */
 424 static void
 425 st2000_fetch_register (int regno)
 426 {
 427   if (regno == -1)
 428     st2000_fetch_registers ();
 429   else
 430     {
 431       char *name = get_reg_name (regno);
 432       printf_stdebug ("DR %s\r", name);
 433       expect (name, 1);
 434       expect (" : ", 1);
 435       get_hex_regs (1, regno);
 436       expect_prompt (1);
 437     }
 438   return;
 439 }
 440
 441 /* Store the remote registers from the contents of the block REGS.  */
 442
 443 static void
 444 st2000_store_registers (void)
 445 {
 446   int regno;
 447
 448   for (regno = 0; regno <= PC_REGNUM; regno++)
 449     st2000_store_register (regno);
 450
 451   registers_changed ();
 452 }
 453
 454 /* Store register REGNO, or all if REGNO == 0.
 455    Return errno value.  */
 456 static void
 457 st2000_store_register (int regno)
 458 {
 459   if (regno == -1)
 460     st2000_store_registers ();
 461   else
 462     {
 463       printf_stdebug ("PR %s %x\r", get_reg_name (regno),
 464                       read_register (regno));
 465
 466       expect_prompt (1);
 467     }
 468 }
 469
 470 /* Get ready to modify the registers array.  On machines which store
 471    individual registers, this doesn't need to do anything.  On machines
 472    which store all the registers in one fell swoop, this makes sure
 473    that registers contains all the registers from the program being
 474    debugged.  */
 475
 476 static void
 477 st2000_prepare_to_store (void)
 478 {
 479   /* Do nothing, since we can store individual regs */
 480 }
 481
 482 static void
 483 st2000_files_info (void)
 484 {
 485   printf ("\tAttached to %s at %d baud.\n",
 486           dev_name, baudrate);
 487 }
 488
 489 /* Copy LEN bytes of data from debugger memory at MYADDR
 490    to inferior's memory at MEMADDR.  Returns length moved.  */
 491 static int
 492 st2000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 493 {
 494   int i;
 495
 496   for (i = 0; i < len; i++)
 497     {
 498       printf_stdebug ("PM.B %x %x\r", memaddr + i, myaddr[i]);
 499       expect_prompt (1);
 500     }
 501   return len;
 502 }
 503
 504 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
 505    at debugger address MYADDR.  Returns length moved.  */
 506 static int
 507 st2000_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
 508 {
 509   int i;
 510
 511   /* Number of bytes read so far.  */
 512   int count;
 513
 514   /* Starting address of this pass.  */
 515   unsigned long startaddr;
 516
 517   /* Number of bytes to read in this pass.  */
 518   int len_this_pass;
 519
 520   /* Note that this code works correctly if startaddr is just less
 521      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
 522      thing).  That is, something like
 523      st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
 524      works--it never adds len to memaddr and gets 0.  */
 525   /* However, something like
 526      st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
 527      doesn't need to work.  Detect it and give up if there's an attempt
 528      to do that.  */
 529   if (((memaddr - 1) + len) < memaddr)
 530     {
 531       errno = EIO;
 532       return 0;
 533     }
 534
 535   startaddr = memaddr;
 536   count = 0;
 537   while (count < len)
 538     {
 539       len_this_pass = 16;
 540       if ((startaddr % 16) != 0)
 541         len_this_pass -= startaddr % 16;
 542       if (len_this_pass > (len - count))
 543         len_this_pass = (len - count);
 544
 545       printf_stdebug ("DI.L %x %x\r", startaddr, len_this_pass);
 546       expect (":  ", 1);
 547
 548       for (i = 0; i < len_this_pass; i++)
 549         get_hex_byte (&myaddr[count++]);
 550
 551       expect_prompt (1);
 552
 553       startaddr += len_this_pass;
 554     }
 555   return len;
 556 }
 557
 558 /* Transfer LEN bytes between GDB address MYADDR and target address
 559    MEMADDR.  If WRITE is non-zero, transfer them to the target,
 560    otherwise transfer them from the target.  TARGET is unused.
 561
 562    Returns the number of bytes transferred. */
 563
 564 static int
 565 st2000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
 566                              int write, struct mem_attrib *attrib,
 567                              struct target_ops *target)
 568 {
 569   if (write)
 570     return st2000_write_inferior_memory (memaddr, myaddr, len);
 571   else
 572     return st2000_read_inferior_memory (memaddr, myaddr, len);
 573 }
 574
 575 static void
 576 st2000_kill (char *args, int from_tty)
 577 {
 578   return;                       /* Ignore attempts to kill target system */
 579 }
 580
 581 /* Clean up when a program exits.
 582
 583    The program actually lives on in the remote processor's RAM, and may be
 584    run again without a download.  Don't leave it full of breakpoint
 585    instructions.  */
 586
 587 static void
 588 st2000_mourn_inferior (void)
 589 {
 590   remove_breakpoints ();
 591   unpush_target (&st2000_ops);
 592   generic_mourn_inferior ();    /* Do all the proper things now */
 593 }
 594
 595 #define MAX_STDEBUG_BREAKPOINTS 16
 596
 597 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] =
 598 {0};
 599
 600 static int
 601 st2000_insert_breakpoint (CORE_ADDR addr, char *shadow)
 602 {
 603   int i;
 604   CORE_ADDR bp_addr = addr;
 605   int bp_size = 0;
 606
 607   BREAKPOINT_FROM_PC (&bp_addr, &bp_size);
 608
 609   for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
 610     if (breakaddr[i] == 0)
 611       {
 612         breakaddr[i] = addr;
 613
 614         st2000_read_inferior_memory (bp_addr, shadow, bp_size);
 615         printf_stdebug ("BR %x H\r", addr);
 616         expect_prompt (1);
 617         return 0;
 618       }
 619
 620   fprintf_unfiltered (gdb_stderr, "Too many breakpoints (> 16) for STDBUG\n");
 621   return 1;
 622 }
 623
 624 static int
 625 st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)
 626 {
 627   int i;
 628
 629   for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
 630     if (breakaddr[i] == addr)
 631       {
 632         breakaddr[i] = 0;
 633
 634         printf_stdebug ("CB %d\r", i);
 635         expect_prompt (1);
 636         return 0;
 637       }
 638
 639   fprintf_unfiltered (gdb_stderr,
 640                       "Can't find breakpoint associated with 0x%x\n", addr);
 641   return 1;
 642 }
 643
 644
 645 /* Put a command string, in args, out to STDBUG.  Output from STDBUG is placed
 646    on the users terminal until the prompt is seen. */
 647
 648 static void
 649 st2000_command (char *args, int fromtty)
 650 {
 651   if (!st2000_desc)
 652     error ("st2000 target not open.");
 653
 654   if (!args)
 655     error ("Missing command.");
 656
 657   printf_stdebug ("%s\r", args);
 658   expect_prompt (0);
 659 }
 660
 661 /* Connect the user directly to STDBUG.  This command acts just like the
 662    'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 663
 664 /*static struct ttystate ttystate; */
 665
 666 static void
 667 cleanup_tty (void)
 668 {
 669   printf ("\r\n[Exiting connect mode]\r\n");
 670 /*  serial_restore(0, &ttystate); */
 671 }
 672
 673 #if 0
 674 /* This all should now be in serial.c */
 675
 676 static void
 677 connect_command (char *args, int fromtty)
 678 {
 679   fd_set readfds;
 680   int numfds;
 681   int c;
 682   char cur_esc = 0;
 683
 684   dont_repeat ();
 685
 686   if (st2000_desc < 0)
 687     error ("st2000 target not open.");
 688
 689   if (args)
 690     fprintf ("This command takes no args.  They have been ignored.\n");
 691
 692   printf ("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 693
 694   serial_raw (0, &ttystate);
 695
 696   make_cleanup (cleanup_tty, 0);
 697
 698   FD_ZERO (&readfds);
 699
 700   while (1)
 701     {
 702       do
 703         {
 704           FD_SET (0, &readfds);
 705           FD_SET (deprecated_serial_fd (st2000_desc), &readfds);
 706           numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
 707         }
 708       while (numfds == 0);
 709
 710       if (numfds < 0)
 711         perror_with_name ("select");
 712
 713       if (FD_ISSET (0, &readfds))
 714         {                       /* tty input, send to stdebug */
 715           c = getchar ();
 716           if (c < 0)
 717             perror_with_name ("connect");
 718
 719           printf_stdebug ("%c", c);
 720           switch (cur_esc)
 721             {
 722             case 0:
 723               if (c == '\r')
 724                 cur_esc = c;
 725               break;
 726             case '\r':
 727               if (c == '~')
 728                 cur_esc = c;
 729               else
 730                 cur_esc = 0;
 731               break;
 732             case '~':
 733               if (c == '.' || c == '\004')
 734                 return;
 735               else
 736                 cur_esc = 0;
 737             }
 738         }
 739
 740       if (FD_ISSET (deprecated_serial_fd (st2000_desc), &readfds))
 741         {
 742           while (1)
 743             {
 744               c = readchar (0);
 745               if (c < 0)
 746                 break;
 747               putchar (c);
 748             }
 749           fflush (stdout);
 750         }
 751     }
 752 }
 753 #endif /* 0 */
 754
 755 /* Define the target subroutine names */
 756
 757 struct target_ops st2000_ops;
 758
 759 static void
 760 init_st2000_ops (void)
 761 {
 762   st2000_ops.to_shortname = "st2000";
 763   st2000_ops.to_longname = "Remote serial Tandem ST2000 target";
 764   st2000_ops.to_doc = "Use a remote computer running STDEBUG connected by a serial line;\n\
 765 or a network connection.\n\
 766 Arguments are the name of the device for the serial line,\n\
 767 the speed to connect at in bits per second.";
 768   st2000_ops.to_open = st2000_open;
 769   st2000_ops.to_close = st2000_close;
 770   st2000_ops.to_attach = 0;
 771   st2000_run_ops.to_post_attach = NULL;
 772   st2000_ops.to_require_attach = NULL;
 773   st2000_ops.to_detach = st2000_detach;
 774   st2000_ops.to_require_detach = NULL;
 775   st2000_ops.to_resume = st2000_resume;
 776   st2000_ops.to_wait = st2000_wait;
 777   st2000_ops.to_post_wait = NULL;
 778   st2000_ops.to_fetch_registers = st2000_fetch_register;
 779   st2000_ops.to_store_registers = st2000_store_register;
 780   st2000_ops.to_prepare_to_store = st2000_prepare_to_store;
 781   st2000_ops.to_xfer_memory = st2000_xfer_inferior_memory;
 782   st2000_ops.to_files_info = st2000_files_info;
 783   st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint;
 784   st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint;   /* Breakpoints */
 785   st2000_ops.to_terminal_init = 0;
 786   st2000_ops.to_terminal_inferior = 0;
 787   st2000_ops.to_terminal_ours_for_output = 0;
 788   st2000_ops.to_terminal_ours = 0;
 789   st2000_ops.to_terminal_info = 0;      /* Terminal handling */
 790   st2000_ops.to_kill = st2000_kill;
 791   st2000_ops.to_load = 0;       /* load */
 792   st2000_ops.to_lookup_symbol = 0;      /* lookup_symbol */
 793   st2000_ops.to_create_inferior = st2000_create_inferior;
 794   st2000_ops.to_post_startup_inferior = NULL;
 795   st2000_ops.to_acknowledge_created_inferior = NULL;
 796   st2000_ops.to_clone_and_follow_inferior = NULL;
 797   st2000_ops.to_post_follow_inferior_by_clone = NULL;
 798   st2000_run_ops.to_insert_fork_catchpoint = NULL;
 799   st2000_run_ops.to_remove_fork_catchpoint = NULL;
 800   st2000_run_ops.to_insert_vfork_catchpoint = NULL;
 801   st2000_run_ops.to_remove_vfork_catchpoint = NULL;
 802   st2000_ops.to_has_forked = NULL;
 803   st2000_ops.to_has_vforked = NULL;
 804   st2000_run_ops.to_can_follow_vfork_prior_to_exec = NULL;
 805   st2000_ops.to_post_follow_vfork = NULL;
 806   st2000_run_ops.to_insert_exec_catchpoint = NULL;
 807   st2000_run_ops.to_remove_exec_catchpoint = NULL;
 808   st2000_run_ops.to_has_execd = NULL;
 809   st2000_run_ops.to_reported_exec_events_per_exec_call = NULL;
 810   st2000_run_ops.to_has_exited = NULL;
 811   st2000_ops.to_mourn_inferior = st2000_mourn_inferior;
 812   st2000_ops.to_can_run = 0;    /* can_run */
 813   st2000_ops.to_notice_signals = 0;     /* notice_signals */
 814   st2000_ops.to_thread_alive = 0;       /* thread alive */
 815   st2000_ops.to_stop = 0;       /* to_stop */
 816   st2000_ops.to_pid_to_exec_file = NULL;
 817   st2000_ops.to_stratum = process_stratum;
 818   st2000_ops.DONT_USE = 0;      /* next */
 819   st2000_ops.to_has_all_memory = 1;
 820   st2000_ops.to_has_memory = 1;
 821   st2000_ops.to_has_stack = 1;
 822   st2000_ops.to_has_registers = 1;
 823   st2000_ops.to_has_execution = 1;      /* all mem, mem, stack, regs, exec */
 824   st2000_ops.to_sections = 0;
 825   st2000_ops.to_sections_end = 0;       /* Section pointers */
 826   st2000_ops.to_magic = OPS_MAGIC;      /* Always the last thing */
 827 };
 828
 829 void
 830 _initialize_remote_st2000 (void)
 831 {
 832   init_st2000_ops ();
 833   add_target (&st2000_ops);
 834   add_com ("st2000 <command>", class_obscure, st2000_command,
 835            "Send a command to the STDBUG monitor.");
 836   add_com ("connect", class_obscure, connect_command,
 837            "Connect the terminal directly up to the STDBUG command monitor.\n\
 838 Use <CR>~. or <CR>~^D to break out.");
 839 }