* i387-tdep.c (print_i387_value): Cast &value to (char *) in
[deliverable/binutils-gdb.git] / gdb / remote-nindy.c
index c168511be7c40613441b70083768100773629748..a1ccea76947bfb236523183d3db621a4884bd688 100644 (file)
@@ -2,29 +2,29 @@
    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
    Contributed by Intel Corporation.  Modified from remote.c by Chris Benenati.
 
    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
    Contributed by Intel Corporation.  Modified from remote.c by Chris Benenati.
 
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY.  No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License.  A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities.  It
-should be in a file named COPYING.  Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther.  Help stamp out software hoarding!
-*/
+   GDB is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY.  No author or distributor accepts responsibility to anyone
+   for the consequences of using it or for whether it serves any
+   particular purpose or works at all, unless he says so in writing.
+   Refer to the GDB General Public License for full details.
+
+   Everyone is granted permission to copy, modify and redistribute GDB,
+   but only under the conditions described in the GDB General Public
+   License.  A copy of this license is supposed to have been given to you
+   along with GDB so you can know your rights and responsibilities.  It
+   should be in a file named COPYING.  Among other things, the copyright
+   notice and this notice must be preserved on all copies.
+
+   In other words, go ahead and share GDB, but don't try to stop
+   anyone else from sharing it farther.  Help stamp out software hoarding!
+ */
 
 /*
 
 /*
-Except for the data cache routines, this file bears little resemblence
-to remote.c.  A new (although similar) protocol has been specified, and
-portions of the code are entirely dependent on having an i80960 with a
-NINDY ROM monitor at the other end of the line.
-*/
+   Except for the data cache routines, this file bears little resemblence
+   to remote.c.  A new (although similar) protocol has been specified, and
+   portions of the code are entirely dependent on having an i80960 with a
+   NINDY ROM monitor at the other end of the line.
+ */
 
 /*****************************************************************************
  *
 
 /*****************************************************************************
  *
@@ -107,33 +107,39 @@ NINDY ROM monitor at the other end of the line.
 #include "target.h"
 #include "gdbcore.h"
 #include "command.h"
 #include "target.h"
 #include "gdbcore.h"
 #include "command.h"
-#include "ieee-float.h"
+#include "floatformat.h"
 
 
-#include "wait.h"
+#include "gdb_wait.h"
 #include <sys/file.h>
 #include <ctype.h>
 #include "serial.h"
 #include "nindy-share/env.h"
 #include "nindy-share/stop.h"
 
 #include <sys/file.h>
 #include <ctype.h>
 #include "serial.h"
 #include "nindy-share/env.h"
 #include "nindy-share/stop.h"
 
-extern int unlink();
-extern char *getenv();
-extern char *mktemp();
+#include "dcache.h"
+#include "remote-utils.h"
+
+static DCACHE *nindy_dcache;
+
+extern int unlink ();
+extern char *getenv ();
+extern char *mktemp ();
 
 extern void generic_mourn_inferior ();
 
 extern struct target_ops nindy_ops;
 extern FILE *instream;
 
 extern void generic_mourn_inferior ();
 
 extern struct target_ops nindy_ops;
 extern FILE *instream;
-extern struct ext_format ext_format_i960;      /* i960-tdep.c */
 
 extern char ninStopWhy ();
 
 extern char ninStopWhy ();
+extern int ninMemGet ();
+extern int ninMemPut ();
 
 
-int nindy_initial_brk; /* nonzero if want to send an initial BREAK to nindy */
-int nindy_old_protocol;        /* nonzero if want to use old protocol */
-char *nindy_ttyname;   /* name of tty to talk to nindy on, or null */
+int nindy_initial_brk;         /* nonzero if want to send an initial BREAK to nindy */
+int nindy_old_protocol;                /* nonzero if want to use old protocol */
+char *nindy_ttyname;           /* name of tty to talk to nindy on, or null */
 
 
-#define DLE    '\020'  /* Character NINDY sends to indicate user program has
-                        * halted.  */
+#define DLE    '\020'          /* Character NINDY sends to indicate user program has
+                                  * halted.  */
 #define TRUE   1
 #define FALSE  0
 
 #define TRUE   1
 #define FALSE  0
 
@@ -143,13 +149,7 @@ extern serial_t nindy_serial;
 static int have_regs = 0;      /* 1 iff regs read since i960 last halted */
 static int regs_changed = 0;   /* 1 iff regs were modified since last read */
 
 static int have_regs = 0;      /* 1 iff regs read since i960 last halted */
 static int regs_changed = 0;   /* 1 iff regs were modified since last read */
 
-extern char *exists();
-
-static void
-dcache_flush (), dcache_poke (), dcache_init();
-
-static int
-dcache_fetch ();
+extern char *exists ();
 
 static void
 nindy_fetch_registers PARAMS ((int));
 
 static void
 nindy_fetch_registers PARAMS ((int));
@@ -173,30 +173,35 @@ nindy_close (quitting)
 }
 
 /* Open a connection to a remote debugger.   
 }
 
 /* Open a connection to a remote debugger.   
-   FIXME, there should be a way to specify the various options that are
-   now specified with gdb command-line options.  (baud_rate, old_protocol,
-   and initial_brk)  */
+   FIXME, there should be "set" commands for the options that are
+   now specified with gdb command-line options (old_protocol,
+   and initial_brk).  */
 void
 nindy_open (name, from_tty)
 void
 nindy_open (name, from_tty)
-    char *name;                /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
-    int from_tty;
+     char *name;               /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
+     int from_tty;
 {
 {
+  char baudrate[1024];
 
   if (!name)
     error_no_arg ("serial port device name");
 
   target_preopen (from_tty);
 
   if (!name)
     error_no_arg ("serial port device name");
 
   target_preopen (from_tty);
-  
+
   nindy_close (0);
 
   have_regs = regs_changed = 0;
   nindy_close (0);
 
   have_regs = regs_changed = 0;
-  dcache_init();
+  nindy_dcache = dcache_init (ninMemGet, ninMemPut);
 
   /* Allow user to interrupt the following -- we could hang if there's
      no NINDY at the other end of the remote tty.  */
   immediate_quit++;
 
   /* Allow user to interrupt the following -- we could hang if there's
      no NINDY at the other end of the remote tty.  */
   immediate_quit++;
-  ninConnect(name, baud_rate ? baud_rate : "9600",
-            nindy_initial_brk, !from_tty, nindy_old_protocol);
+  /* If baud_rate is -1, then ninConnect will not recognize the baud rate
+     and will deal with the situation in a (more or less) reasonable
+     fashion.  */
+  sprintf (baudrate, "%d", baud_rate);
+  ninConnect (name, baudrate,
+             nindy_initial_brk, !from_tty, nindy_old_protocol);
   immediate_quit--;
 
   if (nindy_serial == NULL)
   immediate_quit--;
 
   if (nindy_serial == NULL)
@@ -206,7 +211,13 @@ nindy_open (name, from_tty)
 
   savename = savestring (name, strlen (name));
   push_target (&nindy_ops);
 
   savename = savestring (name, strlen (name));
   push_target (&nindy_ops);
-  target_fetch_registers(-1);
+
+  target_fetch_registers (-1);
+
+  init_thread_list ();
+  init_wait_for_inferior ();
+  clear_proceed_status ();
+  normal_stop ();
 }
 
 /* User-initiated quit of nindy operations.  */
 }
 
 /* User-initiated quit of nindy operations.  */
@@ -224,10 +235,11 @@ nindy_detach (name, from_tty)
 static void
 nindy_files_info ()
 {
 static void
 nindy_files_info ()
 {
-  printf("\tAttached to %s at %s bps%s%s.\n", savename,
-        baud_rate? baud_rate: "9600",
-        nindy_old_protocol? " in old protocol": "",
-         nindy_initial_brk? " with initial break": "");
+  /* FIXME: this lies about the baud rate if we autobauded.  */
+  printf_unfiltered ("\tAttached to %s at %d bits per second%s%s.\n", savename,
+                    baud_rate,
+                    nindy_old_protocol ? " in old protocol" : "",
+                    nindy_initial_brk ? " with initial break" : "");
 }
 \f
 /* Return the number of characters in the buffer before
 }
 \f
 /* Return the number of characters in the buffer before
@@ -235,36 +247,40 @@ nindy_files_info ()
 
 static
 int
 
 static
 int
-non_dle( buf, n )
-    char *buf;         /* Character buffer; NOT '\0'-terminated */
-    int n;             /* Number of characters in buffer */
+non_dle (buf, n)
+     char *buf;                        /* Character buffer; NOT '\0'-terminated */
+     int n;                    /* Number of characters in buffer */
 {
 {
-       int i;
+  int i;
 
 
-       for ( i = 0; i < n; i++ ){
-               if ( buf[i] == DLE ){
-                       break;
-               }
+  for (i = 0; i < n; i++)
+    {
+      if (buf[i] == DLE)
+       {
+         break;
        }
        }
-       return i;
+    }
+  return i;
 }
 \f
 /* Tell the remote machine to resume.  */
 
 void
 nindy_resume (pid, step, siggnal)
 }
 \f
 /* Tell the remote machine to resume.  */
 
 void
 nindy_resume (pid, step, siggnal)
-     int pid, step, siggnal;
+     int pid, step;
+     enum target_signal siggnal;
 {
 {
-       if (siggnal != 0 && siggnal != stop_signal)
-         error ("Can't send signals to remote NINDY targets.");
+  if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
+    warning ("Can't send signals to remote NINDY targets.");
 
 
-       dcache_flush();
-       if ( regs_changed ){
-               nindy_store_registers (-1);
-               regs_changed = 0;
-       }
-       have_regs = 0;
-       ninGo( step );
+  dcache_flush (nindy_dcache);
+  if (regs_changed)
+    {
+      nindy_store_registers (-1);
+      regs_changed = 0;
+    }
+  have_regs = 0;
+  ninGo (step);
 }
 \f
 /* FIXME, we can probably use the normal terminal_inferior stuff here.
 }
 \f
 /* FIXME, we can probably use the normal terminal_inferior stuff here.
@@ -272,10 +288,12 @@ nindy_resume (pid, step, siggnal)
    settings initially.  Thereafter, terminal_ours and terminal_inferior
    will automatically swap the settings around for us.  */
 
    settings initially.  Thereafter, terminal_ours and terminal_inferior
    will automatically swap the settings around for us.  */
 
-struct clean_up_tty_args {
+struct clean_up_tty_args
+{
   serial_ttystate state;
   serial_t serial;
 };
   serial_ttystate state;
   serial_t serial;
 };
+static struct clean_up_tty_args tty_args;
 
 static void
 clean_up_tty (ptrarg)
 
 static void
 clean_up_tty (ptrarg)
@@ -284,37 +302,62 @@ clean_up_tty (ptrarg)
   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
   SERIAL_SET_TTY_STATE (args->serial, args->state);
   free (args->state);
   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
   SERIAL_SET_TTY_STATE (args->serial, args->state);
   free (args->state);
-  warning ("\n\n\
-You may need to reset the 80960 and/or reload your program.\n");
+  warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
+}
+
+/* Recover from ^Z or ^C while remote process is running */
+static void (*old_ctrlc) ();
+#ifdef SIGTSTP
+static void (*old_ctrlz) ();
+#endif
+
+static void
+clean_up_int ()
+{
+  SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
+  free (tty_args.state);
+
+  signal (SIGINT, old_ctrlc);
+#ifdef SIGTSTP
+  signal (SIGTSTP, old_ctrlz);
+#endif
+  error ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
 }
 
 /* Wait until the remote machine stops. While waiting, operate in passthrough
 }
 
 /* Wait until the remote machine stops. While waiting, operate in passthrough
- * mode; i.e., pass everything NINDY sends to stdout, and everything from
+ * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
  * stdin to NINDY.
  *
  * Return to caller, storing status in 'status' just as `wait' would.
  */
 
 static int
  * stdin to NINDY.
  *
  * Return to caller, storing status in 'status' just as `wait' would.
  */
 
 static int
-nindy_wait( status )
-    WAITTYPE *status;
+nindy_wait (pid, status)
+     int pid;
+     struct target_waitstatus *status;
 {
   fd_set fds;
 {
   fd_set fds;
-  char buf[500];       /* FIXME, what is "500" here? */
+  int c;
+  char buf[2];
   int i, n;
   unsigned char stop_exit;
   unsigned char stop_code;
   int i, n;
   unsigned char stop_exit;
   unsigned char stop_code;
-  struct clean_up_tty_args tty_args;
   struct cleanup *old_cleanups;
   long ip_value, fp_value, sp_value;   /* Reg values from stop */
 
   struct cleanup *old_cleanups;
   long ip_value, fp_value, sp_value;   /* Reg values from stop */
 
-  WSETEXIT( (*status), 0 );
+  status->kind = TARGET_WAITKIND_EXITED;
+  status->value.integer = 0;
 
   /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
 
   /* Save current tty attributes, and restore them when done.  */
   tty_args.serial = SERIAL_FDOPEN (0);
   tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
 
   /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
 
   /* Save current tty attributes, and restore them when done.  */
   tty_args.serial = SERIAL_FDOPEN (0);
   tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
+  old_ctrlc = signal (SIGINT, clean_up_int);
+#ifdef SIGTSTP
+  old_ctrlz = signal (SIGTSTP, clean_up_int);
+#endif
+
   old_cleanups = make_cleanup (clean_up_tty, &tty_args);
 
   /* Pass input from keyboard to NINDY as it arrives.  NINDY will interpret
   old_cleanups = make_cleanup (clean_up_tty, &tty_args);
 
   /* Pass input from keyboard to NINDY as it arrives.  NINDY will interpret
@@ -325,92 +368,63 @@ nindy_wait( status )
 
   while (1)
     {
 
   while (1)
     {
-      /* Wait for input on either the remote port or stdin.  */
-      FD_ZERO (&fds);
-      FD_SET (0, &fds);
-      FD_SET (nindy_serial->fd, &fds);
-      if (select (nindy_serial->fd + 1, &fds, 0, 0, 0) <= 0)
-       continue;
-
-      /* Pass input through to correct place */
-      if (FD_ISSET (0, &fds))
+      /* Input on remote */
+      c = SERIAL_READCHAR (nindy_serial, -1);
+      if (c == SERIAL_ERROR)
        {
        {
-         /* Input on stdin */
-         n = read (0, buf, sizeof (buf));
-         if (n)
-           {
-             SERIAL_WRITE (nindy_serial, buf, n );
-           }
+         error ("Cannot read from serial line");
        }
        }
-
-      if (FD_ISSET (nindy_serial->fd, &fds))
+      else if (c == 0x1b)      /* ESC */
        {
        {
-         /* Input on remote */
-         n = read (nindy_serial->fd, buf, sizeof (buf));
-         if (n)
+         c = SERIAL_READCHAR (nindy_serial, -1);
+         c &= ~0x40;
+       }
+      else if (c != 0x10)      /* DLE */
+       /* Write out any characters preceding DLE */
+       {
+         buf[0] = (char) c;
+         write (1, buf, 1);
+       }
+      else
+       {
+         stop_exit = ninStopWhy (&stop_code,
+                                 &ip_value, &fp_value, &sp_value);
+         if (!stop_exit && (stop_code == STOP_SRQ))
            {
            {
-             /* Write out any characters in buffer preceding DLE */
-             i = non_dle( buf, n );
-             if ( i > 0 )
-               {
-                 write (1, buf, i);
-               }
-
-             if (i != n)
-               {
-                 /* There *was* a DLE in the buffer */
-                 stop_exit = ninStopWhy(&stop_code,
-                                        &ip_value, &fp_value, &sp_value);
-                 if (!stop_exit && (stop_code == STOP_SRQ))
-                   {
-                     immediate_quit++;
-                     ninSrq();
-                     immediate_quit--;
-                   }
-                 else
-                   {
-                     /* Get out of loop */
-                     supply_register (IP_REGNUM, 
-                                      (char *)&ip_value);
-                     supply_register (FP_REGNUM, 
-                                      (char *)&fp_value);
-                     supply_register (SP_REGNUM, 
-                                      (char *)&sp_value);
-                     break;
-                   }
-               }
+             immediate_quit++;
+             ninSrq ();
+             immediate_quit--;
+           }
+         else
+           {
+             /* Get out of loop */
+             supply_register (IP_REGNUM,
+                              (char *) &ip_value);
+             supply_register (FP_REGNUM,
+                              (char *) &fp_value);
+             supply_register (SP_REGNUM,
+                              (char *) &sp_value);
+             break;
            }
        }
     }
 
            }
        }
     }
 
-  do_cleanups (old_cleanups);
+  SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
+  free (tty_args.state);
+  discard_cleanups (old_cleanups);
 
   if (stop_exit)
     {
 
   if (stop_exit)
     {
-      /* User program exited */
-      WSETEXIT ((*status), stop_code);
+      status->kind = TARGET_WAITKIND_EXITED;
+      status->value.integer = stop_code;
     }
   else
     {
     }
   else
     {
-      /* Fault or trace */
-      switch (stop_code)
-       {
-       case STOP_GDB_BPT:
-       case TRACE_STEP:
-         /* Breakpoint or single stepping.  */
-         stop_code = SIGTRAP;
-         break;
-       default:
-         /* The target is not running Unix, and its faults/traces do
-            not map nicely into Unix signals.  Make sure they do not
-            get confused with Unix signals by numbering them with
-            values higher than the highest legal Unix signal.  code
-            in i960_print_fault(), called via PRINT_RANDOM_SIGNAL,
-            will interpret the value.  */
-         stop_code += NSIG;
-         break;
-       }
-      WSETSTOP ((*status), stop_code);
+      /* nindy has some special stop code need to be handled */
+      if (stop_code == STOP_GDB_BPT)
+       stop_code = TRACE_STEP;
+      status->kind = TARGET_WAITKIND_STOPPED;
+      status->value.sig = i960_fault_to_signal (stop_code);
     }
   return inferior_pid;
 }
     }
   return inferior_pid;
 }
@@ -418,79 +432,60 @@ nindy_wait( status )
 /* Read the remote registers into the block REGS.  */
 
 /* This is the block that ninRegsGet and ninRegsPut handles.  */
 /* Read the remote registers into the block REGS.  */
 
 /* This is the block that ninRegsGet and ninRegsPut handles.  */
-struct nindy_regs {
-  char local_regs[16 * 4];
-  char global_regs[16 * 4];
-  char pcw_acw[2 * 4];
-  char ip[4];
-  char tcw[4];
-  char fp_as_double[4 * 8];
+struct nindy_regs
+{
+  char local_regs[16 * 4];
+  char global_regs[16 * 4];
+  char pcw_acw[2 * 4];
+  char ip[4];
+  char tcw[4];
+  char fp_as_double[4 * 8];
 };
 
 static void
 };
 
 static void
-nindy_fetch_registers(regno)
+nindy_fetch_registers (regno)
      int regno;
 {
   struct nindy_regs nindy_regs;
      int regno;
 {
   struct nindy_regs nindy_regs;
-  int regnum, inv;
-  double dub;
+  int regnum;
 
   immediate_quit++;
 
   immediate_quit++;
-  ninRegsGet( (char *) &nindy_regs );
+  ninRegsGet ((char *) &nindy_regs);
   immediate_quit--;
 
   immediate_quit--;
 
-  memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16*4);
-  memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16*4);
-  memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2*4);
-  memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1*4);
-  memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1*4);
-  for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
-    dub = unpack_double (builtin_type_double,
-                        &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
-                        &inv);
-    /* dub now in host byte order */
-    double_to_ieee_extended (&ext_format_i960, &dub,
-                            &registers[REGISTER_BYTE (regnum)]);
-  }
+  memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16 * 4);
+  memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16 * 4);
+  memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2 * 4);
+  memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1 * 4);
+  memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1 * 4);
+  memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], nindy_regs.fp_as_double, 4 * 8);
 
   registers_fetched ();
 }
 
 static void
 
   registers_fetched ();
 }
 
 static void
-nindy_prepare_to_store()
+nindy_prepare_to_store ()
 {
   /* Fetch all regs if they aren't already here.  */
   read_register_bytes (0, NULL, REGISTER_BYTES);
 }
 
 static void
 {
   /* Fetch all regs if they aren't already here.  */
   read_register_bytes (0, NULL, REGISTER_BYTES);
 }
 
 static void
-nindy_store_registers(regno)
+nindy_store_registers (regno)
      int regno;
 {
   struct nindy_regs nindy_regs;
      int regno;
 {
   struct nindy_regs nindy_regs;
-  int regnum, inv;
-  double dub;
-
-  memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16*4);
-  memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16*4);
-  memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2*4);
-  memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1*4);
-  memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1*4);
-  /* Float regs.  Only works on IEEE_FLOAT hosts.  FIXME!  */
-  for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
-    ieee_extended_to_double (&ext_format_i960,
-                            &registers[REGISTER_BYTE (regnum)], &dub);
-    /* dub now in host byte order */
-    /* FIXME-someday, the arguments to unpack_double are backward.
-       It expects a target double and returns a host; we pass the opposite.
-       This mostly works but not quite.  */
-    dub = unpack_double (builtin_type_double, (char *)&dub, &inv);
-    /* dub now in target byte order */
-    memcpy (&nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)], &dub, 8);
-  }
+  int regnum;
+
+  memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16 * 4);
+  memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16 * 4);
+  memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2 * 4);
+  memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1 * 4);
+  memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1 * 4);
+  memcpy (nindy_regs.fp_as_double, &registers[REGISTER_BYTE (FP0_REGNUM)], 8 * 4);
 
   immediate_quit++;
 
   immediate_quit++;
-  ninRegsPut( (char *) &nindy_regs );
+  ninRegsPut ((char *) &nindy_regs);
   immediate_quit--;
 }
 
   immediate_quit--;
 }
 
@@ -501,7 +496,7 @@ int
 nindy_fetch_word (addr)
      CORE_ADDR addr;
 {
 nindy_fetch_word (addr)
      CORE_ADDR addr;
 {
-       return dcache_fetch (addr);
+  return dcache_fetch (nindy_dcache, addr);
 }
 
 /* Write a word WORD into remote address ADDR.
 }
 
 /* Write a word WORD into remote address ADDR.
@@ -512,7 +507,7 @@ nindy_store_word (addr, word)
      CORE_ADDR addr;
      int word;
 {
      CORE_ADDR addr;
      int word;
 {
-       dcache_poke (addr, word);
+  dcache_poke (nindy_dcache, addr, word);
 }
 
 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 }
 
 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
@@ -524,30 +519,31 @@ nindy_store_word (addr, word)
    FIXME, rewrite this to not use the word-oriented routines.  */
 
 int
    FIXME, rewrite this to not use the word-oriented routines.  */
 
 int
-nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
+nindy_xfer_inferior_memory (memaddr, myaddr, len, should_write, target)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
-     int write;
-     struct target_ops *target;                        /* ignored */
+     int should_write;
+     struct target_ops *target;        /* ignored */
 {
   register int i;
   /* Round starting address down to longword boundary.  */
 {
   register int i;
   /* Round starting address down to longword boundary.  */
-  register CORE_ADDR addr = memaddr & - sizeof (int);
+  register CORE_ADDR addr = memaddr & -sizeof (int);
   /* Round ending address up; get number of longwords that makes.  */
   register int count
   /* Round ending address up; get number of longwords that makes.  */
   register int count
-    = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+  = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
   /* Allocate buffer of that many longwords.  */
   register int *buffer = (int *) alloca (count * sizeof (int));
 
   /* Allocate buffer of that many longwords.  */
   register int *buffer = (int *) alloca (count * sizeof (int));
 
-  if (write)
+  if (should_write)
     {
       /* Fill start and end extra bytes of buffer with existing memory data.  */
 
     {
       /* Fill start and end extra bytes of buffer with existing memory data.  */
 
-      if (addr != memaddr || len < (int)sizeof (int)) {
-       /* Need part of initial word -- fetch it.  */
-        buffer[0] = nindy_fetch_word (addr);
-      }
+      if (addr != memaddr || len < (int) sizeof (int))
+       {
+         /* Need part of initial word -- fetch it.  */
+         buffer[0] = nindy_fetch_word (addr);
+       }
 
       if (count > 1)           /* FIXME, avoid if even boundary */
        {
 
       if (count > 1)           /* FIXME, avoid if even boundary */
        {
@@ -587,170 +583,6 @@ nindy_xfer_inferior_memory(memaddr, myaddr, len, write, target)
   return len;
 }
 \f
   return len;
 }
 \f
-/* The data cache records all the data read from the remote machine
-   since the last time it stopped.
-
-   Each cache block holds 16 bytes of data
-   starting at a multiple-of-16 address.  */
-
-#define DCACHE_SIZE 64         /* Number of cache blocks */
-
-struct dcache_block {
-       struct dcache_block *next, *last;
-       unsigned int addr;      /* Address for which data is recorded.  */
-       int data[4];
-};
-
-struct dcache_block dcache_free, dcache_valid;
-
-/* Free all the data cache blocks, thus discarding all cached data.  */ 
-static
-void
-dcache_flush ()
-{
-  register struct dcache_block *db;
-
-  while ((db = dcache_valid.next) != &dcache_valid)
-    {
-      remque (db);
-      insque (db, &dcache_free);
-    }
-}
-
-/*
- * If addr is present in the dcache, return the address of the block
- * containing it.
- */
-static
-struct dcache_block *
-dcache_hit (addr)
-     unsigned int addr;
-{
-  register struct dcache_block *db;
-
-  if (addr & 3)
-    abort ();
-
-  /* Search all cache blocks for one that is at this address.  */
-  db = dcache_valid.next;
-  while (db != &dcache_valid)
-    {
-      if ((addr & 0xfffffff0) == db->addr)
-       return db;
-      db = db->next;
-    }
-  return NULL;
-}
-
-/*  Return the int data at address ADDR in dcache block DC.  */
-static
-int
-dcache_value (db, addr)
-     struct dcache_block *db;
-     unsigned int addr;
-{
-  if (addr & 3)
-    abort ();
-  return (db->data[(addr>>2)&3]);
-}
-
-/* Get a free cache block, put or keep it on the valid list,
-   and return its address.  The caller should store into the block
-   the address and data that it describes, then remque it from the
-   free list and insert it into the valid list.  This procedure
-   prevents errors from creeping in if a ninMemGet is interrupted
-   (which used to put garbage blocks in the valid list...).  */
-static
-struct dcache_block *
-dcache_alloc ()
-{
-  register struct dcache_block *db;
-
-  if ((db = dcache_free.next) == &dcache_free)
-    {
-      /* If we can't get one from the free list, take last valid and put
-        it on the free list.  */
-      db = dcache_valid.last;
-      remque (db);
-      insque (db, &dcache_free);
-    }
-
-  remque (db);
-  insque (db, &dcache_valid);
-  return (db);
-}
-
-/* Return the contents of the word at address ADDR in the remote machine,
-   using the data cache.  */
-static
-int
-dcache_fetch (addr)
-     CORE_ADDR addr;
-{
-  register struct dcache_block *db;
-
-  db = dcache_hit (addr);
-  if (db == 0)
-    {
-      db = dcache_alloc ();
-      immediate_quit++;
-      ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16);
-      immediate_quit--;
-      db->addr = addr & ~0xf;
-      remque (db);                     /* Off the free list */
-      insque (db, &dcache_valid);      /* On the valid list */
-    }
-  return (dcache_value (db, addr));
-}
-
-/* Write the word at ADDR both in the data cache and in the remote machine.  */
-static void
-dcache_poke (addr, data)
-     CORE_ADDR addr;
-     int data;
-{
-  register struct dcache_block *db;
-
-  /* First make sure the word is IN the cache.  DB is its cache block.  */
-  db = dcache_hit (addr);
-  if (db == 0)
-    {
-      db = dcache_alloc ();
-      immediate_quit++;
-      ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16);
-      immediate_quit--;
-      db->addr = addr & ~0xf;
-      remque (db);                     /* Off the free list */
-      insque (db, &dcache_valid);      /* On the valid list */
-    }
-
-  /* Modify the word in the cache.  */
-  db->data[(addr>>2)&3] = data;
-
-  /* Send the changed word.  */
-  immediate_quit++;
-  ninMemPut(addr, (unsigned char *)&data, 4);
-  immediate_quit--;
-}
-
-/* The cache itself. */
-struct dcache_block the_cache[DCACHE_SIZE];
-
-/* Initialize the data cache.  */
-static void
-dcache_init ()
-{
-  register i;
-  register struct dcache_block *db;
-
-  db = the_cache;
-  dcache_free.next = dcache_free.last = &dcache_free;
-  dcache_valid.next = dcache_valid.last = &dcache_valid;
-  for (i=0;i<DCACHE_SIZE;i++,db++)
-    insque (db, &dcache_free);
-}
-
-
 static void
 nindy_create_inferior (execfile, args, env)
      char *execfile;
 static void
 nindy_create_inferior (execfile, args, env)
      char *execfile;
@@ -764,18 +596,14 @@ nindy_create_inferior (execfile, args, env)
     error ("Can't pass arguments to remote NINDY process");
 
   if (execfile == 0 || exec_bfd == 0)
     error ("Can't pass arguments to remote NINDY process");
 
   if (execfile == 0 || exec_bfd == 0)
-    error ("No exec file specified");
+    error ("No executable file specified");
 
   entry_pt = (int) bfd_get_start_address (exec_bfd);
 
   pid = 42;
 
 
   entry_pt = (int) bfd_get_start_address (exec_bfd);
 
   pid = 42;
 
-#ifdef CREATE_INFERIOR_HOOK
-  CREATE_INFERIOR_HOOK (pid);
-#endif  
-
-/* The "process" (board) is already stopped awaiting our commands, and
-   the program is already downloaded.  We just set its PC and go.  */
+  /* The "process" (board) is already stopped awaiting our commands, and
+     the program is already downloaded.  We just set its PC and go.  */
 
   inferior_pid = pid;          /* Needed for wait_for_inferior below */
 
 
   inferior_pid = pid;          /* Needed for wait_for_inferior below */
 
@@ -792,19 +620,20 @@ nindy_create_inferior (execfile, args, env)
   target_terminal_inferior ();
 
   /* insert_step_breakpoint ();  FIXME, do we need this?  */
   target_terminal_inferior ();
 
   /* insert_step_breakpoint ();  FIXME, do we need this?  */
-  proceed ((CORE_ADDR)entry_pt, -1, 0);                /* Let 'er rip... */
+  /* Let 'er rip... */
+  proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 }
 
 static void
 }
 
 static void
-reset_command(args, from_tty)
+reset_command (args, from_tty)
      char *args;
      int from_tty;
 {
   if (nindy_serial == NULL)
     {
      char *args;
      int from_tty;
 {
   if (nindy_serial == NULL)
     {
-      error"No target system to reset -- use 'target nindy' command.");
+      error ("No target system to reset -- use 'target nindy' command.");
     }
     }
-  if ( query("Really reset the target system?",0,0) )
+  if (query ("Really reset the target system?", 0, 0))
     {
       SERIAL_SEND_BREAK (nindy_serial);
       tty_flush (nindy_serial);
     {
       SERIAL_SEND_BREAK (nindy_serial);
       tty_flush (nindy_serial);
@@ -816,7 +645,7 @@ nindy_kill (args, from_tty)
      char *args;
      int from_tty;
 {
      char *args;
      int from_tty;
 {
-  return;              /* Ignore attempts to kill target system */
+  return;                      /* Ignore attempts to kill target system */
 }
 
 /* Clean up when a program exits.
 }
 
 /* Clean up when a program exits.
@@ -842,6 +671,46 @@ nindy_open_stub (arg)
   return 1;
 }
 
   return 1;
 }
 
+static void
+nindy_load (filename, from_tty)
+     char *filename;
+     int from_tty;
+{
+  asection *s;
+  /* Can't do unix style forking on a VMS system, so we'll use bfd to do
+     all the work for us
+   */
+
+  bfd *file = bfd_openr (filename, 0);
+  if (!file)
+    {
+      perror_with_name (filename);
+      return;
+    }
+
+  if (!bfd_check_format (file, bfd_object))
+    {
+      error ("can't prove it's an object file\n");
+      return;
+    }
+
+  for (s = file->sections; s; s = s->next)
+    {
+      if (s->flags & SEC_LOAD)
+       {
+         char *buffer = xmalloc (s->_raw_size);
+         bfd_get_section_contents (file, s, buffer, 0, s->_raw_size);
+         printf ("Loading section %s, size %x vma %x\n",
+                 s->name,
+                 s->_raw_size,
+                 s->vma);
+         ninMemPut (s->vma, buffer, s->_raw_size);
+         free (buffer);
+       }
+    }
+  bfd_close (file);
+}
+
 static int
 load_stub (arg)
      char *arg;
 static int
 load_stub (arg)
      char *arg;
@@ -864,76 +733,128 @@ nindy_before_main_loop ()
   char ttyname[100];
   char *p, *p2;
 
   char ttyname[100];
   char *p, *p2;
 
-  while (current_target != &nindy_ops) { /* remote tty not specified yet */
-       if ( instream == stdin ){
-               printf("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
-               fflush( stdout );
+  while (target_stack->target_ops != &nindy_ops)       /* What is this crap??? */
+    {                          /* remote tty not specified yet */
+      if (instream == stdin)
+       {
+         printf_unfiltered ("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
+         gdb_flush (gdb_stdout);
        }
        }
-       fgets( ttyname, sizeof(ttyname)-1, stdin );
+      fgets (ttyname, sizeof (ttyname) - 1, stdin);
 
 
-       /* Strip leading and trailing whitespace */
-       for ( p = ttyname; isspace(*p); p++ ){
-               ;
+      /* Strip leading and trailing whitespace */
+      for (p = ttyname; isspace (*p); p++)
+       {
+         ;
        }
        }
-       if ( *p == '\0' ){
-               return;         /* User just hit spaces or return, wants out */
+      if (*p == '\0')
+       {
+         return;               /* User just hit spaces or return, wants out */
        }
        }
-       for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
-               ;
+      for (p2 = p; !isspace (*p2) && (*p2 != '\0'); p2++)
+       {
+         ;
        }
        }
-       *p2= '\0';
-       if ( STREQ("quit",p) ){
-               exit(1);
+      *p2 = '\0';
+      if (STREQ ("quit", p))
+       {
+         exit (1);
        }
 
        }
 
-       if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
-         {
-           /* Now that we have a tty open for talking to the remote machine,
-              download the executable file if one was specified.  */
-           if (exec_bfd)
-             {
-               catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
-                             RETURN_MASK_ALL);
-             }
-         }
-  }
+      if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
+       {
+         /* Now that we have a tty open for talking to the remote machine,
+            download the executable file if one was specified.  */
+         if (exec_bfd)
+           {
+             catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
+                           RETURN_MASK_ALL);
+           }
+       }
+    }
 }
 \f
 /* Define the target subroutine names */
 
 }
 \f
 /* Define the target subroutine names */
 
-struct target_ops nindy_ops = {
-       "nindy", "Remote serial target in i960 NINDY-specific protocol",
-       "Use a remote i960 system running NINDY connected by a serial line.\n\
+struct target_ops nindy_ops;
+
+static void
+init_nindy_ops (void)
+{
+  nindy_ops.to_shortname = "nindy";
+  "Remote serial target in i960 NINDY-specific protocol",
+    nindy_ops.to_longname = "Use a remote i960 system running NINDY connected by a serial line.\n\
 Specify the name of the device the serial line is connected to.\n\
 The speed (baud rate), whether to use the old NINDY protocol,\n\
 and whether to send a break on startup, are controlled by options\n\
 Specify the name of the device the serial line is connected to.\n\
 The speed (baud rate), whether to use the old NINDY protocol,\n\
 and whether to send a break on startup, are controlled by options\n\
-specified when you started GDB.",
-       nindy_open, nindy_close,
-       0,
-       nindy_detach,
-       nindy_resume,
-       nindy_wait,
-       nindy_fetch_registers, nindy_store_registers,
-       nindy_prepare_to_store,
-       nindy_xfer_inferior_memory, nindy_files_info,
-       0, 0, /* insert_breakpoint, remove_breakpoint, */
-       0, 0, 0, 0, 0,  /* Terminal crud */
-       nindy_kill,
-       generic_load,
-       0, /* lookup_symbol */
-       nindy_create_inferior,
-       nindy_mourn_inferior,
-       0,              /* can_run */
-       0, /* notice_signals */
-       process_stratum, 0, /* next */
-       1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
-       0, 0,                   /* Section pointers */
-       OPS_MAGIC,              /* Always the last thing */
-};
+specified when you started GDB.";
+  nindy_ops.to_doc = "";
+  nindy_ops.to_open = nindy_open;
+  nindy_ops.to_close = nindy_close;
+  nindy_ops.to_attach = 0;
+  nindy_ops.to_post_attach = NULL;
+  nindy_ops.to_require_attach = NULL;
+  nindy_ops.to_detach = nindy_detach;
+  nindy_ops.to_require_detach = NULL;
+  nindy_ops.to_resume = nindy_resume;
+  nindy_ops.to_wait = nindy_wait;
+  nindy_ops.to_post_wait = NULL;
+  nindy_ops.to_fetch_registers = nindy_fetch_registers;
+  nindy_ops.to_store_registers = nindy_store_registers;
+  nindy_ops.to_prepare_to_store = nindy_prepare_to_store;
+  nindy_ops.to_xfer_memory = nindy_xfer_inferior_memory;
+  nindy_ops.to_files_info = nindy_files_info;
+  nindy_ops.to_insert_breakpoint = memory_insert_breakpoint;
+  nindy_ops.to_remove_breakpoint = memory_remove_breakpoint;
+  nindy_ops.to_terminal_init = 0;
+  nindy_ops.to_terminal_inferior = 0;
+  nindy_ops.to_terminal_ours_for_output = 0;
+  nindy_ops.to_terminal_ours = 0;
+  nindy_ops.to_terminal_info = 0;      /* Terminal crud */
+  nindy_ops.to_kill = nindy_kill;
+  nindy_ops.to_load = nindy_load;
+  nindy_ops.to_lookup_symbol = 0;      /* lookup_symbol */
+  nindy_ops.to_create_inferior = nindy_create_inferior;
+  nindy_ops.to_post_startup_inferior = NULL;
+  nindy_ops.to_acknowledge_created_inferior = NULL;
+  nindy_ops.to_clone_and_follow_inferior = NULL;
+  nindy_ops.to_post_follow_inferior_by_clone = NULL;
+  nindy_ops.to_insert_fork_catchpoint = NULL;
+  nindy_ops.to_remove_fork_catchpoint = NULL;
+  nindy_ops.to_insert_vfork_catchpoint = NULL;
+  nindy_ops.to_remove_vfork_catchpoint = NULL;
+  nindy_ops.to_has_forked = NULL;
+  nindy_ops.to_has_vforked = NULL;
+  nindy_ops.to_can_follow_vfork_prior_to_exec = NULL;
+  nindy_ops.to_post_follow_vfork = NULL;
+  nindy_ops.to_insert_exec_catchpoint = NULL;
+  nindy_ops.to_remove_exec_catchpoint = NULL;
+  nindy_ops.to_has_execd = NULL;
+  nindy_ops.to_reported_exec_events_per_exec_call = NULL;
+  nindy_ops.to_has_exited = NULL;
+  nindy_ops.to_mourn_inferior = nindy_mourn_inferior;
+  nindy_ops.to_can_run = 0;    /* can_run */
+  nindy_ops.to_notice_signals = 0;     /* notice_signals */
+  nindy_ops.to_thread_alive = 0;       /* to_thread_alive */
+  nindy_ops.to_stop = 0;       /* to_stop */
+  nindy_ops.to_pid_to_exec_file = NULL;
+  nindy_ops.to_core_file_to_sym_file = NULL;
+  nindy_ops.to_stratum = process_stratum;
+  nindy_ops.DONT_USE = 0;      /* next */
+  nindy_ops.to_has_all_memory = 1;
+  nindy_ops.to_has_memory = 1;
+  nindy_ops.to_has_stack = 1;
+  nindy_ops.to_has_registers = 1;
+  nindy_ops.to_has_execution = 1;      /* all mem, mem, stack, regs, exec */
+  nindy_ops.to_sections = 0;
+  nindy_ops.to_sections_end = 0;       /* Section pointers */
+  nindy_ops.to_magic = OPS_MAGIC;      /* Always the last thing */
+}
 
 void
 _initialize_nindy ()
 {
 
 void
 _initialize_nindy ()
 {
+  init_nindy_ops ();
   add_target (&nindy_ops);
   add_com ("reset", class_obscure, reset_command,
           "Send a 'break' to the remote target system.\n\
   add_target (&nindy_ops);
   add_com ("reset", class_obscure, reset_command,
           "Send a 'break' to the remote target system.\n\
This page took 0.036698 seconds and 4 git commands to generate.