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