gdb/remote-st2000.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 #ifdef CREATE_INFERIOR_HOOK
 255   CREATE_INFERIOR_HOOK (0);             /* No process-ID */
 256 #endif
 257
 258 /* The "process" (board) is already stopped awaiting our commands, and
 259    the program is already downloaded.  We just set its PC and go.  */
 260
 261   clear_proceed_status ();
 262
 263   /* Tell wait_for_inferior that we've started a new process.  */
 264   init_wait_for_inferior ();
 265
 266   /* Set up the "saved terminal modes" of the inferior
 267      based on what modes we are starting it with.  */
 268   target_terminal_init ();
 269
 270   /* Install inferior's terminal modes.  */
 271   target_terminal_inferior ();
 272
 273   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 274   proceed ((CORE_ADDR)entry_pt, -1, 0);         /* Let 'er rip... */
 275 }
 276
 277 /* Open a connection to a remote debugger.
 278    NAME is the filename used for communication.  */
 279
 280 static int baudrate = 9600;
 281 static char dev_name[100];
 282
 283 static void
 284 st2000_open(args, from_tty)
 285      char *args;
 286      int from_tty;
 287 {
 288   int n;
 289   char junk[100];
 290
 291   target_preopen(from_tty);
 292
 293   n = sscanf(args, " %s %d %s", dev_name, &baudrate, junk);
 294
 295   if (n != 2)
 296     error("Bad arguments.  Usage: target st2000 <device> <speed>\n\
 297 or target st2000 <host> <port>\n");
 298
 299   st2000_close(0);
 300
 301   st2000_desc = SERIAL_OPEN(dev_name);
 302
 303   if (!st2000_desc)
 304     perror_with_name(dev_name);
 305
 306   SERIAL_SETBAUDRATE(st2000_desc, baudrate);
 307
 308   SERIAL_RAW(st2000_desc);
 309
 310   push_target(&st2000_ops);
 311
 312 #if defined (LOG_FILE)
 313   log_file = fopen (LOG_FILE, "w");
 314   if (log_file == NULL)
 315     perror_with_name (LOG_FILE);
 316 #endif
 317
 318   /* Hello?  Are you there?  */
 319   printf_stdebug("\003");       /* ^C wakes up dbug */
 320
 321   expect_prompt(1);
 322
 323   if (from_tty)
 324     printf("Remote %s connected to %s\n", target_shortname,
 325            dev_name);
 326 }
 327
 328 /* Close out all files and local state before this target loses control. */
 329
 330 static void
 331 st2000_close (quitting)
 332      int quitting;
 333 {
 334   SERIAL_CLOSE(st2000_desc);
 335
 336 #if defined (LOG_FILE)
 337   if (log_file) {
 338     if (ferror(log_file))
 339       fprintf(stderr, "Error writing log file.\n");
 340     if (fclose(log_file) != 0)
 341       fprintf(stderr, "Error closing log file.\n");
 342   }
 343 #endif
 344 }
 345
 346 /* Terminate the open connection to the remote debugger.
 347    Use this when you want to detach and do something else
 348    with your gdb.  */
 349 static void
 350 st2000_detach (from_tty)
 351      int from_tty;
 352 {
 353   pop_target();         /* calls st2000_close to do the real work */
 354   if (from_tty)
 355     printf ("Ending remote %s debugging\n", target_shortname);
 356 }
 357
 358 /* Tell the remote machine to resume.  */
 359
 360 static void
 361 st2000_resume (step, sig)
 362      int step, sig;
 363 {
 364   if (step)
 365     {
 366       printf_stdebug ("ST\r");
 367       /* Wait for the echo.  */
 368       expect ("ST\r", 1);
 369     }
 370   else
 371     {
 372       printf_stdebug ("GO\r");
 373       /* Swallow the echo.  */
 374       expect ("GO\r", 1);
 375     }
 376 }
 377
 378 /* Wait until the remote machine stops, then return,
 379    storing status in STATUS just as `wait' would.  */
 380
 381 static int
 382 st2000_wait (status)
 383      WAITTYPE *status;
 384 {
 385   int old_timeout = timeout;
 386
 387   WSETEXIT ((*status), 0);
 388
 389   timeout = 0;          /* Don't time out -- user program is running. */
 390
 391   expect_prompt(0);    /* Wait for prompt, outputting extraneous text */
 392
 393   WSETSTOP ((*status), SIGTRAP);
 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   generic_mourn_inferior ();    /* Do all the proper things now */
 612 }
 613
 614 #define MAX_STDEBUG_BREAKPOINTS 16
 615
 616 extern int memory_breakpoint_size;
 617 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] = {0};
 618
 619 static int
 620 st2000_insert_breakpoint (addr, shadow)
 621      CORE_ADDR addr;
 622      char *shadow;
 623 {
 624   int i;
 625
 626   for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
 627     if (breakaddr[i] == 0)
 628       {
 629         breakaddr[i] = addr;
 630
 631         st2000_read_inferior_memory(addr, shadow, memory_breakpoint_size);
 632         printf_stdebug("BR %x H\r", addr);
 633         expect_prompt(1);
 634         return 0;
 635       }
 636
 637   fprintf(stderr, "Too many breakpoints (> 16) for STDBUG\n");
 638   return 1;
 639 }
 640
 641 static int
 642 st2000_remove_breakpoint (addr, shadow)
 643      CORE_ADDR addr;
 644      char *shadow;
 645 {
 646   int i;
 647
 648   for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
 649     if (breakaddr[i] == addr)
 650       {
 651         breakaddr[i] = 0;
 652
 653         printf_stdebug("CB %d\r", i);
 654         expect_prompt(1);
 655         return 0;
 656       }
 657
 658   fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr);
 659   return 1;
 660 }
 661
 662
 663 /* Put a command string, in args, out to STDBUG.  Output from STDBUG is placed
 664    on the users terminal until the prompt is seen. */
 665
 666 static void
 667 st2000_command (args, fromtty)
 668      char       *args;
 669      int        fromtty;
 670 {
 671   if (!st2000_desc)
 672     error("st2000 target not open.");
 673
 674   if (!args)
 675     error("Missing command.");
 676
 677   printf_stdebug("%s\r", args);
 678   expect_prompt(0);
 679 }
 680
 681 /* Connect the user directly to STDBUG.  This command acts just like the
 682    'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 683
 684 /*static struct ttystate ttystate;*/
 685
 686 static void
 687 cleanup_tty()
 688 {
 689   printf("\r\n[Exiting connect mode]\r\n");
 690 /*  SERIAL_RESTORE(0, &ttystate);*/
 691 }
 692
 693 #if 0
 694 /* This all should now be in serial.c */
 695
 696 static void
 697 connect_command (args, fromtty)
 698      char       *args;
 699      int        fromtty;
 700 {
 701   fd_set readfds;
 702   int numfds;
 703   int c;
 704   char cur_esc = 0;
 705
 706   dont_repeat();
 707
 708   if (st2000_desc < 0)
 709     error("st2000 target not open.");
 710
 711   if (args)
 712     fprintf("This command takes no args.  They have been ignored.\n");
 713
 714   printf("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 715
 716   serial_raw(0, &ttystate);
 717
 718   make_cleanup(cleanup_tty, 0);
 719
 720   FD_ZERO(&readfds);
 721
 722   while (1)
 723     {
 724       do
 725         {
 726           FD_SET(0, &readfds);
 727           FD_SET(st2000_desc, &readfds);
 728           numfds = select(sizeof(readfds)*8, &readfds, 0, 0, 0);
 729         }
 730       while (numfds == 0);
 731
 732       if (numfds < 0)
 733         perror_with_name("select");
 734
 735       if (FD_ISSET(0, &readfds))
 736         {                       /* tty input, send to stdebug */
 737           c = getchar();
 738           if (c < 0)
 739             perror_with_name("connect");
 740
 741           printf_stdebug("%c", c);
 742           switch (cur_esc)
 743             {
 744             case 0:
 745               if (c == '\r')
 746                 cur_esc = c;
 747               break;
 748             case '\r':
 749               if (c == '~')
 750                 cur_esc = c;
 751               else
 752                 cur_esc = 0;
 753               break;
 754             case '~':
 755               if (c == '.' || c == '\004')
 756                 return;
 757               else
 758                 cur_esc = 0;
 759             }
 760         }
 761
 762       if (FD_ISSET(st2000_desc, &readfds))
 763         {
 764           while (1)
 765             {
 766               c = readchar(0);
 767               if (c < 0)
 768                 break;
 769               putchar(c);
 770             }
 771           fflush(stdout);
 772         }
 773     }
 774 }
 775 #endif /* 0 */
 776
 777 /* Define the target subroutine names */
 778
 779 struct target_ops st2000_ops = {
 780   "st2000",
 781   "Remote serial Tandem ST2000 target",
 782   "Use a remote computer running STDEBUG connected by a serial line,\n\
 783 or a network connection.\n\
 784 Arguments are the name of the device for the serial line,\n\
 785 the speed to connect at in bits per second.",
 786   st2000_open,
 787   st2000_close,
 788   0,
 789   st2000_detach,
 790   st2000_resume,
 791   st2000_wait,
 792   st2000_fetch_register,
 793   st2000_store_register,
 794   st2000_prepare_to_store,
 795   st2000_xfer_inferior_memory,
 796   st2000_files_info,
 797   st2000_insert_breakpoint,
 798   st2000_remove_breakpoint,     /* Breakpoints */
 799   0,
 800   0,
 801   0,
 802   0,
 803   0,                            /* Terminal handling */
 804   st2000_kill,
 805   0,                            /* load */
 806   0,                            /* lookup_symbol */
 807   st2000_create_inferior,
 808   st2000_mourn_inferior,
 809   0,                            /* can_run */
 810   0,                            /* notice_signals */
 811   process_stratum,
 812   0,                            /* next */
 813   1,
 814   1,
 815   1,
 816   1,
 817   1,                            /* all mem, mem, stack, regs, exec */
 818   0,
 819   0,                            /* Section pointers */
 820   OPS_MAGIC,                    /* Always the last thing */
 821 };
 822
 823 void
 824 _initialize_remote_st2000 ()
 825 {
 826   add_target (&st2000_ops);
 827   add_com ("st2000 <command>", class_obscure, st2000_command,
 828            "Send a command to the STDBUG monitor.");
 829   add_com ("connect", class_obscure, connect_command,
 830            "Connect the terminal directly up to the STDBUG command monitor.\n\
 831 Use <CR>~. or <CR>~^D to break out.");
 832 }