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