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