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 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 a way to specify the various options that are
 178    now specified with gdb command-line options.  (baud_rate, 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("\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 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, inv;
 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   /* Float regs.  Only works on IEEE_FLOAT hosts.  FIXME!  */
 484   for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
 485     ieee_extended_to_double (&ext_format_i960,
 486                              &registers[REGISTER_BYTE (regnum)], &dub);
 487     /* dub now in host byte order */
 488     /* FIXME-someday, the arguments to unpack_double are backward.
 489        It expects a target double and returns a host; we pass the opposite.
 490        This mostly works but not quite.  */
 491     dub = unpack_double (builtin_type_double, (char *)&dub, &inv);
 492     /* dub now in target byte order */
 493     memcpy (&nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)], &dub, 8);
 494   }
 495
 496   immediate_quit++;
 497   ninRegsPut( (char *) &nindy_regs );
 498   immediate_quit--;
 499 }
 500
 501 /* Read a word from remote address ADDR and return it.
 502  * This goes through the data cache.
 503  */
 504 int
 505 nindy_fetch_word (addr)
 506      CORE_ADDR addr;
 507 {
 508         return dcache_fetch (nindy_dcache, addr);
 509 }
 510
 511 /* Write a word WORD into remote address ADDR.
 512    This goes through the data cache.  */
 513
 514 void
 515 nindy_store_word (addr, word)
 516      CORE_ADDR addr;
 517      int word;
 518 {
 519         dcache_poke (nindy_dcache, addr, word);
 520 }
 521
 522 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 523    to debugger memory starting at MYADDR.   Copy to inferior if
 524    WRITE is nonzero.  Returns the length copied.
 525
 526    This is stolen almost directly from infptrace.c's child_xfer_memory,
 527    which also deals with a word-oriented memory interface.  Sometime,
 528    FIXME, rewrite this to not use the word-oriented routines.  */
 529
 530 int
 531 nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
 532      CORE_ADDR memaddr;
 533      char *myaddr;
 534      int len;
 535      int write;
 536      struct target_ops *target;                 /* ignored */
 537 {
 538   register int i;
 539   /* Round starting address down to longword boundary.  */
 540   register CORE_ADDR addr = memaddr & - sizeof (int);
 541   /* Round ending address up; get number of longwords that makes.  */
 542   register int count
 543     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 544   /* Allocate buffer of that many longwords.  */
 545   register int *buffer = (int *) alloca (count * sizeof (int));
 546
 547   if (write)
 548     {
 549       /* Fill start and end extra bytes of buffer with existing memory data.  */
 550
 551       if (addr != memaddr || len < (int)sizeof (int)) {
 552         /* Need part of initial word -- fetch it.  */
 553         buffer[0] = nindy_fetch_word (addr);
 554       }
 555
 556       if (count > 1)            /* FIXME, avoid if even boundary */
 557         {
 558           buffer[count - 1]
 559             = nindy_fetch_word (addr + (count - 1) * sizeof (int));
 560         }
 561
 562       /* Copy data to be written over corresponding part of buffer */
 563
 564       memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 565
 566       /* Write the entire buffer.  */
 567
 568       for (i = 0; i < count; i++, addr += sizeof (int))
 569         {
 570           errno = 0;
 571           nindy_store_word (addr, buffer[i]);
 572           if (errno)
 573             return 0;
 574         }
 575     }
 576   else
 577     {
 578       /* Read all the longwords */
 579       for (i = 0; i < count; i++, addr += sizeof (int))
 580         {
 581           errno = 0;
 582           buffer[i] = nindy_fetch_word (addr);
 583           if (errno)
 584             return 0;
 585           QUIT;
 586         }
 587
 588       /* Copy appropriate bytes out of the buffer.  */
 589       memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 590     }
 591   return len;
 592 }
 593 \f
 594 static void
 595 nindy_create_inferior (execfile, args, env)
 596      char *execfile;
 597      char *args;
 598      char **env;
 599 {
 600   int entry_pt;
 601   int pid;
 602
 603   if (args && *args)
 604     error ("Can't pass arguments to remote NINDY process");
 605
 606   if (execfile == 0 || exec_bfd == 0)
 607     error ("No exec file specified");
 608
 609   entry_pt = (int) bfd_get_start_address (exec_bfd);
 610
 611   pid = 42;
 612
 613   /* The "process" (board) is already stopped awaiting our commands, and
 614      the program is already downloaded.  We just set its PC and go.  */
 615
 616   inferior_pid = pid;           /* Needed for wait_for_inferior below */
 617
 618   clear_proceed_status ();
 619
 620   /* Tell wait_for_inferior that we've started a new process.  */
 621   init_wait_for_inferior ();
 622
 623   /* Set up the "saved terminal modes" of the inferior
 624      based on what modes we are starting it with.  */
 625   target_terminal_init ();
 626
 627   /* Install inferior's terminal modes.  */
 628   target_terminal_inferior ();
 629
 630   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 631   proceed ((CORE_ADDR)entry_pt, -1, 0);         /* Let 'er rip... */
 632 }
 633
 634 static void
 635 reset_command(args, from_tty)
 636      char *args;
 637      int from_tty;
 638 {
 639   if (nindy_serial == NULL)
 640     {
 641       error( "No target system to reset -- use 'target nindy' command.");
 642     }
 643   if ( query("Really reset the target system?",0,0) )
 644     {
 645       SERIAL_SEND_BREAK (nindy_serial);
 646       tty_flush (nindy_serial);
 647     }
 648 }
 649
 650 void
 651 nindy_kill (args, from_tty)
 652      char *args;
 653      int from_tty;
 654 {
 655   return;               /* Ignore attempts to kill target system */
 656 }
 657
 658 /* Clean up when a program exits.
 659
 660    The program actually lives on in the remote processor's RAM, and may be
 661    run again without a download.  Don't leave it full of breakpoint
 662    instructions.  */
 663
 664 void
 665 nindy_mourn_inferior ()
 666 {
 667   remove_breakpoints ();
 668   unpush_target (&nindy_ops);
 669   generic_mourn_inferior ();    /* Do all the proper things now */
 670 }
 671 \f
 672 /* Pass the args the way catch_errors wants them.  */
 673 static int
 674 nindy_open_stub (arg)
 675      char *arg;
 676 {
 677   nindy_open (arg, 1);
 678   return 1;
 679 }
 680
 681 static int
 682 load_stub (arg)
 683      char *arg;
 684 {
 685   target_load (arg, 1);
 686   return 1;
 687 }
 688
 689 /* This routine is run as a hook, just before the main command loop is
 690    entered.  If gdb is configured for the i960, but has not had its
 691    nindy target specified yet, this will loop prompting the user to do so.
 692
 693    Unlike the loop provided by Intel, we actually let the user get out
 694    of this with a RETURN.  This is useful when e.g. simply examining
 695    an i960 object file on the host system.  */
 696
 697 void
 698 nindy_before_main_loop ()
 699 {
 700   char ttyname[100];
 701   char *p, *p2;
 702
 703   while (current_target != &nindy_ops) { /* remote tty not specified yet */
 704         if ( instream == stdin ){
 705                 printf("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
 706                 fflush( stdout );
 707         }
 708         fgets( ttyname, sizeof(ttyname)-1, stdin );
 709
 710         /* Strip leading and trailing whitespace */
 711         for ( p = ttyname; isspace(*p); p++ ){
 712                 ;
 713         }
 714         if ( *p == '\0' ){
 715                 return;         /* User just hit spaces or return, wants out */
 716         }
 717         for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
 718                 ;
 719         }
 720         *p2= '\0';
 721         if ( STREQ("quit",p) ){
 722                 exit(1);
 723         }
 724
 725         if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
 726           {
 727             /* Now that we have a tty open for talking to the remote machine,
 728                download the executable file if one was specified.  */
 729             if (exec_bfd)
 730               {
 731                 catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
 732                               RETURN_MASK_ALL);
 733               }
 734           }
 735   }
 736 }
 737 \f
 738 /* Define the target subroutine names */
 739
 740 struct target_ops nindy_ops = {
 741         "nindy", "Remote serial target in i960 NINDY-specific protocol",
 742         "Use a remote i960 system running NINDY connected by a serial line.\n\
 743 Specify the name of the device the serial line is connected to.\n\
 744 The speed (baud rate), whether to use the old NINDY protocol,\n\
 745 and whether to send a break on startup, are controlled by options\n\
 746 specified when you started GDB.",
 747         nindy_open, nindy_close,
 748         0,
 749         nindy_detach,
 750         nindy_resume,
 751         nindy_wait,
 752         nindy_fetch_registers, nindy_store_registers,
 753         nindy_prepare_to_store,
 754         nindy_xfer_inferior_memory, nindy_files_info,
 755         0, 0, /* insert_breakpoint, remove_breakpoint, */
 756         0, 0, 0, 0, 0,  /* Terminal crud */
 757         nindy_kill,
 758         generic_load,
 759         0, /* lookup_symbol */
 760         nindy_create_inferior,
 761         nindy_mourn_inferior,
 762         0,              /* can_run */
 763         0, /* notice_signals */
 764         process_stratum, 0, /* next */
 765         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
 766         0, 0,                   /* Section pointers */
 767         OPS_MAGIC,              /* Always the last thing */
 768 };
 769
 770 void
 771 _initialize_nindy ()
 772 {
 773   add_target (&nindy_ops);
 774   add_com ("reset", class_obscure, reset_command,
 775            "Send a 'break' to the remote target system.\n\
 776 Only useful if the target has been equipped with a circuit\n\
 777 to perform a hard reset when a break is detected.");
 778 }