gdb/remote-st.c

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