home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gdb-4.12-src.lha / GNU / src / amiga / gdb-4.12 / gdb / remote-nindy.c < prev    next >
C/C++ Source or Header  |  1994-02-03  |  21KB  |  761 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 "bfd.h"
  106. #include "symfile.h"
  107. #include "target.h"
  108. #include "gdbcore.h"
  109. #include "command.h"
  110. #include "ieee-float.h"
  111.  
  112. #include "wait.h"
  113. #include <sys/file.h>
  114. #include <ctype.h>
  115. #include "serial.h"
  116. #include "nindy-share/env.h"
  117. #include "nindy-share/stop.h"
  118.  
  119. #include "dcache.h"
  120. #include "remote-utils.h"
  121.  
  122. static DCACHE *nindy_dcache;
  123.  
  124. extern int unlink();
  125. extern char *getenv();
  126. extern char *mktemp();
  127.  
  128. extern void generic_mourn_inferior ();
  129.  
  130. extern struct target_ops nindy_ops;
  131. extern GDB_FILE *instream;
  132. extern struct ext_format ext_format_i960;    /* i960-tdep.c */
  133.  
  134. extern char ninStopWhy ();
  135. extern int ninMemGet ();
  136. extern int ninMemPut ();
  137.  
  138. int nindy_initial_brk;    /* nonzero if want to send an initial BREAK to nindy */
  139. int nindy_old_protocol;    /* nonzero if want to use old protocol */
  140. char *nindy_ttyname;    /* name of tty to talk to nindy on, or null */
  141.  
  142. #define DLE    '\020'    /* Character NINDY sends to indicate user program has
  143.              * halted.  */
  144. #define TRUE    1
  145. #define FALSE    0
  146.  
  147. /* From nindy-share/nindy.c.  */
  148. extern serial_t nindy_serial;
  149.  
  150. static int have_regs = 0;    /* 1 iff regs read since i960 last halted */
  151. static int regs_changed = 0;    /* 1 iff regs were modified since last read */
  152.  
  153. extern char *exists();
  154.  
  155. static void
  156. nindy_fetch_registers PARAMS ((int));
  157.  
  158. static void
  159. nindy_store_registers PARAMS ((int));
  160.  
  161. static char *savename;
  162.  
  163. static void
  164. nindy_close (quitting)
  165.      int quitting;
  166. {
  167.   if (nindy_serial != NULL)
  168.     SERIAL_CLOSE (nindy_serial);
  169.   nindy_serial = NULL;
  170.  
  171.   if (savename)
  172.     free (savename);
  173.   savename = 0;
  174. }
  175.  
  176. /* Open a connection to a remote debugger.   
  177.    FIXME, there should be "set" commands for the options that are
  178.    now specified with gdb command-line options (old_protocol,
  179.    and initial_brk).  */
  180. void
  181. nindy_open (name, from_tty)
  182.     char *name;        /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
  183.     int from_tty;
  184. {
  185.   char baudrate[1024];
  186.  
  187.   if (!name)
  188.     error_no_arg ("serial port device name");
  189.  
  190.   target_preopen (from_tty);
  191.  
  192.   nindy_close (0);
  193.  
  194.   have_regs = regs_changed = 0;
  195.   nindy_dcache = dcache_init(ninMemGet, ninMemPut);
  196.  
  197.   /* Allow user to interrupt the following -- we could hang if there's
  198.      no NINDY at the other end of the remote tty.  */
  199.   immediate_quit++;
  200.   sprintf(baudrate, "%d", sr_get_baud_rate());
  201.   ninConnect(name, baudrate,
  202.          nindy_initial_brk, !from_tty, nindy_old_protocol);
  203.   immediate_quit--;
  204.  
  205.   if (nindy_serial == NULL)
  206.     {
  207.       perror_with_name (name);
  208.     }
  209.  
  210.   savename = savestring (name, strlen (name));
  211.   push_target (&nindy_ops);
  212.   target_fetch_registers(-1);
  213. }
  214.  
  215. /* User-initiated quit of nindy operations.  */
  216.  
  217. static void
  218. nindy_detach (name, from_tty)
  219.      char *name;
  220.      int from_tty;
  221. {
  222.   if (name)
  223.     error ("Too many arguments");
  224.   pop_target ();
  225. }
  226.  
  227. static void
  228. nindy_files_info ()
  229. {
  230.   printf_unfiltered("\tAttached to %s at %d bps%s%s.\n", savename,
  231.      sr_get_baud_rate(),
  232.      nindy_old_protocol? " in old protocol": "",
  233.          nindy_initial_brk? " with initial break": "");
  234. }
  235.  
  236. /* Return the number of characters in the buffer before
  237.    the first DLE character.  */
  238.  
  239. static
  240. int
  241. non_dle( buf, n )
  242.     char *buf;        /* Character buffer; NOT '\0'-terminated */
  243.     int n;        /* Number of characters in buffer */
  244. {
  245.     int i;
  246.  
  247.     for ( i = 0; i < n; i++ ){
  248.         if ( buf[i] == DLE ){
  249.             break;
  250.         }
  251.     }
  252.     return i;
  253. }
  254.  
  255. /* Tell the remote machine to resume.  */
  256.  
  257. void
  258. nindy_resume (pid, step, siggnal)
  259.      int pid, step;
  260.      enum target_signal siggnal;
  261. {
  262.   if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
  263.     warning ("Can't send signals to remote NINDY targets.");
  264.  
  265.     dcache_flush(nindy_dcache);
  266.     if ( regs_changed ){
  267.         nindy_store_registers (-1);
  268.         regs_changed = 0;
  269.     }
  270.     have_regs = 0;
  271.     ninGo( step );
  272. }
  273.  
  274. /* FIXME, we can probably use the normal terminal_inferior stuff here.
  275.    We have to do terminal_inferior and then set up the passthrough
  276.    settings initially.  Thereafter, terminal_ours and terminal_inferior
  277.    will automatically swap the settings around for us.  */
  278.  
  279. struct clean_up_tty_args {
  280.   serial_ttystate state;
  281.   serial_t serial;
  282. };
  283.  
  284. static void
  285. clean_up_tty (ptrarg)
  286.      PTR ptrarg;
  287. {
  288.   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
  289.   SERIAL_SET_TTY_STATE (args->serial, args->state);
  290.   free (args->state);
  291.   warning ("\n\n\
  292. You may need to reset the 80960 and/or reload you