gdb/remote-nindy.c

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