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