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   /* If baud_rate is -1, then ninConnect will not recognize the baud rate
 201      and will deal with the situation in a (more or less) reasonable
 202      fashion.  */
 203   sprintf(baudrate, "%d", baud_rate);
 204   ninConnect(name, baudrate,
 205              nindy_initial_brk, !from_tty, nindy_old_protocol);
 206   immediate_quit--;
 207
 208   if (nindy_serial == NULL)
 209     {
 210       perror_with_name (name);
 211     }
 212
 213   savename = savestring (name, strlen (name));
 214   push_target (&nindy_ops);
 215   target_fetch_registers(-1);
 216 }
 217
 218 /* User-initiated quit of nindy operations.  */
 219
 220 static void
 221 nindy_detach (name, from_tty)
 222      char *name;
 223      int from_tty;
 224 {
 225   if (name)
 226     error ("Too many arguments");
 227   pop_target ();
 228 }
 229
 230 static void
 231 nindy_files_info ()
 232 {
 233   /* FIXME: this lies about the baud rate if we autobauded.  */
 234   printf_unfiltered("\tAttached to %s at %d bits per second%s%s.\n", savename,
 235          baud_rate,
 236          nindy_old_protocol? " in old protocol": "",
 237          nindy_initial_brk? " with initial break": "");
 238 }
 239 \f
 240 /* Return the number of characters in the buffer before
 241    the first DLE character.  */
 242
 243 static
 244 int
 245 non_dle( buf, n )
 246     char *buf;          /* Character buffer; NOT '\0'-terminated */
 247     int n;              /* Number of characters in buffer */
 248 {
 249         int i;
 250
 251         for ( i = 0; i < n; i++ ){
 252                 if ( buf[i] == DLE ){
 253                         break;
 254                 }
 255         }
 256         return i;
 257 }
 258 \f
 259 /* Tell the remote machine to resume.  */
 260
 261 void
 262 nindy_resume (pid, step, siggnal)
 263      int pid, step;
 264      enum target_signal siggnal;
 265 {
 266   if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
 267     warning ("Can't send signals to remote NINDY targets.");
 268
 269         dcache_flush(nindy_dcache);
 270         if ( regs_changed ){
 271                 nindy_store_registers (-1);
 272                 regs_changed = 0;
 273         }
 274         have_regs = 0;
 275         ninGo( step );
 276 }
 277 \f
 278 /* FIXME, we can probably use the normal terminal_inferior stuff here.
 279    We have to do terminal_inferior and then set up the passthrough
 280    settings initially.  Thereafter, terminal_ours and terminal_inferior
 281    will automatically swap the settings around for us.  */
 282
 283 struct clean_up_tty_args {
 284   serial_ttystate state;
 285   serial_t serial;
 286 };
 287
 288 static void
 289 clean_up_tty (ptrarg)
 290      PTR ptrarg;
 291 {
 292   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
 293   SERIAL_SET_TTY_STATE (args->serial, args->state);
 294   free (args->state);
 295   warning ("\n\n\
 296 You may need to reset the 80960 and/or reload your program.\n");
 297 }
 298
 299 /* Wait until the remote machine stops. While waiting, operate in passthrough
 300  * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
 301  * stdin to NINDY.
 302  *
 303  * Return to caller, storing status in 'status' just as `wait' would.
 304  */
 305
 306 static int
 307 nindy_wait( pid, status )
 308     int pid;
 309     struct target_waitstatus *status;
 310 {
 311   fd_set fds;
 312   char buf[500];        /* FIXME, what is "500" here? */
 313   int i, n;
 314   unsigned char stop_exit;
 315   unsigned char stop_code;
 316   struct clean_up_tty_args tty_args;
 317   struct cleanup *old_cleanups;
 318   long ip_value, fp_value, sp_value;    /* Reg values from stop */
 319
 320   status->kind = TARGET_WAITKIND_EXITED;
 321   status->value.integer = 0;
 322
 323   /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
 324
 325   /* Save current tty attributes, and restore them when done.  */
 326   tty_args.serial = SERIAL_FDOPEN (0);
 327   tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
 328   old_cleanups = make_cleanup (clean_up_tty, &tty_args);
 329
 330   /* Pass input from keyboard to NINDY as it arrives.  NINDY will interpret
 331      <CR> and perform echo.  */
 332   /* This used to set CBREAK and clear ECHO and CRMOD.  I hope this is close
 333      enough.  */
 334   SERIAL_RAW (tty_args.serial);
 335
 336   while (1)
 337     {
 338       /* Wait for input on either the remote port or stdin.  */
 339       FD_ZERO (&fds);
 340       FD_SET (0, &fds);
 341       FD_SET (nindy_serial->fd, &fds);
 342       if (select (nindy_serial->fd + 1, &fds, 0, 0, 0) <= 0)
 343         continue;
 344
 345       /* Pass input through to correct place */
 346       if (FD_ISSET (0, &fds))
 347         {
 348           /* Input on stdin */
 349           n = read (0, buf, sizeof (buf));
 350           if (n)
 351             {
 352               SERIAL_WRITE (nindy_serial, buf, n );
 353             }
 354         }
 355
 356       if (FD_ISSET (nindy_serial->fd, &fds))
 357         {
 358           /* Input on remote */
 359           n = read (nindy_serial->fd, buf, sizeof (buf));
 360           if (n)
 361             {
 362               /* Write out any characters in buffer preceding DLE */
 363               i = non_dle( buf, n );
 364               if ( i > 0 )
 365                 {
 366                   write (1, buf, i);
 367                 }
 368
 369               if (i != n)
 370                 {
 371                   /* There *was* a DLE in the buffer */
 372                   stop_exit = ninStopWhy(&stop_code,
 373                                          &ip_value, &fp_value, &sp_value);
 374                   if (!stop_exit && (stop_code == STOP_SRQ))
 375                     {
 376                       immediate_quit++;
 377                       ninSrq();
 378                       immediate_quit--;
 379                     }
 380                   else
 381                     {
 382                       /* Get out of loop */
 383                       supply_register (IP_REGNUM,
 384                                        (char *)&ip_value);
 385                       supply_register (FP_REGNUM,
 386                                        (char *)&fp_value);
 387                       supply_register (SP_REGNUM,
 388                                        (char *)&sp_value);
 389                       break;
 390                     }
 391                 }
 392             }
 393         }
 394     }
 395
 396   do_cleanups (old_cleanups);
 397
 398   if (stop_exit)
 399     {
 400       status->kind = TARGET_WAITKIND_EXITED;
 401       status->value.integer = stop_code;
 402     }
 403   else
 404     {
 405       status->kind = TARGET_WAITKIND_STOPPED;
 406       status->value.sig = i960_fault_to_signal (stop_code);
 407     }
 408   return inferior_pid;
 409 }
 410
 411 /* Read the remote registers into the block REGS.  */
 412
 413 /* This is the block that ninRegsGet and ninRegsPut handles.  */
 414 struct nindy_regs {
 415   char  local_regs[16 * 4];
 416   char  global_regs[16 * 4];
 417   char  pcw_acw[2 * 4];
 418   char  ip[4];
 419   char  tcw[4];
 420   char  fp_as_double[4 * 8];
 421 };
 422
 423 static void
 424 nindy_fetch_registers(regno)
 425      int regno;
 426 {
 427   struct nindy_regs nindy_regs;
 428   int regnum, inv;
 429   double dub;
 430
 431   immediate_quit++;
 432   ninRegsGet( (char *) &nindy_regs );
 433   immediate_quit--;
 434
 435   memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16*4);
 436   memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16*4);
 437   memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2*4);
 438   memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1*4);
 439   memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1*4);
 440   for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
 441     dub = unpack_double (builtin_type_double,
 442                          &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
 443                          &inv);
 444     /* dub now in host byte order */
 445     double_to_ieee_extended (&ext_format_i960, &dub,
 446                              &registers[REGISTER_BYTE (regnum)]);
 447   }
 448
 449   registers_fetched ();
 450 }
 451
 452 static void
 453 nindy_prepare_to_store()
 454 {
 455   /* Fetch all regs if they aren't already here.  */
 456   read_register_bytes (0, NULL, REGISTER_BYTES);
 457 }
 458
 459 static void
 460 nindy_store_registers(regno)
 461      int regno;
 462 {
 463   struct nindy_regs nindy_regs;
 464   int regnum;
 465   double dub;
 466
 467   memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16*4);
 468   memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16*4);
 469   memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2*4);
 470   memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1*4);
 471   memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1*4);
 472   for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++)
 473     {
 474       ieee_extended_to_double (&ext_format_i960,
 475                                &registers[REGISTER_BYTE (regnum)], &dub);
 476       store_floating (&nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
 477                       REGISTER_VIRTUAL_SIZE (regnum),
 478                       dub);
 479     }
 480
 481   immediate_quit++;
 482   ninRegsPut( (char *) &nindy_regs );
 483   immediate_quit--;
 484 }
 485
 486 /* Read a word from remote address ADDR and return it.
 487  * This goes through the data cache.
 488  */
 489 int
 490 nindy_fetch_word (addr)
 491      CORE_ADDR addr;
 492 {
 493         return dcache_fetch (nindy_dcache, addr);
 494 }
 495
 496 /* Write a word WORD into remote address ADDR.
 497    This goes through the data cache.  */
 498
 499 void
 500 nindy_store_word (addr, word)
 501      CORE_ADDR addr;
 502      int word;
 503 {
 504         dcache_poke (nindy_dcache, addr, word);
 505 }
 506
 507 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 508    to debugger memory starting at MYADDR.   Copy to inferior if
 509    WRITE is nonzero.  Returns the length copied.
 510
 511    This is stolen almost directly from infptrace.c's child_xfer_memory,
 512    which also deals with a word-oriented memory interface.  Sometime,
 513    FIXME, rewrite this to not use the word-oriented routines.  */
 514
 515 int
 516 nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
 517      CORE_ADDR memaddr;
 518      char *myaddr;
 519      int len;
 520      int write;
 521      struct target_ops *target;                 /* ignored */
 522 {
 523   register int i;
 524   /* Round starting address down to longword boundary.  */
 525   register CORE_ADDR addr = memaddr & - sizeof (int);
 526   /* Round ending address up; get number of longwords that makes.  */
 527   register int count
 528     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 529   /* Allocate buffer of that many longwords.  */
 530   register int *buffer = (int *) alloca (count * sizeof (int));
 531
 532   if (write)
 533     {
 534       /* Fill start and end extra bytes of buffer with existing memory data.  */
 535
 536       if (addr != memaddr || len < (int)sizeof (int)) {
 537         /* Need part of initial word -- fetch it.  */
 538         buffer[0] = nindy_fetch_word (addr);
 539       }
 540
 541       if (count > 1)            /* FIXME, avoid if even boundary */
 542         {
 543           buffer[count - 1]
 544             = nindy_fetch_word (addr + (count - 1) * sizeof (int));
 545         }
 546
 547       /* Copy data to be written over corresponding part of buffer */
 548
 549       memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 550
 551       /* Write the entire buffer.  */
 552
 553       for (i = 0; i < count; i++, addr += sizeof (int))
 554         {
 555           errno = 0;
 556           nindy_store_word (addr, buffer[i]);
 557           if (errno)
 558             return 0;
 559         }
 560     }
 561   else
 562     {
 563       /* Read all the longwords */
 564       for (i = 0; i < count; i++, addr += sizeof (int))
 565         {
 566           errno = 0;
 567           buffer[i] = nindy_fetch_word (addr);
 568           if (errno)
 569             return 0;
 570           QUIT;
 571         }
 572
 573       /* Copy appropriate bytes out of the buffer.  */
 574       memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 575     }
 576   return len;
 577 }
 578 \f
 579 static void
 580 nindy_create_inferior (execfile, args, env)
 581      char *execfile;
 582      char *args;
 583      char **env;
 584 {
 585   int entry_pt;
 586   int pid;
 587
 588   if (args && *args)
 589     error ("Can't pass arguments to remote NINDY process");
 590
 591   if (execfile == 0 || exec_bfd == 0)
 592     error ("No exec file specified");
 593
 594   entry_pt = (int) bfd_get_start_address (exec_bfd);
 595
 596   pid = 42;
 597
 598   /* The "process" (board) is already stopped awaiting our commands, and
 599      the program is already downloaded.  We just set its PC and go.  */
 600
 601   inferior_pid = pid;           /* Needed for wait_for_inferior below */
 602
 603   clear_proceed_status ();
 604
 605   /* Tell wait_for_inferior that we've started a new process.  */
 606   init_wait_for_inferior ();
 607
 608   /* Set up the "saved terminal modes" of the inferior
 609      based on what modes we are starting it with.  */
 610   target_terminal_init ();
 611
 612   /* Install inferior's terminal modes.  */
 613   target_terminal_inferior ();
 614
 615   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 616   /* Let 'er rip... */
 617   proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 618 }
 619
 620 static void
 621 reset_command(args, from_tty)
 622      char *args;
 623      int from_tty;
 624 {
 625   if (nindy_serial == NULL)
 626     {
 627       error( "No target system to reset -- use 'target nindy' command.");
 628     }
 629   if ( query("Really reset the target system?",0,0) )
 630     {
 631       SERIAL_SEND_BREAK (nindy_serial);
 632       tty_flush (nindy_serial);
 633     }
 634 }
 635
 636 void
 637 nindy_kill (args, from_tty)
 638      char *args;
 639      int from_tty;
 640 {
 641   return;               /* Ignore attempts to kill target system */
 642 }
 643
 644 /* Clean up when a program exits.
 645
 646    The program actually lives on in the remote processor's RAM, and may be
 647    run again without a download.  Don't leave it full of breakpoint
 648    instructions.  */
 649
 650 void
 651 nindy_mourn_inferior ()
 652 {
 653   remove_breakpoints ();
 654   unpush_target (&nindy_ops);
 655   generic_mourn_inferior ();    /* Do all the proper things now */
 656 }
 657 \f
 658 /* Pass the args the way catch_errors wants them.  */
 659 static int
 660 nindy_open_stub (arg)
 661      char *arg;
 662 {
 663   nindy_open (arg, 1);
 664   return 1;
 665 }
 666
 667 static int
 668 load_stub (arg)
 669      char *arg;
 670 {
 671   target_load (arg, 1);
 672   return 1;
 673 }
 674
 675 /* This routine is run as a hook, just before the main command loop is
 676    entered.  If gdb is configured for the i960, but has not had its
 677    nindy target specified yet, this will loop prompting the user to do so.
 678
 679    Unlike the loop provided by Intel, we actually let the user get out
 680    of this with a RETURN.  This is useful when e.g. simply examining
 681    an i960 object file on the host system.  */
 682
 683 void
 684 nindy_before_main_loop ()
 685 {
 686   char ttyname[100];
 687   char *p, *p2;
 688
 689   while (current_target != &nindy_ops) { /* remote tty not specified yet */
 690         if ( instream == stdin ){
 691                 printf_unfiltered("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
 692                 gdb_flush( gdb_stdout );
 693         }
 694         fgets( ttyname, sizeof(ttyname)-1, stdin );
 695
 696         /* Strip leading and trailing whitespace */
 697         for ( p = ttyname; isspace(*p); p++ ){
 698                 ;
 699         }
 700         if ( *p == '\0' ){
 701                 return;         /* User just hit spaces or return, wants out */
 702         }
 703         for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
 704                 ;
 705         }
 706         *p2= '\0';
 707         if ( STREQ("quit",p) ){
 708                 exit(1);
 709         }
 710
 711         if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
 712           {
 713             /* Now that we have a tty open for talking to the remote machine,
 714                download the executable file if one was specified.  */
 715             if (exec_bfd)
 716               {
 717                 catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
 718                               RETURN_MASK_ALL);
 719               }
 720           }
 721   }
 722 }
 723 \f
 724 /* Define the target subroutine names */
 725
 726 struct target_ops nindy_ops = {
 727         "nindy", "Remote serial target in i960 NINDY-specific protocol",
 728         "Use a remote i960 system running NINDY connected by a serial line.\n\
 729 Specify the name of the device the serial line is connected to.\n\
 730 The speed (baud rate), whether to use the old NINDY protocol,\n\
 731 and whether to send a break on startup, are controlled by options\n\
 732 specified when you started GDB.",
 733         nindy_open, nindy_close,
 734         0,
 735         nindy_detach,
 736         nindy_resume,
 737         nindy_wait,
 738         nindy_fetch_registers, nindy_store_registers,
 739         nindy_prepare_to_store,
 740         nindy_xfer_inferior_memory, nindy_files_info,
 741         0, 0, /* insert_breakpoint, remove_breakpoint, */
 742         0, 0, 0, 0, 0,  /* Terminal crud */
 743         nindy_kill,
 744         generic_load,
 745         0, /* lookup_symbol */
 746         nindy_create_inferior,
 747         nindy_mourn_inferior,
 748         0,              /* can_run */
 749         0, /* notice_signals */
 750         process_stratum, 0, /* next */
 751         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
 752         0, 0,                   /* Section pointers */
 753         OPS_MAGIC,              /* Always the last thing */
 754 };
 755
 756 void
 757 _initialize_nindy ()
 758 {
 759   add_target (&nindy_ops);
 760   add_com ("reset", class_obscure, reset_command,
 761            "Send a 'break' to the remote target system.\n\
 762 Only useful if the target has been equipped with a circuit\n\
 763 to perform a hard reset when a break is detected.");
 764 }