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_invd (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 BUF before
 244    the first DLE character.  N is maximum number of characters to
 245    consider.  */
 246
 247 static
 248 int
 249 non_dle (char *buf, int n)
 250 {
 251   int i;
 252
 253   for (i = 0; i < n; i++)
 254     {
 255       if (buf[i] == DLE)
 256         {
 257           break;
 258         }
 259     }
 260   return i;
 261 }
 262 \f
 263 /* Tell the remote machine to resume.  */
 264
 265 void
 266 nindy_resume (int pid, int step, enum target_signal siggnal)
 267 {
 268   if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
 269     warning ("Can't send signals to remote NINDY targets.");
 270
 271   dcache_invd (nindy_dcache);
 272   if (regs_changed)
 273     {
 274       nindy_store_registers (-1);
 275       regs_changed = 0;
 276     }
 277   have_regs = 0;
 278   ninGo (step);
 279 }
 280 \f
 281 /* FIXME, we can probably use the normal terminal_inferior stuff here.
 282    We have to do terminal_inferior and then set up the passthrough
 283    settings initially.  Thereafter, terminal_ours and terminal_inferior
 284    will automatically swap the settings around for us.  */
 285
 286 struct clean_up_tty_args
 287 {
 288   serial_ttystate state;
 289   serial_t serial;
 290 };
 291 static struct clean_up_tty_args tty_args;
 292
 293 static void
 294 clean_up_tty (PTR ptrarg)
 295 {
 296   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
 297   SERIAL_SET_TTY_STATE (args->serial, args->state);
 298   free (args->state);
 299   warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
 300 }
 301
 302 /* Recover from ^Z or ^C while remote process is running */
 303 static void (*old_ctrlc) ();
 304 #ifdef SIGTSTP
 305 static void (*old_ctrlz) ();
 306 #endif
 307
 308 static void
 309 clean_up_int (void)
 310 {
 311   SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
 312   free (tty_args.state);
 313
 314   signal (SIGINT, old_ctrlc);
 315 #ifdef SIGTSTP
 316   signal (SIGTSTP, old_ctrlz);
 317 #endif
 318   error ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
 319 }
 320
 321 /* Wait until the remote machine stops. While waiting, operate in passthrough
 322  * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
 323  * stdin to NINDY.
 324  *
 325  * Return to caller, storing status in 'status' just as `wait' would.
 326  */
 327
 328 static int
 329 nindy_wait (int pid, struct target_waitstatus *status)
 330 {
 331   fd_set fds;
 332   int c;
 333   char buf[2];
 334   int i, n;
 335   unsigned char stop_exit;
 336   unsigned char stop_code;
 337   struct cleanup *old_cleanups;
 338   long ip_value, fp_value, sp_value;    /* Reg values from stop */
 339
 340   status->kind = TARGET_WAITKIND_EXITED;
 341   status->value.integer = 0;
 342
 343   /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
 344
 345   /* Save current tty attributes, and restore them when done.  */
 346   tty_args.serial = SERIAL_FDOPEN (0);
 347   tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
 348   old_ctrlc = signal (SIGINT, clean_up_int);
 349 #ifdef SIGTSTP
 350   old_ctrlz = signal (SIGTSTP, clean_up_int);
 351 #endif
 352
 353   old_cleanups = make_cleanup (clean_up_tty, &tty_args);
 354
 355   /* Pass input from keyboard to NINDY as it arrives.  NINDY will interpret
 356      <CR> and perform echo.  */
 357   /* This used to set CBREAK and clear ECHO and CRMOD.  I hope this is close
 358      enough.  */
 359   SERIAL_RAW (tty_args.serial);
 360
 361   while (1)
 362     {
 363       /* Input on remote */
 364       c = SERIAL_READCHAR (nindy_serial, -1);
 365       if (c == SERIAL_ERROR)
 366         {
 367           error ("Cannot read from serial line");
 368         }
 369       else if (c == 0x1b)       /* ESC */
 370         {
 371           c = SERIAL_READCHAR (nindy_serial, -1);
 372           c &= ~0x40;
 373         }
 374       else if (c != 0x10)       /* DLE */
 375         /* Write out any characters preceding DLE */
 376         {
 377           buf[0] = (char) c;
 378           write (1, buf, 1);
 379         }
 380       else
 381         {
 382           stop_exit = ninStopWhy (&stop_code,
 383                                   &ip_value, &fp_value, &sp_value);
 384           if (!stop_exit && (stop_code == STOP_SRQ))
 385             {
 386               immediate_quit++;
 387               ninSrq ();
 388               immediate_quit--;
 389             }
 390           else
 391             {
 392               /* Get out of loop */
 393               supply_register (IP_REGNUM,
 394                                (char *) &ip_value);
 395               supply_register (FP_REGNUM,
 396                                (char *) &fp_value);
 397               supply_register (SP_REGNUM,
 398                                (char *) &sp_value);
 399               break;
 400             }
 401         }
 402     }
 403
 404   SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
 405   free (tty_args.state);
 406   discard_cleanups (old_cleanups);
 407
 408   if (stop_exit)
 409     {
 410       status->kind = TARGET_WAITKIND_EXITED;
 411       status->value.integer = stop_code;
 412     }
 413   else
 414     {
 415       /* nindy has some special stop code need to be handled */
 416       if (stop_code == STOP_GDB_BPT)
 417         stop_code = TRACE_STEP;
 418       status->kind = TARGET_WAITKIND_STOPPED;
 419       status->value.sig = i960_fault_to_signal (stop_code);
 420     }
 421   return inferior_pid;
 422 }
 423
 424 /* Read the remote registers into the block REGS.  */
 425
 426 /* This is the block that ninRegsGet and ninRegsPut handles.  */
 427 struct nindy_regs
 428 {
 429   char local_regs[16 * 4];
 430   char global_regs[16 * 4];
 431   char pcw_acw[2 * 4];
 432   char ip[4];
 433   char tcw[4];
 434   char fp_as_double[4 * 8];
 435 };
 436
 437 static void
 438 nindy_fetch_registers (int regno)
 439 {
 440   struct nindy_regs nindy_regs;
 441   int regnum;
 442
 443   immediate_quit++;
 444   ninRegsGet ((char *) &nindy_regs);
 445   immediate_quit--;
 446
 447   memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16 * 4);
 448   memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16 * 4);
 449   memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2 * 4);
 450   memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1 * 4);
 451   memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1 * 4);
 452   memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], nindy_regs.fp_as_double, 4 * 8);
 453
 454   registers_fetched ();
 455 }
 456
 457 static void
 458 nindy_prepare_to_store (void)
 459 {
 460   /* Fetch all regs if they aren't already here.  */
 461   read_register_bytes (0, NULL, REGISTER_BYTES);
 462 }
 463
 464 static void
 465 nindy_store_registers (int regno)
 466 {
 467   struct nindy_regs nindy_regs;
 468   int regnum;
 469
 470   memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16 * 4);
 471   memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16 * 4);
 472   memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2 * 4);
 473   memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1 * 4);
 474   memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1 * 4);
 475   memcpy (nindy_regs.fp_as_double, &registers[REGISTER_BYTE (FP0_REGNUM)], 8 * 4);
 476
 477   immediate_quit++;
 478   ninRegsPut ((char *) &nindy_regs);
 479   immediate_quit--;
 480 }
 481
 482 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 483    to debugger memory starting at MYADDR.   Copy to inferior if
 484    SHOULD_WRITE is nonzero.  Returns the length copied.  TARGET is
 485    unused.  */
 486
 487 int
 488 nindy_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
 489                             int should_write, struct target_ops *target)
 490 {
 491   if (len <= 0)
 492     return 0;
 493   return dcache_xfer_memory (nindy_dcache, memaddr, myaddr,
 494                              len, should_write);
 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_pid = 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           free (buffer);
 610         }
 611     }
 612   bfd_close (file);
 613
 614   dcache_invd(nindy_dcache);
 615 }
 616
 617 static int
 618 load_stub (char *arg)
 619 {
 620   target_load (arg, 1);
 621   return 1;
 622 }
 623
 624 /* This routine is run as a hook, just before the main command loop is
 625    entered.  If gdb is configured for the i960, but has not had its
 626    nindy target specified yet, this will loop prompting the user to do so.
 627
 628    Unlike the loop provided by Intel, we actually let the user get out
 629    of this with a RETURN.  This is useful when e.g. simply examining
 630    an i960 object file on the host system.  */
 631
 632 void
 633 nindy_before_main_loop (void)
 634 {
 635   char ttyname[100];
 636   char *p, *p2;
 637
 638   while (target_stack->target_ops != &nindy_ops)        /* What is this crap??? */
 639     {                           /* remote tty not specified yet */
 640       if (instream == stdin)
 641         {
 642           printf_unfiltered ("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
 643           gdb_flush (gdb_stdout);
 644         }
 645       fgets (ttyname, sizeof (ttyname) - 1, stdin);
 646
 647       /* Strip leading and trailing whitespace */
 648       for (p = ttyname; isspace (*p); p++)
 649         {
 650           ;
 651         }
 652       if (*p == '\0')
 653         {
 654           return;               /* User just hit spaces or return, wants out */
 655         }
 656       for (p2 = p; !isspace (*p2) && (*p2 != '\0'); p2++)
 657         {
 658           ;
 659         }
 660       *p2 = '\0';
 661       if (STREQ ("quit", p))
 662         {
 663           exit (1);
 664         }
 665
 666       if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
 667         {
 668           /* Now that we have a tty open for talking to the remote machine,
 669              download the executable file if one was specified.  */
 670           if (exec_bfd)
 671             {
 672               catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
 673                             RETURN_MASK_ALL);
 674             }
 675         }
 676     }
 677 }
 678 \f
 679 /* Define the target subroutine names */
 680
 681 struct target_ops nindy_ops;
 682
 683 static void
 684 init_nindy_ops (void)
 685 {
 686   nindy_ops.to_shortname = "nindy";
 687   "Remote serial target in i960 NINDY-specific protocol",
 688     nindy_ops.to_longname = "Use a remote i960 system running NINDY connected by a serial line.\n\
 689 Specify the name of the device the serial line is connected to.\n\
 690 The speed (baud rate), whether to use the old NINDY protocol,\n\
 691 and whether to send a break on startup, are controlled by options\n\
 692 specified when you started GDB.";
 693   nindy_ops.to_doc = "";
 694   nindy_ops.to_open = nindy_open;
 695   nindy_ops.to_close = nindy_close;
 696   nindy_ops.to_attach = 0;
 697   nindy_ops.to_post_attach = NULL;
 698   nindy_ops.to_require_attach = NULL;
 699   nindy_ops.to_detach = nindy_detach;
 700   nindy_ops.to_require_detach = NULL;
 701   nindy_ops.to_resume = nindy_resume;
 702   nindy_ops.to_wait = nindy_wait;
 703   nindy_ops.to_post_wait = NULL;
 704   nindy_ops.to_fetch_registers = nindy_fetch_registers;
 705   nindy_ops.to_store_registers = nindy_store_registers;
 706   nindy_ops.to_prepare_to_store = nindy_prepare_to_store;
 707   nindy_ops.to_xfer_memory = nindy_xfer_inferior_memory;
 708   nindy_ops.to_files_info = nindy_files_info;
 709   nindy_ops.to_insert_breakpoint = memory_insert_breakpoint;
 710   nindy_ops.to_remove_breakpoint = memory_remove_breakpoint;
 711   nindy_ops.to_terminal_init = 0;
 712   nindy_ops.to_terminal_inferior = 0;
 713   nindy_ops.to_terminal_ours_for_output = 0;
 714   nindy_ops.to_terminal_ours = 0;
 715   nindy_ops.to_terminal_info = 0;       /* Terminal crud */
 716   nindy_ops.to_kill = nindy_kill;
 717   nindy_ops.to_load = nindy_load;
 718   nindy_ops.to_lookup_symbol = 0;       /* lookup_symbol */
 719   nindy_ops.to_create_inferior = nindy_create_inferior;
 720   nindy_ops.to_post_startup_inferior = NULL;
 721   nindy_ops.to_acknowledge_created_inferior = NULL;
 722   nindy_ops.to_clone_and_follow_inferior = NULL;
 723   nindy_ops.to_post_follow_inferior_by_clone = NULL;
 724   nindy_ops.to_insert_fork_catchpoint = NULL;
 725   nindy_ops.to_remove_fork_catchpoint = NULL;
 726   nindy_ops.to_insert_vfork_catchpoint = NULL;
 727   nindy_ops.to_remove_vfork_catchpoint = NULL;
 728   nindy_ops.to_has_forked = NULL;
 729   nindy_ops.to_has_vforked = NULL;
 730   nindy_ops.to_can_follow_vfork_prior_to_exec = NULL;
 731   nindy_ops.to_post_follow_vfork = NULL;
 732   nindy_ops.to_insert_exec_catchpoint = NULL;
 733   nindy_ops.to_remove_exec_catchpoint = NULL;
 734   nindy_ops.to_has_execd = NULL;
 735   nindy_ops.to_reported_exec_events_per_exec_call = NULL;
 736   nindy_ops.to_has_exited = NULL;
 737   nindy_ops.to_mourn_inferior = nindy_mourn_inferior;
 738   nindy_ops.to_can_run = 0;     /* can_run */
 739   nindy_ops.to_notice_signals = 0;      /* notice_signals */
 740   nindy_ops.to_thread_alive = 0;        /* to_thread_alive */
 741   nindy_ops.to_stop = 0;        /* to_stop */
 742   nindy_ops.to_pid_to_exec_file = NULL;
 743   nindy_ops.to_core_file_to_sym_file = NULL;
 744   nindy_ops.to_stratum = process_stratum;
 745   nindy_ops.DONT_USE = 0;       /* next */
 746   nindy_ops.to_has_all_memory = 1;
 747   nindy_ops.to_has_memory = 1;
 748   nindy_ops.to_has_stack = 1;
 749   nindy_ops.to_has_registers = 1;
 750   nindy_ops.to_has_execution = 1;       /* all mem, mem, stack, regs, exec */
 751   nindy_ops.to_sections = 0;
 752   nindy_ops.to_sections_end = 0;        /* Section pointers */
 753   nindy_ops.to_magic = OPS_MAGIC;       /* Always the last thing */
 754 }
 755
 756 void
 757 _initialize_nindy (void)
 758 {
 759   init_nindy_ops ();
 760   add_target (&nindy_ops);
 761   add_com ("reset", class_obscure, reset_command,
 762            "Send a 'break' to the remote target system.\n\
 763 Only useful if the target has been equipped with a circuit\n\
 764 to perform a hard reset when a break is detected.");
 765 }