gdb/remote-nindy.c

   1 /* Memory-access and commands for remote NINDY process, for GDB.
   2    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Contributed by Intel Corporation.  Modified from remote.c by Chris Benenati.
   4
   5 GDB is distributed in the hope that it will be useful, but WITHOUT ANY
   6 WARRANTY.  No author or distributor accepts responsibility to anyone
   7 for the consequences of using it or for whether it serves any
   8 particular purpose or works at all, unless he says so in writing.
   9 Refer to the GDB General Public License for full details.
  10
  11 Everyone is granted permission to copy, modify and redistribute GDB,
  12 but only under the conditions described in the GDB General Public
  13 License.  A copy of this license is supposed to have been given to you
  14 along with GDB so you can know your rights and responsibilities.  It
  15 should be in a file named COPYING.  Among other things, the copyright
  16 notice and this notice must be preserved on all copies.
  17
  18 In other words, go ahead and share GDB, but don't try to stop
  19 anyone else from sharing it farther.  Help stamp out software hoarding!
  20 */
  21
  22 /*
  23 Except for the data cache routines, this file bears little resemblence
  24 to remote.c.  A new (although similar) protocol has been specified, and
  25 portions of the code are entirely dependent on having an i80960 with a
  26 NINDY ROM monitor at the other end of the line.
  27 */
  28
  29 /*****************************************************************************
  30  *
  31  * REMOTE COMMUNICATION PROTOCOL BETWEEN GDB960 AND THE NINDY ROM MONITOR.
  32  *
  33  *
  34  * MODES OF OPERATION
  35  * ----- -- ---------
  36  *
  37  * As far as NINDY is concerned, GDB is always in one of two modes: command
  38  * mode or passthrough mode.
  39  *
  40  * In command mode (the default) pre-defined packets containing requests
  41  * are sent by GDB to NINDY.  NINDY never talks except in reponse to a request.
  42  *
  43  * Once the the user program is started, GDB enters passthrough mode, to give
  44  * the user program access to the terminal.  GDB remains in this mode until
  45  * NINDY indicates that the program has stopped.
  46  *
  47  *
  48  * PASSTHROUGH MODE
  49  * ----------- ----
  50  *
  51  * GDB writes all input received from the keyboard directly to NINDY, and writes
  52  * all characters received from NINDY directly to the monitor.
  53  *
  54  * Keyboard input is neither buffered nor echoed to the monitor.
  55  *
  56  * GDB remains in passthrough mode until NINDY sends a single ^P character,
  57  * to indicate that the user process has stopped.
  58  *
  59  * Note:
  60  *      GDB assumes NINDY performs a 'flushreg' when the user program stops.
  61  *
  62  *
  63  * COMMAND MODE
  64  * ------- ----
  65  *
  66  * All info (except for message ack and nak) is transferred between gdb
  67  * and the remote processor in messages of the following format:
  68  *
  69  *              <info>#<checksum>
  70  *
  71  * where
  72  *      #       is a literal character
  73  *
  74  *      <info>  ASCII information;  all numeric information is in the
  75  *              form of hex digits ('0'-'9' and lowercase 'a'-'f').
  76  *
  77  *      <checksum>
  78  *              is a pair of ASCII hex digits representing an 8-bit
  79  *              checksum formed by adding together each of the
  80  *              characters in <info>.
  81  *
  82  * The receiver of a message always sends a single character to the sender
  83  * to indicate that the checksum was good ('+') or bad ('-');  the sender
  84  * re-transmits the entire message over until a '+' is received.
  85  *
  86  * In response to a command NINDY always sends back either data or
  87  * a result code of the form "Xnn", where "nn" are hex digits and "X00"
  88  * means no errors.  (Exceptions: the "s" and "c" commands don't respond.)
  89  *
  90  * SEE THE HEADER OF THE FILE "gdb.c" IN THE NINDY MONITOR SOURCE CODE FOR A
  91  * FULL DESCRIPTION OF LEGAL COMMANDS.
  92  *
  93  * SEE THE FILE "stop.h" IN THE NINDY MONITOR SOURCE CODE FOR A LIST
  94  * OF STOP CODES.
  95  *
  96  ***************************************************************************/
  97
  98 #include "defs.h"
  99 #include <signal.h>
 100 #include <sys/types.h>
 101 #include <setjmp.h>
 102
 103 #include "frame.h"
 104 #include "inferior.h"
 105 #include "bfd.h"
 106 #include "symfile.h"
 107 #include "target.h"
 108 #include "gdbcore.h"
 109 #include "command.h"
 110 #include "ieee-float.h"
 111
 112 #include "wait.h"
 113 #include <sys/file.h>
 114 #include <ctype.h>
 115 #include "serial.h"
 116 #include "nindy-share/env.h"
 117 #include "nindy-share/stop.h"
 118
 119 #include "dcache.h"
 120 #include "remote-utils.h"
 121
 122 static DCACHE *nindy_dcache;
 123
 124 extern int unlink();
 125 extern char *getenv();
 126 extern char *mktemp();
 127
 128 extern void generic_mourn_inferior ();
 129
 130 extern struct target_ops nindy_ops;
 131 extern GDB_FILE *instream;
 132 extern struct ext_format ext_format_i960;       /* i960-tdep.c */
 133
 134 extern char ninStopWhy ();
 135 extern int ninMemGet ();
 136 extern int ninMemPut ();
 137
 138 int nindy_initial_brk;  /* nonzero if want to send an initial BREAK to nindy */
 139 int nindy_old_protocol; /* nonzero if want to use old protocol */
 140 char *nindy_ttyname;    /* name of tty to talk to nindy on, or null */
 141
 142 #define DLE     '\020'  /* Character NINDY sends to indicate user program has
 143                          * halted.  */
 144 #define TRUE    1
 145 #define FALSE   0
 146
 147 /* From nindy-share/nindy.c.  */
 148 extern serial_t nindy_serial;
 149
 150 static int have_regs = 0;       /* 1 iff regs read since i960 last halted */
 151 static int regs_changed = 0;    /* 1 iff regs were modified since last read */
 152
 153 extern char *exists();
 154
 155 static void
 156 nindy_fetch_registers PARAMS ((int));
 157
 158 static void
 159 nindy_store_registers PARAMS ((int));
 160 \f
 161 static char *savename;
 162
 163 static void
 164 nindy_close (quitting)
 165      int quitting;
 166 {
 167   if (nindy_serial != NULL)
 168     SERIAL_CLOSE (nindy_serial);
 169   nindy_serial = NULL;
 170
 171   if (savename)
 172     free (savename);
 173   savename = 0;
 174 }
 175
 176 /* Open a connection to a remote debugger.
 177    FIXME, there should be "set" commands for the options that are
 178    now specified with gdb command-line options (old_protocol,
 179    and initial_brk).  */
 180 void
 181 nindy_open (name, from_tty)
 182     char *name;         /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
 183     int from_tty;
 184 {
 185   char baudrate[1024];
 186
 187   if (!name)
 188     error_no_arg ("serial port device name");
 189
 190   target_preopen (from_tty);
 191
 192   nindy_close (0);
 193
 194   have_regs = regs_changed = 0;
 195   nindy_dcache = dcache_init(ninMemGet, ninMemPut);
 196
 197   /* Allow user to interrupt the following -- we could hang if there's
 198      no NINDY at the other end of the remote tty.  */
 199   immediate_quit++;
 200   sprintf(baudrate, "%d", sr_get_baud_rate());
 201   ninConnect(name, baudrate,
 202              nindy_initial_brk, !from_tty, nindy_old_protocol);
 203   immediate_quit--;
 204
 205   if (nindy_serial == NULL)
 206     {
 207       perror_with_name (name);
 208     }
 209
 210   savename = savestring (name, strlen (name));
 211   push_target (&nindy_ops);
 212   target_fetch_registers(-1);
 213 }
 214
 215 /* User-initiated quit of nindy operations.  */
 216
 217 static void
 218 nindy_detach (name, from_tty)
 219      char *name;
 220      int from_tty;
 221 {
 222   if (name)
 223     error ("Too many arguments");
 224   pop_target ();
 225 }
 226
 227 static void
 228 nindy_files_info ()
 229 {
 230   printf_unfiltered("\tAttached to %s at %d bps%s%s.\n", savename,
 231          sr_get_baud_rate(),
 232          nindy_old_protocol? " in old protocol": "",
 233          nindy_initial_brk? " with initial break": "");
 234 }
 235 \f
 236 /* Return the number of characters in the buffer before
 237    the first DLE character.  */
 238
 239 static
 240 int
 241 non_dle( buf, n )
 242     char *buf;          /* Character buffer; NOT '\0'-terminated */
 243     int n;              /* Number of characters in buffer */
 244 {
 245         int i;
 246
 247         for ( i = 0; i < n; i++ ){
 248                 if ( buf[i] == DLE ){
 249                         break;
 250                 }
 251         }
 252         return i;
 253 }
 254 \f
 255 /* Tell the remote machine to resume.  */
 256
 257 void
 258 nindy_resume (pid, step, siggnal)
 259      int pid, step;
 260      enum target_signal siggnal;
 261 {
 262   if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
 263     warning ("Can't send signals to remote NINDY targets.");
 264
 265         dcache_flush(nindy_dcache);
 266         if ( regs_changed ){
 267                 nindy_store_registers (-1);
 268                 regs_changed = 0;
 269         }
 270         have_regs = 0;
 271         ninGo( step );
 272 }
 273 \f
 274 /* FIXME, we can probably use the normal terminal_inferior stuff here.
 275    We have to do terminal_inferior and then set up the passthrough
 276    settings initially.  Thereafter, terminal_ours and terminal_inferior
 277    will automatically swap the settings around for us.  */
 278
 279 struct clean_up_tty_args {
 280   serial_ttystate state;
 281   serial_t serial;
 282 };
 283
 284 static void
 285 clean_up_tty (ptrarg)
 286      PTR ptrarg;
 287 {
 288   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
 289   SERIAL_SET_TTY_STATE (args->serial, args->state);
 290   free (args->state);
 291   warning ("\n\n\
 292 You may need to reset the 80960 and/or reload your program.\n");
 293 }
 294
 295 /* Wait until the remote machine stops. While waiting, operate in passthrough
 296  * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
 297  * stdin to NINDY.
 298  *
 299  * Return to caller, storing status in 'status' just as `wait' would.
 300  */
 301
 302 static int
 303 nindy_wait( pid, status )
 304     int pid;
 305     struct target_waitstatus *status;
 306 {
 307   fd_set fds;
 308   char buf[500];        /* FIXME, what is "500" here? */
 309   int i, n;
 310   unsigned char stop_exit;
 311   unsigned char stop_code;
 312   struct clean_up_tty_args tty_args;
 313   struct cleanup *old_cleanups;
 314   long ip_value, fp_value, sp_value;    /* Reg values from stop */
 315
 316   status->kind = TARGET_WAITKIND_EXITED;
 317   status->value.integer = 0;
 318
 319   /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
 320
 321   /* Save current tty attributes, and restore them when done.  */
 322   tty_args.serial = SERIAL_FDOPEN (0);
 323   tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
 324   old_cleanups = make_cleanup (clean_up_tty, &tty_args);
 325
 326   /* Pass input from keyboard to NINDY as it arrives.  NINDY will interpret
 327      <CR> and perform echo.  */
 328   /* This used to set CBREAK and clear ECHO and CRMOD.  I hope this is close
 329      enough.  */
 330   SERIAL_RAW (tty_args.serial);
 331
 332   while (1)
 333     {
 334       /* Wait for input on either the remote port or stdin.  */
 335       FD_ZERO (&fds);
 336       FD_SET (0, &fds);
 337       FD_SET (nindy_serial->fd, &fds);
 338       if (select (nindy_serial->fd + 1, &fds, 0, 0, 0) <= 0)
 339         continue;
 340
 341       /* Pass input through to correct place */
 342       if (FD_ISSET (0, &fds))
 343         {
 344           /* Input on stdin */
 345           n = read (0, buf, sizeof (buf));
 346           if (n)
 347             {
 348               SERIAL_WRITE (nindy_serial, buf, n );
 349             }
 350         }
 351
 352       if (FD_ISSET (nindy_serial->fd, &fds))
 353         {
 354           /* Input on remote */
 355           n = read (nindy_serial->fd, buf, sizeof (buf));
 356           if (n)
 357             {
 358               /* Write out any characters in buffer preceding DLE */
 359               i = non_dle( buf, n );
 360               if ( i > 0 )
 361                 {
 362                   write (1, buf, i);
 363                 }
 364
 365               if (i != n)
 366                 {
 367                   /* There *was* a DLE in the buffer */
 368                   stop_exit = ninStopWhy(&stop_code,
 369                                          &ip_value, &fp_value, &sp_value);
 370                   if (!stop_exit && (stop_code == STOP_SRQ))
 371                     {
 372                       immediate_quit++;
 373                       ninSrq();
 374                       immediate_quit--;
 375                     }
 376                   else
 377                     {
 378                       /* Get out of loop */
 379                       supply_register (IP_REGNUM,
 380                                        (char *)&ip_value);
 381                       supply_register (FP_REGNUM,
 382                                        (char *)&fp_value);
 383                       supply_register (SP_REGNUM,
 384                                        (char *)&sp_value);
 385                       break;
 386                     }
 387                 }
 388             }
 389         }
 390     }
 391
 392   do_cleanups (old_cleanups);
 393
 394   if (stop_exit)
 395     {
 396       status->kind = TARGET_WAITKIND_EXITED;
 397       status->value.integer = stop_code;
 398     }
 399   else
 400     {
 401       status->kind = TARGET_WAITKIND_STOPPED;
 402       status->value.sig = i960_fault_to_signal (stop_code);
 403     }
 404   return inferior_pid;
 405 }
 406
 407 /* Read the remote registers into the block REGS.  */
 408
 409 /* This is the block that ninRegsGet and ninRegsPut handles.  */
 410 struct nindy_regs {
 411   char  local_regs[16 * 4];
 412   char  global_regs[16 * 4];
 413   char  pcw_acw[2 * 4];
 414   char  ip[4];
 415   char  tcw[4];
 416   char  fp_as_double[4 * 8];
 417 };
 418
 419 static void
 420 nindy_fetch_registers(regno)
 421      int regno;
 422 {
 423   struct nindy_regs nindy_regs;
 424   int regnum, inv;
 425   double dub;
 426
 427   immediate_quit++;
 428   ninRegsGet( (char *) &nindy_regs );
 429   immediate_quit--;
 430
 431   memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16*4);
 432   memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16*4);
 433   memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2*4);
 434   memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1*4);
 435   memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1*4);
 436   for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
 437     dub = unpack_double (builtin_type_double,
 438                          &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
 439                          &inv);
 440     /* dub now in host byte order */
 441     double_to_ieee_extended (&ext_format_i960, &dub,
 442                              &registers[REGISTER_BYTE (regnum)]);
 443   }
 444
 445   registers_fetched ();
 446 }
 447
 448 static void
 449 nindy_prepare_to_store()
 450 {
 451   /* Fetch all regs if they aren't already here.  */
 452   read_register_bytes (0, NULL, REGISTER_BYTES);
 453 }
 454
 455 static void
 456 nindy_store_registers(regno)
 457      int regno;
 458 {
 459   struct nindy_regs nindy_regs;
 460   int regnum;
 461   double dub;
 462
 463   memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16*4);
 464   memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16*4);
 465   memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2*4);
 466   memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1*4);
 467   memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1*4);
 468   for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++)
 469     {
 470       ieee_extended_to_double (&ext_format_i960,
 471                                &registers[REGISTER_BYTE (regnum)], &dub);
 472       store_floating (&nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
 473                       REGISTER_VIRTUAL_SIZE (regnum),
 474                       dub);
 475     }
 476
 477   immediate_quit++;
 478   ninRegsPut( (char *) &nindy_regs );
 479   immediate_quit--;
 480 }
 481
 482 /* Read a word from remote address ADDR and return it.
 483  * This goes through the data cache.
 484  */
 485 int
 486 nindy_fetch_word (addr)
 487      CORE_ADDR addr;
 488 {
 489         return dcache_fetch (nindy_dcache, addr);
 490 }
 491
 492 /* Write a word WORD into remote address ADDR.
 493    This goes through the data cache.  */
 494
 495 void
 496 nindy_store_word (addr, word)
 497      CORE_ADDR addr;
 498      int word;
 499 {
 500         dcache_poke (nindy_dcache, addr, word);
 501 }
 502
 503 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 504    to debugger memory starting at MYADDR.   Copy to inferior if
 505    WRITE is nonzero.  Returns the length copied.
 506
 507    This is stolen almost directly from infptrace.c's child_xfer_memory,
 508    which also deals with a word-oriented memory interface.  Sometime,
 509    FIXME, rewrite this to not use the word-oriented routines.  */
 510
 511 int
 512 nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
 513      CORE_ADDR memaddr;
 514      char *myaddr;
 515      int len;
 516      int write;
 517      struct target_ops *target;                 /* ignored */
 518 {
 519   register int i;
 520   /* Round starting address down to longword boundary.  */
 521   register CORE_ADDR addr = memaddr & - sizeof (int);
 522   /* Round ending address up; get number of longwords that makes.  */
 523   register int count
 524     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 525   /* Allocate buffer of that many longwords.  */
 526   register int *buffer = (int *) alloca (count * sizeof (int));
 527
 528   if (write)
 529     {
 530       /* Fill start and end extra bytes of buffer with existing memory data.  */
 531
 532       if (addr != memaddr || len < (int)sizeof (int)) {
 533         /* Need part of initial word -- fetch it.  */
 534         buffer[0] = nindy_fetch_word (addr);
 535       }
 536
 537       if (count > 1)            /* FIXME, avoid if even boundary */
 538         {
 539           buffer[count - 1]
 540             = nindy_fetch_word (addr + (count - 1) * sizeof (int));
 541         }
 542
 543       /* Copy data to be written over corresponding part of buffer */
 544
 545       memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 546
 547       /* Write the entire buffer.  */
 548
 549       for (i = 0; i < count; i++, addr += sizeof (int))
 550         {
 551           errno = 0;
 552           nindy_store_word (addr, buffer[i]);
 553           if (errno)
 554             return 0;
 555         }
 556     }
 557   else
 558     {
 559       /* Read all the longwords */
 560       for (i = 0; i < count; i++, addr += sizeof (int))
 561         {
 562           errno = 0;
 563           buffer[i] = nindy_fetch_word (addr);
 564           if (errno)
 565             return 0;
 566           QUIT;
 567         }
 568
 569       /* Copy appropriate bytes out of the buffer.  */
 570       memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 571     }
 572   return len;
 573 }
 574 \f
 575 static void
 576 nindy_create_inferior (execfile, args, env)
 577      char *execfile;
 578      char *args;
 579      char **env;
 580 {
 581   int entry_pt;
 582   int pid;
 583
 584   if (args && *args)
 585     error ("Can't pass arguments to remote NINDY process");
 586
 587   if (execfile == 0 || exec_bfd == 0)
 588     error ("No exec file specified");
 589
 590   entry_pt = (int) bfd_get_start_address (exec_bfd);
 591
 592   pid = 42;
 593
 594   /* The "process" (board) is already stopped awaiting our commands, and
 595      the program is already downloaded.  We just set its PC and go.  */
 596
 597   inferior_pid = pid;           /* Needed for wait_for_inferior below */
 598
 599   clear_proceed_status ();
 600
 601   /* Tell wait_for_inferior that we've started a new process.  */
 602   init_wait_for_inferior ();
 603
 604   /* Set up the "saved terminal modes" of the inferior
 605      based on what modes we are starting it with.  */
 606   target_terminal_init ();
 607
 608   /* Install inferior's terminal modes.  */
 609   target_terminal_inferior ();
 610
 611   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 612   /* Let 'er rip... */
 613   proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 614 }
 615
 616 static void
 617 reset_command(args, from_tty)
 618      char *args;
 619      int from_tty;
 620 {
 621   if (nindy_serial == NULL)
 622     {
 623       error( "No target system to reset -- use 'target nindy' command.");
 624     }
 625   if ( query("Really reset the target system?",0,0) )
 626     {
 627       SERIAL_SEND_BREAK (nindy_serial);
 628       tty_flush (nindy_serial);
 629     }
 630 }
 631
 632 void
 633 nindy_kill (args, from_tty)
 634      char *args;
 635      int from_tty;
 636 {
 637   return;               /* Ignore attempts to kill target system */
 638 }
 639
 640 /* Clean up when a program exits.
 641
 642    The program actually lives on in the remote processor's RAM, and may be
 643    run again without a download.  Don't leave it full of breakpoint
 644    instructions.  */
 645
 646 void
 647 nindy_mourn_inferior ()
 648 {
 649   remove_breakpoints ();
 650   unpush_target (&nindy_ops);
 651   generic_mourn_inferior ();    /* Do all the proper things now */
 652 }
 653 \f
 654 /* Pass the args the way catch_errors wants them.  */
 655 static int
 656 nindy_open_stub (arg)
 657      char *arg;
 658 {
 659   nindy_open (arg, 1);
 660   return 1;
 661 }
 662
 663 static int
 664 load_stub (arg)
 665      char *arg;
 666 {
 667   target_load (arg, 1);
 668   return 1;
 669 }
 670
 671 /* This routine is run as a hook, just before the main command loop is
 672    entered.  If gdb is configured for the i960, but has not had its
 673    nindy target specified yet, this will loop prompting the user to do so.
 674
 675    Unlike the loop provided by Intel, we actually let the user get out
 676    of this with a RETURN.  This is useful when e.g. simply examining
 677    an i960 object file on the host system.  */
 678
 679 void
 680 nindy_before_main_loop ()
 681 {
 682   char ttyname[100];
 683   char *p, *p2;
 684
 685   while (current_target != &nindy_ops) { /* remote tty not specified yet */
 686         if ( instream == stdin ){
 687                 printf_unfiltered("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
 688                 gdb_flush( gdb_stdout );
 689         }
 690         fgets( ttyname, sizeof(ttyname)-1, stdin );
 691
 692         /* Strip leading and trailing whitespace */
 693         for ( p = ttyname; isspace(*p); p++ ){
 694                 ;
 695         }
 696         if ( *p == '\0' ){
 697                 return;         /* User just hit spaces or return, wants out */
 698         }
 699         for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
 700                 ;
 701         }
 702         *p2= '\0';
 703         if ( STREQ("quit",p) ){
 704                 exit(1);
 705         }
 706
 707         if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
 708           {
 709             /* Now that we have a tty open for talking to the remote machine,
 710                download the executable file if one was specified.  */
 711             if (exec_bfd)
 712               {
 713                 catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
 714                               RETURN_MASK_ALL);
 715               }
 716           }
 717   }
 718 }
 719 \f
 720 /* Define the target subroutine names */
 721
 722 struct target_ops nindy_ops = {
 723         "nindy", "Remote serial target in i960 NINDY-specific protocol",
 724         "Use a remote i960 system running NINDY connected by a serial line.\n\
 725 Specify the name of the device the serial line is connected to.\n\
 726 The speed (baud rate), whether to use the old NINDY protocol,\n\
 727 and whether to send a break on startup, are controlled by options\n\
 728 specified when you started GDB.",
 729         nindy_open, nindy_close,
 730         0,
 731         nindy_detach,
 732         nindy_resume,
 733         nindy_wait,
 734         nindy_fetch_registers, nindy_store_registers,
 735         nindy_prepare_to_store,
 736         nindy_xfer_inferior_memory, nindy_files_info,
 737         0, 0, /* insert_breakpoint, remove_breakpoint, */
 738         0, 0, 0, 0, 0,  /* Terminal crud */
 739         nindy_kill,
 740         generic_load,
 741         0, /* lookup_symbol */
 742         nindy_create_inferior,
 743         nindy_mourn_inferior,
 744         0,              /* can_run */
 745         0, /* notice_signals */
 746         process_stratum, 0, /* next */
 747         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
 748         0, 0,                   /* Section pointers */
 749         OPS_MAGIC,              /* Always the last thing */
 750 };
 751
 752 void
 753 _initialize_nindy ()
 754 {
 755   add_target (&nindy_ops);
 756   add_com ("reset", class_obscure, reset_command,
 757            "Send a 'break' to the remote target system.\n\
 758 Only useful if the target has been equipped with a circuit\n\
 759 to perform a hard reset when a break is detected.");
 760 }