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 exec 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 = reg_names[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 extern int memory_breakpoint_size;
 631 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] = {0};
 632
 633 static int
 634 st2000_insert_breakpoint (addr, shadow)
 635      CORE_ADDR addr;
 636      char *shadow;
 637 {
 638   int i;
 639
 640   for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
 641     if (breakaddr[i] == 0)
 642       {
 643         breakaddr[i] = addr;
 644
 645         st2000_read_inferior_memory(addr, shadow, memory_breakpoint_size);
 646         printf_stdebug("BR %x H\r", addr);
 647         expect_prompt(1);
 648         return 0;
 649       }
 650
 651   fprintf(stderr, "Too many breakpoints (> 16) for STDBUG\n");
 652   return 1;
 653 }
 654
 655 static int
 656 st2000_remove_breakpoint (addr, shadow)
 657      CORE_ADDR addr;
 658      char *shadow;
 659 {
 660   int i;
 661
 662   for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
 663     if (breakaddr[i] == addr)
 664       {
 665         breakaddr[i] = 0;
 666
 667         printf_stdebug("CB %d\r", i);
 668         expect_prompt(1);
 669         return 0;
 670       }
 671
 672   fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr);
 673   return 1;
 674 }
 675
 676
 677 /* Put a command string, in args, out to STDBUG.  Output from STDBUG is placed
 678    on the users terminal until the prompt is seen. */
 679
 680 static void
 681 st2000_command (args, fromtty)
 682      char       *args;
 683      int        fromtty;
 684 {
 685   if (!st2000_desc)
 686     error("st2000 target not open.");
 687
 688   if (!args)
 689     error("Missing command.");
 690
 691   printf_stdebug("%s\r", args);
 692   expect_prompt(0);
 693 }
 694
 695 /* Connect the user directly to STDBUG.  This command acts just like the
 696    'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 697
 698 /*static struct ttystate ttystate;*/
 699
 700 static void
 701 cleanup_tty()
 702 {
 703   printf("\r\n[Exiting connect mode]\r\n");
 704 /*  SERIAL_RESTORE(0, &ttystate);*/
 705 }
 706
 707 #if 0
 708 /* This all should now be in serial.c */
 709
 710 static void
 711 connect_command (args, fromtty)
 712      char       *args;
 713      int        fromtty;
 714 {
 715   fd_set readfds;
 716   int numfds;
 717   int c;
 718   char cur_esc = 0;
 719
 720   dont_repeat();
 721
 722   if (st2000_desc < 0)
 723     error("st2000 target not open.");
 724
 725   if (args)
 726     fprintf("This command takes no args.  They have been ignored.\n");
 727
 728   printf("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 729
 730   serial_raw(0, &ttystate);
 731
 732   make_cleanup(cleanup_tty, 0);
 733
 734   FD_ZERO(&readfds);
 735
 736   while (1)
 737     {
 738       do
 739         {
 740           FD_SET(0, &readfds);
 741           FD_SET(st2000_desc, &readfds);
 742           numfds = select(sizeof(readfds)*8, &readfds, 0, 0, 0);
 743         }
 744       while (numfds == 0);
 745
 746       if (numfds < 0)
 747         perror_with_name("select");
 748
 749       if (FD_ISSET(0, &readfds))
 750         {                       /* tty input, send to stdebug */
 751           c = getchar();
 752           if (c < 0)
 753             perror_with_name("connect");
 754
 755           printf_stdebug("%c", c);
 756           switch (cur_esc)
 757             {
 758             case 0:
 759               if (c == '\r')
 760                 cur_esc = c;
 761               break;
 762             case '\r':
 763               if (c == '~')
 764                 cur_esc = c;
 765               else
 766                 cur_esc = 0;
 767               break;
 768             case '~':
 769               if (c == '.' || c == '\004')
 770                 return;
 771               else
 772                 cur_esc = 0;
 773             }
 774         }
 775
 776       if (FD_ISSET(st2000_desc, &readfds))
 777         {
 778           while (1)
 779             {
 780               c = readchar(0);
 781               if (c < 0)
 782                 break;
 783               putchar(c);
 784             }
 785           fflush(stdout);
 786         }
 787     }
 788 }
 789 #endif /* 0 */
 790
 791 /* Define the target subroutine names */
 792
 793 struct target_ops st2000_ops ;
 794
 795 static void init_st2000_ops(void)
 796 {
 797   st2000_ops.to_shortname =   "st2000";
 798   st2000_ops.to_longname =   "Remote serial Tandem ST2000 target";
 799   st2000_ops.to_doc =   "Use a remote computer running STDEBUG connected by a serial line;\n\
 800 or a network connection.\n\
 801 Arguments are the name of the device for the serial line,\n\
 802 the speed to connect at in bits per second." ;
 803   st2000_ops.to_open =   st2000_open;
 804   st2000_ops.to_close =   st2000_close;
 805   st2000_ops.to_attach =   0;
 806   st2000_ops.to_detach =   st2000_detach;
 807   st2000_ops.to_resume =   st2000_resume;
 808   st2000_ops.to_wait  =   st2000_wait;
 809   st2000_ops.to_fetch_registers  =   st2000_fetch_register;
 810   st2000_ops.to_store_registers  =   st2000_store_register;
 811   st2000_ops.to_prepare_to_store =   st2000_prepare_to_store;
 812   st2000_ops.to_xfer_memory  =   st2000_xfer_inferior_memory;
 813   st2000_ops.to_files_info  =   st2000_files_info;
 814   st2000_ops.to_insert_breakpoint =   st2000_insert_breakpoint;
 815   st2000_ops.to_remove_breakpoint =   st2000_remove_breakpoint; /* Breakpoints */
 816   st2000_ops.to_terminal_init  =   0;
 817   st2000_ops.to_terminal_inferior =   0;
 818   st2000_ops.to_terminal_ours_for_output =   0;
 819   st2000_ops.to_terminal_ours  =   0;
 820   st2000_ops.to_terminal_info  =   0;                           /* Terminal handling */
 821   st2000_ops.to_kill  =   st2000_kill;
 822   st2000_ops.to_load  =   0;                            /* load */
 823   st2000_ops.to_lookup_symbol =   0;                            /* lookup_symbol */
 824   st2000_ops.to_create_inferior =   st2000_create_inferior;
 825   st2000_ops.to_mourn_inferior =   st2000_mourn_inferior;
 826   st2000_ops.to_can_run  =   0;                         /* can_run */
 827   st2000_ops.to_notice_signals =   0;                           /* notice_signals */
 828   st2000_ops.to_thread_alive  =   0;                            /* thread alive */
 829   st2000_ops.to_stop  =   0;                            /* to_stop */
 830   st2000_ops.to_stratum =   process_stratum;
 831   st2000_ops.DONT_USE =   0;                            /* next */
 832   st2000_ops.to_has_all_memory =   1;
 833   st2000_ops.to_has_memory =   1;
 834   st2000_ops.to_has_stack =   1;
 835   st2000_ops.to_has_registers =   1;
 836   st2000_ops.to_has_execution =   1;                            /* all mem, mem, stack, regs, exec */
 837   st2000_ops.to_sections =   0;
 838   st2000_ops.to_sections_end =   0;                             /* Section pointers */
 839   st2000_ops.to_magic =   OPS_MAGIC;                    /* Always the last thing */
 840 } ;
 841
 842 void
 843 _initialize_remote_st2000 ()
 844 {
 845   init_st2000_ops() ;
 846   add_target (&st2000_ops);
 847   add_com ("st2000 <command>", class_obscure, st2000_command,
 848            "Send a command to the STDBUG monitor.");
 849   add_com ("connect", class_obscure, connect_command,
 850            "Connect the terminal directly up to the STDBUG command monitor.\n\
 851 Use <CR>~. or <CR>~^D to break out.");
 852 }