2002-05-14 Elena Zannoni <ezannoni@redhat.com>

[deliverable/binutils-gdb.git] / gdb / remote-nindy.c

diff --git a/gdb/remote-nindy.c b/gdb/remote-nindy.c
index 17096f99d9641cc80ef31cb9f4f1390a6cb57dc7..679dfad919e8b07e7ce16247a4afbb7f9f9aba8b 100644 (file)
--- a/gdb/remote-nindy.c
+++ b/gdb/remote-nindy.c
@@ -1,30 +1,32 @@
 /* Memory-access and commands for remote NINDY process, for GDB.
 /* Memory-access and commands for remote NINDY process, for GDB.

-   Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
+   2000, 2001, 2002 Free Software Foundation, Inc.
+

    Contributed by Intel Corporation.  Modified from remote.c by Chris Benenati.
 
    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.
+   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.
+   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!
-*/
+   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.
+ */

 
 /*****************************************************************************
  *
 
 /*****************************************************************************
  *


@@ -108,67 +110,60 @@ NINDY ROM monitor at the other end of the line.
 #include "gdbcore.h"
 #include "command.h"
 #include "floatformat.h"
 #include "gdbcore.h"
 #include "command.h"
 #include "floatformat.h"

+#include "regcache.h"

 
 

-#include "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"

-
-#include "dcache.h"

 #include "remote-utils.h"
 
 #include "remote-utils.h"
 

-static DCACHE *nindy_dcache;
-
-extern int unlink();
-extern char *getenv();
-extern char *mktemp();
+extern int unlink ();
+extern char *getenv ();
+extern char *mktemp ();

 
 extern void generic_mourn_inferior ();
 
 extern struct target_ops nindy_ops;
 
 extern void generic_mourn_inferior ();
 
 extern struct target_ops nindy_ops;

-extern GDB_FILE *instream;
+extern FILE *instream;

 
 extern char ninStopWhy ();
 extern int ninMemGet ();
 extern int ninMemPut ();
 
 
 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
 
 /* From nindy-share/nindy.c.  */
 #define TRUE   1
 #define FALSE  0
 
 /* From nindy-share/nindy.c.  */

-extern serial_t nindy_serial;
+extern struct serial *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();
+extern char *exists ();

 
 

-static void
-nindy_fetch_registers PARAMS ((int));
+static void nindy_fetch_registers (int);

 
 

-static void
-nindy_store_registers PARAMS ((int));
+static void nindy_store_registers (int);

 \f
 static char *savename;
 
 static void
 \f
 static char *savename;
 
 static void

-nindy_close (quitting)
-     int quitting;
+nindy_close (int quitting)

 {
   if (nindy_serial != NULL)
 {
   if (nindy_serial != NULL)

-    SERIAL_CLOSE (nindy_serial);
+    serial_close (nindy_serial);

   nindy_serial = NULL;
 
   if (savename)
   nindy_serial = NULL;
 
   if (savename)

-    free (savename);
+    xfree (savename);

   savename = 0;
 }
 
   savename = 0;
 }
 


@@ -177,9 +172,8 @@ nindy_close (quitting)
    now specified with gdb command-line options (old_protocol,
    and initial_brk).  */
 void
    now specified with gdb command-line options (old_protocol,
    and initial_brk).  */
 void

-nindy_open (name, from_tty)
-    char *name;                /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
-    int from_tty;
+nindy_open (char *name,                /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
+           int from_tty)

 {
   char baudrate[1024];
 
 {
   char baudrate[1024];
 


@@ -191,7 +185,6 @@ nindy_open (name, from_tty)
   nindy_close (0);
 
   have_regs = regs_changed = 0;
   nindy_close (0);
 
   have_regs = regs_changed = 0;

-  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.  */
 
   /* Allow user to interrupt the following -- we could hang if there's
      no NINDY at the other end of the remote tty.  */


@@ -199,9 +192,9 @@ nindy_open (name, from_tty)
   /* 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.  */
   /* 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);
+  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)


@@ -212,7 +205,7 @@ 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 ();
 
   init_thread_list ();
   init_wait_for_inferior ();


@@ -223,9 +216,7 @@ nindy_open (name, from_tty)
 /* User-initiated quit of nindy operations.  */
 
 static void
 /* User-initiated quit of nindy operations.  */
 
 static void

-nindy_detach (name, from_tty)
-     char *name;
-     int from_tty;
+nindy_detach (char *name, int from_tty)

 {
   if (name)
     error ("Too many arguments");
 {
   if (name)
     error ("Too many arguments");


@@ -233,52 +224,50 @@ nindy_detach (name, from_tty)
 }
 
 static void
 }
 
 static void

-nindy_files_info ()
+nindy_files_info (void)

 {
   /* FIXME: this lies about the baud rate if we autobauded.  */
 {
   /* 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": "");
+  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
 }
 \f

-/* Return the number of characters in the buffer before
-   the first DLE character.  */
+/* Return the number of characters in the buffer BUF before
+   the first DLE character.  N is maximum number of characters to
+   consider.  */

 
 static
 int
 
 static
 int

-non_dle( buf, n )
-    char *buf;         /* Character buffer; NOT '\0'-terminated */
-    int n;             /* Number of characters in buffer */
+non_dle (char *buf, int n)

 {
   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;
 }
 \f
 /* Tell the remote machine to resume.  */
 
 void
   return i;
 }
 \f
 /* Tell the remote machine to resume.  */
 
 void

-nindy_resume (pid, step, siggnal)
-     int pid, step;
-     enum target_signal siggnal;
+nindy_resume (ptid_t ptid, int step, enum target_signal siggnal)

 {
   if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
     warning ("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(nindy_dcache);
-  if ( regs_changed )
+  if (regs_changed)

     {
       nindy_store_registers (-1);
       regs_changed = 0;
     }
   have_regs = 0;
     {
       nindy_store_registers (-1);
       regs_changed = 0;
     }
   have_regs = 0;

-  ninGo( step );
+  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.


@@ -286,39 +275,39 @@ 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_ttystate state;

-  serial_t serial;
+  struct serial *serial;

 };
 };

-static  struct clean_up_tty_args tty_args;
+static struct clean_up_tty_args tty_args;

 
 static void
 
 static void

-clean_up_tty (ptrarg)
-     PTR ptrarg;
+clean_up_tty (PTR ptrarg)

 {
   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
 {
   struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;

-  SERIAL_SET_TTY_STATE (args->serial, args->state);
-  free (args->state);
+  serial_set_tty_state (args->serial, args->state);
+  xfree (args->state);

   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 */
   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)();  
+static void (*old_ctrlc) ();

 #ifdef SIGTSTP
 #ifdef SIGTSTP

-static void (*old_ctrlz)();
+static void (*old_ctrlz) ();

 #endif
 
 static void
 #endif
 
 static void

-clean_up_int()
+clean_up_int (void)

 {
 {

-  SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
-  free (tty_args.state);
+  serial_set_tty_state (tty_args.serial, tty_args.state);
+  xfree (tty_args.state);

 
 

-  signal(SIGINT, old_ctrlc);
+  signal (SIGINT, old_ctrlc);

 #ifdef SIGTSTP
 #ifdef SIGTSTP

-  signal(SIGTSTP, old_ctrlz);
+  signal (SIGTSTP, old_ctrlz);

 #endif
 #endif

-  error("\n\nYou may need to reset the 80960 and/or reload your program.\n");
+  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


@@ -328,10 +317,8 @@ clean_up_int()
  * Return to caller, storing status in 'status' just as `wait' would.
  */
 
  * Return to caller, storing status in 'status' just as `wait' would.
  */
 

-static int
-nindy_wait( pid, status )
-    int pid;
-    struct target_waitstatus *status;
+static ptid_t
+nindy_wait (ptid_t ptid, struct target_waitstatus *status)

 {
   fd_set fds;
   int c;
 {
   fd_set fds;
   int c;


@@ -348,11 +335,11 @@ nindy_wait( pid, status )
   /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
 
   /* Save current tty attributes, and restore them when done.  */
   /* 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 );
+  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
 #ifdef SIGTSTP

-  old_ctrlz = signal( SIGTSTP, clean_up_int );
+  old_ctrlz = signal (SIGTSTP, clean_up_int);

 #endif
 
   old_cleanups = make_cleanup (clean_up_tty, &tty_args);
 #endif
 
   old_cleanups = make_cleanup (clean_up_tty, &tty_args);


@@ -361,53 +348,53 @@ nindy_wait( pid, status )
      <CR> and perform echo.  */
   /* This used to set CBREAK and clear ECHO and CRMOD.  I hope this is close
      enough.  */
      <CR> and perform echo.  */
   /* This used to set CBREAK and clear ECHO and CRMOD.  I hope this is close
      enough.  */

-  SERIAL_RAW (tty_args.serial);
+  serial_raw (tty_args.serial);

 
   while (1)
     {
       /* Input on remote */
 
   while (1)
     {
       /* Input on remote */

-      c = SERIAL_READCHAR (nindy_serial, -1);
+      c = serial_readchar (nindy_serial, -1);

       if (c == SERIAL_ERROR)
        {
          error ("Cannot read from serial line");
        }
       if (c == SERIAL_ERROR)
        {
          error ("Cannot read from serial line");
        }

-      else if (c == 0x1b) /* ESC */
+      else if (c == 0x1b)      /* ESC */

        {
        {

-         c = SERIAL_READCHAR (nindy_serial, -1);
+         c = serial_readchar (nindy_serial, -1);

          c &= ~0x40;
          c &= ~0x40;

-       } 
-      else if (c != 0x10) /* DLE */
+       }
+      else if (c != 0x10)      /* DLE */

        /* Write out any characters preceding DLE */
        {
        /* Write out any characters preceding DLE */
        {

-         buf[0] = (char)c;
+         buf[0] = (char) c;

          write (1, buf, 1);
        }
       else
        {
          write (1, buf, 1);
        }
       else
        {

-         stop_exit = ninStopWhy(&stop_code,
-                                &ip_value, &fp_value, &sp_value);
+         stop_exit = ninStopWhy (&stop_code,
+                                 &ip_value, &fp_value, &sp_value);

          if (!stop_exit && (stop_code == STOP_SRQ))
            {
              immediate_quit++;
          if (!stop_exit && (stop_code == STOP_SRQ))
            {
              immediate_quit++;

-             ninSrq();
+             ninSrq ();

              immediate_quit--;
            }
          else
            {
              /* Get out of loop */
              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);
+             supply_register (IP_REGNUM,
+                              (char *) &ip_value);
+             supply_register (FP_REGNUM,
+                              (char *) &fp_value);
+             supply_register (SP_REGNUM,
+                              (char *) &sp_value);

              break;
            }
        }
     }
 
              break;
            }
        }
     }
 

-  SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
-  free (tty_args.state);
+  serial_set_tty_state (tty_args.serial, tty_args.state);
+  xfree (tty_args.state);

   discard_cleanups (old_cleanups);
 
   if (stop_exit)
   discard_cleanups (old_cleanups);
 
   if (stop_exit)


@@ -423,166 +410,92 @@ nindy_wait( pid, status )
       status->kind = TARGET_WAITKIND_STOPPED;
       status->value.sig = i960_fault_to_signal (stop_code);
     }
       status->kind = TARGET_WAITKIND_STOPPED;
       status->value.sig = i960_fault_to_signal (stop_code);
     }

-  return inferior_pid;
+  return inferior_ptid;

 }
 
 /* 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)
-     int regno;
+nindy_fetch_registers (int regno)

 {
   struct nindy_regs nindy_regs;
   int regnum;
 
   immediate_quit++;
 {
   struct nindy_regs nindy_regs;
   int regnum;
 
   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);
+  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
   memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], nindy_regs.fp_as_double, 4 * 8);
 
   registers_fetched ();
 }
 
 static void

-nindy_prepare_to_store()
+nindy_prepare_to_store (void)

 {
   /* 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)
-     int regno;
+nindy_store_registers (int regno)

 {
   struct nindy_regs nindy_regs;
   int regnum;
 
 {
   struct nindy_regs nindy_regs;
   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);
+  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--;
 }
 

-/* Read a word from remote address ADDR and return it.
- * This goes through the data cache.
- */
-int
-nindy_fetch_word (addr)
-     CORE_ADDR addr;
-{
-       return dcache_fetch (nindy_dcache, addr);
-}
-
-/* Write a word WORD into remote address ADDR.
-   This goes through the data cache.  */
-
-void
-nindy_store_word (addr, word)
-     CORE_ADDR addr;
-     int word;
-{
-       dcache_poke (nindy_dcache, addr, word);
-}
-

 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
    to debugger memory starting at MYADDR.   Copy to inferior if
 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
    to debugger memory starting at MYADDR.   Copy to inferior if

-   WRITE is nonzero.  Returns the length copied.
-
-   This is stolen almost directly from infptrace.c's child_xfer_memory,
-   which also deals with a word-oriented memory interface.  Sometime,
-   FIXME, rewrite this to not use the word-oriented routines.  */
+   SHOULD_WRITE is nonzero.  Returns the length copied.  TARGET is
+   unused.  */

 
 int
 
 int

-nindy_xfer_inferior_memory(memaddr, myaddr, len, should_write, target)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int should_write;
-     struct target_ops *target;                        /* ignored */
+nindy_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
+                           int should_write, struct mem_attrib *attrib,
+                           struct target_ops *target)

 {
 {

-  register int i;
-  /* Round starting address down to longword boundary.  */
-  register CORE_ADDR addr = memaddr & - sizeof (int);
-  /* Round ending address up; get number of longwords that makes.  */
-  register int count
-    = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
-  /* Allocate buffer of that many longwords.  */
-  register int *buffer = (int *) alloca (count * sizeof (int));
-
-  if (should_write)
-    {
-      /* 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 (count > 1)           /* FIXME, avoid if even boundary */
-       {
-         buffer[count - 1]
-           = nindy_fetch_word (addr + (count - 1) * sizeof (int));
-       }
-
-      /* Copy data to be written over corresponding part of buffer */
+  int res;

 
 

-      memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+  if (len <= 0)
+    return 0;

 
 

-      /* Write the entire buffer.  */
-
-      for (i = 0; i < count; i++, addr += sizeof (int))
-       {
-         errno = 0;
-         nindy_store_word (addr, buffer[i]);
-         if (errno)
-           return 0;
-       }
-    }
+  if (should_write)
+    res = ninMemPut (memaddr, myaddr, len);

   else
   else

-    {
-      /* Read all the longwords */
-      for (i = 0; i < count; i++, addr += sizeof (int))
-       {
-         errno = 0;
-         buffer[i] = nindy_fetch_word (addr);
-         if (errno)
-           return 0;
-         QUIT;
-       }
+    res = ninMemGet (memaddr, myaddr, len);

 
 

-      /* Copy appropriate bytes out of the buffer.  */
-      memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
-    }
-  return len;
+  return res;

 }
 \f
 static void
 }
 \f
 static void

-nindy_create_inferior (execfile, args, env)
-     char *execfile;
-     char *args;
-     char **env;
+nindy_create_inferior (char *execfile, char *args, char **env)

 {
   int entry_pt;
   int pid;
 {
   int entry_pt;
   int pid;


@@ -600,7 +513,7 @@ nindy_create_inferior (execfile, args, env)
   /* 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_ptid = pid_to_ptid (pid);   /* Needed for wait_for_inferior below */

 
   clear_proceed_status ();
 
 
   clear_proceed_status ();
 


@@ -616,31 +529,27 @@ nindy_create_inferior (execfile, args, env)
 
   /* insert_step_breakpoint ();  FIXME, do we need this?  */
   /* Let 'er rip... */
 
   /* insert_step_breakpoint ();  FIXME, do we need this?  */
   /* Let 'er rip... */

-  proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
+  proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);

 }
 
 static void
 }
 
 static void

-reset_command(args, from_tty)
-     char *args;
-     int from_tty;
+reset_command (char *args, int from_tty)

 {
   if (nindy_serial == NULL)
     {
 {
   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);
+      serial_send_break (nindy_serial);

       tty_flush (nindy_serial);
     }
 }
 
 void
       tty_flush (nindy_serial);
     }
 }
 
 void

-nindy_kill (args, from_tty)
-     char *args;
-     int from_tty;
+nindy_kill (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.


@@ -650,7 +559,7 @@ nindy_kill (args, from_tty)
    instructions.  */
 
 void
    instructions.  */
 
 void

-nindy_mourn_inferior ()
+nindy_mourn_inferior (void)

 {
   remove_breakpoints ();
   unpush_target (&nindy_ops);
 {
   remove_breakpoints ();
   unpush_target (&nindy_ops);


@@ -659,56 +568,52 @@ nindy_mourn_inferior ()
 \f
 /* Pass the args the way catch_errors wants them.  */
 static int
 \f
 /* Pass the args the way catch_errors wants them.  */
 static int

-nindy_open_stub (arg)
-     char *arg;
+nindy_open_stub (char *arg)

 {
   nindy_open (arg, 1);
   return 1;
 }
 
 static void
 {
   nindy_open (arg, 1);
   return 1;
 }
 
 static void

-nindy_load( filename, from_tty )
-    char *filename;
-    int from_tty;
+nindy_load (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
 {
   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);
+  bfd *file = bfd_openr (filename, 0);

   if (!file)
   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);
+      perror_with_name (filename);
+      return;
+    }
+
+  if (!bfd_check_format (file, bfd_object))
+    {
+      error ("can't prove it's an object file\n");
+      return;

     }
     }

-  }
-  bfd_close(file);
+
+  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);
+         xfree (buffer);
+       }
+    }
+  bfd_close (file);

 }
 
 static int
 }
 
 static int

-load_stub (arg)
-     char *arg;
+load_stub (char *arg)

 {
   target_load (arg, 1);
   return 1;
 {
   target_load (arg, 1);
   return 1;


@@ -723,102 +628,132 @@ load_stub (arg)
    an i960 object file on the host system.  */
 
 void
    an i960 object file on the host system.  */
 
 void

-nindy_before_main_loop ()
+nindy_before_main_loop (void)

 {
   char ttyname[100];
   char *p, *p2;
 
 {
   char ttyname[100];
   char *p, *p2;
 

-  while (target_stack->target_ops != &nindy_ops) /* What is this crap??? */
+  while (target_stack->target_ops != &nindy_ops)       /* What is this crap??? */

     {                          /* remote tty not specified yet */
     {                          /* remote tty not specified yet */

-       if ( instream == stdin ){
-               printf_unfiltered("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit:  ");
-               gdb_flush( gdb_stdout );
+      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 ;
-static void init_nindy_ops(void)
+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\
+  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_ops.to_doc =   "";
-  nindy_ops.to_open =   nindy_open;
-  nindy_ops.to_close =   nindy_close;
-  nindy_ops.to_attach =   0;
-  nindy_ops.to_detach =   nindy_detach;
-  nindy_ops.to_resume =   nindy_resume;
-  nindy_ops.to_wait  =   nindy_wait;
-  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_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_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 */
+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_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
 }
 
 void

-_initialize_nindy ()
+_initialize_nindy (void)

 {
 {

-  init_nindy_ops() ;
+  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\