gdb/remote-st.c

   1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
   2    Copyright 1990, 1991, 1992, 2001 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,
 560                              struct mem_attrib *attrib ATTRIBUTE_UNUSED,
 561                              struct target_ops *target ATTRIBUTE_UNUSED)
 562 {
 563   if (write)
 564     return st2000_write_inferior_memory (memaddr, myaddr, len);
 565   else
 566     return st2000_read_inferior_memory (memaddr, myaddr, len);
 567 }
 568
 569 static void
 570 st2000_kill (char *args, int from_tty)
 571 {
 572   return;                       /* Ignore attempts to kill target system */
 573 }
 574
 575 /* Clean up when a program exits.
 576
 577    The program actually lives on in the remote processor's RAM, and may be
 578    run again without a download.  Don't leave it full of breakpoint
 579    instructions.  */
 580
 581 static void
 582 st2000_mourn_inferior (void)
 583 {
 584   remove_breakpoints ();
 585   unpush_target (&st2000_ops);
 586   generic_mourn_inferior ();    /* Do all the proper things now */
 587 }
 588
 589 #define MAX_STDEBUG_BREAKPOINTS 16
 590
 591 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] =
 592 {0};
 593
 594 static int
 595 st2000_insert_breakpoint (CORE_ADDR addr, char *shadow)
 596 {
 597   int i;
 598   CORE_ADDR bp_addr = addr;
 599   int bp_size = 0;
 600
 601   BREAKPOINT_FROM_PC (&bp_addr, &bp_size);
 602
 603   for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
 604     if (breakaddr[i] == 0)
 605       {
 606         breakaddr[i] = addr;
 607
 608         st2000_read_inferior_memory (bp_addr, shadow, bp_size);
 609         printf_stdebug ("BR %x H\r", addr);
 610         expect_prompt (1);
 611         return 0;
 612       }
 613
 614   fprintf (stderr, "Too many breakpoints (> 16) for STDBUG\n");
 615   return 1;
 616 }
 617
 618 static int
 619 st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)
 620 {
 621   int i;
 622
 623   for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
 624     if (breakaddr[i] == addr)
 625       {
 626         breakaddr[i] = 0;
 627
 628         printf_stdebug ("CB %d\r", i);
 629         expect_prompt (1);
 630         return 0;
 631       }
 632
 633   fprintf (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
 634   return 1;
 635 }
 636
 637
 638 /* Put a command string, in args, out to STDBUG.  Output from STDBUG is placed
 639    on the users terminal until the prompt is seen. */
 640
 641 static void
 642 st2000_command (char *args, int fromtty)
 643 {
 644   if (!st2000_desc)
 645     error ("st2000 target not open.");
 646
 647   if (!args)
 648     error ("Missing command.");
 649
 650   printf_stdebug ("%s\r", args);
 651   expect_prompt (0);
 652 }
 653
 654 /* Connect the user directly to STDBUG.  This command acts just like the
 655    'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
 656
 657 /*static struct ttystate ttystate; */
 658
 659 static void
 660 cleanup_tty (void)
 661 {
 662   printf ("\r\n[Exiting connect mode]\r\n");
 663 /*  SERIAL_RESTORE(0, &ttystate); */
 664 }
 665
 666 #if 0
 667 /* This all should now be in serial.c */
 668
 669 static void
 670 connect_command (char *args, int fromtty)
 671 {
 672   fd_set readfds;
 673   int numfds;
 674   int c;
 675   char cur_esc = 0;
 676
 677   dont_repeat ();
 678
 679   if (st2000_desc < 0)
 680     error ("st2000 target not open.");
 681
 682   if (args)
 683     fprintf ("This command takes no args.  They have been ignored.\n");
 684
 685   printf ("[Entering connect mode.  Use ~. or ~^D to escape]\n");
 686
 687   serial_raw (0, &ttystate);
 688
 689   make_cleanup (cleanup_tty, 0);
 690
 691   FD_ZERO (&readfds);
 692
 693   while (1)
 694     {
 695       do
 696         {
 697           FD_SET (0, &readfds);
 698           FD_SET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds);
 699           numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
 700         }
 701       while (numfds == 0);
 702
 703       if (numfds < 0)
 704         perror_with_name ("select");
 705
 706       if (FD_ISSET (0, &readfds))
 707         {                       /* tty input, send to stdebug */
 708           c = getchar ();
 709           if (c < 0)
 710             perror_with_name ("connect");
 711
 712           printf_stdebug ("%c", c);
 713           switch (cur_esc)
 714             {
 715             case 0:
 716               if (c == '\r')
 717                 cur_esc = c;
 718               break;
 719             case '\r':
 720               if (c == '~')
 721                 cur_esc = c;
 722               else
 723                 cur_esc = 0;
 724               break;
 725             case '~':
 726               if (c == '.' || c == '\004')
 727                 return;
 728               else
 729                 cur_esc = 0;
 730             }
 731         }
 732
 733       if (FD_ISSET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds))
 734         {
 735           while (1)
 736             {
 737               c = readchar (0);
 738               if (c < 0)
 739                 break;
 740               putchar (c);
 741             }
 742           fflush (stdout);
 743         }
 744     }
 745 }
 746 #endif /* 0 */
 747
 748 /* Define the target subroutine names */
 749
 750 struct target_ops st2000_ops;
 751
 752 static void
 753 init_st2000_ops (void)
 754 {
 755   st2000_ops.to_shortname = "st2000";
 756   st2000_ops.to_longname = "Remote serial Tandem ST2000 target";
 757   st2000_ops.to_doc = "Use a remote computer running STDEBUG connected by a serial line;\n\
 758 or a network connection.\n\
 759 Arguments are the name of the device for the serial line,\n\
 760 the speed to connect at in bits per second.";
 761   st2000_ops.to_open = st2000_open;
 762   st2000_ops.to_close = st2000_close;
 763   st2000_ops.to_attach = 0;
 764   st2000_run_ops.to_post_attach = NULL;
 765   st2000_ops.to_require_attach = NULL;
 766   st2000_ops.to_detach = st2000_detach;
 767   st2000_ops.to_require_detach = NULL;
 768   st2000_ops.to_resume = st2000_resume;
 769   st2000_ops.to_wait = st2000_wait;
 770   st2000_ops.to_post_wait = NULL;
 771   st2000_ops.to_fetch_registers = st2000_fetch_register;
 772   st2000_ops.to_store_registers = st2000_store_register;
 773   st2000_ops.to_prepare_to_store = st2000_prepare_to_store;
 774   st2000_ops.to_xfer_memory = st2000_xfer_inferior_memory;
 775   st2000_ops.to_files_info = st2000_files_info;
 776   st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint;
 777   st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint;   /* Breakpoints */
 778   st2000_ops.to_terminal_init = 0;
 779   st2000_ops.to_terminal_inferior = 0;
 780   st2000_ops.to_terminal_ours_for_output = 0;
 781   st2000_ops.to_terminal_ours = 0;
 782   st2000_ops.to_terminal_info = 0;      /* Terminal handling */
 783   st2000_ops.to_kill = st2000_kill;
 784   st2000_ops.to_load = 0;       /* load */
 785   st2000_ops.to_lookup_symbol = 0;      /* lookup_symbol */
 786   st2000_ops.to_create_inferior = st2000_create_inferior;
 787   st2000_ops.to_post_startup_inferior = NULL;
 788   st2000_ops.to_acknowledge_created_inferior = NULL;
 789   st2000_ops.to_clone_and_follow_inferior = NULL;
 790   st2000_ops.to_post_follow_inferior_by_clone = NULL;
 791   st2000_run_ops.to_insert_fork_catchpoint = NULL;
 792   st2000_run_ops.to_remove_fork_catchpoint = NULL;
 793   st2000_run_ops.to_insert_vfork_catchpoint = NULL;
 794   st2000_run_ops.to_remove_vfork_catchpoint = NULL;
 795   st2000_ops.to_has_forked = NULL;
 796   st2000_ops.to_has_vforked = NULL;
 797   st2000_run_ops.to_can_follow_vfork_prior_to_exec = NULL;
 798   st2000_ops.to_post_follow_vfork = NULL;
 799   st2000_run_ops.to_insert_exec_catchpoint = NULL;
 800   st2000_run_ops.to_remove_exec_catchpoint = NULL;
 801   st2000_run_ops.to_has_execd = NULL;
 802   st2000_run_ops.to_reported_exec_events_per_exec_call = NULL;
 803   st2000_run_ops.to_has_exited = NULL;
 804   st2000_ops.to_mourn_inferior = st2000_mourn_inferior;
 805   st2000_ops.to_can_run = 0;    /* can_run */
 806   st2000_ops.to_notice_signals = 0;     /* notice_signals */
 807   st2000_ops.to_thread_alive = 0;       /* thread alive */
 808   st2000_ops.to_stop = 0;       /* to_stop */
 809   st2000_ops.to_pid_to_exec_file = NULL;
 810   st2000_run_ops.to_core_file_to_sym_file = NULL;
 811   st2000_ops.to_stratum = process_stratum;
 812   st2000_ops.DONT_USE = 0;      /* next */
 813   st2000_ops.to_has_all_memory = 1;
 814   st2000_ops.to_has_memory = 1;
 815   st2000_ops.to_has_stack = 1;
 816   st2000_ops.to_has_registers = 1;
 817   st2000_ops.to_has_execution = 1;      /* all mem, mem, stack, regs, exec */
 818   st2000_ops.to_sections = 0;
 819   st2000_ops.to_sections_end = 0;       /* Section pointers */
 820   st2000_ops.to_magic = OPS_MAGIC;      /* Always the last thing */
 821 };
 822
 823 void
 824 _initialize_remote_st2000 (void)
 825 {
 826   init_st2000_ops ();
 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 }