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 "floatformat.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
 133 extern char ninStopWhy ();
 134 extern int ninMemGet ();
 135 extern int ninMemPut ();
 136
 137 int nindy_initial_brk;  /* nonzero if want to send an initial BREAK to nindy */
 138 int nindy_old_protocol; /* nonzero if want to use old protocol */
 139 char *nindy_ttyname;    /* name of tty to talk to nindy on, or null */
 140
 141 #define DLE     '\020'  /* Character NINDY sends to indicate user program has
 142                          * halted.  */
 143 #define TRUE    1
 144 #define FALSE   0
 145
 146 /* From nindy-share/nindy.c.  */
 147 extern serial_t nindy_serial;
 148
 149 static int have_regs = 0;       /* 1 iff regs read since i960 last halted */
 150 static int regs_changed = 0;    /* 1 iff regs were modified since last read */
 151
 152 extern char *exists();
 153
 154 static void
 155 nindy_fetch_registers PARAMS ((int));
 156
 157 static void
 158 nindy_store_registers PARAMS ((int));
 159 \f
 160 static char *savename;
 161
 162 static void
 163 nindy_close (quitting)
 164      int quitting;
 165 {
 166   if (nindy_serial != NULL)
 167     SERIAL_CLOSE (nindy_serial);
 168   nindy_serial = NULL;
 169
 170   if (savename)
 171     free (savename);
 172   savename = 0;
 173 }
 174
 175 /* Open a connection to a remote debugger.
 176    FIXME, there should be "set" commands for the options that are
 177    now specified with gdb command-line options (old_protocol,
 178    and initial_brk).  */
 179 void
 180 nindy_open (name, from_tty)
 181     char *name;         /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
 182     int from_tty;
 183 {
 184   char baudrate[1024];
 185
 186   if (!name)
 187     error_no_arg ("serial port device name");
 188
 189   target_preopen (from_tty);
 190
 191   nindy_close (0);
 192
 193   have_regs = regs_changed = 0;
 194   nindy_dcache = dcache_init(ninMemGet, ninMemPut);
 195
 196   /* Allow user to interrupt the following -- we could hang if there's
 197      no NINDY at the other end of the remote tty.  */
 198   immediate_quit++;
 199   /* If baud_rate is -1, then ninConnect will not recognize the baud rate
 200      and will deal with the situation in a (more or less) reasonable
 201      fashion.  */
 202   sprintf(baudrate, "%d", baud_rate);
 203   ninConnect(name, baudrate,
 204              nindy_initial_brk, !from_tty, nindy_old_protocol);
 205   immediate_quit--;
 206
 207   if (nindy_serial == NULL)
 208     {
 209       perror_with_name (name);
 210     }
 211
 212   savename = savestring (name, strlen (name));
 213   push_target (&nindy_ops);
 214
 215   target_fetch_registers(-1);
 216
 217   init_thread_list ();
 218   init_wait_for_inferior ();
 219   clear_proceed_status ();
 220   normal_stop ();
 221 }
 222
 223 /* User-initiated quit of nindy operations.  */
 224
 225 static void
 226 nindy_detach (name, from_tty)
 227      char *name;
 228      int from_tty;
 229 {
 230   if (name)
 231     error ("Too many arguments");
 232   pop_target ();
 233 }
 234
 235 static void
 236 nindy_files_info ()
 237 {
 238   /* FIXME: this lies about the baud rate if we autobauded.  */
 239   printf_unfiltered("\tAttached to %s at %d bits per second%s%s.\n", savename,
 240          baud_rate,
 241          nindy_old_protocol? " in old protocol": "",
 242          nindy_initial_brk? " with initial break": "");
 243 }
 244 \f
 245 /* Return the number of characters in the buffer before
 246    the first DLE character.  */
 247
 248 static
 249 int
 250 non_dle( buf, n )
 251     char *buf;          /* Character buffer; NOT '\0'-terminated */
 252     int n;              /* Number of characters in buffer */
 253 {
 254   int i;
 255
 256   for ( i = 0; i < n; i++ ){
 257     if ( buf[i] == DLE ){
 258       break;
 259     }
 260   }
 261   return i;
 262 }
 263 \f
 264 /* Tell the remote machine to resume.  */
 265
 266 void
 267 nindy_resume (pid, step, siggnal)
 268      int pid, step;
 269      enum target_signal siggnal;
 270 {
 271   if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
 272     warning ("Can't send signals to remote NINDY targets.");
 273
 274   dcache_flush(nindy_dcache);
 275   if ( regs_changed )
 276     {
 277       nindy_store_registers (-1);
 278       regs_changed = 0;
 279     }
 280   have_regs = 0;
 281   ninGo( step );
 282 }
 283 \f
 284 /* FIXME, we can probably use the normal terminal_inferior stuff here.
 285    We have to do terminal_inferior and then set up the passthrough
 286    settings initially.  Thereafter, terminal_ours and terminal_inferior
 287    will automatically swap the settings around for us.  */
 288
 289 struct clean_up_tty_args {
 290   serial_ttystate state;
 291   serial_t serial;
 292 };
 293 static  struct clean_up_tty_args tty_args;
 294
 295 static void
 296 clean_up_tty (ptrarg)
 297      PTR ptrarg;
 298 {
 299   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
 300   SERIAL_SET_TTY_STATE (args->serial, args->state);
 301   free (args->state);
 302   warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
 303 }
 304
 305 /* Recover from ^Z or ^C while remote process is running */
 306 static void (*old_ctrlc)();
 307 #ifdef SIGTSTP
 308 static void (*old_ctrlz)();
 309 #endif
 310
 311 static void
 312 clean_up_int()
 313 {
 314   SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
 315   free (tty_args.state);
 316
 317   signal(SIGINT, old_ctrlc);
 318 #ifdef SIGTSTP
 319   signal(SIGTSTP, old_ctrlz);
 320 #endif
 321   error("\n\nYou may need to reset the 80960 and/or reload your program.\n");
 322 }
 323
 324 /* Wait until the remote machine stops. While waiting, operate in passthrough
 325  * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
 326  * stdin to NINDY.
 327  *
 328  * Return to caller, storing status in 'status' just as `wait' would.
 329  */
 330
 331 static int
 332 nindy_wait( pid, status )
 333     int pid;
 334     struct target_waitstatus *status;
 335 {
 336   fd_set fds;
 337   int c;
 338   char buf[2];
 339   int i, n;
 340   unsigned char stop_exit;
 341   unsigned char stop_code;
 342   struct cleanup *old_cleanups;
 343   long ip_value, fp_value, sp_value;    /* Reg values from stop */
 344
 345   status->kind = TARGET_WAITKIND_EXITED;
 346   status->value.integer = 0;
 347
 348   /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
 349
 350   /* Save current tty attributes, and restore them when done.  */
 351   tty_args.serial = SERIAL_FDOPEN (0);
 352   tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
 353   old_ctrlc = signal( SIGINT, clean_up_int );
 354 #ifdef SIGTSTP
 355   old_ctrlz = signal( SIGTSTP, clean_up_int );
 356 #endif
 357
 358   old_cleanups = make_cleanup (clean_up_tty, &tty_args);
 359
 360   /* Pass input from keyboard to NINDY as it arrives.  NINDY will interpret
 361      <CR> and perform echo.  */
 362   /* This used to set CBREAK and clear ECHO and CRMOD.  I hope this is close
 363      enough.  */
 364   SERIAL_RAW (tty_args.serial);
 365
 366   while (1)
 367     {
 368       /* Input on remote */
 369       c = SERIAL_READCHAR (nindy_serial, -1);
 370       if (c == SERIAL_ERROR)
 371         {
 372           error ("Cannot read from serial line");
 373         }
 374       else if (c == 0x1b) /* ESC */
 375         {
 376           c = SERIAL_READCHAR (nindy_serial, -1);
 377           c &= ~0x40;
 378         }
 379       else if (c != 0x10) /* DLE */
 380         /* Write out any characters preceding DLE */
 381         {
 382           buf[0] = (char)c;
 383           write (1, buf, 1);
 384         }
 385       else
 386         {
 387           stop_exit = ninStopWhy(&stop_code,
 388                                  &ip_value, &fp_value, &sp_value);
 389           if (!stop_exit && (stop_code == STOP_SRQ))
 390             {
 391               immediate_quit++;
 392               ninSrq();
 393               immediate_quit--;
 394             }
 395           else
 396             {
 397               /* Get out of loop */
 398               supply_register (IP_REGNUM,
 399                                (char *)&ip_value);
 400               supply_register (FP_REGNUM,
 401                                (char *)&fp_value);
 402               supply_register (SP_REGNUM,
 403                                (char *)&sp_value);
 404               break;
 405             }
 406         }
 407     }
 408
 409   SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
 410   free (tty_args.state);
 411   discard_cleanups (old_cleanups);
 412
 413   if (stop_exit)
 414     {
 415       status->kind = TARGET_WAITKIND_EXITED;
 416       status->value.integer = stop_code;
 417     }
 418   else
 419     {
 420       /* nindy has some special stop code need to be handled */
 421       if (stop_code == STOP_GDB_BPT)
 422         stop_code = TRACE_STEP;
 423       status->kind = TARGET_WAITKIND_STOPPED;
 424       status->value.sig = i960_fault_to_signal (stop_code);
 425     }
 426   return inferior_pid;
 427 }
 428
 429 /* Read the remote registers into the block REGS.  */
 430
 431 /* This is the block that ninRegsGet and ninRegsPut handles.  */
 432 struct nindy_regs {
 433   char  local_regs[16 * 4];
 434   char  global_regs[16 * 4];
 435   char  pcw_acw[2 * 4];
 436   char  ip[4];
 437   char  tcw[4];
 438   char  fp_as_double[4 * 8];
 439 };
 440
 441 static void
 442 nindy_fetch_registers(regno)
 443      int regno;
 444 {
 445   struct nindy_regs nindy_regs;
 446   int regnum;
 447
 448   immediate_quit++;
 449   ninRegsGet( (char *) &nindy_regs );
 450   immediate_quit--;
 451
 452   memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16*4);
 453   memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16*4);
 454   memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2*4);
 455   memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1*4);
 456   memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1*4);
 457   memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], nindy_regs.fp_as_double, 4 * 8);
 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;
 475
 476   memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16*4);
 477   memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16*4);
 478   memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2*4);
 479   memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1*4);
 480   memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1*4);
 481   memcpy (nindy_regs.fp_as_double, &registers[REGISTER_BYTE (FP0_REGNUM)], 8*4);
 482
 483   immediate_quit++;
 484   ninRegsPut( (char *) &nindy_regs );
 485   immediate_quit--;
 486 }
 487
 488 /* Read a word from remote address ADDR and return it.
 489  * This goes through the data cache.
 490  */
 491 int
 492 nindy_fetch_word (addr)
 493      CORE_ADDR addr;
 494 {
 495         return dcache_fetch (nindy_dcache, addr);
 496 }
 497
 498 /* Write a word WORD into remote address ADDR.
 499    This goes through the data cache.  */
 500
 501 void
 502 nindy_store_word (addr, word)
 503      CORE_ADDR addr;
 504      int word;
 505 {
 506         dcache_poke (nindy_dcache, addr, word);
 507 }
 508
 509 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 510    to debugger memory starting at MYADDR.   Copy to inferior if
 511    WRITE is nonzero.  Returns the length copied.
 512
 513    This is stolen almost directly from infptrace.c's child_xfer_memory,
 514    which also deals with a word-oriented memory interface.  Sometime,
 515    FIXME, rewrite this to not use the word-oriented routines.  */
 516
 517 int
 518 nindy_xfer_inferior_memory(memaddr, myaddr, len, should_write, target)
 519      CORE_ADDR memaddr;
 520      char *myaddr;
 521      int len;
 522      int should_write;
 523      struct target_ops *target;                 /* ignored */
 524 {
 525   register int i;
 526   /* Round starting address down to longword boundary.  */
 527   register CORE_ADDR addr = memaddr & - sizeof (int);
 528   /* Round ending address up; get number of longwords that makes.  */
 529   register int count
 530     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 531   /* Allocate buffer of that many longwords.  */
 532   register int *buffer = (int *) alloca (count * sizeof (int));
 533
 534   if (should_write)
 535     {
 536       /* Fill start and end extra bytes of buffer with existing memory data.  */
 537
 538       if (addr != memaddr || len < (int)sizeof (int)) {
 539         /* Need part of initial word -- fetch it.  */
 540         buffer[0] = nindy_fetch_word (addr);
 541       }
 542
 543       if (count > 1)            /* FIXME, avoid if even boundary */
 544         {
 545           buffer[count - 1]
 546             = nindy_fetch_word (addr + (count - 1) * sizeof (int));
 547         }
 548
 549       /* Copy data to be written over corresponding part of buffer */
 550
 551       memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 552
 553       /* Write the entire buffer.  */
 554
 555       for (i = 0; i < count; i++, addr += sizeof (int))
 556         {
 557           errno = 0;
 558           nindy_store_word (addr, buffer[i]);
 559           if (errno)
 560             return 0;
 561         }
 562     }
 563   else
 564     {
 565       /* Read all the longwords */
 566       for (i = 0; i < count; i++, addr += sizeof (int))
 567         {
 568           errno = 0;
 569           buffer[i] = nindy_fetch_word (addr);
 570           if (errno)
 571             return 0;
 572           QUIT;
 573         }
 574
 575       /* Copy appropriate bytes out of the buffer.  */
 576       memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 577     }
 578   return len;
 579 }
 580 \f
 581 static void
 582 nindy_create_inferior (execfile, args, env)
 583      char *execfile;
 584      char *args;
 585      char **env;
 586 {
 587   int entry_pt;
 588   int pid;
 589
 590   if (args && *args)
 591     error ("Can't pass arguments to remote NINDY process");
 592
 593   if (execfile == 0 || exec_bfd == 0)
 594     error ("No executable file specified");
 595
 596   entry_pt = (int) bfd_get_start_address (exec_bfd);
 597
 598   pid = 42;
 599
 600   /* The "process" (board) is already stopped awaiting our commands, and
 601      the program is already downloaded.  We just set its PC and go.  */
 602
 603   inferior_pid = pid;           /* Needed for wait_for_inferior below */
 604
 605   clear_proceed_status ();
 606
 607   /* Tell wait_for_inferior that we've started a new process.  */
 608   init_wait_for_inferior ();
 609
 610   /* Set up the "saved terminal modes" of the inferior
 611      based on what modes we are starting it with.  */
 612   target_terminal_init ();
 613
 614   /* Install inferior's terminal modes.  */
 615   target_terminal_inferior ();
 616
 617   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 618   /* Let 'er rip... */
 619   proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 620 }
 621
 622 static void
 623 reset_command(args, from_tty)
 624      char *args;
 625      int from_tty;
 626 {
 627   if (nindy_serial == NULL)
 628     {
 629       error( "No target system to reset -- use 'target nindy' command.");
 630     }
 631   if ( query("Really reset the target system?",0,0) )
 632     {
 633       SERIAL_SEND_BREAK (nindy_serial);
 634       tty_flush (nindy_serial);
 635     }
 636 }
 637
 638 void
 639 nindy_kill (args, from_tty)
 640      char *args;
 641      int from_tty;
 642 {
 643   return;               /* Ignore attempts to kill target system */
 644 }
 645
 646 /* Clean up when a program exits.
 647
 648    The program actually lives on in the remote processor's RAM, and may be
 649    run again without a download.  Don't leave it full of breakpoint
 650    instructions.  */
 651
 652 void
 653 nindy_mourn_inferior ()
 654 {
 655   remove_breakpoints ();
 656   unpush_target (&nindy_ops);
 657   generic_mourn_inferior ();    /* Do all the proper things now */
 658 }
 659 \f
 660 /* Pass the args the way catch_errors wants them.  */
 661 static int
 662 nindy_open_stub (arg)
 663      char *arg;
 664 {
 665   nindy_open (arg, 1);
 666   return 1;
 667 }
 668
 669 static void
 670 nindy_load( filename, from_tty )
 671     char *filename;
 672     int from_tty;
 673 {
 674   asection *s;
 675   /* Can't do unix style forking on a VMS system, so we'll use bfd to do
 676      all the work for us
 677      */
 678
 679   bfd *file = bfd_openr(filename,0);
 680   if (!file)
 681   {
 682     perror_with_name(filename);
 683     return;
 684   }
 685
 686   if (!bfd_check_format(file, bfd_object))
 687   {
 688     error("can't prove it's an object file\n");
 689     return;
 690   }
 691
 692   for ( s = file->sections; s; s=s->next)
 693   {
 694     if (s->flags & SEC_LOAD)
 695     {
 696       char *buffer = xmalloc(s->_raw_size);
 697       bfd_get_section_contents(file, s, buffer, 0, s->_raw_size);
 698       printf("Loading section %s, size %x vma %x\n",
 699              s->name,
 700              s->_raw_size,
 701              s->vma);
 702       ninMemPut(s->vma, buffer, s->_raw_size);
 703       free(buffer);
 704     }
 705   }
 706   bfd_close(file);
 707 }
 708
 709 static int
 710 load_stub (arg)
 711      char *arg;
 712 {
 713   target_load (arg, 1);
 714   return 1;
 715 }
 716
 717 /* This routine is run as a hook, just before the main command loop is
 718    entered.  If gdb is configured for the i960, but has not had its
 719    nindy target specified yet, this will loop prompting the user to do so.
 720
 721    Unlike the loop provided by Intel, we actually let the user get out
 722    of this with a RETURN.  This is useful when e.g. simply examining
 723    an i960 object file on the host system.  */
 724
 725 void
 726 nindy_before_main_loop ()
 727 {
 728   char ttyname[100];
 729   char *p, *p2;
 730
 731   while (target_stack->target_ops != &nindy_ops) /* What is this crap??? */
 732     {                           /* remote tty not specified yet */
 733         if ( instream == stdin ){
 734                 printf_unfiltered("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
 735                 gdb_flush( gdb_stdout );
 736         }
 737         fgets( ttyname, sizeof(ttyname)-1, stdin );
 738
 739         /* Strip leading and trailing whitespace */
 740         for ( p = ttyname; isspace(*p); p++ ){
 741                 ;
 742         }
 743         if ( *p == '\0' ){
 744                 return;         /* User just hit spaces or return, wants out */
 745         }
 746         for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
 747                 ;
 748         }
 749         *p2= '\0';
 750         if ( STREQ("quit",p) ){
 751                 exit(1);
 752         }
 753
 754         if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
 755           {
 756             /* Now that we have a tty open for talking to the remote machine,
 757                download the executable file if one was specified.  */
 758             if (exec_bfd)
 759               {
 760                 catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
 761                               RETURN_MASK_ALL);
 762               }
 763           }
 764       }
 765 }
 766 \f
 767 /* Define the target subroutine names */
 768
 769 struct target_ops nindy_ops ;
 770 static void init_nindy_ops(void)
 771 {
 772   nindy_ops.to_shortname =   "nindy"; "Remote serial target in i960 NINDY-specific protocol",
 773                                         nindy_ops.to_longname =   "Use a remote i960 system running NINDY connected by a serial line.\n\
 774 Specify the name of the device the serial line is connected to.\n\
 775 The speed (baud rate), whether to use the old NINDY protocol,\n\
 776 and whether to send a break on startup, are controlled by options\n\
 777 specified when you started GDB." ;
 778   nindy_ops.to_doc =   "";
 779   nindy_ops.to_open =   nindy_open;
 780   nindy_ops.to_close =   nindy_close;
 781   nindy_ops.to_attach =   0;
 782   nindy_ops.to_post_attach = NULL;
 783   nindy_ops.to_require_attach = NULL;
 784   nindy_ops.to_detach =   nindy_detach;
 785   nindy_ops.to_require_detach = NULL;
 786   nindy_ops.to_resume =   nindy_resume;
 787   nindy_ops.to_wait  =   nindy_wait;
 788   nindy_ops.to_post_wait = NULL;
 789   nindy_ops.to_fetch_registers  =   nindy_fetch_registers;
 790   nindy_ops.to_store_registers  =   nindy_store_registers;
 791   nindy_ops.to_prepare_to_store =   nindy_prepare_to_store;
 792   nindy_ops.to_xfer_memory  =   nindy_xfer_inferior_memory;
 793   nindy_ops.to_files_info  =   nindy_files_info;
 794   nindy_ops.to_insert_breakpoint =   memory_insert_breakpoint;
 795   nindy_ops.to_remove_breakpoint =   memory_remove_breakpoint;
 796   nindy_ops.to_terminal_init  =   0;
 797   nindy_ops.to_terminal_inferior =   0;
 798   nindy_ops.to_terminal_ours_for_output =   0;
 799   nindy_ops.to_terminal_ours  =   0;
 800   nindy_ops.to_terminal_info  =   0;    /* Terminal crud */
 801   nindy_ops.to_kill  =   nindy_kill;
 802   nindy_ops.to_load  =   nindy_load;
 803   nindy_ops.to_lookup_symbol =   0; /* lookup_symbol */
 804   nindy_ops.to_create_inferior =   nindy_create_inferior;
 805   nindy_ops.to_post_startup_inferior = NULL;
 806   nindy_ops.to_acknowledge_created_inferior = NULL;
 807   nindy_ops.to_clone_and_follow_inferior = NULL;
 808   nindy_ops.to_post_follow_inferior_by_clone = NULL;
 809   nindy_ops.to_insert_fork_catchpoint = NULL;
 810   nindy_ops.to_remove_fork_catchpoint = NULL;
 811   nindy_ops.to_insert_vfork_catchpoint = NULL;
 812   nindy_ops.to_remove_vfork_catchpoint = NULL;
 813   nindy_ops.to_has_forked = NULL;
 814   nindy_ops.to_has_vforked = NULL;
 815   nindy_ops.to_can_follow_vfork_prior_to_exec = NULL;
 816   nindy_ops.to_post_follow_vfork = NULL;
 817   nindy_ops.to_insert_exec_catchpoint = NULL;
 818   nindy_ops.to_remove_exec_catchpoint = NULL;
 819   nindy_ops.to_has_execd = NULL;
 820   nindy_ops.to_reported_exec_events_per_exec_call = NULL;
 821   nindy_ops.to_has_exited = NULL;
 822   nindy_ops.to_mourn_inferior =   nindy_mourn_inferior;
 823   nindy_ops.to_can_run  =   0;          /* can_run */
 824   nindy_ops.to_notice_signals =   0; /* notice_signals */
 825   nindy_ops.to_thread_alive  =   0;                     /* to_thread_alive */
 826   nindy_ops.to_stop  =   0;                     /* to_stop */
 827   nindy_ops.to_pid_to_exec_file = NULL;
 828   nindy_ops.to_core_file_to_sym_file = NULL;
 829   nindy_ops.to_stratum =   process_stratum;
 830   nindy_ops.DONT_USE =   0; /* next */
 831   nindy_ops.to_has_all_memory =   1;
 832   nindy_ops.to_has_memory =   1;
 833   nindy_ops.to_has_stack =   1;
 834   nindy_ops.to_has_registers =   1;
 835   nindy_ops.to_has_execution =   1;     /* all mem, mem, stack, regs, exec */
 836   nindy_ops.to_sections =   0;
 837   nindy_ops.to_sections_end =   0;                      /* Section pointers */
 838   nindy_ops.to_magic =   OPS_MAGIC;             /* Always the last thing */
 839 }
 840
 841 void
 842 _initialize_nindy ()
 843 {
 844   init_nindy_ops() ;
 845   add_target (&nindy_ops);
 846   add_com ("reset", class_obscure, reset_command,
 847            "Send a 'break' to the remote target system.\n\
 848 Only useful if the target has been equipped with a circuit\n\
 849 to perform a hard reset when a break is detected.");
 850 }