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 "ieee-float.h"
 111
 112 #include "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 extern int unlink();
 120 extern char *getenv();
 121 extern char *mktemp();
 122
 123 extern void generic_mourn_inferior ();
 124
 125 extern struct target_ops nindy_ops;
 126 extern FILE *instream;
 127 extern struct ext_format ext_format_i960;       /* i960-tdep.c */
 128
 129 extern char ninStopWhy ();
 130
 131 int nindy_initial_brk;  /* nonzero if want to send an initial BREAK to nindy */
 132 int nindy_old_protocol; /* nonzero if want to use old protocol */
 133 char *nindy_ttyname;    /* name of tty to talk to nindy on, or null */
 134
 135 #define DLE     '\020'  /* Character NINDY sends to indicate user program has
 136                          * halted.  */
 137 #define TRUE    1
 138 #define FALSE   0
 139
 140 /* From nindy-share/nindy.c.  */
 141 extern serial_t nindy_serial;
 142
 143 static int have_regs = 0;       /* 1 iff regs read since i960 last halted */
 144 static int regs_changed = 0;    /* 1 iff regs were modified since last read */
 145
 146 extern char *exists();
 147
 148 static void
 149 dcache_flush (), dcache_poke (), dcache_init();
 150
 151 static int
 152 dcache_fetch ();
 153
 154 static void
 155 nindy_fetch_registers PARAMS ((int));
 156
 157 static void
 158 nindy_store_registers PARAMS ((int));
 159 \f
 160 static char *savename;
 161
 162 static void
 163 nindy_close (quitting)
 164      int quitting;
 165 {
 166   if (nindy_serial != NULL)
 167     SERIAL_CLOSE (nindy_serial);
 168   nindy_serial = NULL;
 169
 170   if (savename)
 171     free (savename);
 172   savename = 0;
 173 }
 174
 175 /* Open a connection to a remote debugger.
 176    FIXME, there should be a way to specify the various options that are
 177    now specified with gdb command-line options.  (baud_rate, old_protocol,
 178    and initial_brk)  */
 179 void
 180 nindy_open (name, from_tty)
 181     char *name;         /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
 182     int from_tty;
 183 {
 184
 185   if (!name)
 186     error_no_arg ("serial port device name");
 187
 188   target_preopen (from_tty);
 189
 190   nindy_close (0);
 191
 192   have_regs = regs_changed = 0;
 193   dcache_init();
 194
 195   /* Allow user to interrupt the following -- we could hang if there's
 196      no NINDY at the other end of the remote tty.  */
 197   immediate_quit++;
 198   ninConnect(name, baud_rate ? baud_rate : "9600",
 199              nindy_initial_brk, !from_tty, nindy_old_protocol);
 200   immediate_quit--;
 201
 202   if (nindy_serial == NULL)
 203     {
 204       perror_with_name (name);
 205     }
 206
 207   savename = savestring (name, strlen (name));
 208   push_target (&nindy_ops);
 209   target_fetch_registers(-1);
 210 }
 211
 212 /* User-initiated quit of nindy operations.  */
 213
 214 static void
 215 nindy_detach (name, from_tty)
 216      char *name;
 217      int from_tty;
 218 {
 219   if (name)
 220     error ("Too many arguments");
 221   pop_target ();
 222 }
 223
 224 static void
 225 nindy_files_info ()
 226 {
 227   printf("\tAttached to %s at %s bps%s%s.\n", savename,
 228          baud_rate? baud_rate: "9600",
 229          nindy_old_protocol? " in old protocol": "",
 230          nindy_initial_brk? " with initial break": "");
 231 }
 232 \f
 233 /* Return the number of characters in the buffer before
 234    the first DLE character.  */
 235
 236 static
 237 int
 238 non_dle( buf, n )
 239     char *buf;          /* Character buffer; NOT '\0'-terminated */
 240     int n;              /* Number of characters in buffer */
 241 {
 242         int i;
 243
 244         for ( i = 0; i < n; i++ ){
 245                 if ( buf[i] == DLE ){
 246                         break;
 247                 }
 248         }
 249         return i;
 250 }
 251 \f
 252 /* Tell the remote machine to resume.  */
 253
 254 void
 255 nindy_resume (pid, step, siggnal)
 256      int pid, step, siggnal;
 257 {
 258         if (siggnal != 0 && siggnal != stop_signal)
 259           error ("Can't send signals to remote NINDY targets.");
 260
 261         dcache_flush();
 262         if ( regs_changed ){
 263                 nindy_store_registers (-1);
 264                 regs_changed = 0;
 265         }
 266         have_regs = 0;
 267         ninGo( step );
 268 }
 269 \f
 270 /* FIXME, we can probably use the normal terminal_inferior stuff here.
 271    We have to do terminal_inferior and then set up the passthrough
 272    settings initially.  Thereafter, terminal_ours and terminal_inferior
 273    will automatically swap the settings around for us.  */
 274
 275 struct clean_up_tty_args {
 276   serial_ttystate state;
 277   serial_t serial;
 278 };
 279
 280 static void
 281 clean_up_tty (ptrarg)
 282      PTR ptrarg;
 283 {
 284   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
 285   SERIAL_SET_TTY_STATE (args->serial, args->state);
 286   free (args->state);
 287   warning ("\n\n\
 288 You may need to reset the 80960 and/or reload your program.\n");
 289 }
 290
 291 /* Wait until the remote machine stops. While waiting, operate in passthrough
 292  * mode; i.e., pass everything NINDY sends to stdout, and everything from
 293  * stdin to NINDY.
 294  *
 295  * Return to caller, storing status in 'status' just as `wait' would.
 296  */
 297
 298 static int
 299 nindy_wait( status )
 300     WAITTYPE *status;
 301 {
 302   fd_set fds;
 303   char buf[500];        /* FIXME, what is "500" here? */
 304   int i, n;
 305   unsigned char stop_exit;
 306   unsigned char stop_code;
 307   struct clean_up_tty_args tty_args;
 308   struct cleanup *old_cleanups;
 309   long ip_value, fp_value, sp_value;    /* Reg values from stop */
 310
 311   WSETEXIT( (*status), 0 );
 312
 313   /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
 314
 315   /* Save current tty attributes, and restore them when done.  */
 316   tty_args.serial = SERIAL_FDOPEN (0);
 317   tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
 318   old_cleanups = make_cleanup (clean_up_tty, &tty_args);
 319
 320   /* Pass input from keyboard to NINDY as it arrives.  NINDY will interpret
 321      <CR> and perform echo.  */
 322   /* This used to set CBREAK and clear ECHO and CRMOD.  I hope this is close
 323      enough.  */
 324   SERIAL_RAW (tty_args.serial);
 325
 326   while (1)
 327     {
 328       /* Wait for input on either the remote port or stdin.  */
 329       FD_ZERO (&fds);
 330       FD_SET (0, &fds);
 331       FD_SET (nindy_serial->fd, &fds);
 332       if (select (nindy_serial->fd + 1, &fds, 0, 0, 0) <= 0)
 333         continue;
 334
 335       /* Pass input through to correct place */
 336       if (FD_ISSET (0, &fds))
 337         {
 338           /* Input on stdin */
 339           n = read (0, buf, sizeof (buf));
 340           if (n)
 341             {
 342               SERIAL_WRITE (nindy_serial, buf, n );
 343             }
 344         }
 345
 346       if (FD_ISSET (nindy_serial->fd, &fds))
 347         {
 348           /* Input on remote */
 349           n = read (nindy_serial->fd, buf, sizeof (buf));
 350           if (n)
 351             {
 352               /* Write out any characters in buffer preceding DLE */
 353               i = non_dle( buf, n );
 354               if ( i > 0 )
 355                 {
 356                   write (1, buf, i);
 357                 }
 358
 359               if (i != n)
 360                 {
 361                   /* There *was* a DLE in the buffer */
 362                   stop_exit = ninStopWhy(&stop_code,
 363                                          &ip_value, &fp_value, &sp_value);
 364                   if (!stop_exit && (stop_code == STOP_SRQ))
 365                     {
 366                       immediate_quit++;
 367                       ninSrq();
 368                       immediate_quit--;
 369                     }
 370                   else
 371                     {
 372                       /* Get out of loop */
 373                       supply_register (IP_REGNUM,
 374                                        (char *)&ip_value);
 375                       supply_register (FP_REGNUM,
 376                                        (char *)&fp_value);
 377                       supply_register (SP_REGNUM,
 378                                        (char *)&sp_value);
 379                       break;
 380                     }
 381                 }
 382             }
 383         }
 384     }
 385
 386   do_cleanups (old_cleanups);
 387
 388   if (stop_exit)
 389     {
 390       /* User program exited */
 391       WSETEXIT ((*status), stop_code);
 392     }
 393   else
 394     {
 395       /* Fault or trace */
 396       switch (stop_code)
 397         {
 398         case STOP_GDB_BPT:
 399         case TRACE_STEP:
 400           /* Breakpoint or single stepping.  */
 401           stop_code = SIGTRAP;
 402           break;
 403         default:
 404           /* The target is not running Unix, and its faults/traces do
 405              not map nicely into Unix signals.  Make sure they do not
 406              get confused with Unix signals by numbering them with
 407              values higher than the highest legal Unix signal.  code
 408              in i960_print_fault(), called via PRINT_RANDOM_SIGNAL,
 409              will interpret the value.  */
 410           stop_code += NSIG;
 411           break;
 412         }
 413       WSETSTOP ((*status), stop_code);
 414     }
 415   return inferior_pid;
 416 }
 417
 418 /* Read the remote registers into the block REGS.  */
 419
 420 /* This is the block that ninRegsGet and ninRegsPut handles.  */
 421 struct nindy_regs {
 422   char  local_regs[16 * 4];
 423   char  global_regs[16 * 4];
 424   char  pcw_acw[2 * 4];
 425   char  ip[4];
 426   char  tcw[4];
 427   char  fp_as_double[4 * 8];
 428 };
 429
 430 static void
 431 nindy_fetch_registers(regno)
 432      int regno;
 433 {
 434   struct nindy_regs nindy_regs;
 435   int regnum, inv;
 436   double dub;
 437
 438   immediate_quit++;
 439   ninRegsGet( (char *) &nindy_regs );
 440   immediate_quit--;
 441
 442   memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16*4);
 443   memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16*4);
 444   memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2*4);
 445   memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1*4);
 446   memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1*4);
 447   for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
 448     dub = unpack_double (builtin_type_double,
 449                          &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
 450                          &inv);
 451     /* dub now in host byte order */
 452     double_to_ieee_extended (&ext_format_i960, &dub,
 453                              &registers[REGISTER_BYTE (regnum)]);
 454   }
 455
 456   registers_fetched ();
 457 }
 458
 459 static void
 460 nindy_prepare_to_store()
 461 {
 462   /* Fetch all regs if they aren't already here.  */
 463   read_register_bytes (0, NULL, REGISTER_BYTES);
 464 }
 465
 466 static void
 467 nindy_store_registers(regno)
 468      int regno;
 469 {
 470   struct nindy_regs nindy_regs;
 471   int regnum, inv;
 472   double dub;
 473
 474   memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16*4);
 475   memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16*4);
 476   memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2*4);
 477   memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1*4);
 478   memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1*4);
 479   /* Float regs.  Only works on IEEE_FLOAT hosts.  FIXME!  */
 480   for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
 481     ieee_extended_to_double (&ext_format_i960,
 482                              &registers[REGISTER_BYTE (regnum)], &dub);
 483     /* dub now in host byte order */
 484     /* FIXME-someday, the arguments to unpack_double are backward.
 485        It expects a target double and returns a host; we pass the opposite.
 486        This mostly works but not quite.  */
 487     dub = unpack_double (builtin_type_double, (char *)&dub, &inv);
 488     /* dub now in target byte order */
 489     memcpy (&nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)], &dub, 8);
 490   }
 491
 492   immediate_quit++;
 493   ninRegsPut( (char *) &nindy_regs );
 494   immediate_quit--;
 495 }
 496
 497 /* Read a word from remote address ADDR and return it.
 498  * This goes through the data cache.
 499  */
 500 int
 501 nindy_fetch_word (addr)
 502      CORE_ADDR addr;
 503 {
 504         return dcache_fetch (addr);
 505 }
 506
 507 /* Write a word WORD into remote address ADDR.
 508    This goes through the data cache.  */
 509
 510 void
 511 nindy_store_word (addr, word)
 512      CORE_ADDR addr;
 513      int word;
 514 {
 515         dcache_poke (addr, word);
 516 }
 517
 518 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 519    to debugger memory starting at MYADDR.   Copy to inferior if
 520    WRITE is nonzero.  Returns the length copied.
 521
 522    This is stolen almost directly from infptrace.c's child_xfer_memory,
 523    which also deals with a word-oriented memory interface.  Sometime,
 524    FIXME, rewrite this to not use the word-oriented routines.  */
 525
 526 int
 527 nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
 528      CORE_ADDR memaddr;
 529      char *myaddr;
 530      int len;
 531      int write;
 532      struct target_ops *target;                 /* ignored */
 533 {
 534   register int i;
 535   /* Round starting address down to longword boundary.  */
 536   register CORE_ADDR addr = memaddr & - sizeof (int);
 537   /* Round ending address up; get number of longwords that makes.  */
 538   register int count
 539     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 540   /* Allocate buffer of that many longwords.  */
 541   register int *buffer = (int *) alloca (count * sizeof (int));
 542
 543   if (write)
 544     {
 545       /* Fill start and end extra bytes of buffer with existing memory data.  */
 546
 547       if (addr != memaddr || len < (int)sizeof (int)) {
 548         /* Need part of initial word -- fetch it.  */
 549         buffer[0] = nindy_fetch_word (addr);
 550       }
 551
 552       if (count > 1)            /* FIXME, avoid if even boundary */
 553         {
 554           buffer[count - 1]
 555             = nindy_fetch_word (addr + (count - 1) * sizeof (int));
 556         }
 557
 558       /* Copy data to be written over corresponding part of buffer */
 559
 560       memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 561
 562       /* Write the entire buffer.  */
 563
 564       for (i = 0; i < count; i++, addr += sizeof (int))
 565         {
 566           errno = 0;
 567           nindy_store_word (addr, buffer[i]);
 568           if (errno)
 569             return 0;
 570         }
 571     }
 572   else
 573     {
 574       /* Read all the longwords */
 575       for (i = 0; i < count; i++, addr += sizeof (int))
 576         {
 577           errno = 0;
 578           buffer[i] = nindy_fetch_word (addr);
 579           if (errno)
 580             return 0;
 581           QUIT;
 582         }
 583
 584       /* Copy appropriate bytes out of the buffer.  */
 585       memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 586     }
 587   return len;
 588 }
 589 \f
 590 /* The data cache records all the data read from the remote machine
 591    since the last time it stopped.
 592
 593    Each cache block holds 16 bytes of data
 594    starting at a multiple-of-16 address.  */
 595
 596 #define DCACHE_SIZE 64          /* Number of cache blocks */
 597
 598 struct dcache_block {
 599         struct dcache_block *next, *last;
 600         unsigned int addr;      /* Address for which data is recorded.  */
 601         int data[4];
 602 };
 603
 604 struct dcache_block dcache_free, dcache_valid;
 605
 606 /* Free all the data cache blocks, thus discarding all cached data.  */
 607 static
 608 void
 609 dcache_flush ()
 610 {
 611   register struct dcache_block *db;
 612
 613   while ((db = dcache_valid.next) != &dcache_valid)
 614     {
 615       remque (db);
 616       insque (db, &dcache_free);
 617     }
 618 }
 619
 620 /*
 621  * If addr is present in the dcache, return the address of the block
 622  * containing it.
 623  */
 624 static
 625 struct dcache_block *
 626 dcache_hit (addr)
 627      unsigned int addr;
 628 {
 629   register struct dcache_block *db;
 630
 631   if (addr & 3)
 632     abort ();
 633
 634   /* Search all cache blocks for one that is at this address.  */
 635   db = dcache_valid.next;
 636   while (db != &dcache_valid)
 637     {
 638       if ((addr & 0xfffffff0) == db->addr)
 639         return db;
 640       db = db->next;
 641     }
 642   return NULL;
 643 }
 644
 645 /*  Return the int data at address ADDR in dcache block DC.  */
 646 static
 647 int
 648 dcache_value (db, addr)
 649      struct dcache_block *db;
 650      unsigned int addr;
 651 {
 652   if (addr & 3)
 653     abort ();
 654   return (db->data[(addr>>2)&3]);
 655 }
 656
 657 /* Get a free cache block, put or keep it on the valid list,
 658    and return its address.  The caller should store into the block
 659    the address and data that it describes, then remque it from the
 660    free list and insert it into the valid list.  This procedure
 661    prevents errors from creeping in if a ninMemGet is interrupted
 662    (which used to put garbage blocks in the valid list...).  */
 663 static
 664 struct dcache_block *
 665 dcache_alloc ()
 666 {
 667   register struct dcache_block *db;
 668
 669   if ((db = dcache_free.next) == &dcache_free)
 670     {
 671       /* If we can't get one from the free list, take last valid and put
 672          it on the free list.  */
 673       db = dcache_valid.last;
 674       remque (db);
 675       insque (db, &dcache_free);
 676     }
 677
 678   remque (db);
 679   insque (db, &dcache_valid);
 680   return (db);
 681 }
 682
 683 /* Return the contents of the word at address ADDR in the remote machine,
 684    using the data cache.  */
 685 static
 686 int
 687 dcache_fetch (addr)
 688      CORE_ADDR addr;
 689 {
 690   register struct dcache_block *db;
 691
 692   db = dcache_hit (addr);
 693   if (db == 0)
 694     {
 695       db = dcache_alloc ();
 696       immediate_quit++;
 697       ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16);
 698       immediate_quit--;
 699       db->addr = addr & ~0xf;
 700       remque (db);                      /* Off the free list */
 701       insque (db, &dcache_valid);       /* On the valid list */
 702     }
 703   return (dcache_value (db, addr));
 704 }
 705
 706 /* Write the word at ADDR both in the data cache and in the remote machine.  */
 707 static void
 708 dcache_poke (addr, data)
 709      CORE_ADDR addr;
 710      int data;
 711 {
 712   register struct dcache_block *db;
 713
 714   /* First make sure the word is IN the cache.  DB is its cache block.  */
 715   db = dcache_hit (addr);
 716   if (db == 0)
 717     {
 718       db = dcache_alloc ();
 719       immediate_quit++;
 720       ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16);
 721       immediate_quit--;
 722       db->addr = addr & ~0xf;
 723       remque (db);                      /* Off the free list */
 724       insque (db, &dcache_valid);       /* On the valid list */
 725     }
 726
 727   /* Modify the word in the cache.  */
 728   db->data[(addr>>2)&3] = data;
 729
 730   /* Send the changed word.  */
 731   immediate_quit++;
 732   ninMemPut(addr, (unsigned char *)&data, 4);
 733   immediate_quit--;
 734 }
 735
 736 /* The cache itself. */
 737 struct dcache_block the_cache[DCACHE_SIZE];
 738
 739 /* Initialize the data cache.  */
 740 static void
 741 dcache_init ()
 742 {
 743   register i;
 744   register struct dcache_block *db;
 745
 746   db = the_cache;
 747   dcache_free.next = dcache_free.last = &dcache_free;
 748   dcache_valid.next = dcache_valid.last = &dcache_valid;
 749   for (i=0;i<DCACHE_SIZE;i++,db++)
 750     insque (db, &dcache_free);
 751 }
 752
 753
 754 static void
 755 nindy_create_inferior (execfile, args, env)
 756      char *execfile;
 757      char *args;
 758      char **env;
 759 {
 760   int entry_pt;
 761   int pid;
 762
 763   if (args && *args)
 764     error ("Can't pass arguments to remote NINDY process");
 765
 766   if (execfile == 0 || exec_bfd == 0)
 767     error ("No exec file specified");
 768
 769   entry_pt = (int) bfd_get_start_address (exec_bfd);
 770
 771   pid = 42;
 772
 773 #ifdef CREATE_INFERIOR_HOOK
 774   CREATE_INFERIOR_HOOK (pid);
 775 #endif
 776
 777 /* The "process" (board) is already stopped awaiting our commands, and
 778    the program is already downloaded.  We just set its PC and go.  */
 779
 780   inferior_pid = pid;           /* Needed for wait_for_inferior below */
 781
 782   clear_proceed_status ();
 783
 784   /* Tell wait_for_inferior that we've started a new process.  */
 785   init_wait_for_inferior ();
 786
 787   /* Set up the "saved terminal modes" of the inferior
 788      based on what modes we are starting it with.  */
 789   target_terminal_init ();
 790
 791   /* Install inferior's terminal modes.  */
 792   target_terminal_inferior ();
 793
 794   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 795   proceed ((CORE_ADDR)entry_pt, -1, 0);         /* Let 'er rip... */
 796 }
 797
 798 static void
 799 reset_command(args, from_tty)
 800      char *args;
 801      int from_tty;
 802 {
 803   if (nindy_serial == NULL)
 804     {
 805       error( "No target system to reset -- use 'target nindy' command.");
 806     }
 807   if ( query("Really reset the target system?",0,0) )
 808     {
 809       SERIAL_SEND_BREAK (nindy_serial);
 810       tty_flush (nindy_serial);
 811     }
 812 }
 813
 814 void
 815 nindy_kill (args, from_tty)
 816      char *args;
 817      int from_tty;
 818 {
 819   return;               /* Ignore attempts to kill target system */
 820 }
 821
 822 /* Clean up when a program exits.
 823
 824    The program actually lives on in the remote processor's RAM, and may be
 825    run again without a download.  Don't leave it full of breakpoint
 826    instructions.  */
 827
 828 void
 829 nindy_mourn_inferior ()
 830 {
 831   remove_breakpoints ();
 832   unpush_target (&nindy_ops);
 833   generic_mourn_inferior ();    /* Do all the proper things now */
 834 }
 835 \f
 836 /* Pass the args the way catch_errors wants them.  */
 837 static int
 838 nindy_open_stub (arg)
 839      char *arg;
 840 {
 841   nindy_open (arg, 1);
 842   return 1;
 843 }
 844
 845 static int
 846 load_stub (arg)
 847      char *arg;
 848 {
 849   target_load (arg, 1);
 850   return 1;
 851 }
 852
 853 /* This routine is run as a hook, just before the main command loop is
 854    entered.  If gdb is configured for the i960, but has not had its
 855    nindy target specified yet, this will loop prompting the user to do so.
 856
 857    Unlike the loop provided by Intel, we actually let the user get out
 858    of this with a RETURN.  This is useful when e.g. simply examining
 859    an i960 object file on the host system.  */
 860
 861 void
 862 nindy_before_main_loop ()
 863 {
 864   char ttyname[100];
 865   char *p, *p2;
 866
 867   while (current_target != &nindy_ops) { /* remote tty not specified yet */
 868         if ( instream == stdin ){
 869                 printf("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
 870                 fflush( stdout );
 871         }
 872         fgets( ttyname, sizeof(ttyname)-1, stdin );
 873
 874         /* Strip leading and trailing whitespace */
 875         for ( p = ttyname; isspace(*p); p++ ){
 876                 ;
 877         }
 878         if ( *p == '\0' ){
 879                 return;         /* User just hit spaces or return, wants out */
 880         }
 881         for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
 882                 ;
 883         }
 884         *p2= '\0';
 885         if ( STREQ("quit",p) ){
 886                 exit(1);
 887         }
 888
 889         if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
 890           {
 891             /* Now that we have a tty open for talking to the remote machine,
 892                download the executable file if one was specified.  */
 893             if (exec_bfd)
 894               {
 895                 catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
 896                               RETURN_MASK_ALL);
 897               }
 898           }
 899   }
 900 }
 901 \f
 902 /* Define the target subroutine names */
 903
 904 struct target_ops nindy_ops = {
 905         "nindy", "Remote serial target in i960 NINDY-specific protocol",
 906         "Use a remote i960 system running NINDY connected by a serial line.\n\
 907 Specify the name of the device the serial line is connected to.\n\
 908 The speed (baud rate), whether to use the old NINDY protocol,\n\
 909 and whether to send a break on startup, are controlled by options\n\
 910 specified when you started GDB.",
 911         nindy_open, nindy_close,
 912         0,
 913         nindy_detach,
 914         nindy_resume,
 915         nindy_wait,
 916         nindy_fetch_registers, nindy_store_registers,
 917         nindy_prepare_to_store,
 918         nindy_xfer_inferior_memory, nindy_files_info,
 919         0, 0, /* insert_breakpoint, remove_breakpoint, */
 920         0, 0, 0, 0, 0,  /* Terminal crud */
 921         nindy_kill,
 922         generic_load,
 923         0, /* lookup_symbol */
 924         nindy_create_inferior,
 925         nindy_mourn_inferior,
 926         0,              /* can_run */
 927         0, /* notice_signals */
 928         process_stratum, 0, /* next */
 929         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
 930         0, 0,                   /* Section pointers */
 931         OPS_MAGIC,              /* Always the last thing */
 932 };
 933
 934 void
 935 _initialize_nindy ()
 936 {
 937   add_target (&nindy_ops);
 938   add_com ("reset", class_obscure, reset_command,
 939            "Send a 'break' to the remote target system.\n\
 940 Only useful if the target has been equipped with a circuit\n\
 941 to perform a hard reset when a break is detected.");
 942 }