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 (stderr, "serial_write failed: %s\n", safe_strerror (errno));
  83 }
  84
  85 /* Read a character from the remote system, doing all the fancy timeout
  86    stuff.  */
  87
  88 static int
  89 readchar (int timeout)
  90 {
  91   int c;
  92
  93   c = serial_readchar (st2000_desc, timeout);
  94
  95 #ifdef LOG_FILE
  96   putc (c & 0x7f, log_file);
  97 #endif
  98
  99   if (c >= 0)
 100     return c & 0x7f;
 101
 102   if (c == SERIAL_TIMEOUT)
 103     {
 104       if (timeout == 0)
 105         return c;               /* Polls shouldn't generate timeout errors */
 106
 107       error ("Timeout reading from remote system.");
 108     }
 109
 110   perror_with_name ("remote-st2000");
 111 }
 112
 113 /* Scan input from the remote system, until STRING is found.  If DISCARD is
 114    non-zero, then discard non-matching input, else print it out.
 115    Let the user break out immediately.  */
 116 static void
 117 expect (char *string, int discard)
 118 {
 119   char *p = string;
 120   int c;
 121
 122   immediate_quit++;
 123   while (1)
 124     {
 125       c = readchar (timeout);
 126       if (c == *p++)
 127         {
 128           if (*p == '\0')
 129             {
 130               immediate_quit--;
 131               return;
 132             }
 133         }
 134       else
 135         {
 136           if (!discard)
 137             {
 138               fwrite (string, 1, (p - 1) - string, stdout);
 139               putchar ((char) c);
 140               fflush (stdout);
 141             }
 142           p = string;
 143         }
 144     }
 145 }
 146
 147 /* Keep discarding input until we see the STDEBUG prompt.
 148
 149    The convention for dealing with the prompt is that you
 150    o give your command
 151    o *then* wait for the prompt.
 152
 153    Thus the last thing that a procedure does with the serial line
 154    will be an expect_prompt().  Exception:  st2000_resume does not
 155    wait for the prompt, because the terminal is being handed over
 156    to the inferior.  However, the next thing which happens after that
 157    is a st2000_wait which does wait for the prompt.
 158    Note that this includes abnormal exit, e.g. error().  This is
 159    necessary to prevent getting into states from which we can't
 160    recover.  */
 161 static void
 162 expect_prompt (int discard)
 163 {
 164 #if defined (LOG_FILE)
 165   /* This is a convenient place to do this.  The idea is to do it often
 166      enough that we never lose much data if we terminate abnormally.  */
 167   fflush (log_file);
 168 #endif
 169   expect ("dbug> ", discard);
 170 }
 171
 172 /* Get a hex digit from the remote system & return its value.
 173    If ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
 174 static int
 175 get_hex_digit (int ignore_space)
 176 {
 177   int ch;
 178   while (1)
 179     {
 180       ch = readchar (timeout);
 181       if (ch >= '0' && ch <= '9')
 182         return ch - '0';
 183       else if (ch >= 'A' && ch <= 'F')
 184         return ch - 'A' + 10;
 185       else if (ch >= 'a' && ch <= 'f')
 186         return ch - 'a' + 10;
 187       else if (ch == ' ' && ignore_space)
 188         ;
 189       else
 190         {
 191           expect_prompt (1);
 192           error ("Invalid hex digit from remote system.");
 193         }
 194     }
 195 }
 196
 197 /* Get a byte from stdebug and put it in *BYT.  Accept any number
 198    leading spaces.  */
 199 static void
 200 get_hex_byte (char *byt)
 201 {
 202   int val;
 203
 204   val = get_hex_digit (1) << 4;
 205   val |= get_hex_digit (0);
 206   *byt = val;
 207 }
 208
 209 /* Get N 32-bit words from remote, each preceded by a space,
 210    and put them in registers starting at REGNO.  */
 211 static void
 212 get_hex_regs (int n, int regno)
 213 {
 214   long val;
 215   int i;
 216
 217   for (i = 0; i < n; i++)
 218     {
 219       int j;
 220
 221       val = 0;
 222       for (j = 0; j < 8; j++)
 223         val = (val << 4) + get_hex_digit (j == 0);
 224       supply_register (regno++, (char *) &val);
 225     }
 226 }
 227
 228 /* This is called not only when we first attach, but also when the
 229    user types "run" after having attached.  */
 230 static void
 231 st2000_create_inferior (char *execfile, char *args, char **env)
 232 {
 233   int entry_pt;
 234
 235   if (args && *args)
 236     error ("Can't pass arguments to remote STDEBUG process");
 237
 238   if (execfile == 0 || exec_bfd == 0)
 239     error ("No executable file specified");
 240
 241   entry_pt = (int) bfd_get_start_address (exec_bfd);
 242
 243 /* The "process" (board) is already stopped awaiting our commands, and
 244    the program is already downloaded.  We just set its PC and go.  */
 245
 246   clear_proceed_status ();
 247
 248   /* Tell wait_for_inferior that we've started a new process.  */
 249   init_wait_for_inferior ();
 250
 251   /* Set up the "saved terminal modes" of the inferior
 252      based on what modes we are starting it with.  */
 253   target_terminal_init ();
 254
 255   /* Install inferior's terminal modes.  */
 256   target_terminal_inferior ();
 257
 258   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 259   /* Let 'er rip... */
 260   proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 261 }
 262
 263 /* Open a connection to a remote debugger.
 264    NAME is the filename used for communication.  */
 265
 266 static int baudrate = 9600;
 267 static char dev_name[100];
 268
 269 static void
 270 st2000_open (char *args, int from_tty)
 271 {
 272   int n;
 273   char junk[100];
 274
 275   target_preopen (from_tty);
 276
 277   n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk);
 278
 279   if (n != 2)
 280     error ("Bad arguments.  Usage: target st2000 <device> <speed>\n\
 281 or target st2000 <host> <port>\n");
 282
 283   st2000_close (0);
 284
 285   st2000_desc = serial_open (dev_name);
 286
 287   if (!st2000_desc)
 288     perror_with_name (dev_name);
 289
 290   if (serial_setbaudrate (st2000_desc, baudrate))
 291     {
 292       serial_close (dev_name);
 293       perror_with_name (dev_name);
 294     }
 295
 296   serial_raw (st2000_desc);
 297
 298   push_target (&st2000_ops);
 299
 300 #if defined (LOG_FILE)
 301   log_file = fopen (LOG_FILE, "w");
 302   if (log_file == NULL)
 303     perror_with_name (LOG_FILE);
 304 #endif
 305
 306   /* Hello?  Are you there?  */
 307   printf_stdebug ("\003");      /* ^C wakes up dbug */
 308
 309   expect_prompt (1);
 310
 311   if (from_tty)
 312     printf ("Remote %s connected to %s\n", target_shortname,
 313             dev_name);
 314 }
 315
 316 /* Close out all files and local state before this target loses control. */
 317
 318 static void
 319 st2000_close (int quitting)
 320 {
 321   serial_close (st2000_desc);
 322
 323 #if defined (LOG_FILE)
 324   if (log_file)
 325     {
 326       if (ferror (log_file))
 327         fprintf (stderr, "Error writing log file.\n");
 328       if (fclose (log_file) != 0)
 329         fprintf (stderr, "Error closing log file.\n");
 330     }
 331 #endif
 332 }
 333
 334 /* Terminate the open connection to the remote debugger.
 335    Use this when you want to detach and do something else
 336    with your gdb.  */
 337 static void
 338 st2000_detach (int from_tty)
 339 {
 340   pop_target ();                /* calls st2000_close to do the real work */
 341   if (from_tty)
 342     printf ("Ending remote %s debugging\n", target_shortname);
 343 }
 344
 345 /* Tell the remote machine to resume.  */
 346
 347 static void
 348 st2000_resume (ptid_t ptid, int step, enum target_signal sig)
 349 {
 350   if (step)
 351     {
 352       printf_stdebug ("ST\r");
 353       /* Wait for the echo.  */
 354       expect ("ST\r", 1);
 355     }
 356   else
 357     {
 358       printf_stdebug ("GO\r");
 359       /* Swallow the echo.  */
 360       expect ("GO\r", 1);
 361     }
 362 }
 363
 364 /* Wait until the remote machine stops, then return,
 365    storing status in STATUS just as `wait' would.  */
 366
 367 static ptid_t
 368 st2000_wait (ptid_t ptid, struct target_waitstatus *status)
 369 {
 370   int old_timeout = timeout;
 371
 372   status->kind = TARGET_WAITKIND_EXITED;
 373   status->value.integer = 0;
 374
 375   timeout = 0;                  /* Don't time out -- user program is running. */
 376
 377   expect_prompt (0);            /* Wait for prompt, outputting extraneous text */
 378
 379   status->kind = TARGET_WAITKIND_STOPPED;
 380   status->value.sig = TARGET_SIGNAL_TRAP;
 381
 382   timeout = old_timeout;
 383
 384   return inferior_ptid;
 385 }
 386
 387 /* Return the name of register number REGNO in the form input and output by
 388    STDEBUG.  Currently, REGISTER_NAMES just happens to contain exactly what
 389    STDEBUG wants.  Lets take advantage of that just as long as possible! */
 390
 391 static char *
 392 get_reg_name (int regno)
 393 {
 394   static char buf[50];
 395   const char *p;
 396   char *b;
 397
 398   b = buf;
 399
 400   for (p = REGISTER_NAME (regno); *p; p++)
 401     *b++ = toupper (*p);
 402   *b = '\000';
 403
 404   return buf;
 405 }
 406
 407 /* Read the remote registers into the block REGS.  */
 408
 409 static void
 410 st2000_fetch_registers (void)
 411 {
 412   int regno;
 413
 414   /* Yeah yeah, I know this is horribly inefficient.  But it isn't done
 415      very often...  I'll clean it up later.  */
 416
 417   for (regno = 0; regno <= PC_REGNUM; regno++)
 418     st2000_fetch_register (regno);
 419 }
 420
 421 /* Fetch register REGNO, or all registers if REGNO is -1.
 422    Returns errno value.  */
 423 static void
 424 st2000_fetch_register (int regno)
 425 {
 426   if (regno == -1)
 427     st2000_fetch_registers ();
 428   else
 429     {
 430       char *name = get_reg_name (regno);
 431       printf_stdebug ("DR %s\r", name);
 432       expect (name, 1);
 433       expect (" : ", 1);
 434       get_hex_regs (1, regno);
 435       expect_prompt (1);
 436     }
 437   return;
 438 }
 439
 440 /* Store the remote registers from the contents of the block REGS.  */
 441
 442 static void
 443 st2000_store_registers (void)
 444 {
 445   int regno;
 446
 447   for (regno = 0; regno <= PC_REGNUM; regno++)
 448     st2000_store_register (regno);
 449
 450   registers_changed ();
 451 }
 452
 453 /* Store register REGNO, or all if REGNO == 0.
 454    Return errno value.  */
 455 static void
 456 st2000_store_register (int regno)
 457 {
 458   if (regno == -1)
 459     st2000_store_registers ();
 460   else
 461     {
 462       printf_stdebug ("PR %s %x\r", get_reg_name (regno),
 463                       read_register (regno));
 464
 465       expect_prompt (1);
 466     }
 467 }
 468
 469 /* Get ready to modify the registers array.  On machines which store
 470    individual registers, this doesn't need to do anything.  On machines
 471    which store all the registers in one fell swoop, this makes sure
 472    that registers contains all the registers from the program being
 473    debugged.  */
 474
 475 static void
 476 st2000_prepare_to_store (void)
 477 {
 478   /* Do nothing, since we can store individual regs */
 479 }
 480
 481 static void
 482 st2000_files_info (void)
 483 {
 484   printf ("\tAttached to %s at %d baud.\n",
 485           dev_name, baudrate);
 486 }
 487
 488 /* Copy LEN bytes of data from debugger memory at MYADDR
 489    to inferior's memory at MEMADDR.  Returns length moved.  */
 490 static int
 491 st2000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
 492 {
 493   int i;
 494
 495   for (i = 0; i < len; i++)
 496     {
 497       printf_stdebug ("PM.B %x %x\r", memaddr + i, myaddr[i]);
 498       expect_prompt (1);
 499     }
 500   return len;
 501 }
 502
 503 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
 504    at debugger address MYADDR.  Returns length moved.  */
 505 static int
 506 st2000_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
 507 {
 508   int i;
 509
 510   /* Number of bytes read so far.  */
 511   int count;
 512
 513   /* Starting address of this pass.  */
 514   unsigned long startaddr;
 515
 516   /* Number of bytes to read in this pass.  */
 517   int len_this_pass;
 518
 519   /* Note that this code works correctly if startaddr is just less
 520      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
 521      thing).  That is, something like
 522      st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
 523      works--it never adds len to memaddr and gets 0.  */
 524   /* However, something like
 525      st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
 526      doesn't need to work.  Detect it and give up if there's an attempt
 527      to do that.  */
 528   if (((memaddr - 1) + len) < memaddr)
 529     {
 530       errno = EIO;
 531       return 0;
 532     }
 533
 534   startaddr = memaddr;
 535   count = 0;
 536   while (count < len)
 537     {
 538       len_this_pass = 16;
 539       if ((startaddr % 16) != 0)
 540         len_this_pass -= startaddr % 16;
 541       if (len_this_pass > (len - count))
 542         len_this_pass = (len - count);
 543
 544       printf_stdebug ("DI.L %x %x\r", startaddr, len_this_pass);
 545       expect (":  ", 1);
 546
 547       for (i = 0; i < len_this_pass; i++)
 548         get_hex_byte (&myaddr[count++]);
 549
 550       expect_prompt (1);
 551
 552       startaddr += len_this_pass;
 553     }
 554   return len;
 555 }
 556
 557 /* Transfer LEN bytes between GDB address MYADDR and target address
 558    MEMADDR.  If WRITE is non-zero, transfer them to the target,
 559    otherwise transfer them from the target.  TARGET is unused.
 560
 561    Returns the number of bytes transferred. */
 562
 563 static int
 564 st2000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
 565                              int write, struct mem_attrib *attrib,
 566                              struct target_ops *target)
 567 {
 568   if (write)
 569     return st2000_write_inferior_memory (memaddr, myaddr, len);
 570   else
 571     return st2000_read_inferior_memory (memaddr, myaddr, len);
 572 }
 573
 574 static void
 575 st2000_kill (char *args, int from_tty)
 576 {
 577   return;                       /* Ignore attempts to kill target system */
 578 }
 579
 580 /* Clean up when a program exits.
 581
 582    The program actually lives on in the remote processor's RAM, and may be
 583    run again without a download.  Don't leave it full of breakpoint
 584    instructions.  */
 585
 586 static void
 587 st2000_mourn_inferior (void)
 588 {
 589   remove_breakpoints ();
 590   unpush_target (&st2000_ops);
 591   generic_mourn_inferior ();    /* Do all the proper things now */
 592 }
 593
 594 #define MAX_STDEBUG_BREAKPOINTS 16
 595
 596 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] =
 597 {0};
 598
 599 static int
 600 st2000_insert_breakpoint (CORE_ADDR addr, char *shadow)
 601 {
 602   int i;
 603   CORE_ADDR bp_addr = addr;
 604   int bp_size = 0;
 605
 606   BREAKPOINT_FROM_PC (&bp_addr, &bp_size);
 607
 608   for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
 609     if (breakaddr[i] == 0)
 610       {
 611         breakaddr[i] = addr;
 612
 613         st2000_read_inferior_memory (bp_addr, shadow, bp_size);
 614         printf_stdebug ("BR %x H\r", addr);
 615         expect_prompt (1);
 616         return 0;
 617       }
 618
 619   fprintf (stderr, "Too many breakpoints (> 16) for STDBUG\n");
 620   return 1;
 621 }
 622
 623 static int
 624 st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)
 625 {
 626   int i;
 627
 628   for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
 629     if (breakaddr[i] == addr)
 630       {
 631         breakaddr[i] = 0;
 632
 633         printf_stdebug ("CB %d\r", i);
 634         expect_prompt (1);
 635         return 0;
 636       }
 637
 638   fprintf (stderr, "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 = 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_attach = 0;
 769   st2000_run_ops.to_post_attach = NULL;
 770   st2000_ops.to_require_attach = NULL;
 771   st2000_ops.to_detach = st2000_detach;
 772   st2000_ops.to_require_detach = NULL;
 773   st2000_ops.to_resume = st2000_resume;
 774   st2000_ops.to_wait = st2000_wait;
 775   st2000_ops.to_post_wait = NULL;
 776   st2000_ops.to_fetch_registers = st2000_fetch_register;
 777   st2000_ops.to_store_registers = st2000_store_register;
 778   st2000_ops.to_prepare_to_store = st2000_prepare_to_store;
 779   st2000_ops.to_xfer_memory = st2000_xfer_inferior_memory;
 780   st2000_ops.to_files_info = st2000_files_info;
 781   st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint;
 782   st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint;   /* Breakpoints */
 783   st2000_ops.to_terminal_init = 0;
 784   st2000_ops.to_terminal_inferior = 0;
 785   st2000_ops.to_terminal_ours_for_output = 0;
 786   st2000_ops.to_terminal_ours = 0;
 787   st2000_ops.to_terminal_info = 0;      /* Terminal handling */
 788   st2000_ops.to_kill = st2000_kill;
 789   st2000_ops.to_load = 0;       /* load */
 790   st2000_ops.to_lookup_symbol = 0;      /* lookup_symbol */
 791   st2000_ops.to_create_inferior = st2000_create_inferior;
 792   st2000_ops.to_post_startup_inferior = NULL;
 793   st2000_ops.to_acknowledge_created_inferior = NULL;
 794   st2000_ops.to_clone_and_follow_inferior = NULL;
 795   st2000_ops.to_post_follow_inferior_by_clone = NULL;
 796   st2000_run_ops.to_insert_fork_catchpoint = NULL;
 797   st2000_run_ops.to_remove_fork_catchpoint = NULL;
 798   st2000_run_ops.to_insert_vfork_catchpoint = NULL;
 799   st2000_run_ops.to_remove_vfork_catchpoint = NULL;
 800   st2000_ops.to_has_forked = NULL;
 801   st2000_ops.to_has_vforked = NULL;
 802   st2000_run_ops.to_can_follow_vfork_prior_to_exec = NULL;
 803   st2000_ops.to_post_follow_vfork = NULL;
 804   st2000_run_ops.to_insert_exec_catchpoint = NULL;
 805   st2000_run_ops.to_remove_exec_catchpoint = NULL;
 806   st2000_run_ops.to_has_execd = NULL;
 807   st2000_run_ops.to_reported_exec_events_per_exec_call = NULL;
 808   st2000_run_ops.to_has_exited = NULL;
 809   st2000_ops.to_mourn_inferior = st2000_mourn_inferior;
 810   st2000_ops.to_can_run = 0;    /* can_run */
 811   st2000_ops.to_notice_signals = 0;     /* notice_signals */
 812   st2000_ops.to_thread_alive = 0;       /* thread alive */
 813   st2000_ops.to_stop = 0;       /* to_stop */
 814   st2000_ops.to_pid_to_exec_file = NULL;
 815   st2000_ops.to_stratum = process_stratum;
 816   st2000_ops.DONT_USE = 0;      /* next */
 817   st2000_ops.to_has_all_memory = 1;
 818   st2000_ops.to_has_memory = 1;
 819   st2000_ops.to_has_stack = 1;
 820   st2000_ops.to_has_registers = 1;
 821   st2000_ops.to_has_execution = 1;      /* all mem, mem, stack, regs, exec */
 822   st2000_ops.to_sections = 0;
 823   st2000_ops.to_sections_end = 0;       /* Section pointers */
 824   st2000_ops.to_magic = OPS_MAGIC;      /* Always the last thing */
 825 };
 826
 827 void
 828 _initialize_remote_st2000 (void)
 829 {
 830   init_st2000_ops ();
 831   add_target (&st2000_ops);
 832   add_com ("st2000 <command>", class_obscure, st2000_command,
 833            "Send a command to the STDBUG monitor.");
 834   add_com ("connect", class_obscure, connect_command,
 835            "Connect the terminal directly up to the STDBUG command monitor.\n\
 836 Use <CR>~. or <CR>~^D to break out.");
 837 }