#include "gdbcore.h"
#include "command.h"
#include "symtab.h"
-#include "symfile.h" /* for struct complaint */
+#include "complaints.h"
+#include "gdbcmd.h"
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/types.h>
-#include <sys/time.h>
#include <sys/socket.h>
#define malloc bogon_malloc /* Sun claims "char *malloc()" not void * */
#define free bogon_free /* Sun claims "int free()" not void */
#include "vx-share/xdr_ld.h"
#include "vx-share/xdr_rdb.h"
#include "vx-share/dbgRpcLib.h"
-#include "vx-share/reg.h"
#include <symtab.h>
extern void symbol_file_command ();
extern int stop_soon_quietly; /* for wait_for_inferior */
-extern void host_convert_to_virtual ();
-extern void host_convert_from_virtual ();
static int net_ptrace_clnt_call (); /* Forward decl */
static enum clnt_stat net_clnt_call (); /* Forward decl */
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.
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;
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 */
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 */
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);
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 ();
ptrace_in.pid = inferior_pid;
ptrace_out.info.more_data = (caddr_t) &out_data;
-#ifndef I80960
- out_data.len = 18 * REGISTER_RAW_SIZE (0); /* FIXME 68k hack */
-#else
- out_data.len = (16 + 16 + 3) * REGISTER_RAW_SIZE (0);
-#endif
+ out_data.len = VX_NUM_REGS * REGISTER_RAW_SIZE (0);
out_data.bytes = (caddr_t) registers;
status = net_ptrace_clnt_call (PTRACE_GETREGS, &ptrace_in, &ptrace_out);
perror_with_name ("net_ptrace_clnt_call(PTRACE_GETREGS)");
}
-#ifdef I80960
-
- {
+#ifdef VX_SIZE_FPREGS
/* If the target has floating point registers, fetch them.
Otherwise, zero the floating point register values in
registers[] for good measure, even though we might not
need to. */
- /* @@ Can't use this -- the rdb library for the 960 target
- doesn't support setting or retrieving FP regs. KR */
-#if 0
- struct fp_status inferior_fp_registers;
-
- if (target_has_fp)
- {
- ptrace_in.pid = inferior_pid;
- ptrace_out.info.more_data = (caddr_t) &inferior_fp_registers;
- status = net_ptrace_clnt_call (PTRACE_GETFPREGS,
- &ptrace_in, &ptrace_out);
- if (status)
- error (rpcerr);
- if (ptrace_out.status == -1)
- {
- errno = ptrace_out.errno;
- perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
- }
-
- bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
- REGISTER_RAW_SIZE (FP0_REGNUM) * 4);
- }
- else
- {
- bzero ((char *) ®isters[REGISTER_BYTE (FP0_REGNUM)],
- REGISTER_RAW_SIZE (FP0_REGNUM) * 4);
- }
-#endif
- }
-#else /* not 960, thus must be 68000: FIXME! */
if (target_has_fp)
{
ptrace_in.pid = inferior_pid;
ptrace_out.info.more_data = (caddr_t) &out_data;
- out_data.len = 8 * REGISTER_RAW_SIZE (FP0_REGNUM) /* FIXME */
- + (3 * sizeof (REGISTER_TYPE));
+ out_data.len = VX_SIZE_FPREGS;
out_data.bytes = (caddr_t) ®isters[REGISTER_BYTE (FP0_REGNUM)];
status = net_ptrace_clnt_call (PTRACE_GETFPREGS, &ptrace_in, &ptrace_out);
}
else
{
- bzero (®isters[REGISTER_BYTE (FP0_REGNUM)],
- 8 * REGISTER_RAW_SIZE (FP0_REGNUM));
- bzero (®isters[REGISTER_BYTE (FPC_REGNUM)],
- 3 * sizeof (REGISTER_TYPE));
+ memset (®isters[REGISTER_BYTE (FP0_REGNUM)], '\0', VX_SIZE_FPREGS);
}
-#endif /* various architectures */
+#endif /* VX_SIZE_FPREGS */
}
/* Prepare to store registers. Since we will store all of them,
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;
in_data.bytes = registers;
-#ifdef I80960
-
- in_data.len = (16 + 16 + 3) * sizeof (REGISTER_TYPE);
-
-#else /* not 960 -- assume 68k -- FIXME */
-
- in_data.len = 18 * sizeof (REGISTER_TYPE);
-
-#endif /* Different register sets */
+ in_data.len = VX_NUM_REGS * sizeof (REGISTER_TYPE);
/* XXX change second param to be a proc number */
status = net_ptrace_clnt_call (PTRACE_SETREGS, &ptrace_in, &ptrace_out);
perror_with_name ("net_ptrace_clnt_call(PTRACE_SETREGS)");
}
+#ifdef VX_SIZE_FPREGS
/* Store floating point registers if the target has them. */
if (target_has_fp)
ptrace_in.info.more_data = (caddr_t) &in_data;
-#ifdef I80960
-#if 0 /* @@ Not supported by target. */
in_data.bytes = ®isters[REGISTER_BYTE (FP0_REGNUM)];
- in_data.len = 4 * REGISTER_RAW_SIZE (FP0_REGNUM);
-#endif
-#else /* not 960 -- assume 68k -- FIXME */
-
- in_data.bytes = ®isters[REGISTER_BYTE (FP0_REGNUM)];
- in_data.len = (8 * REGISTER_RAW_SIZE (FP0_REGNUM)
- + (3 * sizeof (REGISTER_TYPE)));
-
-#endif /* Different register sets */
+ in_data.len = VX_SIZE_FPREGS;
status = net_ptrace_clnt_call (PTRACE_SETFPREGS, &ptrace_in, &ptrace_out);
if (status)
perror_with_name ("net_ptrace_clnt_call(PTRACE_SETFPREGS)");
}
}
+#endif /* VX_SIZE_FPREGS */
}
/* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
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 */
}
static void
-vx_resume (step, siggnal)
+vx_resume (pid, step, siggnal)
+ int pid;
int step;
int 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 */
{
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;
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);
if (status != RPC_SUCCESS) {
- complain (&cant_contact_target, 0);
+ complain (&cant_contact_target);
return -1;
}
{
struct sockaddr_in destAddr;
struct hostent *destHost;
+ unsigned long addr;
+
+ /* Get the internet address for the given host. Allow a numeric
+ IP address or a hostname. */
- /* get the internet address for the given host */
-
- if ((destHost = (struct hostent *) gethostbyname (host)) == NULL)
- error ("Invalid hostname. Couldn't find remote host address.");
+ addr = inet_addr (host);
+ if (addr == -1)
+ {
+ destHost = (struct hostent *) gethostbyname (host);
+ if (destHost == NULL)
+ error ("Invalid hostname. Couldn't find remote host address.");
+ addr = * (unsigned long *) destHost->h_addr;
+ }
- bzero (&destAddr, sizeof (destAddr));
+ memset (&destAddr, '\0', sizeof (destAddr));
- destAddr.sin_addr.s_addr = * (u_long *) destHost->h_addr;
+ 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. */
{
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");
/* 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");
clnt_freeres (pClient, xdr_ldtabl, &loadTable);
}
\f
-/* attach_command --
- takes a task started up outside of gdb and ``attaches'' to it.
+/* Takes a task started up outside of gdb and ``attaches'' to it.
This stops it cold in its tracks and allows us to start tracing it. */
static void
Ptrace_return ptrace_out;
int status;
- dont_repeat();
-
if (!args)
error_no_arg ("process-id to attach");
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);
push_target (&vx_run_ops);
inferior_pid = pid;
vx_running = 0;
-
- mark_breakpoints_out ();
-
- /* Set up the "saved terminal modes" of the inferior
- based on what modes we are starting it with. */
- target_terminal_init ();
-
- /* Install inferior's terminal modes. */
- target_terminal_inferior ();
-
- /* We will get a task spawn event immediately. */
- init_wait_for_inferior ();
- clear_proceed_status ();
- stop_soon_quietly = 1;
- wait_for_inferior ();
- stop_soon_quietly = 0;
- normal_stop ();
}
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);
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);
if (status == -1)
- error (rpcerr);
- if (ptrace_out.status == -1)
+ warning (rpcerr);
+ else if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
perror_with_name ("Killing VxWorks process");
}
- /* If it gives good status, the process is *gone*, no events remain. */
+ /* 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 */
}
vx_open, vx_close, vx_attach, 0, /* vx_detach, */
0, 0, /* resume, wait */
0, 0, /* read_reg, write_reg */
- 0, host_convert_to_virtual, host_convert_from_virtual, /* prep_to_store, */
+ 0, /* prep_to_store, */
vx_xfer_memory, vx_files_info,
0, 0, /* insert_breakpoint, remove_breakpoint */
0, 0, 0, 0, 0, /* terminal stuff */
vx_load_command,
vx_lookup_symbol,
vx_create_inferior, 0, /* mourn_inferior */
+ 0, /* can_run */
+ 0, /* notice_signals */
core_stratum, 0, /* next */
1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */
0, 0, /* Section pointers */
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, host_convert_to_virtual, host_convert_from_virtual,
+ 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_load_command,
vx_lookup_symbol,
0, vx_mourn_inferior,
+ 0, /* can_run */
+ 0, /* notice_signals */
process_stratum, 0, /* next */
0, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
/* all_mem is off to avoid spurious msg in "i files" */
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);
}
projects / binutils.git / blobdiff