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