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