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   proceed ((CORE_ADDR)entry_pt, -1, 0);         /* Let 'er rip... */
 271 }
 272
 273 /* Open a connection to a remote debugger.
 274    NAME is the filename used for communication.  */
 275
 276 static int baudrate = 9600;
 277 static char dev_name[100];
 278
 279 static void
 280 st2000_open(args, from_tty)
 281      char *args;
 282      int from_tty;
 283 {
 284   int n;
 285   char junk[100];
 286
 287   target_preopen(from_tty);
 288
 289   n = sscanf(args, " %s %d %s", dev_name, &baudrate, junk);
 290
 291   if (n != 2)
 292     error("Bad arguments.  Usage: target st2000 <device> <speed>\n\
 293 or target st2000 <host> <port>\n");
 294
 295   st2000_close(0);
 296
 297   st2000_desc = SERIAL_OPEN(dev_name);
 298
 299   if (!st2000_desc)
 300     perror_with_name(dev_name);
 301
 302   SERIAL_SETBAUDRATE(st2000_desc, baudrate);
 303
 304   SERIAL_RAW(st2000_desc);
 305
 306   push_target(&st2000_ops);
 307
 308 #if defined (LOG_FILE)
 309   log_file = fopen (LOG_FILE, "w");
 310   if (log_file == NULL)
 311     perror_with_name (LOG_FILE);
 312 #endif
 313
 314   /* Hello?  Are you there?  */
 315   printf_stdebug("\003");       /* ^C wakes up dbug */
 316
 317   expect_prompt(1);
 318
 319   if (from_tty)
 320     printf("Remote %s connected to %s\n", target_shortname,
 321            dev_name);
 322 }
 323
 324 /* Close out all files and local state before this target loses control. */
 325
 326 static void
 327 st2000_close (quitting)
 328      int quitting;
 329 {
 330   SERIAL_CLOSE(st2000_desc);
 331
 332 #if defined (LOG_FILE)
 333   if (log_file) {
 334     if (ferror(log_file))
 335       fprintf(stderr, "Error writing log file.\n");
 336     if (fclose(log_file) != 0)
 337       fprintf(stderr, "Error closing log file.\n");
 338   }
 339 #endif
 340 }
 341
 342 /* Terminate the open connection to the remote debugger.
 343    Use this when you want to detach and do something else
 344    with your gdb.  */
 345 static void
 346 st2000_detach (from_tty)
 347      int from_tty;
 348 {
 349   pop_target();         /* calls st2000_close to do the real work */
 350   if (from_tty)
 351     printf ("Ending remote %s debugging\n", target_shortname);
 352 }
 353
 354 /* Tell the remote machine to resume.  */
 355
 356 static void
 357 st2000_resume (pid, step, sig)
 358      int pid, step;
 359      enum target_signal sig;
 360 {
 361   if (step)
 362     {
 363       printf_stdebug ("ST\r");
 364       /* Wait for the echo.  */
 365       expect ("ST\r", 1);
 366     }
 367   else
 368     {
 369       printf_stdebug ("GO\r");
 370       /* Swallow the echo.  */
 371       expect ("GO\r", 1);
 372     }
 373 }
 374
 375 /* Wait until the remote machine stops, then return,
 376    storing status in STATUS just as `wait' would.  */
 377
 378 static int
 379 st2000_wait (status)
 380      struct target_waitstatus *status;
 381 {
 382   int old_timeout = timeout;
 383
 384   status->kind = TARGET_WAITKIND_EXITED;
 385   status->value.integer = 0;
 386
 387   timeout = 0;          /* Don't time out -- user program is running. */
 388
 389   expect_prompt(0);    /* Wait for prompt, outputting extraneous text */
 390
 391   status->kind = TARGET_WAITKIND_STOPPED;
 392   status->value.sig = TARGET_SIGNAL_TRAP;
 393
 394   timeout = old_timeout;
 395
 396   return 0;
 397 }
 398
 399 /* Return the name of register number REGNO in the form input and output by
 400    STDEBUG.  Currently, REGISTER_NAMES just happens to contain exactly what
 401    STDEBUG wants.  Lets take advantage of that just as long as possible! */
 402
 403 static char *
 404 get_reg_name (regno)
 405      int regno;
 406 {
 407   static char buf[50];
 408   const char *p;
 409   char *b;
 410
 411   b = buf;
 412
 413   for (p = reg_names[regno]; *p; p++)
 414     *b++ = toupper(*p);
 415   *b = '\000';
 416
 417   return buf;
 418 }
 419
 420 /* Read the remote registers into the block REGS.  */
 421
 422 static void
 423 st2000_fetch_registers ()
 424 {
 425   int regno;
 426
 427   /* Yeah yeah, I know this is horribly inefficient.  But it isn't done
 428      very often...  I'll clean it up later.  */
 429
 430   for (regno = 0; regno <= PC_REGNUM; regno++)
 431     st2000_fetch_register(regno);
 432 }
 433
 434 /* Fetch register REGNO, or all registers if REGNO is -1.
 435    Returns errno value.  */
 436 static void
 437 st2000_fetch_register (regno)
 438      int regno;
 439 {
 440   if (regno == -1)
 441     st2000_fetch_registers ();
 442   else
 443     {
 444       char *name = get_reg_name (regno);
 445       printf_stdebug ("DR %s\r", name);
 446       expect (name, 1);
 447       expect (" : ", 1);
 448       get_hex_regs (1, regno);
 449       expect_prompt (1);
 450     }
 451   return;
 452 }
 453
 454 /* Store the remote registers from the contents of the block REGS.  */
 455
 456 static void
 457 st2000_store_registers ()
 458 {
 459   int regno;
 460
 461   for (regno = 0; regno <= PC_REGNUM; regno++)
 462     st2000_store_register(regno);
 463
 464   registers_changed ();
 465 }
 466
 467 /* Store register REGNO, or all if REGNO == 0.
 468    Return errno value.  */
 469 static void
 470 st2000_store_register (regno)
 471      int regno;
 472 {
 473   if (regno == -1)
 474     st2000_store_registers ();
 475   else
 476     {
 477       printf_stdebug ("PR %s %x\r", get_reg_name (regno),
 478                       read_register (regno));
 479
 480       expect_prompt (1);
 481     }
 482 }
 483
 484 /* Get ready to modify the registers array.  On machines which store
 485    individual registers, this doesn't need to do anything.  On machines
 486    which store all the registers in one fell swoop, this makes sure
 487    that registers contains all the registers from the program being
 488    debugged.  */
 489
 490 static void
 491 st2000_prepare_to_store ()
 492 {
 493   /* Do nothing, since we can store individual regs */
 494 }
 495
 496 static void
 497 st2000_files_info ()
 498 {
 499   printf ("\tAttached to %s at %d baud.\n",
 500           dev_name, baudrate);
 501 }
 502
 503 /* Copy LEN bytes of data from debugger memory at MYADDR
 504    to inferior's memory at MEMADDR.  Returns length moved.  */
 505 static int
 506 st2000_write_inferior_memory (memaddr, myaddr, len)
 507      CORE_ADDR memaddr;
 508      unsigned char *myaddr;
 509      int len;
 510 {
 511   int i;
 512
 513   for (i = 0; i < len; i++)
 514     {
 515       printf_stdebug ("PM.B %x %x\r", memaddr + i, myaddr[i]);
 516       expect_prompt (1);
 517     }
 518   return len;
 519 }
 520
 521 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
 522    at debugger address MYADDR.  Returns length moved.  */
 523 static int
 524 st2000_read_inferior_memory(memaddr, myaddr, len)
 525      CORE_ADDR memaddr;
 526      char *myaddr;
 527      int len;
 528 {
 529   int i;
 530
 531   /* Number of bytes read so far.  */
 532   int count;
 533
 534   /* Starting address of this pass.  */
 535   unsigned long startaddr;
 536
 537   /* Number of bytes to read in this pass.  */
 538   int len_this_pass;
 539
 540   /* Note that this code works correctly if startaddr is just less
 541      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
 542      thing).  That is, something like
 543      st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
 544      works--it never adds len to memaddr and gets 0.  */
 545   /* However, something like
 546      st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
 547      doesn't need to work.  Detect it and give up if there's an attempt
 548      to do that.  */
 549   if (((memaddr - 1) + len) < memaddr) {
 550     errno = EIO;
 551     return 0;
 552   }
 553
 554   startaddr = memaddr;
 555   count = 0;
 556   while (count < len)
 557     {
 558       len_this_pass = 16;
 559       if ((startaddr % 16) != 0)
 560         len_this_pass -= startaddr % 16;
 561       if (len_this_pass > (len - count))
 562         len_this_pass = (len - count);
 563
 564       printf_stdebug ("DI.L %x %x\r", startaddr, len_this_pass);
 565       expect (":  ", 1);
 566
 567       for (i = 0; i < len_this_pass; i++)
 568         get_hex_byte (&myaddr[count++]);
 569
 570       expect_prompt (1);
 571
 572       startaddr += len_this_pass;
 573     }
 574   return len;
 575 }
 576
 577 /* FIXME-someday!  Merge these two.  */
 578 static int
 579 st2000_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 580      CORE_ADDR memaddr;
 581      char *myaddr;
 582      int len;
 583      int write;
 584      struct target_ops *target;         /* ignored */
 585 {
 586   if (write)
 587     return st2000_write_inferior_memory (memaddr, myaddr, len);
 588   else
 589     return st2000_read_inferior_memory (memaddr, myaddr, len);
 590 }
 591
 592 static void
 593 st2000_kill (args, from_tty)
 594      char *args;
 595      int from_tty;
 596 {
 597   return;               /* Ignore attempts to kill target system */
 598 }
 599
 600 /* Clean up when a program exits.
 601
 602    The program actually lives on in the remote processor's RAM, and may be
 603    run again without a download.  Don't leave it full of breakpoint
 604    instructions.  */
 605
 606 static void
 607 st2000_mourn_inferior ()
 608 {
 609   remove_breakpoints ();
 610   unpush_target (&st2000_ops);
 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 }