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