Use ftp device rather than "load" command.

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

diff --git a/gdb/remote-vx.c b/gdb/remote-vx.c
index bb621a546d574724550e39e8e930bd5c6ed02e09..d4d5f9e9bfdb83d5253f1d32c582343f3d1238ee 100644 (file)
--- a/gdb/remote-vx.c
+++ b/gdb/remote-vx.c
@@ -27,6 +27,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "command.h"
 #include "symtab.h"
 #include "complaints.h"
+#include "gdbcmd.h"
 
 #include <string.h>
 #include <errno.h>
@@ -100,7 +101,7 @@ net_load (filename, pTextAddr, pDataAddr, pBssAddr)
     struct ldfile ldstruct;
     struct timeval load_timeout;
  
-    bzero ((char *) &ldstruct, sizeof (ldstruct));
+    memset ((char *) &ldstruct, '\0', sizeof (ldstruct));
 
     /* We invoke clnt_call () here directly, instead of through
        net_clnt_call (), because we need to set a large timeout value.
@@ -142,7 +143,7 @@ net_break (addr, procnum)
     Rptrace ptrace_in;  /* XXX This is stupid.  It doesn't need to be a ptrace
                            structure.  How about something smaller? */
 
-    bzero ((char *) &ptrace_in, sizeof (ptrace_in));
+    memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
     break_status = 0;
 
     ptrace_in.addr = addr;
@@ -194,8 +195,8 @@ vx_create_inferior (exec_file, args, env)
   arg_array passArgs;
   TASK_START taskStart;
 
-  bzero ((char *) &passArgs, sizeof (passArgs));
-  bzero ((char *) &taskStart, sizeof (taskStart));
+  memset ((char *) &passArgs, '\0', sizeof (passArgs));
+  memset ((char *) &taskStart, '\0', sizeof (taskStart));
 
   /* parse arguments, put them in passArgs */
 
@@ -253,7 +254,7 @@ parse_args (arg_string, arg_struct)
   register int arg_index = 0;
   register char *p0;
  
-  bzero ((char *) arg_struct, sizeof (arg_array));
+  memset ((char *) arg_struct, '\0', sizeof (arg_array));
  
   /* first count how many arguments there are */
 
@@ -333,7 +334,7 @@ net_wait (pEvent)
     int pid;
     enum clnt_stat status;
 
-    bzero ((char *) pEvent, sizeof (RDB_EVENT));
+    memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));
 
     pid = inferior_pid;
     status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT, pEvent);
@@ -377,8 +378,8 @@ vx_read_register (regno)
   C_bytes out_data;
   extern char registers[];
 
-  bzero ((char *) &ptrace_in, sizeof (ptrace_in));
-  bzero ((char *) &ptrace_out, sizeof (ptrace_out));
+  memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+  memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
 
   /* FIXME, eventually only get the ones we need.  */
   registers_fetched ();
@@ -421,7 +422,7 @@ vx_read_register (regno)
     }
   else
     {
-      bzero (&registers[REGISTER_BYTE (FP0_REGNUM)], VX_SIZE_FPREGS);
+      memset (&registers[REGISTER_BYTE (FP0_REGNUM)], '\0', VX_SIZE_FPREGS);
     }
 #endif /* VX_SIZE_FPREGS */
 }
@@ -453,8 +454,8 @@ vx_write_register (regno)
   Rptrace ptrace_in;
   Ptrace_return ptrace_out;
 
-  bzero ((char *) &ptrace_in, sizeof (ptrace_in));
-  bzero ((char *) &ptrace_out, sizeof (ptrace_out));
+  memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+  memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
 
   ptrace_in.pid = inferior_pid;
   ptrace_in.info.ttype     = DATA;
@@ -520,8 +521,8 @@ vx_xfer_memory (memaddr, myaddr, len, write, target)
   Ptrace_return ptrace_out;
   C_bytes data;
 
-  bzero ((char *) &ptrace_in, sizeof (ptrace_in));
-  bzero ((char *) &ptrace_out, 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.addr = (int) memaddr;      /* Where from */
@@ -577,7 +578,8 @@ vx_run_files_info ()
 }
 
 static void
-vx_resume (step, siggnal)
+vx_resume (pid, step, siggnal)
+     int pid;
      int step;
      int siggnal;
 {
@@ -588,10 +590,10 @@ vx_resume (step, siggnal)
   if (siggnal != 0 && siggnal != stop_signal)
     error ("Cannot send signals to VxWorks processes");
 
-  bzero ((char *) &ptrace_in, sizeof (ptrace_in));
-  bzero ((char *) &ptrace_out, sizeof (ptrace_out));
+  memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
+  memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
 
-  ptrace_in.pid = inferior_pid;
+  ptrace_in.pid = pid;
   ptrace_in.addr = 1;  /* Target side insists on this, or it panics.  */
 
   /* XXX change second param to be a proc number */
@@ -726,7 +728,7 @@ net_get_symbols (pLoadTable)
 {
   enum clnt_stat status;
 
-  bzero ((char *) pLoadTable, sizeof (struct ldtabl));
+  memset ((char *) pLoadTable, '\0', sizeof (struct ldtabl));
 
   status = net_clnt_call (VX_STATE_INQ, xdr_void, 0, xdr_ldtabl, pLoadTable);
   return (status == RPC_SUCCESS) ? 0 : -1;
@@ -748,7 +750,7 @@ vx_lookup_symbol (name, pAddr)
   SYMBOL_ADDR symbolAddr;
 
   *pAddr = 0;
-  bzero ((char *) &symbolAddr, sizeof (symbolAddr));
+  memset ((char *) &symbolAddr, '\0', sizeof (symbolAddr));
 
   status = net_clnt_call (VX_SYMBOL_INQ, xdr_wrapstring, &name,
                          xdr_SYMBOL_ADDR, &symbolAddr);
@@ -801,7 +803,7 @@ net_connect (host)
       addr = * (unsigned long *) destHost->h_addr;
     }
 
-  bzero (&destAddr, sizeof (destAddr));
+  memset (&destAddr, '\0', sizeof (destAddr));
 
   destAddr.sin_addr.s_addr = addr;
   destAddr.sin_family      = AF_INET;
@@ -1031,8 +1033,9 @@ vx_open (args, from_tty)
     {
       if (*bootFile) {
        printf_filtered ("\t%s: ", bootFile);
-       if (catch_errors (symbol_stub, bootFile,
-               "Error while reading symbols from boot file:\n"))
+       if (catch_errors
+           (symbol_stub, bootFile,
+            "Error while reading symbols from boot file:\n", RETURN_MASK_ALL))
          puts_filtered ("ok\n");
       } else if (from_tty)
        printf ("VxWorks kernel symbols not loaded.\n");
@@ -1068,7 +1071,8 @@ vx_open (args, from_tty)
       /* Botches, FIXME:
         (1)  Searches the PATH, not the source path.
         (2)  data and bss are assumed to be at the usual offsets from text.  */
-      catch_errors (add_symbol_stub, (char *)pLoadFile, (char *)0);
+      catch_errors (add_symbol_stub, (char *)pLoadFile, (char *)0,
+                   RETURN_MASK_ALL);
 #endif
     }
   printf_filtered ("Done.\n");
@@ -1100,8 +1104,8 @@ vx_attach (args, from_tty)
   if (from_tty)
       printf ("Attaching pid %s.\n", local_hex_string(pid));
 
-  bzero ((char *)&ptrace_in,  sizeof (ptrace_in));
-  bzero ((char *)&ptrace_out, 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);
@@ -1148,8 +1152,8 @@ vx_detach (args, from_tty)
   if (args)            /* FIXME, should be possible to leave suspended */
     signal = atoi (args);
   
-  bzero ((char *)&ptrace_in,  sizeof (ptrace_in));
-  bzero ((char *)&ptrace_out, sizeof (ptrace_out));
+  memset ((char *)&ptrace_in,  '\0', sizeof (ptrace_in));
+  memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
   ptrace_in.pid = inferior_pid;
 
   status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out);
@@ -1176,8 +1180,8 @@ vx_kill ()
 
   printf ("Killing pid %s.\n", local_hex_string(inferior_pid));
 
-  bzero ((char *)&ptrace_in,  sizeof (ptrace_in));
-  bzero ((char *)&ptrace_out, sizeof (ptrace_out));
+  memset ((char *)&ptrace_in,  '\0', sizeof (ptrace_in));
+  memset ((char *)&ptrace_out, '\0', sizeof (ptrace_out));
   ptrace_in.pid = inferior_pid;
 
   status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out);
@@ -1307,6 +1311,14 @@ struct target_ops vx_run_ops = {
 void
 _initialize_vx ()
 {
-  add_target (&vx_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_target (&vx_ops);
   add_target (&vx_run_ops);
 }