gdb/remote-nindy.c

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