* arm-linux-tdep.c (ARM_LINUX_JB_ELEMENT_SIZE): Define to

[binutils.git] / gdb / remote-vx.c

diff --git a/gdb/remote-vx.c b/gdb/remote-vx.c
index 9fe9894bfe1bc5a9c75ab0ebf52d5098dd669acc..fd51781b196629634d63f2899cd789a61423cfed 100644 (file)
--- a/gdb/remote-vx.c
+++ b/gdb/remote-vx.c
@@ -1,37 +1,41 @@
 /* Memory-access and commands for remote VxWorks processes, for GDB.
 /* Memory-access and commands for remote VxWorks processes, for GDB.

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

    Contributed by Wind River Systems and Cygnus Support.
 
    Contributed by Wind River Systems and Cygnus Support.
 

-This file is part of GDB.
+   This file is part of GDB.

 
 

-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.

 
 

-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.

 
 

-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */

 
 #include "defs.h"
 #include "frame.h"
 #include "inferior.h"
 
 #include "defs.h"
 #include "frame.h"
 #include "inferior.h"

-#include "wait.h"

 #include "target.h"
 #include "gdbcore.h"
 #include "command.h"
 #include "symtab.h"
 #include "complaints.h"
 #include "gdbcmd.h"
 #include "target.h"
 #include "gdbcore.h"
 #include "command.h"
 #include "symtab.h"
 #include "complaints.h"
 #include "gdbcmd.h"

-#include "bfd.h" /* Required by objfiles.h.  */
-#include "symfile.h" /* Required by objfiles.h.  */
+#include "bfd.h"               /* Required by objfiles.h.  */
+#include "symfile.h"

 #include "objfiles.h"
 #include "gdb-stabs.h"
 #include "objfiles.h"
 #include "gdb-stabs.h"

+#include "regcache.h"

 
 #include "gdb_string.h"
 #include <errno.h>
 
 #include "gdb_string.h"
 #include <errno.h>


@@ -63,18 +67,25 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 extern void vx_read_register ();
 extern void vx_write_register ();
 extern void symbol_file_command ();
 extern void vx_read_register ();
 extern void vx_write_register ();
 extern void symbol_file_command ();

-extern int stop_soon_quietly;          /* for wait_for_inferior */
+extern enum stop_kind stop_soon;       /* for wait_for_inferior */

 
 static int net_step ();
 static int net_ptrace_clnt_call ();    /* Forward decl */
 
 static int net_step ();
 static int net_ptrace_clnt_call ();    /* Forward decl */

-static enum clnt_stat net_clnt_call ();        /* Forward decl */
-extern struct target_ops vx_ops, vx_run_ops;   /* Forward declaration */
+static enum clnt_stat net_clnt_call ();                /* Forward decl */
+
+/* Target ops structure for accessing memory and such over the net */
+
+static struct target_ops vx_ops;
+
+/* Target ops structure for accessing VxWorks child processes over the net */
+
+static struct target_ops vx_run_ops;

 
 /* Saved name of target host and called function for "info files".
    Both malloc'd.  */
 
 static char *vx_host;
 
 /* Saved name of target host and called function for "info files".
    Both malloc'd.  */
 
 static char *vx_host;

-static char *vx_running;               /* Called function */
+static char *vx_running;       /* Called function */

 
 /* Nonzero means target that is being debugged remotely has a floating
    point processor.  */
 
 /* Nonzero means target that is being debugged remotely has a floating
    point processor.  */


@@ -85,28 +96,26 @@ int target_has_fp;
 
 static const char rpcerr[] = "network target debugging:  rpc error";
 
 
 static const char rpcerr[] = "network target debugging:  rpc error";
 

-CLIENT *pClient;         /* client used in net debugging */
+CLIENT *pClient;               /* client used in net debugging */

 static int ptraceSock = RPC_ANYSOCK;
 
 static int ptraceSock = RPC_ANYSOCK;
 

-enum clnt_stat net_clnt_call();
+enum clnt_stat net_clnt_call ();

 static void parse_args ();
 
 static void parse_args ();
 

-static struct timeval rpcTimeout = { 10, 0 };
+static struct timeval rpcTimeout =
+{10, 0};

 
 static char *skip_white_space ();
 static char *find_white_space ();
 
 static char *skip_white_space ();
 static char *find_white_space ();

- 
+

 /* Tell the VxWorks target system to download a file.
    The load addresses of the text, data, and bss segments are
    stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
    Returns 0 for success, -1 for failure.  */
 
 static int
 /* Tell the VxWorks target system to download a file.
    The load addresses of the text, data, and bss segments are
    stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
    Returns 0 for success, -1 for failure.  */
 
 static int

-net_load (filename, pTextAddr, pDataAddr, pBssAddr)
-     char *filename;
-     CORE_ADDR *pTextAddr;
-     CORE_ADDR *pDataAddr;
-     CORE_ADDR *pBssAddr;
+net_load (char *filename, CORE_ADDR *pTextAddr, CORE_ADDR *pDataAddr,
+         CORE_ADDR *pBssAddr)

 {
   enum clnt_stat status;
   struct ldfile ldstruct;
 {
   enum clnt_stat status;
   struct ldfile ldstruct;


@@ -123,9 +132,9 @@ net_load (filename, pTextAddr, pDataAddr, pBssAddr)
      Do not change the tv_sec value without checking -- select() imposes
      a limit of 10**8 on it for no good reason that I can see...  */
 
      Do not change the tv_sec value without checking -- select() imposes
      a limit of 10**8 on it for no good reason that I can see...  */
 

-  load_timeout.tv_sec = 99999999;   /* A large number, effectively inf. */
+  load_timeout.tv_sec = 99999999;      /* A large number, effectively inf. */

   load_timeout.tv_usec = 0;
   load_timeout.tv_usec = 0;

- 
+

   status = clnt_call (pClient, VX_LOAD, xdr_wrapstring, &filename, xdr_ldfile,
                      &ldstruct, load_timeout);
 
   status = clnt_call (pClient, VX_LOAD, xdr_wrapstring, &filename, xdr_ldfile,
                      &ldstruct, load_timeout);
 


@@ -145,37 +154,34 @@ net_load (filename, pTextAddr, pDataAddr, pBssAddr)
 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
 
 static int
 /* returns 0 if successful, errno if RPC failed or VxWorks complains. */
 
 static int

-net_break (addr, procnum)
-     int addr;
-     u_long procnum;
+net_break (int addr, u_long procnum)

 {
   enum clnt_stat status;
   int break_status;
 {
   enum clnt_stat status;
   int break_status;

-  Rptrace ptrace_in;  /* XXX This is stupid.  It doesn't need to be a ptrace
-                        structure.  How about something smaller? */
+  Rptrace ptrace_in;           /* XXX This is stupid.  It doesn't need to be a ptrace
+                                  structure.  How about something smaller? */

 
   memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
   break_status = 0;
 
   ptrace_in.addr = addr;
 
   memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
   break_status = 0;
 
   ptrace_in.addr = addr;

-  ptrace_in.pid = inferior_pid;
+  ptrace_in.pid = PIDGET (inferior_ptid);

 
   status = net_clnt_call (procnum, xdr_rptrace, &ptrace_in, xdr_int,
                          &break_status);
 
   if (status != RPC_SUCCESS)
 
   status = net_clnt_call (procnum, xdr_rptrace, &ptrace_in, xdr_int,
                          &break_status);
 
   if (status != RPC_SUCCESS)

-      return errno;
+    return errno;

 
   if (break_status == -1)
     return ENOMEM;
 
   if (break_status == -1)
     return ENOMEM;

-  return break_status; /* probably (FIXME) zero */
+  return break_status;         /* probably (FIXME) zero */

 }
 
 /* returns 0 if successful, errno otherwise */
 
 static int
 }
 
 /* returns 0 if successful, errno otherwise */
 
 static int

-vx_insert_breakpoint (addr)
-     int addr;
+vx_insert_breakpoint (int addr)

 {
   return net_break (addr, VX_BREAK_ADD);
 }
 {
   return net_break (addr, VX_BREAK_ADD);
 }


@@ -183,24 +189,20 @@ vx_insert_breakpoint (addr)
 /* returns 0 if successful, errno otherwise */
 
 static int
 /* returns 0 if successful, errno otherwise */
 
 static int

-vx_remove_breakpoint (addr)
-     int addr;
+vx_remove_breakpoint (int addr)

 {
   return net_break (addr, VX_BREAK_DELETE);
 }
 
 {
   return net_break (addr, VX_BREAK_DELETE);
 }
 

-/* Start an inferior process and sets inferior_pid to its pid.
+/* Start an inferior process and sets inferior_ptid to its pid.

    EXEC_FILE is the file to run.
    ALLARGS is a string containing the arguments to the program.
    ENV is the environment vector to pass.
    Returns process id.  Errors reported with error().
    On VxWorks, we ignore exec_file.  */
    EXEC_FILE is the file to run.
    ALLARGS is a string containing the arguments to the program.
    ENV is the environment vector to pass.
    Returns process id.  Errors reported with error().
    On VxWorks, we ignore exec_file.  */

- 
+

 static void
 static void

-vx_create_inferior (exec_file, args, env)
-     char *exec_file;
-     char *args;
-     char **env;
+vx_create_inferior (char *exec_file, char *args, char **env)

 {
   enum clnt_stat status;
   arg_array passArgs;
 {
   enum clnt_stat status;
   arg_array passArgs;


@@ -227,7 +229,7 @@ vx_create_inferior (exec_file, args, env)
                           strlen (passArgs.arg_array_val[0]));
 
   push_target (&vx_run_ops);
                           strlen (passArgs.arg_array_val[0]));
 
   push_target (&vx_run_ops);

-  inferior_pid = taskStart.pid;
+  inferior_ptid = pid_to_ptid (taskStart.pid);

 
   /* We will get a trace trap after one instruction.
      Insert breakpoints and continue.  */
 
   /* We will get a trace trap after one instruction.
      Insert breakpoints and continue.  */


@@ -241,9 +243,9 @@ vx_create_inferior (exec_file, args, env)
   /* Install inferior's terminal modes.  */
   target_terminal_inferior ();
 
   /* Install inferior's terminal modes.  */
   target_terminal_inferior ();
 

-  stop_soon_quietly = 1;
+  stop_soon = STOP_QUIETLY;

   wait_for_inferior ();                /* Get the task spawn event */
   wait_for_inferior ();                /* Get the task spawn event */

-  stop_soon_quietly = 0;
+  stop_soon = NO_STOP_QUIETLY;

 
   /* insert_step_breakpoint ();  FIXME, do we need this?  */
   proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
 
   /* insert_step_breakpoint ();  FIXME, do we need this?  */
   proceed (-1, TARGET_SIGNAL_DEFAULT, 0);


@@ -253,16 +255,14 @@ vx_create_inferior (exec_file, args, env)
    argument string ARGSTRING.  */
 
 static void
    argument string ARGSTRING.  */
 
 static void

-parse_args (arg_string, arg_struct)
-     register char *arg_string;
-     arg_array *arg_struct;
+parse_args (char *arg_string, arg_array *arg_struct)

 {
 {

-  register int arg_count = 0;  /* number of arguments */
-  register int arg_index = 0;
-  register char *p0;
- 
+  int arg_count = 0;   /* number of arguments */
+  int arg_index = 0;
+  char *p0;
+

   memset ((char *) arg_struct, '\0', sizeof (arg_array));
   memset ((char *) arg_struct, '\0', sizeof (arg_array));

- 
+

   /* first count how many arguments there are */
 
   p0 = arg_string;
   /* first count how many arguments there are */
 
   p0 = arg_string;


@@ -295,23 +295,21 @@ parse_args (arg_string, arg_struct)
    to the first non-white character.  */
 
 static char *
    to the first non-white character.  */
 
 static char *

-skip_white_space (p)
-     register char *p;
+skip_white_space (char *p)

 {
   while (*p == ' ' || *p == '\t')
     p++;
   return p;
 }
 {
   while (*p == ' ' || *p == '\t')
     p++;
   return p;
 }

-    
+

 /* Search for the first unquoted whitespace character in a string.
    Returns a pointer to the character, or to the null terminator
    if no whitespace is found.  */
 
 static char *
 /* Search for the first unquoted whitespace character in a string.
    Returns a pointer to the character, or to the null terminator
    if no whitespace is found.  */
 
 static char *

-find_white_space (p)
-     register char *p;
+find_white_space (char *p)

 {
 {

-  register int c;
+  int c;

 
   while ((c = *p) != ' ' && c != '\t' && c)
     {
 
   while ((c = *p) != ' ' && c != '\t' && c)
     {


@@ -329,38 +327,37 @@ find_white_space (p)
     }
   return p;
 }
     }
   return p;
 }

-    
+

 /* Poll the VxWorks target system for an event related
    to the debugged task.
    Returns -1 if remote wait failed, task status otherwise.  */
 
 static int
 /* Poll the VxWorks target system for an event related
    to the debugged task.
    Returns -1 if remote wait failed, task status otherwise.  */
 
 static int

-net_wait (pEvent)
-    RDB_EVENT *pEvent;
+net_wait (RDB_EVENT *pEvent)

 {
 {

-    int pid;
-    enum clnt_stat status;
-
-    memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));
-
-    pid = inferior_pid;
-    status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT,
-                           pEvent);
-
-    /* return (status == RPC_SUCCESS)? pEvent->status: -1; */
-    if (status == RPC_SUCCESS)
-      return ((pEvent->status) ? 1 : 0);
-    else if (status == RPC_TIMEDOUT)
-      return (1);
-    else
-      return (-1);
+  int pid;
+  enum clnt_stat status;
+
+  memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));
+
+  pid = PIDGET (inferior_ptid);
+  status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT,
+                         pEvent);
+
+  /* return (status == RPC_SUCCESS)? pEvent->status: -1; */
+  if (status == RPC_SUCCESS)
+    return ((pEvent->status) ? 1 : 0);
+  else if (status == RPC_TIMEDOUT)
+    return (1);
+  else
+    return (-1);

 }
 }

-    
+

 /* Suspend the remote task.
    Returns -1 if suspend fails on target system, 0 otherwise.  */
 
 static int
 /* Suspend the remote task.
    Returns -1 if suspend fails on target system, 0 otherwise.  */
 
 static int

-net_quit ()
+net_quit (void)

 {
   int pid;
   int quit_status;
 {
   int pid;
   int quit_status;


@@ -370,22 +367,19 @@ net_quit ()
 
   /* don't let rdbTask suspend itself by passing a pid of 0 */
 
 
   /* don't let rdbTask suspend itself by passing a pid of 0 */
 

-  if ((pid = inferior_pid) == 0)
+  if ((pid = PIDGET (inferior_ptid)) == 0)

     return -1;
 
   status = net_clnt_call (VX_TASK_SUSPEND, xdr_int, &pid, xdr_int,
                          &quit_status);
 
     return -1;
 
   status = net_clnt_call (VX_TASK_SUSPEND, xdr_int, &pid, xdr_int,
                          &quit_status);
 

-  return (status == RPC_SUCCESS)? quit_status: -1;
+  return (status == RPC_SUCCESS) ? quit_status : -1;

 }
 
 /* Read a register or registers from the remote system.  */
 
 void
 }
 
 /* Read a register or registers from the remote system.  */
 
 void

-net_read_registers (reg_buf, len, procnum)
-     char *reg_buf;
-     int len;
-     u_long procnum;
+net_read_registers (char *reg_buf, int len, u_long procnum)

 {
   int status;
   Rptrace ptrace_in;
 {
   int status;
   Rptrace ptrace_in;


@@ -398,14 +392,14 @@ net_read_registers (reg_buf, len, procnum)
 
   /* Initialize RPC input argument structure.  */
 
 
   /* Initialize RPC input argument structure.  */
 

-  ptrace_in.pid = inferior_pid;
+  ptrace_in.pid = PIDGET (inferior_ptid);

   ptrace_in.info.ttype = NOINFO;
 
   /* Initialize RPC return value structure.  */
 
   out_data.bytes = reg_buf;
   out_data.len = len;
   ptrace_in.info.ttype = NOINFO;
 
   /* Initialize RPC return value structure.  */
 
   out_data.bytes = reg_buf;
   out_data.len = len;

-  ptrace_out.info.more_data = (caddr_t) &out_data;
+  ptrace_out.info.more_data = (caddr_t) & out_data;

 
   /* Call RPC; take an error exit if appropriate.  */
 
 
   /* Call RPC; take an error exit if appropriate.  */
 


@@ -414,10 +408,10 @@ net_read_registers (reg_buf, len, procnum)
     error (rpcerr);
   if (ptrace_out.status == -1)
     {
     error (rpcerr);
   if (ptrace_out.status == -1)
     {

-      errno = ptrace_out.errno;
+      errno = ptrace_out.errno_num;

       sprintf (message, "reading %s registers", (procnum == PTRACE_GETREGS)
       sprintf (message, "reading %s registers", (procnum == PTRACE_GETREGS)

-                                                ? "general-purpose"
-                                                : "floating-point");
+              ? "general-purpose"
+              : "floating-point");

       perror_with_name (message);
     }
 }
       perror_with_name (message);
     }
 }


@@ -430,10 +424,7 @@ net_read_registers (reg_buf, len, procnum)
    a utility routine used by vx_write_register ().  */
 
 void
    a utility routine used by vx_write_register ().  */
 
 void

-net_write_registers (reg_buf, len, procnum)
-     char *reg_buf;
-     int len;
-     u_long procnum;
+net_write_registers (char *reg_buf, int len, u_long procnum)

 {
   int status;
   Rptrace ptrace_in;
 {
   int status;
   Rptrace ptrace_in;


@@ -449,9 +440,9 @@ net_write_registers (reg_buf, len, procnum)
   in_data.bytes = reg_buf;
   in_data.len = len;
 
   in_data.bytes = reg_buf;
   in_data.len = len;
 

-  ptrace_in.pid = inferior_pid;
+  ptrace_in.pid = PIDGET (inferior_ptid);

   ptrace_in.info.ttype = DATA;
   ptrace_in.info.ttype = DATA;

-  ptrace_in.info.more_data = (caddr_t) &in_data;
+  ptrace_in.info.more_data = (caddr_t) & in_data;

 
   /* Call RPC; take an error exit if appropriate.  */
 
 
   /* Call RPC; take an error exit if appropriate.  */
 


@@ -460,10 +451,10 @@ net_write_registers (reg_buf, len, procnum)
     error (rpcerr);
   if (ptrace_out.status == -1)
     {
     error (rpcerr);
   if (ptrace_out.status == -1)
     {

-      errno = ptrace_out.errno;
+      errno = ptrace_out.errno_num;

       sprintf (message, "writing %s registers", (procnum == PTRACE_SETREGS)
       sprintf (message, "writing %s registers", (procnum == PTRACE_SETREGS)

-                                                ? "general-purpose"
-                                                : "floating-point");
+              ? "general-purpose"
+              : "floating-point");

       perror_with_name (message);
     }
 }
       perror_with_name (message);
     }
 }


@@ -472,27 +463,23 @@ net_write_registers (reg_buf, len, procnum)
    read out their current values now.  */
 
 static void
    read out their current values now.  */
 
 static void

-vx_prepare_to_store ()
+vx_prepare_to_store (void)

 {
   /* Fetch all registers, if any of them are not yet fetched.  */
 {
   /* Fetch all registers, if any of them are not yet fetched.  */

-  read_register_bytes (0, NULL, REGISTER_BYTES);
+  deprecated_read_register_bytes (0, NULL, DEPRECATED_REGISTER_BYTES);

 }
 
 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
    to debugger memory starting at MYADDR.  WRITE is true if writing to the
 }
 
 /* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
    to debugger memory starting at MYADDR.  WRITE is true if writing to the

-   inferior.
+   inferior.  TARGET is unused.

    Result is the number of bytes written or read (zero if error).  The
    protocol allows us to return a negative count, indicating that we can't
    handle the current address but can handle one N bytes further, but
    vxworks doesn't give us that information.  */
 
 static int
    Result is the number of bytes written or read (zero if error).  The
    protocol allows us to return a negative count, indicating that we can't
    handle the current address but can handle one N bytes further, but
    vxworks doesn't give us that information.  */
 
 static int

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

 {
   int status;
   Rptrace ptrace_in;
 {
   int status;
   Rptrace ptrace_in;


@@ -504,22 +491,22 @@ vx_xfer_memory (memaddr, myaddr, len, write, target)
   memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
   memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
 
   memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
   memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
 

-  ptrace_in.pid = inferior_pid;                /* XXX pid unnecessary for READDATA */
+  ptrace_in.pid = PIDGET (inferior_ptid); /* XXX pid unnecessary for READDATA */

   ptrace_in.addr = (int) memaddr;      /* Where from */
   ptrace_in.addr = (int) memaddr;      /* Where from */

-  ptrace_in.data = len;                        /* How many bytes */
+  ptrace_in.data = len;                /* How many bytes */

 
   if (write)
     {
 
   if (write)
     {

-      ptrace_in.info.ttype     = DATA;
-      ptrace_in.info.more_data = (caddr_t) &data;
+      ptrace_in.info.ttype = DATA;
+      ptrace_in.info.more_data = (caddr_t) & data;

 
       data.bytes = (caddr_t) myaddr;   /* Where from */
 
       data.bytes = (caddr_t) myaddr;   /* Where from */

-      data.len   = len;                        /* How many bytes (again, for XDR) */
+      data.len = len;          /* How many bytes (again, for XDR) */

       request = PTRACE_WRITEDATA;
     }
   else
     {
       request = PTRACE_WRITEDATA;
     }
   else
     {

-      ptrace_out.info.more_data = (caddr_t) &data;
+      ptrace_out.info.more_data = (caddr_t) & data;

       request = PTRACE_READDATA;
     }
   /* Loop until the entire request has been satisfied, transferring
       request = PTRACE_READDATA;
     }
   /* Loop until the entire request has been satisfied, transferring


@@ -542,23 +529,23 @@ vx_xfer_memory (memaddr, myaddr, len, write, target)
          report an error and return to debugger command level.  */
 
       if (net_ptrace_clnt_call (request, &ptrace_in, &ptrace_out))
          report an error and return to debugger command level.  */
 
       if (net_ptrace_clnt_call (request, &ptrace_in, &ptrace_out))

-        error (rpcerr);
+       error (rpcerr);

 
       status = ptrace_out.status;
       if (status == 0)
 
       status = ptrace_out.status;
       if (status == 0)

-        {
-          memaddr += nxfer;
-          myaddr += nxfer;
-          nleft -= nxfer;
-        }
+       {
+         memaddr += nxfer;
+         myaddr += nxfer;
+         nleft -= nxfer;
+       }

       else
       else

-        {
-          /* A target-side error has ocurred.  Set errno to the error
-             code chosen by the target so that a later perror () will
-             say something meaningful.  */
+       {
+         /* A target-side error has ocurred.  Set errno to the error
+            code chosen by the target so that a later perror () will
+            say something meaningful.  */

 
 

-          errno = ptrace_out.errno;
-        }
+         errno = ptrace_out.errno_num;
+       }

     }
 
   /* Return the number of bytes transferred.  */
     }
 
   /* Return the number of bytes transferred.  */


@@ -567,37 +554,34 @@ vx_xfer_memory (memaddr, myaddr, len, write, target)
 }
 
 static void
 }
 
 static void

-vx_files_info ()
+vx_files_info (void)

 {
   printf_unfiltered ("\tAttached to host `%s'", vx_host);
 {
   printf_unfiltered ("\tAttached to host `%s'", vx_host);

-  printf_unfiltered (", which has %sfloating point", target_has_fp? "": "no ");
+  printf_unfiltered (", which has %sfloating point", target_has_fp ? "" : "no ");

   printf_unfiltered (".\n");
 }
 
 static void
   printf_unfiltered (".\n");
 }
 
 static void

-vx_run_files_info ()
+vx_run_files_info (void)

 {
 {

-  printf_unfiltered ("\tRunning %s VxWorks process %s", 
+  printf_unfiltered ("\tRunning %s VxWorks process %s",

                     vx_running ? "child" : "attached",
                     vx_running ? "child" : "attached",

-                    local_hex_string (inferior_pid));
+                    local_hex_string (PIDGET (inferior_ptid)));

   if (vx_running)
     printf_unfiltered (", function `%s'", vx_running);
   if (vx_running)
     printf_unfiltered (", function `%s'", vx_running);

-  printf_unfiltered(".\n");
+  printf_unfiltered (".\n");

 }
 
 static void
 }
 
 static void

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

 {
   int status;
   Rptrace ptrace_in;
   Ptrace_return ptrace_out;
   CORE_ADDR cont_addr;
 
 {
   int status;
   Rptrace ptrace_in;
   Ptrace_return ptrace_out;
   CORE_ADDR cont_addr;
 

-  if (pid == -1)
-    pid = inferior_pid;
+  if (ptid_equal (ptid, minus_one_ptid))
+    ptid = inferior_ptid;

 
   if (siggnal != 0 && siggnal != stop_signal)
     error ("Cannot send signals to VxWorks processes");
 
   if (siggnal != 0 && siggnal != stop_signal)
     error ("Cannot send signals to VxWorks processes");


@@ -617,11 +601,11 @@ vx_resume (pid, step, siggnal)
   memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
   memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
 
   memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
   memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
 

-  ptrace_in.pid = pid;
-  ptrace_in.addr = cont_addr; /* Target side insists on this, or it panics.  */
+  ptrace_in.pid = PIDGET (ptid);
+  ptrace_in.addr = cont_addr;  /* Target side insists on this, or it panics.  */

 
   if (step)
 
   if (step)

-    status = net_step();
+    status = net_step ();

   else
     status = net_ptrace_clnt_call (PTRACE_CONT, &ptrace_in, &ptrace_out);
 
   else
     status = net_ptrace_clnt_call (PTRACE_CONT, &ptrace_in, &ptrace_out);
 


@@ -629,37 +613,34 @@ vx_resume (pid, step, siggnal)
     error (rpcerr);
   if (ptrace_out.status == -1)
     {
     error (rpcerr);
   if (ptrace_out.status == -1)
     {

-      errno = ptrace_out.errno;
+      errno = ptrace_out.errno_num;

       perror_with_name ("Resuming remote process");
     }
 }
 
 static void
       perror_with_name ("Resuming remote process");
     }
 }
 
 static void

-vx_mourn_inferior ()
+vx_mourn_inferior (void)

 {
   pop_target ();               /* Pop back to no-child state */
   generic_mourn_inferior ();
 }
 {
   pop_target ();               /* Pop back to no-child state */
   generic_mourn_inferior ();
 }

-

 \f
 \f

-static void vx_add_symbols PARAMS ((char *, int, CORE_ADDR, CORE_ADDR,
-                                   CORE_ADDR));

 
 

-struct find_sect_args {
-  CORE_ADDR text_start;
-  CORE_ADDR data_start;
-  CORE_ADDR bss_start;
-};
+static void vx_add_symbols (char *, int, CORE_ADDR, CORE_ADDR, CORE_ADDR);
+
+struct find_sect_args
+  {
+    CORE_ADDR text_start;
+    CORE_ADDR data_start;
+    CORE_ADDR bss_start;
+  };

 
 

-static void find_sect PARAMS ((bfd *, asection *, void *));
+static void find_sect (bfd *, asection *, void *);

 
 static void
 
 static void

-find_sect (abfd, sect, obj)
-     bfd *abfd;
-     asection *sect;
-     PTR obj;
+find_sect (bfd *abfd, asection *sect, void *obj)

 {
 {

-  struct find_sect_args *args = (struct find_sect_args *)obj;
+  struct find_sect_args *args = (struct find_sect_args *) obj;

 
   if (bfd_get_section_flags (abfd, sect) & (SEC_CODE & SEC_READONLY))
     args->text_start = bfd_get_section_vma (abfd, sect);
 
   if (bfd_get_section_flags (abfd, sect) & (SEC_CODE & SEC_READONLY))
     args->text_start = bfd_get_section_vma (abfd, sect);


@@ -678,12 +659,8 @@ find_sect (abfd, sect, obj)
 }
 
 static void
 }
 
 static void

-vx_add_symbols (name, from_tty, text_addr, data_addr, bss_addr)
-     char *name;
-     int from_tty;
-     CORE_ADDR text_addr;
-     CORE_ADDR data_addr;
-     CORE_ADDR bss_addr;
+vx_add_symbols (char *name, int from_tty, CORE_ADDR text_addr,
+               CORE_ADDR data_addr, CORE_ADDR bss_addr)

 {
   struct section_offsets *offs;
   struct objfile *objfile;
 {
   struct section_offsets *offs;
   struct objfile *objfile;


@@ -691,19 +668,18 @@ vx_add_symbols (name, from_tty, text_addr, data_addr, bss_addr)
 
   /* It might be nice to suppress the breakpoint_re_set which happens here
      because we are going to do one again after the objfile_relocate.  */
 
   /* It might be nice to suppress the breakpoint_re_set which happens here
      because we are going to do one again after the objfile_relocate.  */

-  objfile = symbol_file_add (name, from_tty, 0, 0, 0, 0);
+  objfile = symbol_file_add (name, from_tty, NULL, 0, 0);

 
   /* This is a (slightly cheesy) way of superceding the old symbols.  A less
      cheesy way would be to find the objfile with the same name and
      free_objfile it.  */
   objfile_to_front (objfile);
 
 
   /* This is a (slightly cheesy) way of superceding the old symbols.  A less
      cheesy way would be to find the objfile with the same name and
      free_objfile it.  */
   objfile_to_front (objfile);
 

-  offs = (struct section_offsets *)
-    alloca (sizeof (struct section_offsets)
-           + objfile->num_sections * sizeof (offs->offsets));
+  offs =
+    (struct section_offsets *)
+    alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));

   memcpy (offs, objfile->section_offsets,
   memcpy (offs, objfile->section_offsets,

-         sizeof (struct section_offsets)
-         + objfile->num_sections * sizeof (offs->offsets));
+          SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));

 
   ss.text_start = 0;
   ss.data_start = 0;
 
   ss.text_start = 0;
   ss.data_start = 0;


@@ -711,18 +687,16 @@ vx_add_symbols (name, from_tty, text_addr, data_addr, bss_addr)
   bfd_map_over_sections (objfile->obfd, find_sect, &ss);
 
   /* Both COFF and b.out frontends use these SECT_OFF_* values.  */
   bfd_map_over_sections (objfile->obfd, find_sect, &ss);
 
   /* Both COFF and b.out frontends use these SECT_OFF_* values.  */

-  ANOFFSET (offs, SECT_OFF_TEXT) = text_addr - ss.text_start;
-  ANOFFSET (offs, SECT_OFF_DATA) = data_addr - ss.data_start;
-  ANOFFSET (offs, SECT_OFF_BSS) = bss_addr - ss.bss_start;
+  offs->offsets[SECT_OFF_TEXT (objfile)]  = text_addr - ss.text_start;
+  offs->offsets[SECT_OFF_DATA (objfile)] = data_addr - ss.data_start;
+  offs->offsets[SECT_OFF_BSS (objfile)] = bss_addr - ss.bss_start;

   objfile_relocate (objfile, offs);
 }
 
 /* This function allows the addition of incrementally linked object files.  */
 
 static void
   objfile_relocate (objfile, offs);
 }
 
 /* This function allows the addition of incrementally linked object files.  */
 
 static void

-vx_load_command (arg_string, from_tty)
-     char *arg_string;
-     int from_tty;
+vx_load_command (char *arg_string, int from_tty)

 {
   CORE_ADDR text_addr;
   CORE_ADDR data_addr;
 {
   CORE_ADDR text_addr;
   CORE_ADDR data_addr;


@@ -732,20 +706,20 @@ vx_load_command (arg_string, from_tty)
     error ("The load command takes a file name");
 
   arg_string = tilde_expand (arg_string);
     error ("The load command takes a file name");
 
   arg_string = tilde_expand (arg_string);

-  make_cleanup (free, arg_string);
+  make_cleanup (xfree, arg_string);

 
   dont_repeat ();
 
   /* Refuse to load the module if a debugged task is running.  Doing so
      can have a number of unpleasant consequences to the running task.  */
 
 
   dont_repeat ();
 
   /* Refuse to load the module if a debugged task is running.  Doing so
      can have a number of unpleasant consequences to the running task.  */
 

-  if (inferior_pid != 0 && target_has_execution)
+  if (PIDGET (inferior_ptid) != 0 && target_has_execution)

     {
       if (query ("You may not load a module while the target task is running.\n\
 Kill the target task? "))
     {
       if (query ("You may not load a module while the target task is running.\n\
 Kill the target task? "))

-        target_kill ();
+       target_kill ();

       else
       else

-        error ("Load cancelled.");
+       error ("Load canceled.");

     }
 
   QUIT;
     }
 
   QUIT;


@@ -766,13 +740,13 @@ Kill the target task? "))
    Returns -1 if remote single-step operation fails, else 0.  */
 
 static int
    Returns -1 if remote single-step operation fails, else 0.  */
 
 static int

-net_step ()
+net_step (void)

 {
   enum clnt_stat status;
   int step_status;
   SOURCE_STEP source_step;
 
 {
   enum clnt_stat status;
   int step_status;
   SOURCE_STEP source_step;
 

-  source_step.taskId = inferior_pid;
+  source_step.taskId = PIDGET (inferior_ptid);

 
   if (step_range_end)
     {
 
   if (step_range_end)
     {


@@ -790,7 +764,7 @@ net_step ()
 
   if (status == RPC_SUCCESS)
     return step_status;
 
   if (status == RPC_SUCCESS)
     return step_status;

-  else 
+  else

     error (rpcerr);
 }
 
     error (rpcerr);
 }
 


@@ -798,10 +772,8 @@ net_step ()
    Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise.  */
 
 static int
    Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise.  */
 
 static int

-net_ptrace_clnt_call (request, pPtraceIn, pPtraceOut)
-    enum ptracereq request;
-    Rptrace *pPtraceIn;
-    Ptrace_return *pPtraceOut;
+net_ptrace_clnt_call (enum ptracereq request, Rptrace *pPtraceIn,
+                     Ptrace_return *pPtraceOut)

 {
   enum clnt_stat status;
 
 {
   enum clnt_stat status;
 


@@ -809,7 +781,7 @@ net_ptrace_clnt_call (request, pPtraceIn, pPtraceOut)
                          pPtraceOut);
 
   if (status != RPC_SUCCESS)
                          pPtraceOut);
 
   if (status != RPC_SUCCESS)

-      return -1;
+    return -1;

 
   return 0;
 }
 
   return 0;
 }


@@ -821,8 +793,7 @@ net_ptrace_clnt_call (request, pPtraceIn, pPtraceOut)
    Returns -1 if rpc failed, 0 otherwise.  */
 
 static int
    Returns -1 if rpc failed, 0 otherwise.  */
 
 static int

-net_get_boot_file (pBootFile)
-     char **pBootFile;
+net_get_boot_file (char **pBootFile)

 {
   enum clnt_stat status;
 
 {
   enum clnt_stat status;
 


@@ -831,14 +802,14 @@ net_get_boot_file (pBootFile)
   return (status == RPC_SUCCESS) ? 0 : -1;
 }
 
   return (status == RPC_SUCCESS) ? 0 : -1;
 }
 

-/* Fetch a list of loaded object modules from the VxWorks target.
+/* Fetch a list of loaded object modules from the VxWorks target
+   and store in PLOADTABLE.

    Returns -1 if rpc failed, 0 otherwise
    There's no way to check if the returned loadTable is correct.
    VxWorks doesn't check it.  */
 
 static int
    Returns -1 if rpc failed, 0 otherwise
    There's no way to check if the returned loadTable is correct.
    VxWorks doesn't check it.  */
 
 static int

-net_get_symbols (pLoadTable)
-     ldtabl *pLoadTable;               /* return pointer to ldtabl here */
+net_get_symbols (ldtabl *pLoadTable)

 {
   enum clnt_stat status;
 
 {
   enum clnt_stat status;
 


@@ -852,13 +823,9 @@ net_get_symbols (pLoadTable)
    Returns status of symbol read on target side (0=success, -1=fail)
    Returns -1 and complain()s if rpc fails.  */
 
    Returns status of symbol read on target side (0=success, -1=fail)
    Returns -1 and complain()s if rpc fails.  */
 

-struct complaint cant_contact_target =
-  {"Lost contact with VxWorks target", 0, 0};
-

 static int
 static int

-vx_lookup_symbol (name, pAddr)
-     char *name;               /* symbol name */
-     CORE_ADDR *pAddr;
+vx_lookup_symbol (char *name,  /* symbol name */
+                 CORE_ADDR *pAddr)

 {
   enum clnt_stat status;
   SYMBOL_ADDR symbolAddr;
 {
   enum clnt_stat status;
   SYMBOL_ADDR symbolAddr;


@@ -870,7 +837,7 @@ vx_lookup_symbol (name, pAddr)
                          xdr_SYMBOL_ADDR, &symbolAddr);
   if (status != RPC_SUCCESS)
     {
                          xdr_SYMBOL_ADDR, &symbolAddr);
   if (status != RPC_SUCCESS)
     {

-      complain (&cant_contact_target);
+      complaint (&symfile_complaints, "Lost contact with VxWorks target");

       return -1;
     }
 
       return -1;
     }
 


@@ -883,24 +850,23 @@ vx_lookup_symbol (name, pAddr)
    Calls error() if rpc fails.  */
 
 static int
    Calls error() if rpc fails.  */
 
 static int

-net_check_for_fp ()
+net_check_for_fp (void)

 {
   enum clnt_stat status;
 {
   enum clnt_stat status;

-  bool_t fp = 0;       /* true if fp processor is present on target board */
+  bool_t fp = 0;               /* true if fp processor is present on target board */

 
   status = net_clnt_call (VX_FP_INQUIRE, xdr_void, 0, xdr_bool, &fp);
   if (status != RPC_SUCCESS)
     error (rpcerr);
 
 
   status = net_clnt_call (VX_FP_INQUIRE, xdr_void, 0, xdr_bool, &fp);
   if (status != RPC_SUCCESS)
     error (rpcerr);
 

-   return (int) fp;
+  return (int) fp;

 }
 
 /* Establish an RPC connection with the VxWorks target system.
    Calls error () if unable to establish connection.  */
 
 static void
 }
 
 /* Establish an RPC connection with the VxWorks target system.
    Calls error () if unable to establish connection.  */
 
 static void

-net_connect (host)
-     char *host;
+net_connect (char *host)

 {
   struct sockaddr_in destAddr;
   struct hostent *destHost;
 {
   struct sockaddr_in destAddr;
   struct hostent *destHost;


@@ -918,15 +884,15 @@ net_connect (host)
           For example if the user types "target vxworks vx960 " it should
           say "Invalid host `vx960 '." not just "Invalid hostname".  */
        error ("Invalid hostname.  Couldn't find remote host address.");
           For example if the user types "target vxworks vx960 " it should
           say "Invalid host `vx960 '." not just "Invalid hostname".  */
        error ("Invalid hostname.  Couldn't find remote host address.");

-      addr = * (unsigned long *) destHost->h_addr;
+      addr = *(unsigned long *) destHost->h_addr;

     }
 
   memset (&destAddr, '\0', sizeof (destAddr));
 
   destAddr.sin_addr.s_addr = addr;
     }
 
   memset (&destAddr, '\0', sizeof (destAddr));
 
   destAddr.sin_addr.s_addr = addr;

-  destAddr.sin_family      = AF_INET;
-  destAddr.sin_port        = 0;        /* set to actual port that remote
-                                  ptrace is listening on.  */
+  destAddr.sin_family = AF_INET;
+  destAddr.sin_port = 0;       /* set to actual port that remote
+                                  ptrace is listening on.  */

 
   /* Create a tcp client transport on which to issue
      calls to the remote ptrace server.  */
 
   /* Create a tcp client transport on which to issue
      calls to the remote ptrace server.  */


@@ -950,8 +916,7 @@ net_connect (host)
  */
 
 static void
  */
 
 static void

-sleep_ms (ms)
-     long ms;
+sleep_ms (long ms)

 {
   struct timeval select_timeout;
   int status;
 {
   struct timeval select_timeout;
   int status;


@@ -966,19 +931,17 @@ sleep_ms (ms)
     perror_with_name ("select");
 }
 
     perror_with_name ("select");
 }
 

-static int
-vx_wait (pid_to_wait_for, status)
-     int pid_to_wait_for;
-     struct target_waitstatus *status;
+static ptid_t
+vx_wait (ptid_t ptid_to_wait_for, struct target_waitstatus *status)

 {
 {

-  register int pid;
+  int pid;

   RDB_EVENT rdbEvent;
   int quit_failed;
 
   do
     {
       /* If CTRL-C is hit during this loop,
   RDB_EVENT rdbEvent;
   int quit_failed;
 
   do
     {
       /* If CTRL-C is hit during this loop,

-        suspend the inferior process.  */
+         suspend the inferior process.  */

 
       quit_failed = 0;
       if (quit_flag)
 
       quit_failed = 0;
       if (quit_flag)


@@ -988,19 +951,19 @@ vx_wait (pid_to_wait_for, status)
        }
 
       /* If a net_quit () or net_wait () call has failed,
        }
 
       /* If a net_quit () or net_wait () call has failed,

-        allow the user to break the connection with the target.
-        We can't simply error () out of this loop, since the 
-        data structures representing the state of the inferior
-        are in an inconsistent state.  */
+         allow the user to break the connection with the target.
+         We can't simply error () out of this loop, since the 
+         data structures representing the state of the inferior
+         are in an inconsistent state.  */

 
       if (quit_failed || net_wait (&rdbEvent) == -1)
        {
          terminal_ours ();
          if (query ("Can't %s.  Disconnect from target system? ",
                     (quit_failed) ? "suspend remote task"
 
       if (quit_failed || net_wait (&rdbEvent) == -1)
        {
          terminal_ours ();
          if (query ("Can't %s.  Disconnect from target system? ",
                     (quit_failed) ? "suspend remote task"

-                                  : "get status of remote task"))
+                    : "get status of remote task"))

            {
            {

-             target_mourn_inferior();
+             target_mourn_inferior ();

              error ("Use the \"target\" command to reconnect.");
            }
          else
              error ("Use the \"target\" command to reconnect.");
            }
          else


@@ -1009,16 +972,18 @@ vx_wait (pid_to_wait_for, status)
              continue;
            }
        }
              continue;
            }
        }

-      
+

       pid = rdbEvent.taskId;
       if (pid == 0)
        {
          sleep_ms (200);       /* FIXME Don't kill the network too badly */
        }
       pid = rdbEvent.taskId;
       if (pid == 0)
        {
          sleep_ms (200);       /* FIXME Don't kill the network too badly */
        }

-      else if (pid != inferior_pid)
-       fatal ("Bad pid for debugged task: %s\n",
-              local_hex_string((unsigned long) pid));
-    } while (pid == 0);
+      else if (pid != PIDGET (inferior_ptid))
+       internal_error (__FILE__, __LINE__,
+                       "Bad pid for debugged task: %s\n",
+                       local_hex_string ((unsigned long) pid));
+    }
+  while (pid == 0);

 
   /* The mostly likely kind.  */
   status->kind = TARGET_WAITKIND_STOPPED;
 
   /* The mostly likely kind.  */
   status->kind = TARGET_WAITKIND_STOPPED;


@@ -1028,7 +993,7 @@ vx_wait (pid_to_wait_for, status)
     case EVENT_EXIT:
       status->kind = TARGET_WAITKIND_EXITED;
       /* FIXME is it possible to distinguish between a
     case EVENT_EXIT:
       status->kind = TARGET_WAITKIND_EXITED;
       /* FIXME is it possible to distinguish between a

-        normal vs abnormal exit in VxWorks? */
+         normal vs abnormal exit in VxWorks? */

       status->value.integer = 0;
       break;
 
       status->value.integer = 0;
       break;
 


@@ -1046,11 +1011,11 @@ vx_wait (pid_to_wait_for, status)
       status->value.sig = TARGET_SIGNAL_TRAP;
       break;
 
       status->value.sig = TARGET_SIGNAL_TRAP;
       break;
 

-    case EVENT_SUSPEND:                /* Task was suspended, probably by ^C. */
+    case EVENT_SUSPEND:        /* Task was suspended, probably by ^C. */

       status->value.sig = TARGET_SIGNAL_INT;
       break;
 
       status->value.sig = TARGET_SIGNAL_INT;
       break;
 

-    case EVENT_BUS_ERR:                /* Task made evil nasty reference. */
+    case EVENT_BUS_ERR:        /* Task made evil nasty reference. */

       status->value.sig = TARGET_SIGNAL_BUS;
       break;
 
       status->value.sig = TARGET_SIGNAL_BUS;
       break;
 


@@ -1063,32 +1028,30 @@ vx_wait (pid_to_wait_for, status)
       status->value.sig = i960_fault_to_signal (rdbEvent.sigType);
 #else
       /* Back in the old days, before enum target_signal, this code used
       status->value.sig = i960_fault_to_signal (rdbEvent.sigType);
 #else
       /* Back in the old days, before enum target_signal, this code used

-        to add NSIG to the signal number and claim that PRINT_RANDOM_SIGNAL
-        would take care of it.  But PRINT_RANDOM_SIGNAL has never been
-        defined except on the i960, so I don't really know what we are
-        supposed to do on other architectures.  */
+         to add NSIG to the signal number and claim that PRINT_RANDOM_SIGNAL
+         would take care of it.  But PRINT_RANDOM_SIGNAL has never been
+         defined except on the i960, so I don't really know what we are
+         supposed to do on other architectures.  */

       status->value.sig = TARGET_SIGNAL_UNKNOWN;
 #endif
       break;
       status->value.sig = TARGET_SIGNAL_UNKNOWN;
 #endif
       break;

-    } /* switch */
-  return pid;
+    }                          /* switch */
+  return pid_to_ptid (pid);

 }
 \f
 static int
 }
 \f
 static int

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

 {
 {

-  symbol_file_command (arg, 0);
+  symbol_file_add_main (arg, 0);

   return 1;
 }
 
 static int
   return 1;
 }
 
 static int

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

 {
 {

-  struct ldfile *pLoadFile = (struct ldfile *)arg;
+  struct ldfile *pLoadFile = (struct ldfile *) arg;

 
 

-  printf_unfiltered("\t%s: ", pLoadFile->name);
+  printf_unfiltered ("\t%s: ", pLoadFile->name);

   vx_add_symbols (pLoadFile->name, 0, pLoadFile->txt_addr,
                  pLoadFile->data_addr, pLoadFile->bss_addr);
   printf_unfiltered ("ok\n");
   vx_add_symbols (pLoadFile->name, 0, pLoadFile->txt_addr,
                  pLoadFile->data_addr, pLoadFile->bss_addr);
   printf_unfiltered ("ok\n");


@@ -1101,9 +1064,7 @@ add_symbol_stub (arg)
    debugging.  */
 
 static void
    debugging.  */
 
 static void

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

 {
   extern int close ();
   char *bootFile;
 {
   extern int close ();
   char *bootFile;


@@ -1118,7 +1079,7 @@ vx_open (args, from_tty)
     error_no_arg ("target machine name");
 
   target_preopen (from_tty);
     error_no_arg ("target machine name");
 
   target_preopen (from_tty);

-  
+

   unpush_target (&vx_ops);
   printf_unfiltered ("Attaching remote machine across net...\n");
   gdb_flush (gdb_stdout);
   unpush_target (&vx_ops);
   printf_unfiltered ("Attaching remote machine across net...\n");
   gdb_flush (gdb_stdout);


@@ -1171,31 +1132,31 @@ vx_open (args, from_tty)
   if (net_get_symbols (&loadTable) != 0)
     error ("Can't read loaded modules from target machine");
 
   if (net_get_symbols (&loadTable) != 0)
     error ("Can't read loaded modules from target machine");
 

-  i = 0-1;
+  i = 0 - 1;

   while (++i < loadTable.tbl_size)
     {
   while (++i < loadTable.tbl_size)
     {

-      QUIT;    /* FIXME, avoids clnt_freeres below:  mem leak */
-      pLoadFile = &loadTable.tbl_ent [i];
+      QUIT;                    /* FIXME, avoids clnt_freeres below:  mem leak */
+      pLoadFile = &loadTable.tbl_ent[i];

 #ifdef WRS_ORIG
 #ifdef WRS_ORIG

-  {
-    register int desc;
-    struct cleanup *old_chain;
-    char *fullname = NULL;
-
-    desc = openp (source_path, 0, pLoadFile->name, O_RDONLY, 0, &fullname);
-    if (desc < 0)
-       perror_with_name (pLoadFile->name);
-    old_chain = make_cleanup (close, desc);
-    add_file_at_addr (fullname, desc, pLoadFile->txt_addr, pLoadFile->data_addr,
-                     pLoadFile->bss_addr);
-    do_cleanups (old_chain);
-  }
+      {
+       int desc;
+       struct cleanup *old_chain;
+       char *fullname = NULL;
+
+       desc = openp (source_path, 0, pLoadFile->name, O_RDONLY, 0, &fullname);
+       if (desc < 0)
+         perror_with_name (pLoadFile->name);
+       old_chain = make_cleanup (close, desc);
+       add_file_at_addr (fullname, desc, pLoadFile->txt_addr, pLoadFile->data_addr,
+                         pLoadFile->bss_addr);
+       do_cleanups (old_chain);
+      }

 #else
       /* FIXME: Is there something better to search than the PATH? (probably
 #else
       /* FIXME: Is there something better to search than the PATH? (probably

-        not the source path, since source might be in different directories
-        than objects.  */
+         not the source path, since source might be in different directories
+         than objects.  */

 
 

-      if (catch_errors (add_symbol_stub, (char *)pLoadFile, (char *)0,
+      if (catch_errors (add_symbol_stub, (char *) pLoadFile, (char *) 0,

                        RETURN_MASK_ALL))
        symbols_added = 1;
 #endif
                        RETURN_MASK_ALL))
        symbols_added = 1;
 #endif


@@ -1214,9 +1175,7 @@ vx_open (args, from_tty)
    This stops it cold in its tracks and allows us to start tracing it.  */
 
 static void
    This stops it cold in its tracks and allows us to start tracing it.  */
 
 static void

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

 {
   unsigned long pid;
   char *cptr = 0;
 {
   unsigned long pid;
   char *cptr = 0;


@@ -1233,10 +1192,10 @@ vx_attach (args, from_tty)
 
   if (from_tty)
     printf_unfiltered ("Attaching pid %s.\n",
 
   if (from_tty)
     printf_unfiltered ("Attaching pid %s.\n",

-                      local_hex_string((unsigned long) pid));
+                      local_hex_string ((unsigned long) pid));

 
 

-  memset ((char *)&ptrace_in,  '\0', sizeof (ptrace_in));
-  memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
+  memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+  memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));

   ptrace_in.pid = pid;
 
   status = net_ptrace_clnt_call (PTRACE_ATTACH, &ptrace_in, &ptrace_out);
   ptrace_in.pid = pid;
 
   status = net_ptrace_clnt_call (PTRACE_ATTACH, &ptrace_in, &ptrace_out);


@@ -1244,17 +1203,17 @@ vx_attach (args, from_tty)
     error (rpcerr);
   if (ptrace_out.status == -1)
     {
     error (rpcerr);
   if (ptrace_out.status == -1)
     {

-      errno = ptrace_out.errno;
+      errno = ptrace_out.errno_num;

       perror_with_name ("Attaching remote process");
     }
 
   /* It worked... */
 
       perror_with_name ("Attaching remote process");
     }
 
   /* It worked... */
 

-  inferior_pid = pid;
+  inferior_ptid = pid_to_ptid (pid);

   push_target (&vx_run_ops);
 
   if (vx_running)
   push_target (&vx_run_ops);
 
   if (vx_running)

-    free (vx_running);
+    xfree (vx_running);

   vx_running = 0;
 }
 
   vx_running = 0;
 }
 


@@ -1268,9 +1227,7 @@ vx_attach (args, from_tty)
    started via the normal ptrace (PTRACE_TRACEME).  */
 
 static void
    started via the normal ptrace (PTRACE_TRACEME).  */
 
 static void

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

 {
   Rptrace ptrace_in;
   Ptrace_return ptrace_out;
 {
   Rptrace ptrace_in;
   Ptrace_return ptrace_out;


@@ -1281,68 +1238,68 @@ vx_detach (args, from_tty)
     error ("Argument given to VxWorks \"detach\".");
 
   if (from_tty)
     error ("Argument given to VxWorks \"detach\".");
 
   if (from_tty)

-      printf_unfiltered ("Detaching pid %s.\n",
-             local_hex_string((unsigned long) inferior_pid));
+    printf_unfiltered ("Detaching pid %s.\n",
+                      local_hex_string (
+                        (unsigned long) PIDGET (inferior_ptid)));

 
 

-  if (args)            /* FIXME, should be possible to leave suspended */
+  if (args)                    /* FIXME, should be possible to leave suspended */

     signal = atoi (args);
     signal = atoi (args);

-  
-  memset ((char *)&ptrace_in,  '\0', sizeof (ptrace_in));
-  memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
-  ptrace_in.pid = inferior_pid;
+
+  memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+  memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
+  ptrace_in.pid = PIDGET (inferior_ptid);

 
   status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out);
   if (status == -1)
     error (rpcerr);
   if (ptrace_out.status == -1)
     {
 
   status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out);
   if (status == -1)
     error (rpcerr);
   if (ptrace_out.status == -1)
     {

-      errno = ptrace_out.errno;
+      errno = ptrace_out.errno_num;

       perror_with_name ("Detaching VxWorks process");
     }
 
       perror_with_name ("Detaching VxWorks process");
     }
 

-  inferior_pid = 0;
-  pop_target ();       /* go back to non-executing VxWorks connection */
+  inferior_ptid = null_ptid;
+  pop_target ();               /* go back to non-executing VxWorks connection */

 }
 
 /* vx_kill -- takes a running task and wipes it out.  */
 
 static void
 }
 
 /* vx_kill -- takes a running task and wipes it out.  */
 
 static void

-vx_kill ()
+vx_kill (void)

 {
   Rptrace ptrace_in;
   Ptrace_return ptrace_out;
   int status;
 
 {
   Rptrace ptrace_in;
   Ptrace_return ptrace_out;
   int status;
 

-  printf_unfiltered ("Killing pid %s.\n", local_hex_string((unsigned long) inferior_pid));
+  printf_unfiltered ("Killing pid %s.\n", local_hex_string ((unsigned long) PIDGET (inferior_ptid)));

 
 

-  memset ((char *)&ptrace_in,  '\0', sizeof (ptrace_in));
-  memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
-  ptrace_in.pid = inferior_pid;
+  memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+  memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
+  ptrace_in.pid = PIDGET (inferior_ptid);

 
   status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out);
   if (status == -1)
     warning (rpcerr);
   else if (ptrace_out.status == -1)
     {
 
   status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out);
   if (status == -1)
     warning (rpcerr);
   else if (ptrace_out.status == -1)
     {

-      errno = ptrace_out.errno;
+      errno = ptrace_out.errno_num;

       perror_with_name ("Killing VxWorks process");
     }
 
   /* If it gives good status, the process is *gone*, no events remain.
      If the kill failed, assume the process is gone anyhow.  */
       perror_with_name ("Killing VxWorks process");
     }
 
   /* If it gives good status, the process is *gone*, no events remain.
      If the kill failed, assume the process is gone anyhow.  */

-  inferior_pid = 0;
-  pop_target ();       /* go back to non-executing VxWorks connection */
+  inferior_ptid = null_ptid;
+  pop_target ();               /* go back to non-executing VxWorks connection */

 }
 
 /* Clean up from the VxWorks process target as it goes away.  */
 
 static void
 }
 
 /* Clean up from the VxWorks process target as it goes away.  */
 
 static void

-vx_proc_close (quitting)
-     int quitting;
+vx_proc_close (int quitting)

 {
 {

-  inferior_pid = 0;            /* No longer have a process.  */
+  inferior_ptid = null_ptid;   /* No longer have a process.  */

   if (vx_running)
   if (vx_running)

-    free (vx_running);
+    xfree (vx_running);

   vx_running = 0;
 }
 \f
   vx_running = 0;
 }
 \f


@@ -1350,19 +1307,15 @@ vx_proc_close (quitting)
    Returns RPC status.  */
 
 static enum clnt_stat
    Returns RPC status.  */
 
 static enum clnt_stat

-net_clnt_call (procNum, inProc, in, outProc, out)
-    enum ptracereq procNum;
-    xdrproc_t inProc;
-    char *in;
-    xdrproc_t outProc;
-    char *out;
+net_clnt_call (enum ptracereq procNum, xdrproc_t inProc, char *in,
+              xdrproc_t outProc, char *out)

 {
   enum clnt_stat status;
 {
   enum clnt_stat status;

-  
+

   status = clnt_call (pClient, procNum, inProc, in, outProc, out, rpcTimeout);
 
   if (status != RPC_SUCCESS)
   status = clnt_call (pClient, procNum, inProc, in, outProc, out, rpcTimeout);
 
   if (status != RPC_SUCCESS)

-      clnt_perrno (status);
+    clnt_perrno (status);

 
   return status;
 }
 
   return status;
 }


@@ -1370,93 +1323,87 @@ net_clnt_call (procNum, inProc, in, outProc, out)
 /* Clean up before losing control.  */
 
 static void
 /* Clean up before losing control.  */
 
 static void

-vx_close (quitting)
-     int quitting;
+vx_close (int quitting)

 {
   if (pClient)
     clnt_destroy (pClient);    /* The net connection */
   pClient = 0;
 
   if (vx_host)
 {
   if (pClient)
     clnt_destroy (pClient);    /* The net connection */
   pClient = 0;
 
   if (vx_host)

-    free (vx_host);            /* The hostname */
+    xfree (vx_host);           /* The hostname */

   vx_host = 0;
 }
 
 /* A vxprocess target should be started via "run" not "target".  */
   vx_host = 0;
 }
 
 /* A vxprocess target should be started via "run" not "target".  */

-/*ARGSUSED*/

 static void
 static void

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

 {
   error ("Use the \"run\" command to start a VxWorks process.");
 }
 
 {
   error ("Use the \"run\" command to start a VxWorks process.");
 }
 

-/* Target ops structure for accessing memory and such over the net */
-
-struct target_ops vx_ops = {
-  "vxworks", "VxWorks target memory via RPC over TCP/IP",
-  "Use VxWorks target memory.  \n\
-Specify the name of the machine to connect to.",
-  vx_open, vx_close, vx_attach, 0, /* vx_detach, */
-  0, 0, /* resume, wait */
-  0, 0, /* read_reg, write_reg */
-  0, /* prep_to_store, */
-  vx_xfer_memory, vx_files_info,
-  0, 0, /* insert_breakpoint, remove_breakpoint */
-  0, 0, 0, 0, 0,       /* terminal stuff */
-  0, /* vx_kill, */
-  vx_load_command,
-  vx_lookup_symbol,
-  vx_create_inferior, 0,  /* mourn_inferior */
-  0, /* can_run */
-  0, /* notice_signals */
-  0, /* thread_alive */
-  0,                           /* to_stop */
-  core_stratum, 0, /* next */
-  1, 1, 0, 0, 0,       /* all mem, mem, stack, regs, exec */
-  0, 0,                        /* Section pointers */
-  OPS_MAGIC,           /* Always the last thing */
+static void
+init_vx_ops (void)
+{
+  vx_ops.to_shortname = "vxworks";
+  vx_ops.to_longname = "VxWorks target memory via RPC over TCP/IP";
+  vx_ops.to_doc = "Use VxWorks target memory.  \n\
+Specify the name of the machine to connect to.";
+  vx_ops.to_open = vx_open;
+  vx_ops.to_close = vx_close;
+  vx_ops.to_attach = vx_attach;
+  vx_ops.to_xfer_memory = vx_xfer_memory;
+  vx_ops.to_files_info = vx_files_info;
+  vx_ops.to_load = vx_load_command;
+  vx_ops.to_lookup_symbol = vx_lookup_symbol;
+  vx_ops.to_create_inferior = vx_create_inferior;
+  vx_ops.to_stratum = core_stratum;
+  vx_ops.to_has_all_memory = 1;
+  vx_ops.to_has_memory = 1;
+  vx_ops.to_magic = OPS_MAGIC; /* Always the last thing */

 };
 
 };
 

-/* Target ops structure for accessing VxWorks child processes over the net */
-
-struct target_ops vx_run_ops = {
-  "vxprocess", "VxWorks process",
-  "VxWorks process, started by the \"run\" command.",
-  vx_proc_open, vx_proc_close, 0, vx_detach, /* vx_attach */
-  vx_resume, vx_wait,
-  vx_read_register, vx_write_register,
-  vx_prepare_to_store,
-  vx_xfer_memory, vx_run_files_info,
-  vx_insert_breakpoint, vx_remove_breakpoint,
-  0, 0, 0, 0, 0,       /* terminal stuff */
-  vx_kill,
-  vx_load_command,
-  vx_lookup_symbol,
-  0, vx_mourn_inferior,
-  0, /* can_run */
-  0, /* notice_signals */
-  0, /* thread_alive */
-  0,                           /* to_stop */
-  process_stratum, 0, /* next */
-  0, /* all_mem--off to avoid spurious msg in "i files" */
-  1, 1, 1, 1,  /* mem, stack, regs, exec */
-  0, 0,                        /* Section pointers */
-  OPS_MAGIC,           /* Always the last thing */
-};
-/* ==> Remember when reading at end of file, there are two "ops" structs here. */
+static void
+init_vx_run_ops (void)
+{
+  vx_run_ops.to_shortname = "vxprocess";
+  vx_run_ops.to_longname = "VxWorks process";
+  vx_run_ops.to_doc = "VxWorks process; started by the \"run\" command.";
+  vx_run_ops.to_open = vx_proc_open;
+  vx_run_ops.to_close = vx_proc_close;
+  vx_run_ops.to_detach = vx_detach;
+  vx_run_ops.to_resume = vx_resume;
+  vx_run_ops.to_wait = vx_wait;
+  vx_run_ops.to_fetch_registers = vx_read_register;
+  vx_run_ops.to_store_registers = vx_write_register;
+  vx_run_ops.to_prepare_to_store = vx_prepare_to_store;
+  vx_run_ops.to_xfer_memory = vx_xfer_memory;
+  vx_run_ops.to_files_info = vx_run_files_info;
+  vx_run_ops.to_insert_breakpoint = vx_insert_breakpoint;
+  vx_run_ops.to_remove_breakpoint = vx_remove_breakpoint;
+  vx_run_ops.to_kill = vx_kill;
+  vx_run_ops.to_load = vx_load_command;
+  vx_run_ops.to_lookup_symbol = vx_lookup_symbol;
+  vx_run_ops.to_mourn_inferior = vx_mourn_inferior;
+  vx_run_ops.to_stratum = process_stratum;
+  vx_run_ops.to_has_memory = 1;
+  vx_run_ops.to_has_stack = 1;
+  vx_run_ops.to_has_registers = 1;
+  vx_run_ops.to_has_execution = 1;
+  vx_run_ops.to_magic = OPS_MAGIC;
+}

 \f
 void
 \f
 void

-_initialize_vx ()
+_initialize_vx (void)

 {
 {

+  init_vx_ops ();
+  add_target (&vx_ops);
+  init_vx_run_ops ();
+  add_target (&vx_run_ops);
+

   add_show_from_set
     (add_set_cmd ("vxworks-timeout", class_support, var_uinteger,
                  (char *) &rpcTimeout.tv_sec,
                  "Set seconds to wait for rpc calls to return.\n\
 Set the number of seconds to wait for rpc calls to return.", &setlist),
      &showlist);
   add_show_from_set
     (add_set_cmd ("vxworks-timeout", class_support, var_uinteger,
                  (char *) &rpcTimeout.tv_sec,
                  "Set seconds to wait for rpc calls to return.\n\
 Set the number of seconds to wait for rpc calls to return.", &setlist),
      &showlist);

-
-  add_target (&vx_ops);
-  add_target (&vx_run_ops);

 }
 }