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 int
 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   return 0;
 501 }
 502
 503 static void
 504 nindy_prepare_to_store()
 505 {
 506   nindy_fetch_registers(-1);
 507 }
 508
 509 static int
 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   return 0;
 540 }
 541
 542 /* Read a word from remote address ADDR and return it.
 543  * This goes through the data cache.
 544  */
 545 int
 546 nindy_fetch_word (addr)
 547      CORE_ADDR addr;
 548 {
 549         return dcache_fetch (addr);
 550 }
 551
 552 /* Write a word WORD into remote address ADDR.
 553    This goes through the data cache.  */
 554
 555 void
 556 nindy_store_word (addr, word)
 557      CORE_ADDR addr;
 558      int word;
 559 {
 560         dcache_poke (addr, word);
 561 }
 562
 563 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 564    to debugger memory starting at MYADDR.   Copy to inferior if
 565    WRITE is nonzero.  Returns the length copied.
 566
 567    This is stolen almost directly from infptrace.c's child_xfer_memory,
 568    which also deals with a word-oriented memory interface.  Sometime,
 569    FIXME, rewrite this to not use the word-oriented routines.  */
 570
 571 int
 572 nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
 573      CORE_ADDR memaddr;
 574      char *myaddr;
 575      int len;
 576      int write;
 577      struct target_ops *target;                 /* ignored */
 578 {
 579   register int i;
 580   /* Round starting address down to longword boundary.  */
 581   register CORE_ADDR addr = memaddr & - sizeof (int);
 582   /* Round ending address up; get number of longwords that makes.  */
 583   register int count
 584     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
 585   /* Allocate buffer of that many longwords.  */
 586   register int *buffer = (int *) alloca (count * sizeof (int));
 587
 588   if (write)
 589     {
 590       /* Fill start and end extra bytes of buffer with existing memory data.  */
 591
 592       if (addr != memaddr || len < (int)sizeof (int)) {
 593         /* Need part of initial word -- fetch it.  */
 594         buffer[0] = nindy_fetch_word (addr);
 595       }
 596
 597       if (count > 1)            /* FIXME, avoid if even boundary */
 598         {
 599           buffer[count - 1]
 600             = nindy_fetch_word (addr + (count - 1) * sizeof (int));
 601         }
 602
 603       /* Copy data to be written over corresponding part of buffer */
 604
 605       bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
 606
 607       /* Write the entire buffer.  */
 608
 609       for (i = 0; i < count; i++, addr += sizeof (int))
 610         {
 611           errno = 0;
 612           nindy_store_word (addr, buffer[i]);
 613           if (errno)
 614             return 0;
 615         }
 616     }
 617   else
 618     {
 619       /* Read all the longwords */
 620       for (i = 0; i < count; i++, addr += sizeof (int))
 621         {
 622           errno = 0;
 623           buffer[i] = nindy_fetch_word (addr);
 624           if (errno)
 625             return 0;
 626           QUIT;
 627         }
 628
 629       /* Copy appropriate bytes out of the buffer.  */
 630       bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
 631     }
 632   return len;
 633 }
 634 \f
 635 /* The data cache records all the data read from the remote machine
 636    since the last time it stopped.
 637
 638    Each cache block holds 16 bytes of data
 639    starting at a multiple-of-16 address.  */
 640
 641 #define DCACHE_SIZE 64          /* Number of cache blocks */
 642
 643 struct dcache_block {
 644         struct dcache_block *next, *last;
 645         unsigned int addr;      /* Address for which data is recorded.  */
 646         int data[4];
 647 };
 648
 649 struct dcache_block dcache_free, dcache_valid;
 650
 651 /* Free all the data cache blocks, thus discarding all cached data.  */
 652 static
 653 void
 654 dcache_flush ()
 655 {
 656   register struct dcache_block *db;
 657
 658   while ((db = dcache_valid.next) != &dcache_valid)
 659     {
 660       remque (db);
 661       insque (db, &dcache_free);
 662     }
 663 }
 664
 665 /*
 666  * If addr is present in the dcache, return the address of the block
 667  * containing it.
 668  */
 669 static
 670 struct dcache_block *
 671 dcache_hit (addr)
 672      unsigned int addr;
 673 {
 674   register struct dcache_block *db;
 675
 676   if (addr & 3)
 677     abort ();
 678
 679   /* Search all cache blocks for one that is at this address.  */
 680   db = dcache_valid.next;
 681   while (db != &dcache_valid)
 682     {
 683       if ((addr & 0xfffffff0) == db->addr)
 684         return db;
 685       db = db->next;
 686     }
 687   return NULL;
 688 }
 689
 690 /*  Return the int data at address ADDR in dcache block DC.  */
 691 static
 692 int
 693 dcache_value (db, addr)
 694      struct dcache_block *db;
 695      unsigned int addr;
 696 {
 697   if (addr & 3)
 698     abort ();
 699   return (db->data[(addr>>2)&3]);
 700 }
 701
 702 /* Get a free cache block, put or keep it on the valid list,
 703    and return its address.  The caller should store into the block
 704    the address and data that it describes, then remque it from the
 705    free list and insert it into the valid list.  This procedure
 706    prevents errors from creeping in if a ninMemGet is interrupted
 707    (which used to put garbage blocks in the valid list...).  */
 708 static
 709 struct dcache_block *
 710 dcache_alloc ()
 711 {
 712   register struct dcache_block *db;
 713
 714   if ((db = dcache_free.next) == &dcache_free)
 715     {
 716       /* If we can't get one from the free list, take last valid and put
 717          it on the free list.  */
 718       db = dcache_valid.last;
 719       remque (db);
 720       insque (db, &dcache_free);
 721     }
 722
 723   remque (db);
 724   insque (db, &dcache_valid);
 725   return (db);
 726 }
 727
 728 /* Return the contents of the word at address ADDR in the remote machine,
 729    using the data cache.  */
 730 static
 731 int
 732 dcache_fetch (addr)
 733      CORE_ADDR addr;
 734 {
 735   register struct dcache_block *db;
 736
 737   db = dcache_hit (addr);
 738   if (db == 0)
 739     {
 740       db = dcache_alloc ();
 741       immediate_quit++;
 742       ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16);
 743       immediate_quit--;
 744       db->addr = addr & ~0xf;
 745       remque (db);                      /* Off the free list */
 746       insque (db, &dcache_valid);       /* On the valid list */
 747     }
 748   return (dcache_value (db, addr));
 749 }
 750
 751 /* Write the word at ADDR both in the data cache and in the remote machine.  */
 752 static void
 753 dcache_poke (addr, data)
 754      CORE_ADDR addr;
 755      int data;
 756 {
 757   register struct dcache_block *db;
 758
 759   /* First make sure the word is IN the cache.  DB is its cache block.  */
 760   db = dcache_hit (addr);
 761   if (db == 0)
 762     {
 763       db = dcache_alloc ();
 764       immediate_quit++;
 765       ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16);
 766       immediate_quit--;
 767       db->addr = addr & ~0xf;
 768       remque (db);                      /* Off the free list */
 769       insque (db, &dcache_valid);       /* On the valid list */
 770     }
 771
 772   /* Modify the word in the cache.  */
 773   db->data[(addr>>2)&3] = data;
 774
 775   /* Send the changed word.  */
 776   immediate_quit++;
 777   ninMemPut(addr, (unsigned char *)&data, 4);
 778   immediate_quit--;
 779 }
 780
 781 /* The cache itself. */
 782 struct dcache_block the_cache[DCACHE_SIZE];
 783
 784 /* Initialize the data cache.  */
 785 static void
 786 dcache_init ()
 787 {
 788   register i;
 789   register struct dcache_block *db;
 790
 791   db = the_cache;
 792   dcache_free.next = dcache_free.last = &dcache_free;
 793   dcache_valid.next = dcache_valid.last = &dcache_valid;
 794   for (i=0;i<DCACHE_SIZE;i++,db++)
 795     insque (db, &dcache_free);
 796 }
 797
 798
 799 static void
 800 nindy_create_inferior (execfile, args, env)
 801      char *execfile;
 802      char *args;
 803      char **env;
 804 {
 805   int entry_pt;
 806   int pid;
 807
 808   if (args && *args)
 809     error ("Can't pass arguments to remote NINDY process");
 810
 811   if (execfile == 0 || exec_bfd == 0)
 812     error ("No exec file specified");
 813
 814   entry_pt = (int) bfd_get_start_address (exec_bfd);
 815
 816   pid = 42;
 817
 818 #ifdef CREATE_INFERIOR_HOOK
 819   CREATE_INFERIOR_HOOK (pid);
 820 #endif
 821
 822 /* The "process" (board) is already stopped awaiting our commands, and
 823    the program is already downloaded.  We just set its PC and go.  */
 824
 825   inferior_pid = pid;           /* Needed for wait_for_inferior below */
 826
 827   clear_proceed_status ();
 828
 829   /* Tell wait_for_inferior that we've started a new process.  */
 830   init_wait_for_inferior ();
 831
 832   /* Set up the "saved terminal modes" of the inferior
 833      based on what modes we are starting it with.  */
 834   target_terminal_init ();
 835
 836   /* Install inferior's terminal modes.  */
 837   target_terminal_inferior ();
 838
 839   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 840   proceed ((CORE_ADDR)entry_pt, -1, 0);         /* Let 'er rip... */
 841 }
 842
 843 static void
 844 reset_command(args, from_tty)
 845      char *args;
 846      int from_tty;
 847 {
 848         if ( !nindy_fd ){
 849             error( "No target system to reset -- use 'target nindy' command.");
 850         }
 851         if ( query("Really reset the target system?",0,0) ){
 852                 send_break( nindy_fd );
 853                 tty_flush( nindy_fd );
 854         }
 855 }
 856
 857 void
 858 nindy_kill (args, from_tty)
 859      char *args;
 860      int from_tty;
 861 {
 862   return;               /* Ignore attempts to kill target system */
 863 }
 864
 865 /* Clean up when a program exits.
 866
 867    The program actually lives on in the remote processor's RAM, and may be
 868    run again without a download.  Don't leave it full of breakpoint
 869    instructions.  */
 870
 871 void
 872 nindy_mourn_inferior ()
 873 {
 874   remove_breakpoints ();
 875   generic_mourn_inferior ();    /* Do all the proper things now */
 876 }
 877 \f
 878 /* This routine is run as a hook, just before the main command loop is
 879    entered.  If gdb is configured for the i960, but has not had its
 880    nindy target specified yet, this will loop prompting the user to do so.
 881
 882    Unlike the loop provided by Intel, we actually let the user get out
 883    of this with a RETURN.  This is useful when e.g. simply examining
 884    an i960 object file on the host system.  */
 885
 886 nindy_before_main_loop ()
 887 {
 888   char ttyname[100];
 889   char *p, *p2;
 890
 891   setjmp(to_top_level);
 892   while (current_target != &nindy_ops) { /* remote tty not specified yet */
 893         if ( instream == stdin ){
 894                 printf("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
 895                 fflush( stdout );
 896         }
 897         fgets( ttyname, sizeof(ttyname)-1, stdin );
 898
 899         /* Strip leading and trailing whitespace */
 900         for ( p = ttyname; isspace(*p); p++ ){
 901                 ;
 902         }
 903         if ( *p == '\0' ){
 904                 return;         /* User just hit spaces or return, wants out */
 905         }
 906         for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
 907                 ;
 908         }
 909         *p2= '\0';
 910         if ( !strcmp("quit",p) ){
 911                 exit(1);
 912         }
 913
 914         nindy_open( p, 1 );
 915
 916         /* Now that we have a tty open for talking to the remote machine,
 917            download the executable file if one was specified.  */
 918         if ( !setjmp(to_top_level) && exec_bfd ) {
 919               target_load (bfd_get_filename (exec_bfd), 1);
 920         }
 921   }
 922 }
 923 \f
 924 /* Define the target subroutine names */
 925
 926 struct target_ops nindy_ops = {
 927         "nindy", "Remote serial target in i960 NINDY-specific protocol",
 928         "Use a remote i960 system running NINDY connected by a serial line.\n\
 929 Specify the name of the device the serial line is connected to.\n\
 930 The speed (baud rate), whether to use the old NINDY protocol,\n\
 931 and whether to send a break on startup, are controlled by options\n\
 932 specified when you started GDB.",
 933         nindy_open, nindy_close,
 934         0, nindy_detach, nindy_resume, nindy_wait,
 935         nindy_fetch_registers, nindy_store_registers,
 936         nindy_prepare_to_store, 0, 0, /* conv_from, conv_to */
 937         nindy_xfer_inferior_memory, nindy_files_info,
 938         0, 0, /* insert_breakpoint, remove_breakpoint, */
 939         0, 0, 0, 0, 0,  /* Terminal crud */
 940         nindy_kill,
 941         nindy_load,
 942         0, /* lookup_symbol */
 943         nindy_create_inferior,
 944         nindy_mourn_inferior,
 945         process_stratum, 0, /* next */
 946         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
 947         0, 0,                   /* Section pointers */
 948         OPS_MAGIC,              /* Always the last thing */
 949 };
 950
 951 void
 952 _initialize_nindy ()
 953 {
 954   add_target (&nindy_ops);
 955   add_com ("reset", class_obscure, reset_command,
 956            "Send a 'break' to the remote target system.\n\
 957 Only useful if the target has been equipped with a circuit\n\
 958 to perform a hard reset when a break is detected.");
 959 }