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 #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   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   process_stratum,
 813   0,                            /* next */
 814   1,
 815   1,
 816   1,
 817   1,
 818   1,                            /* all mem, mem, stack, regs, exec */
 819   0,
 820   0,                            /* Section pointers */
 821   OPS_MAGIC,                    /* Always the last thing */
 822 };
 823
 824 void
 825 _initialize_remote_st2000 ()
 826 {
 827   add_target (&st2000_ops);
 828   add_com ("st2000 <command>", class_obscure, st2000_command,
 829            "Send a command to the STDBUG monitor.");
 830   add_com ("connect", class_obscure, connect_command,
 831            "Connect the terminal directly up to the STDBUG command monitor.\n\
 832 Use <CR>~. or <CR>~^D to break out.");
 833 }