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