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