home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gdb-4.9 / gdb / remote-nindy.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-12  |  25.4 KB  |  980 lines
  1. /* Memory-access and commands for remote NINDY process, for GDB.
  2.    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  3.    Contributed by Intel Corporation.  Modified from remote.c by Chris Benenati.
  4.  
  5. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  6. WARRANTY.  No author or distributor accepts responsibility to anyone
  7. for the consequences of using it or for whether it serves any
  8. particular purpose or works at all, unless he says so in writing.
  9. Refer to the GDB General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute GDB,
  12. but only under the conditions described in the GDB General Public
  13. License.  A copy of this license is supposed to have been given to you
  14. along with GDB so you can know your rights and responsibilities.  It
  15. should be in a file named COPYING.  Among other things, the copyright
  16. notice and this notice must be preserved on all copies.
  17.  
  18. In other words, go ahead and share GDB, but don't try to stop
  19. anyone else from sharing it farther.  Help stamp out software hoarding!
  20. */
  21.  
  22. /*
  23. Except for the data cache routines, this file bears little resemblence
  24. to remote.c.  A new (although similar) protocol has been specified, and
  25. portions of the code are entirely dependent on having an i80960 with a
  26. NINDY ROM monitor at the other end of the line.
  27. */
  28.  
  29. /*****************************************************************************
  30.  *
  31.  * REMOTE COMMUNICATION PROTOCOL BETWEEN GDB960 AND THE NINDY ROM MONITOR.
  32.  *
  33.  *
  34.  * MODES OF OPERATION
  35.  * ----- -- ---------
  36.  *    
  37.  * As far as NINDY is concerned, GDB is always in one of two modes: command
  38.  * mode or passthrough mode.
  39.  *
  40.  * In command mode (the default) pre-defined packets containing requests
  41.  * are sent by GDB to NINDY.  NINDY never talks except in reponse to a request.
  42.  *
  43.  * Once the the user program is started, GDB enters passthrough mode, to give
  44.  * the user program access to the terminal.  GDB remains in this mode until
  45.  * NINDY indicates that the program has stopped.
  46.  *
  47.  *
  48.  * PASSTHROUGH MODE
  49.  * ----------- ----
  50.  *
  51.  * GDB writes all input received from the keyboard directly to NINDY, and writes
  52.  * all characters received from NINDY directly to the monitor.
  53.  *
  54.  * Keyboard input is neither buffered nor echoed to the monitor.
  55.  *
  56.  * GDB remains in passthrough mode until NINDY sends a single ^P character,
  57.  * to indicate that the user process has stopped.
  58.  *
  59.  * Note:
  60.  *    GDB assumes NINDY performs a 'flushreg' when the user program stops.
  61.  *
  62.  *
  63.  * COMMAND MODE
  64.  * ------- ----
  65.  *
  66.  * All info (except for message ack and nak) is transferred between gdb
  67.  * and the remote processor in messages of the following format:
  68.  *
  69.  *        <info>#<checksum>
  70.  *
  71.  * where 
  72.  *    #    is a literal character
  73.  *
  74.  *    <info>    ASCII information;  all numeric information is in the
  75.  *        form of hex digits ('0'-'9' and lowercase 'a'-'f').
  76.  *
  77.  *    <checksum>
  78.  *        is a pair of ASCII hex digits representing an 8-bit
  79.  *        checksum formed by adding together each of the
  80.  *        characters in <info>.
  81.  *
  82.  * The receiver of a message always sends a single character to the sender
  83.  * to indicate that the checksum was good ('+') or bad ('-');  the sender
  84.  * re-transmits the entire message over until a '+' is received.
  85.  *
  86.  * In response to a command NINDY always sends back either data or
  87.  * a result code of the form "Xnn", where "nn" are hex digits and "X00"
  88.  * means no errors.  (Exceptions: the "s" and "c" commands don't respond.)
  89.  *
  90.  * SEE THE HEADER OF THE FILE "gdb.c" IN THE NINDY MONITOR SOURCE CODE FOR A
  91.  * FULL DESCRIPTION OF LEGAL COMMANDS.
  92.  *
  93.  * SEE THE FILE "stop.h" IN THE NINDY MONITOR SOURCE CODE FOR A LIST
  94.  * OF STOP CODES.
  95.  *
  96.  ******************************************************************************/
  97.  
  98. #include "defs.h"
  99. #include <signal.h>
  100. #include <sys/types.h>
  101. #include <setjmp.h>
  102.  
  103. #include "frame.h"
  104. #include "inferior.h"
  105. #include "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.  
  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.  
  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.  
  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.  
  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 (-1);
  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, 
  433.                              (char *)&ip_value);
  434.                     supply_register (FP_REGNUM, 
  435.                              (char *)&fp_value);
  436.                     supply_register (SP_REGNUM, 
  437.                              (char *)&sp_value);
  438.                     break;
  439.                 }
  440.             }
  441.         }
  442.     }
  443.  
  444.     signal( SIGINT, old_ctrlc );
  445. #ifdef SIGTSTP
  446.     signal( SIGTSTP, old_ctrlz );
  447. #endif
  448.     restore_tty();
  449.  
  450.     if ( stop_exit ){            /* User program exited */
  451.         WSETEXIT( (*status), stop_code );
  452.     } else {                /* Fault or trace */
  453.         switch (stop_code){
  454.         case STOP_GDB_BPT:
  455.         case TRACE_STEP:
  456.             /* Make it look like a VAX trace trap */
  457.             stop_code = SIGTRAP;
  458.             break;
  459.         default:
  460.             /* The target is not running Unix, and its
  461.                faults/traces do not map nicely into Unix signals.
  462.                Make sure they do not get confused with Unix signals
  463.                by numbering them with values higher than the highest
  464.                legal Unix signal.  code in i960_print_fault(),
  465.                called via PRINT_RANDOM_SIGNAL, will interpret the
  466.                value.  */
  467.             stop_code += NSIG;
  468.             break;
  469.         }
  470.         WSETSTOP( (*status), stop_code );
  471.     }
  472.     return inferior_pid;
  473. }
  474.  
  475. /* Read the remote registers into the block REGS.  */
  476.  
  477. /* This is the block that ninRegsGet and ninRegsPut handles.  */
  478. struct nindy_regs {
  479.   char    local_regs[16 * 4];
  480.   char    global_regs[16 * 4];
  481.   char    pcw_acw[2 * 4];
  482.   char    ip[4];
  483.   char    tcw[4];
  484.   char    fp_as_double[4 * 8];
  485. };
  486.  
  487. static void
  488. nindy_fetch_registers(regno)
  489.      int regno;
  490. {
  491.   struct nindy_regs nindy_regs;
  492.   int regnum, inv;
  493.   double dub;
  494.  
  495.   immediate_quit++;
  496.   ninRegsGet( (char *) &nindy_regs );
  497.   immediate_quit--;
  498.  
  499.   bcopy (nindy_regs.local_regs, ®isters[REGISTER_BYTE (R0_REGNUM)], 16*4);
  500.   bcopy (nindy_regs.global_regs, ®isters[REGISTER_BYTE (G0_REGNUM)], 16*4);
  501.   bcopy (nindy_regs.pcw_acw, ®isters[REGISTER_BYTE (PCW_REGNUM)], 2*4);
  502.   bcopy (nindy_regs.ip, ®isters[REGISTER_BYTE (IP_REGNUM)], 1*4);
  503.   bcopy (nindy_regs.tcw, ®isters[REGISTER_BYTE (TCW_REGNUM)], 1*4);
  504.   for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
  505.     dub = unpack_double (builtin_type_double,
  506.              &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
  507.              &inv);
  508.     /* dub now in host byte order */
  509.     double_to_ieee_extended (&ext_format_i960, &dub,
  510.                  ®isters[REGISTER_BYTE (regnum)]);
  511.   }
  512.  
  513.   registers_fetched ();
  514. }
  515.  
  516. static void
  517. nindy_prepare_to_store()
  518. {
  519.   /* Fetch all regs if they aren't already here.  */
  520.   read_register_bytes (0, NULL, REGISTER_BYTES);
  521. }
  522.  
  523. static void
  524. nindy_store_registers(regno)
  525.      int regno;
  526. {
  527.   struct nindy_regs nindy_regs;
  528.   int regnum, inv;
  529.   double dub;
  530.  
  531.   bcopy (®isters[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs,  16*4);
  532.   bcopy (®isters[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16*4);
  533.   bcopy (®isters[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw,     2*4);
  534.   bcopy (®isters[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip,           1*4);
  535.   bcopy (®isters[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw,         1*4);
  536.   /* Float regs.  Only works on IEEE_FLOAT hosts.  FIXME!  */
  537.   for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
  538.     ieee_extended_to_double (&ext_format_i960,
  539.                  ®isters[REGISTER_BYTE (regnum)], &dub);
  540.     /* dub now in host byte order */
  541.     /* FIXME-someday, the arguments to unpack_double are backward.
  542.        It expects a target double and returns a host; we pass the opposite.
  543.        This mostly works but not quite.  */
  544.     dub = unpack_double (builtin_type_double, (char *)&dub, &inv);
  545.     /* dub now in target byte order */
  546.     bcopy ((char *)&dub, &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
  547.     8);
  548.   }
  549.  
  550.   immediate_quit++;
  551.   ninRegsPut( (char *) &nindy_regs );
  552.   immediate_quit--;
  553. }
  554.  
  555. /* Read a word from remote address ADDR and return it.
  556.  * This goes through the data cache.
  557.  */
  558. int
  559. nindy_fetch_word (addr)
  560.      CORE_ADDR addr;
  561. {
  562.     return dcache_fetch (addr);
  563. }
  564.  
  565. /* Write a word WORD into remote address ADDR.
  566.    This goes through the data cache.  */
  567.  
  568. void
  569. nindy_store_word (addr, word)
  570.      CORE_ADDR addr;
  571.      int word;
  572. {
  573.     dcache_poke (addr, word);
  574. }
  575.  
  576. /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
  577.    to debugger memory starting at MYADDR.   Copy to inferior if
  578.    WRITE is nonzero.  Returns the length copied.
  579.  
  580.    This is stolen almost directly from infptrace.c's child_xfer_memory,
  581.    which also deals with a word-oriented memory interface.  Sometime,
  582.    FIXME, rewrite this to not use the word-oriented routines.  */
  583.  
  584. int
  585. nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
  586.      CORE_ADDR memaddr;
  587.      char *myaddr;
  588.      int len;
  589.      int write;
  590.      struct target_ops *target;            /* ignored */
  591. {
  592.   register int i;
  593.   /* Round starting address down to longword boundary.  */
  594.   register CORE_ADDR addr = memaddr & - sizeof (int);
  595.   /* Round ending address up; get number of longwords that makes.  */
  596.   register int count
  597.     = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
  598.   /* Allocate buffer of that many longwords.  */
  599.   register int *buffer = (int *) alloca (count * sizeof (int));
  600.  
  601.   if (write)
  602.     {
  603.       /* Fill start and end extra bytes of buffer with existing memory data.  */
  604.  
  605.       if (addr != memaddr || len < (int)sizeof (int)) {
  606.     /* Need part of initial word -- fetch it.  */
  607.         buffer[0] = nindy_fetch_word (addr);
  608.       }
  609.  
  610.       if (count > 1)        /* FIXME, avoid if even boundary */
  611.     {
  612.       buffer[count - 1]
  613.         = nindy_fetch_word (addr + (count - 1) * sizeof (int));
  614.     }
  615.  
  616.       /* Copy data to be written over corresponding part of buffer */
  617.  
  618.       bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
  619.  
  620.       /* Write the entire buffer.  */
  621.  
  622.       for (i = 0; i < count; i++, addr += sizeof (int))
  623.     {
  624.       errno = 0;
  625.       nindy_store_word (addr, buffer[i]);
  626.       if (errno)
  627.         return 0;
  628.     }
  629.     }
  630.   else
  631.     {
  632.       /* Read all the longwords */
  633.       for (i = 0; i < count; i++, addr += sizeof (int))
  634.     {
  635.       errno = 0;
  636.       buffer[i] = nindy_fetch_word (addr);
  637.       if (errno)
  638.         return 0;
  639.       QUIT;
  640.     }
  641.  
  642.       /* Copy appropriate bytes out of the buffer.  */
  643.       bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
  644.     }
  645.   return len;
  646. }
  647.  
  648. /* The data cache records all the data read from the remote machine
  649.    since the last time it stopped.
  650.  
  651.    Each cache block holds 16 bytes of data
  652.    starting at a multiple-of-16 address.  */
  653.  
  654. #define DCACHE_SIZE 64        /* Number of cache blocks */
  655.  
  656. struct dcache_block {
  657.     struct dcache_block *next, *last;
  658.     unsigned int addr;    /* Address for which data is recorded.  */
  659.     int data[4];
  660. };
  661.  
  662. struct dcache_block dcache_free, dcache_valid;
  663.  
  664. /* Free all the data cache blocks, thus discarding all cached data.  */ 
  665. static
  666. void
  667. dcache_flush ()
  668. {
  669.   register struct dcache_block *db;
  670.  
  671.   while ((db = dcache_valid.next) != &dcache_valid)
  672.     {
  673.       remque (db);
  674.       insque (db, &dcache_free);
  675.     }
  676. }
  677.  
  678. /*
  679.  * If addr is present in the dcache, return the address of the block
  680.  * containing it.
  681.  */
  682. static
  683. struct dcache_block *
  684. dcache_hit (addr)
  685.      unsigned int addr;
  686. {
  687.   register struct dcache_block *db;
  688.  
  689.   if (addr & 3)
  690.     abort ();
  691.  
  692.   /* Search all cache blocks for one that is at this address.  */
  693.   db = dcache_valid.next;
  694.   while (db != &dcache_valid)
  695.     {
  696.       if ((addr & 0xfffffff0) == db->addr)
  697.     return db;
  698.       db = db->next;
  699.     }
  700.   return NULL;
  701. }
  702.  
  703. /*  Return the int data at address ADDR in dcache block DC.  */
  704. static
  705. int
  706. dcache_value (db, addr)
  707.      struct dcache_block *db;
  708.      unsigned int addr;
  709. {
  710.   if (addr & 3)
  711.     abort ();
  712.   return (db->data[(addr>>2)&3]);
  713. }
  714.  
  715. /* Get a free cache block, put or keep it on the valid list,
  716.    and return its address.  The caller should store into the block
  717.    the address and data that it describes, then remque it from the
  718.    free list and insert it into the valid list.  This procedure
  719.    prevents errors from creeping in if a ninMemGet is interrupted
  720.    (which used to put garbage blocks in the valid list...).  */
  721. static
  722. struct dcache_block *
  723. dcache_alloc ()
  724. {
  725.   register struct dcache_block *db;
  726.  
  727.   if ((db = dcache_free.next) == &dcache_free)
  728.     {
  729.       /* If we can't get one from the free list, take last valid and put
  730.      it on the free list.  */
  731.       db = dcache_valid.last;
  732.       remque (db);
  733.       insque (db, &dcache_free);
  734.     }
  735.  
  736.   remque (db);
  737.   insque (db, &dcache_valid);
  738.   return (db);
  739. }
  740.  
  741. /* Return the contents of the word at address ADDR in the remote machine,
  742.    using the data cache.  */
  743. static
  744. int
  745. dcache_fetch (addr)
  746.      CORE_ADDR addr;
  747. {
  748.   register struct dcache_block *db;
  749.  
  750.   db = dcache_hit (addr);
  751.   if (db == 0)
  752.     {
  753.       db = dcache_alloc ();
  754.       immediate_quit++;
  755.       ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16);
  756.       immediate_quit--;
  757.       db->addr = addr & ~0xf;
  758.       remque (db);            /* Off the free list */
  759.       insque (db, &dcache_valid);    /* On the valid list */
  760.     }
  761.   return (dcache_value (db, addr));
  762. }
  763.  
  764. /* Write the word at ADDR both in the data cache and in the remote machine.  */
  765. static void
  766. dcache_poke (addr, data)
  767.      CORE_ADDR addr;
  768.      int data;
  769. {
  770.   register struct dcache_block *db;
  771.  
  772.   /* First make sure the word is IN the cache.  DB is its cache block.  */
  773.   db = dcache_hit (addr);
  774.   if (db == 0)
  775.     {
  776.       db = dcache_alloc ();
  777.       immediate_quit++;
  778.       ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16);
  779.       immediate_quit--;
  780.       db->addr = addr & ~0xf;
  781.       remque (db);            /* Off the free list */
  782.       insque (db, &dcache_valid);    /* On the valid list */
  783.     }
  784.  
  785.   /* Modify the word in the cache.  */
  786.   db->data[(addr>>2)&3] = data;
  787.  
  788.   /* Send the changed word.  */
  789.   immediate_quit++;
  790.   ninMemPut(addr, (unsigned char *)&data, 4);
  791.   immediate_quit--;
  792. }
  793.  
  794. /* The cache itself. */
  795. struct dcache_block the_cache[DCACHE_SIZE];
  796.  
  797. /* Initialize the data cache.  */
  798. static void
  799. dcache_init ()
  800. {
  801.   register i;
  802.   register struct dcache_block *db;
  803.  
  804.   db = the_cache;
  805.   dcache_free.next = dcache_free.last = &dcache_free;
  806.   dcache_valid.next = dcache_valid.last = &dcache_valid;
  807.   for (i=0;i<DCACHE_SIZE;i++,db++)
  808.     insque (db, &dcache_free);
  809. }
  810.  
  811.  
  812. static void
  813. nindy_create_inferior (execfile, args, env)
  814.      char *execfile;
  815.      char *args;
  816.      char **env;
  817. {
  818.   int entry_pt;
  819.   int pid;
  820.  
  821.   if (args && *args)
  822.     error ("Can't pass arguments to remote NINDY process");
  823.  
  824.   if (execfile == 0 || exec_bfd == 0)
  825.     error ("No exec file specified");
  826.  
  827.   entry_pt = (int) bfd_get_start_address (exec_bfd);
  828.  
  829.   pid = 42;
  830.  
  831. #ifdef CREATE_INFERIOR_HOOK
  832.   CREATE_INFERIOR_HOOK (pid);
  833. #endif  
  834.  
  835. /* The "process" (board) is already stopped awaiting our commands, and
  836.    the program is already downloaded.  We just set its PC and go.  */
  837.  
  838.   inferior_pid = pid;        /* Needed for wait_for_inferior below */
  839.  
  840.   clear_proceed_status ();
  841.  
  842.   /* Tell wait_for_inferior that we've started a new process.  */
  843.   init_wait_for_inferior ();
  844.  
  845.   /* Set up the "saved terminal modes" of the inferior
  846.      based on what modes we are starting it with.  */
  847.   target_terminal_init ();
  848.  
  849.   /* Install inferior's terminal modes.  */
  850.   target_terminal_inferior ();
  851.  
  852.   /* insert_step_breakpoint ();  FIXME, do we need this?  */
  853.   proceed ((CORE_ADDR)entry_pt, -1, 0);        /* Let 'er rip... */
  854. }
  855.  
  856. static void
  857. reset_command(args, from_tty)
  858.      char *args;
  859.      int from_tty;
  860. {
  861.     if ( !nindy_fd ){
  862.         error( "No target system to reset -- use 'target nindy' command.");
  863.     }
  864.     if ( query("Really reset the target system?",0,0) ){
  865.         send_break( nindy_fd );
  866.         tty_flush( nindy_fd );
  867.     }
  868. }
  869.  
  870. void
  871. nindy_kill (args, from_tty)
  872.      char *args;
  873.      int from_tty;
  874. {
  875.   return;        /* Ignore attempts to kill target system */
  876. }
  877.  
  878. /* Clean up when a program exits.
  879.  
  880.    The program actually lives on in the remote processor's RAM, and may be
  881.    run again without a download.  Don't leave it full of breakpoint
  882.    instructions.  */
  883.  
  884. void
  885. nindy_mourn_inferior ()
  886. {
  887.   remove_breakpoints ();
  888.   unpush_target (&nindy_ops);
  889.   generic_mourn_inferior ();    /* Do all the proper things now */
  890. }
  891.  
  892. /* This routine is run as a hook, just before the main command loop is
  893.    entered.  If gdb is configured for the i960, but has not had its
  894.    nindy target specified yet, this will loop prompting the user to do so.
  895.  
  896.    Unlike the loop provided by Intel, we actually let the user get out
  897.    of this with a RETURN.  This is useful when e.g. simply examining
  898.    an i960 object file on the host system.  */
  899.  
  900. void
  901. nindy_before_main_loop ()
  902. {
  903.   char ttyname[100];
  904.   char *p, *p2;
  905.  
  906.   setjmp(to_top_level);
  907.   while (current_target != &nindy_ops) { /* remote tty not specified yet */
  908.     if ( instream == stdin ){
  909.         printf("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
  910.         fflush( stdout );
  911.     }
  912.     fgets( ttyname, sizeof(ttyname)-1, stdin );
  913.  
  914.     /* Strip leading and trailing whitespace */
  915.     for ( p = ttyname; isspace(*p); p++ ){
  916.         ;
  917.     }
  918.     if ( *p == '\0' ){
  919.         return;        /* User just hit spaces or return, wants out */
  920.     }
  921.     for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
  922.         ;
  923.     }
  924.     *p2= '\0';
  925.     if ( STREQ("quit",p) ){
  926.         exit(1);
  927.     }
  928.  
  929.     nindy_open( p, 1 );
  930.  
  931.     /* Now that we have a tty open for talking to the remote machine,
  932.        download the executable file if one was specified.  */
  933.     if ( !setjmp(to_top_level) && exec_bfd ) {
  934.           target_load (bfd_get_filename (exec_bfd), 1);
  935.     }
  936.   }
  937. }
  938.  
  939. /* Define the target subroutine names */
  940.  
  941. struct target_ops nindy_ops = {
  942.     "nindy", "Remote serial target in i960 NINDY-specific protocol",
  943.     "Use a remote i960 system running NINDY connected by a serial line.\n\
  944. Specify the name of the device the serial line is connected to.\n\
  945. The speed (baud rate), whether to use the old NINDY protocol,\n\
  946. and whether to send a break on startup, are controlled by options\n\
  947. specified when you started GDB.",
  948.     nindy_open, nindy_close,
  949.     0,
  950.     nindy_detach,
  951.     nindy_resume,
  952.     nindy_wait,
  953.     nindy_fetch_registers, nindy_store_registers,
  954.     nindy_prepare_to_store,
  955.     nindy_xfer_inferior_memory, nindy_files_info,
  956.     0, 0, /* insert_breakpoint, remove_breakpoint, */
  957.     0, 0, 0, 0, 0,    /* Terminal crud */
  958.     nindy_kill,
  959.     nindy_load,
  960.     0, /* lookup_symbol */
  961.     nindy_create_inferior,
  962.     nindy_mourn_inferior,
  963.     0,        /* can_run */
  964.     0, /* notice_signals */
  965.     process_stratum, 0, /* next */
  966.     1, 1, 1, 1, 1,    /* all mem, mem, stack, regs, exec */
  967.     0, 0,            /* Section pointers */
  968.     OPS_MAGIC,        /* Always the last thing */
  969. };
  970.  
  971. void
  972. _initialize_nindy ()
  973. {
  974.   add_target (&nindy_ops);
  975.   add_com ("reset", class_obscure, reset_command,
  976.        "Send a 'break' to the remote target system.\n\
  977. Only useful if the target has been equipped with a circuit\n\
  978. to perform a hard reset when a break is detected.");
  979. }
  980.