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