gdb/remote-nindy.c

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