gdb/remote-nindy.c

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