gdb/remote-st2000.c

   1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
   2    Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.  Written by Jim Kingdon for Cygnus.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* This file was derived from remote-eb.c, which did a similar job, but for
  22    an AMD-29K running EBMON.  That file was in turn derived from remote.c
  23    as mentioned in the following comment (left in for comic relief):
  24
  25   "This is like remote.c but is for an esoteric situation--
  26    having a 29k 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 "terminal.h"
  40 #include "target.h"
  41 #include "wait.h"
  42 #include <varargs.h>
  43 #include <signal.h>
  44 #include <string.h>
  45
  46 extern struct target_ops st2000_ops;            /* Forward declaration */
  47
  48 static void st2000_close();
  49 static void st2000_fetch_register();
  50 static void st2000_store_register();
  51
  52 #define LOG_FILE "st2000.log"
  53 #if defined (LOG_FILE)
  54 FILE *log_file;
  55 #endif
  56
  57 static int timeout = 24;
  58
  59 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
  60    st2000_open knows that we don't have a file open when the program
  61    starts.  */
  62 int st2000_desc = -1;
  63
  64 /* stream which is fdopen'd from st2000_desc.  Only valid when
  65    st2000_desc != -1.  */
  66 FILE *st2000_stream;
  67
  68 /* Send data to stdebug.  Works just like printf. */
  69
  70 static void
  71 printf_stdebug(va_alist)
  72      va_dcl
  73 {
  74   va_list args;
  75   char *pattern;
  76
  77   va_start(args);
  78
  79   pattern = va_arg(args, char *);
  80
  81   vfprintf(st2000_stream, pattern, args);
  82   fflush(st2000_stream);
  83 }
  84
  85 /* Read a character from the remote system, doing all the fancy
  86    timeout stuff.  */
  87 static int
  88 readchar ()
  89 {
  90   char buf;
  91
  92   buf = '\0';
  93 #ifdef HAVE_TERMIO
  94   /* termio does the timeout for us.  */
  95   read (st2000_desc, &buf, 1);
  96 #else
  97   alarm (timeout);
  98   if (read (st2000_desc, &buf, 1) < 0)
  99     {
 100       if (errno == EINTR)
 101         error ("Timeout reading from remote system.");
 102       else
 103         perror_with_name ("remote");
 104     }
 105   alarm (0);
 106 #endif
 107
 108   if (buf == '\0')
 109     error ("Timeout reading from remote system.");
 110 #if defined (LOG_FILE)
 111   putc (buf & 0x7f, log_file);
 112 #endif
 113   return buf & 0x7f;
 114 }
 115
 116 /* Keep discarding input from the remote system, until STRING is found.
 117    Let the user break out immediately.  */
 118 static void
 119 expect (string)
 120      char *string;
 121 {
 122   char *p = string;
 123
 124   immediate_quit = 1;
 125   while (1)
 126     {
 127       if (readchar() == *p)
 128         {
 129           p++;
 130           if (*p == '\0')
 131             {
 132               immediate_quit = 0;
 133               return;
 134             }
 135         }
 136       else
 137         p = string;
 138     }
 139 }
 140
 141 /* Keep discarding input until we see the STDEBUG prompt.
 142
 143    The convention for dealing with the prompt is that you
 144    o give your command
 145    o *then* wait for the prompt.
 146
 147    Thus the last thing that a procedure does with the serial line
 148    will be an expect_prompt().  Exception:  st2000_resume does not
 149    wait for the prompt, because the terminal is being handed over
 150    to the inferior.  However, the next thing which happens after that
 151    is a st2000_wait which does wait for the prompt.
 152    Note that this includes abnormal exit, e.g. error().  This is
 153    necessary to prevent getting into states from which we can't
 154    recover.  */
 155 static void
 156 expect_prompt ()
 157 {
 158 #if defined (LOG_FILE)
 159   /* This is a convenient place to do this.  The idea is to do it often
 160      enough that we never lose much data if we terminate abnormally.  */
 161   fflush (log_file);
 162 #endif
 163   expect ("dbug> ");
 164 }
 165
 166 /* Get a hex digit from the remote system & return its value.
 167    If ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
 168 static int
 169 get_hex_digit (ignore_space)
 170      int ignore_space;
 171 {
 172   int ch;
 173   while (1)
 174     {
 175       ch = readchar ();
 176       if (ch >= '0' && ch <= '9')
 177         return ch - '0';
 178       else if (ch >= 'A' && ch <= 'F')
 179         return ch - 'A' + 10;
 180       else if (ch >= 'a' && ch <= 'f')
 181         return ch - 'a' + 10;
 182       else if (ch == ' ' && ignore_space)
 183         ;
 184       else
 185         {
 186           expect_prompt ();
 187           error ("Invalid hex digit from remote system.");
 188         }
 189     }
 190 }
 191
 192 /* Get a byte from st2000_desc and put it in *BYT.  Accept any number
 193    leading spaces.  */
 194 static void
 195 get_hex_byte (byt)
 196      char *byt;
 197 {
 198   int val;
 199
 200   val = get_hex_digit (1) << 4;
 201   val |= get_hex_digit (0);
 202   *byt = val;
 203 }
 204
 205 /* Get N 32-bit words from remote, each preceded by a space,
 206    and put them in registers starting at REGNO.  */
 207 static void
 208 get_hex_regs (n, regno)
 209      int n;
 210      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 /* Called when SIGALRM signal sent due to alarm() timeout.  */
 227 #ifndef HAVE_TERMIO
 228
 229 #ifndef __STDC__
 230 #define volatile /**/
 231 #endif
 232 volatile int n_alarms;
 233
 234 static void
 235 st2000_timer ()
 236 {
 237   n_alarms++;
 238 }
 239 #endif
 240
 241 /* This is called not only when we first attach, but also when the
 242    user types "run" after having attached.  */
 243 static void
 244 st2000_create_inferior (execfile, args, env)
 245      char *execfile;
 246      char *args;
 247      char **env;
 248 {
 249   int entry_pt;
 250
 251   if (args && *args)
 252     error ("Can't pass arguments to remote STDEBUG process");
 253
 254   if (execfile == 0 || exec_bfd == 0)
 255     error ("No exec file specified");
 256
 257   entry_pt = (int) bfd_get_start_address (exec_bfd);
 258
 259 #ifdef CREATE_INFERIOR_HOOK
 260   CREATE_INFERIOR_HOOK (0);             /* No process-ID */
 261 #endif
 262
 263 /* The "process" (board) is already stopped awaiting our commands, and
 264    the program is already downloaded.  We just set its PC and go.  */
 265
 266   clear_proceed_status ();
 267
 268   /* Tell wait_for_inferior that we've started a new process.  */
 269   init_wait_for_inferior ();
 270
 271   /* Set up the "saved terminal modes" of the inferior
 272      based on what modes we are starting it with.  */
 273   target_terminal_init ();
 274
 275   /* Install inferior's terminal modes.  */
 276   target_terminal_inferior ();
 277
 278   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 279   proceed ((CORE_ADDR)entry_pt, -1, 0);         /* Let 'er rip... */
 280 }
 281
 282 /* Translate baud rates from integers to damn B_codes.  Unix should
 283    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 284
 285 #ifndef B19200
 286 #define B19200 EXTA
 287 #endif
 288 #ifndef B38400
 289 #define B38400 EXTB
 290 #endif
 291
 292 static struct {int rate, damn_b;} baudtab[] = {
 293         {0, B0},
 294         {50, B50},
 295         {75, B75},
 296         {110, B110},
 297         {134, B134},
 298         {150, B150},
 299         {200, B200},
 300         {300, B300},
 301         {600, B600},
 302         {1200, B1200},
 303         {1800, B1800},
 304         {2400, B2400},
 305         {4800, B4800},
 306         {9600, B9600},
 307         {19200, B19200},
 308         {38400, B38400},
 309         {-1, -1},
 310 };
 311
 312 static int
 313 damn_b (rate)
 314      int rate;
 315 {
 316   int i;
 317
 318   for (i = 0; baudtab[i].rate != -1; i++)
 319     if (rate == baudtab[i].rate) return baudtab[i].damn_b;
 320   return B38400;        /* Random */
 321 }
 322
 323
 324 /* Open a connection to a remote debugger.
 325    NAME is the filename used for communication.  */
 326
 327 static int baudrate = 9600;
 328 static char *dev_name;
 329
 330 static TERMINAL old_sg;
 331
 332 static void
 333 st2000_open (name, from_tty)
 334      char *name;
 335      int from_tty;
 336 {
 337   TERMINAL sg;
 338
 339   char *p;
 340
 341   target_preopen (from_tty);
 342
 343   if (!name)
 344     goto erroid;
 345
 346   /* Find the first whitespace character, it separates dev_name from
 347      the baud rate.  */
 348
 349   for (p = name; *p && !isspace (*p); p++)
 350     ;
 351   if (*p == '\0')
 352 erroid:
 353     error ("\
 354 Please include the name of the device for the serial port, and the baud rate.");
 355
 356   dev_name = alloca (p - name + 1);
 357   strncpy (dev_name, name, p - name);
 358   dev_name[p - name] = '\0';
 359
 360   /* Skip over the whitespace after dev_name */
 361   for (; isspace (*p); p++)
 362     /*EMPTY*/;
 363
 364   if (1 != sscanf (p, "%d ", &baudrate))
 365     goto erroid;
 366
 367   st2000_close (0);
 368
 369   st2000_desc = open (dev_name, O_RDWR);
 370   if (st2000_desc < 0)
 371     perror_with_name (dev_name);
 372   ioctl (st2000_desc, TIOCGETP, &sg);
 373   old_sg = sg;
 374
 375 #ifdef HAVE_TERMIO
 376   sg.c_cc[VMIN] = 0;            /* read with timeout.  */
 377   sg.c_cc[VTIME] = timeout * 10;
 378   sg.c_lflag &= ~(ICANON | ECHO);
 379   sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);
 380 #else
 381   sg.sg_ispeed = damn_b (baudrate);
 382   sg.sg_ospeed = damn_b (baudrate);
 383   sg.sg_flags |= RAW | ANYP;
 384   sg.sg_flags &= ~ECHO;
 385 #endif
 386
 387   ioctl (st2000_desc, TIOCSETP, &sg);
 388   st2000_stream = fdopen (st2000_desc, "r+");
 389
 390   push_target (&st2000_ops);
 391
 392 #ifndef HAVE_TERMIO
 393 #ifndef NO_SIGINTERRUPT
 394   /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
 395      the read.  */
 396   if (siginterrupt (SIGALRM, 1) != 0)
 397     perror ("st2000_open: error in siginterrupt");
 398 #endif
 399
 400   /* Set up read timeout timer.  */
 401   if ((void (*)) signal (SIGALRM, st2000_timer) == (void (*)) -1)
 402     perror ("st2000_open: error in signal");
 403 #endif
 404
 405 #if defined (LOG_FILE)
 406   log_file = fopen (LOG_FILE, "w");
 407   if (log_file == NULL)
 408     perror_with_name (LOG_FILE);
 409 #endif
 410
 411   /* Hello?  Are you there?  */
 412   printf_stdebug ("\r");
 413
 414   expect_prompt ();
 415
 416   if (from_tty)
 417     printf ("Remote %s connected to %s\n", target_shortname,
 418             dev_name);
 419 }
 420
 421 /* Close out all files and local state before this target loses control. */
 422
 423 static void
 424 st2000_close (quitting)
 425      int quitting;
 426 {
 427
 428   /* Reset the terminal to its original settings. */
 429
 430   ioctl (st2000_desc, TIOCSETP, &old_sg);
 431
 432   /* Due to a bug in Unix, fclose closes not only the stdio stream,
 433      but also the file descriptor.  So we don't actually close
 434      st2000_desc.  */
 435   if (st2000_stream)
 436     fclose (st2000_stream);     /* This also closes st2000_desc */
 437
 438   /* Do not try to close st2000_desc again, later in the program.  */
 439   st2000_stream = NULL;
 440   st2000_desc = -1;
 441
 442 #if defined (LOG_FILE)
 443   if (log_file) {
 444     if (ferror (log_file))
 445       printf ("Error writing log file.\n");
 446     if (fclose (log_file) != 0)
 447       printf ("Error closing log file.\n");
 448   }
 449 #endif
 450 }
 451
 452 /* Terminate the open connection to the remote debugger.
 453    Use this when you want to detach and do something else
 454    with your gdb.  */
 455 static void
 456 st2000_detach (from_tty)
 457      int from_tty;
 458 {
 459   pop_target();         /* calls st2000_close to do the real work */
 460   if (from_tty)
 461     printf ("Ending remote %s debugging\n", target_shortname);
 462 }
 463
 464 /* Tell the remote machine to resume.  */
 465
 466 static void
 467 st2000_resume (step, sig)
 468      int step, sig;
 469 {
 470   if (step)
 471     {
 472       printf_stdebug ("ST\r");
 473       /* Wait for the echo.  */
 474       expect ("ST\r");
 475     }
 476   else
 477     {
 478       printf_stdebug ("GO\r");
 479       /* Swallow the echo.  */
 480       expect ("GO\r");
 481     }
 482 }
 483
 484 /* Wait until the remote machine stops, then return,
 485    storing status in STATUS just as `wait' would.  */
 486
 487 static int
 488 st2000_wait (status)
 489      WAITTYPE *status;
 490 {
 491   /* FIXME --- USE A REAL STRING MATCHING ALGORITHM HERE!!! */
 492
 493   static char bpt[] = "dbug> ";
 494   char *bp = bpt;
 495
 496   /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars.  */
 497   char swallowed[50];
 498   /* Current position in swallowed.  */
 499   char *swallowed_p = swallowed;
 500
 501   int ch;
 502   int ch_handled;
 503
 504   int old_timeout = timeout;
 505
 506   WSETEXIT ((*status), 0);
 507
 508   timeout = 0;          /* Don't time out -- user program is running. */
 509   while (1)
 510     {
 511       ch_handled = 0;
 512       ch = readchar ();
 513       if (ch == *bp)
 514         {
 515           bp++;
 516           if (*bp == '\0')
 517             break;
 518           ch_handled = 1;
 519
 520           *swallowed_p++ = ch;
 521         }
 522       else
 523         bp = bpt;
 524
 525       if (!ch_handled)
 526         {
 527           char *p;
 528
 529           /* Print out any characters which have been swallowed.  */
 530           for (p = swallowed; p < swallowed_p; ++p)
 531             putc (*p, stdout);
 532           swallowed_p = swallowed;
 533
 534           putc (ch, stdout);
 535         }
 536     }
 537   if (*bp == '\000')
 538     WSETSTOP ((*status), SIGTRAP);
 539   else
 540     WSETEXIT ((*status), 0);
 541   timeout = old_timeout;
 542
 543   return 0;
 544 }
 545
 546 /* Return the name of register number REGNO in the form input and output by
 547    STDEBUG.  Currently, REGISTER_NAMES just happens to contain exactly what
 548    STDEBUG wants.  Lets take advantage of that just as long as possible! */
 549
 550 static char *
 551 get_reg_name (regno)
 552      int regno;
 553 {
 554   static char buf[50];
 555   char *p, *b;
 556
 557   b = buf;
 558
 559   for (p = reg_names[regno]; *p; p++)
 560     *b++ = toupper(*p);
 561   *b = '\000';
 562
 563   return buf;
 564 }
 565
 566 /* Read the remote registers into the block REGS.  */
 567
 568 static void
 569 st2000_fetch_registers ()
 570 {
 571   int regno;
 572
 573   /* Yeah yeah, I know this is horribly inefficient.  But it isn't done
 574      very often...  I'll clean it up later.  */
 575
 576   for (regno = 0; regno <= PC_REGNUM; regno++)
 577     st2000_fetch_register(regno);
 578 }
 579
 580 /* Fetch register REGNO, or all registers if REGNO is -1.
 581    Returns errno value.  */
 582 static void
 583 st2000_fetch_register (regno)
 584      int regno;
 585 {
 586   if (regno == -1)
 587     st2000_fetch_registers ();
 588   else
 589     {
 590       char *name = get_reg_name (regno);
 591       printf_stdebug ("DR %s\r", name);
 592       expect (name);
 593       expect (" : ");
 594       get_hex_regs (1, regno);
 595       expect_prompt ();
 596     }
 597   return;
 598 }
 599
 600 /* Store the remote registers from the contents of the block REGS.  */
 601
 602 static void
 603 st2000_store_registers ()
 604 {
 605   int regno;
 606
 607   for (regno = 0; regno <= PC_REGNUM; regno++)
 608     st2000_store_register(regno);
 609
 610   registers_changed ();
 611 }
 612
 613 /* Store register REGNO, or all if REGNO == 0.
 614    Return errno value.  */
 615 static void
 616 st2000_store_register (regno)
 617      int regno;
 618 {
 619   if (regno == -1)
 620     st2000_store_registers ();
 621   else
 622     {
 623       printf_stdebug ("PR %s %x\r", get_reg_name (regno),
 624                       read_register (regno));
 625
 626       expect_prompt ();
 627     }
 628 }
 629
 630 /* Get ready to modify the registers array.  On machines which store
 631    individual registers, this doesn't need to do anything.  On machines
 632    which store all the registers in one fell swoop, this makes sure
 633    that registers contains all the registers from the program being
 634    debugged.  */
 635
 636 static void
 637 st2000_prepare_to_store ()
 638 {
 639   /* Do nothing, since we can store individual regs */
 640 }
 641
 642 static void
 643 st2000_files_info ()
 644 {
 645   printf ("\tAttached to %s at %d baud.\n",
 646           dev_name, baudrate);
 647 }
 648
 649 /* Copy LEN bytes of data from debugger memory at MYADDR
 650    to inferior's memory at MEMADDR.  Returns length moved.  */
 651 static int
 652 st2000_write_inferior_memory (memaddr, myaddr, len)
 653      CORE_ADDR memaddr;
 654      unsigned char *myaddr;
 655      int len;
 656 {
 657   int i;
 658
 659   for (i = 0; i < len; i++)
 660     {
 661       printf_stdebug ("PM.B %x %x\r", memaddr + i, myaddr[i]);
 662       expect_prompt ();
 663     }
 664   return len;
 665 }
 666
 667 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
 668    at debugger address MYADDR.  Returns length moved.  */
 669 static int
 670 st2000_read_inferior_memory(memaddr, myaddr, len)
 671      CORE_ADDR memaddr;
 672      char *myaddr;
 673      int len;
 674 {
 675   int i;
 676
 677   /* Number of bytes read so far.  */
 678   int count;
 679
 680   /* Starting address of this pass.  */
 681   unsigned long startaddr;
 682
 683   /* Number of bytes to read in this pass.  */
 684   int len_this_pass;
 685
 686   /* Note that this code works correctly if startaddr is just less
 687      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
 688      thing).  That is, something like
 689      st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
 690      works--it never adds len to memaddr and gets 0.  */
 691   /* However, something like
 692      st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
 693      doesn't need to work.  Detect it and give up if there's an attempt
 694      to do that.  */
 695   if (((memaddr - 1) + len) < memaddr) {
 696     errno = EIO;
 697     return 0;
 698   }
 699
 700   startaddr = memaddr;
 701   count = 0;
 702   while (count < len)
 703     {
 704       len_this_pass = 16;
 705       if ((startaddr % 16) != 0)
 706         len_this_pass -= startaddr % 16;
 707       if (len_this_pass > (len - count))
 708         len_this_pass = (len - count);
 709
 710       printf_stdebug ("DI.L %x %x\r", startaddr, len_this_pass);
 711       expect (":  ");
 712
 713       for (i = 0; i < len_this_pass; i++)
 714         get_hex_byte (&myaddr[count++]);
 715
 716       expect_prompt ();
 717
 718       startaddr += len_this_pass;
 719     }
 720   return len;
 721 }
 722
 723 /* FIXME-someday!  Merge these two.  */
 724 static int
 725 st2000_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 726      CORE_ADDR memaddr;
 727      char *myaddr;
 728      int len;
 729      int write;
 730      struct target_ops *target;         /* ignored */
 731 {
 732   if (write)
 733     return st2000_write_inferior_memory (memaddr, myaddr, len);
 734   else
 735     return st2000_read_inferior_memory (memaddr, myaddr, len);
 736 }
 737
 738 static void
 739 st2000_kill (args, from_tty)
 740      char *args;
 741      int from_tty;
 742 {
 743   return;               /* Ignore attempts to kill target system */
 744 }
 745
 746 /* Clean up when a program exits.
 747
 748    The program actually lives on in the remote processor's RAM, and may be
 749    run again without a download.  Don't leave it full of breakpoint
 750    instructions.  */
 751
 752 static void
 753 st2000_mourn_inferior ()
 754 {
 755   remove_breakpoints ();
 756   generic_mourn_inferior ();    /* Do all the proper things now */
 757 }
 758
 759 #define MAX_STDEBUG_BREAKPOINTS 16
 760
 761 extern int memory_breakpoint_size;
 762 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] = {0};
 763
 764 static int
 765 st2000_insert_breakpoint (addr, shadow)
 766      CORE_ADDR addr;
 767      char *shadow;
 768 {
 769   int i;
 770
 771   for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
 772     if (breakaddr[i] == 0)
 773       {
 774         breakaddr[i] = addr;
 775
 776         st2000_read_inferior_memory(addr, shadow, memory_breakpoint_size);
 777         printf_stdebug("BR %x H\r", addr);
 778         expect_prompt();
 779         return 0;
 780       }
 781
 782   fprintf(stderr, "Too many breakpoints (> 16) for STDBUG\n");
 783   return 1;
 784 }
 785
 786 static int
 787 st2000_remove_breakpoint (addr, shadow)
 788      CORE_ADDR addr;
 789      char *shadow;
 790 {
 791   int i;
 792
 793   for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
 794     if (breakaddr[i] == addr)
 795       {
 796         breakaddr[i] = 0;
 797
 798         printf_stdebug("CB %d\r", i);
 799         expect_prompt();
 800         return 0;
 801       }
 802
 803   fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr);
 804   return 1;
 805 }
 806
 807 /* Define the target subroutine names */
 808
 809 static struct target_ops st2000_ops = {
 810         "st2000", "Remote serial Tandem ST2000 target",
 811         "Use a remote computer running STDEBUG connected by a serial line,\n\
 812 or a network connection.\n\
 813 Arguments are the name of the device for the serial line,\n\
 814 the speed to connect at in bits per second.",
 815         st2000_open, st2000_close,
 816         0, st2000_detach, st2000_resume, st2000_wait,
 817         st2000_fetch_register, st2000_store_register,
 818         st2000_prepare_to_store, 0, 0,  /* conv_to, conv_from */
 819         st2000_xfer_inferior_memory, st2000_files_info,
 820         st2000_insert_breakpoint, st2000_remove_breakpoint, /* Breakpoints */
 821         0, 0, 0, 0, 0,  /* Terminal handling */
 822         st2000_kill,
 823         0,      /* load */
 824         0, /* lookup_symbol */
 825         st2000_create_inferior,
 826         st2000_mourn_inferior,
 827         process_stratum, 0, /* next */
 828         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
 829         0, 0,                   /* Section pointers */
 830         OPS_MAGIC,              /* Always the last thing */
 831 };
 832
 833 void
 834 _initialize_remote_st2000 ()
 835 {
 836   add_target (&st2000_ops);
 837 }