/* Memory-access and commands for remote VxWorks processes, for GDB.
- Copyright (C) 1990-1991 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
Contributed by Wind River Systems and Cygnus Support.
This file is part of GDB.
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
#include "defs.h"
#include "frame.h"
#include "inferior.h"
#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 */
+#define realloc bogon_realloc /* Sun claims "char *realloc()", not void * */
#include <rpc/rpc.h>
+#undef malloc
#undef free
+#undef realloc
#include <sys/time.h> /* UTek's <rpc/rpc.h> doesn't #incl this */
#include <netdb.h>
-#include <ptrace.h>
-#include "xdr_ptrace.h"
-#include "xdr_ld.h"
-#include "xdr_rdb.h"
-#include "dbgRpcLib.h"
-
-/* get rid of value.h if possible */
-#include <value.h>
+#include "vx-share/ptrace.h"
+#include "vx-share/xdr_ptrace.h"
+#include "vx-share/xdr_ld.h"
+#include "vx-share/xdr_rdb.h"
+#include "vx-share/dbgRpcLib.h"
+
#include <symtab.h>
-
-extern value call_function_by_hand ();
+
extern void symbol_file_command ();
extern int stop_soon_quietly; /* for wait_for_inferior */
/* 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).
+ stored in *pTextAddr, *pDataAddr, and *pBssAddr (respectively).
Returns 0 for success, -1 for failure. */
static int
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.
The load on the target side can take quite a while, easily
more than 10 seconds. The user can kill this call by typing
CTRL-C if there really is a problem with the load.
-
+
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... */
if (status == RPC_SUCCESS)
{
- if (*ldstruct.name == NULL) /* load failed on VxWorks side */
+ if (*ldstruct.name == 0) /* load failed on VxWorks side */
return -1;
*pTextAddr = ldstruct.txt_addr;
*pDataAddr = ldstruct.data_addr;
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;
/* returns 0 if successful, errno otherwise */
-int
+static int
vx_insert_breakpoint (addr)
int addr;
{
/* returns 0 if successful, errno otherwise */
-int
+static int
vx_remove_breakpoint (addr)
int addr;
{
Returns process id. Errors reported with error().
On VxWorks, we ignore exec_file. */
-void
+static void
vx_create_inferior (exec_file, args, env)
char *exec_file;
char *args;
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 */
vx_running = savestring (passArgs.arg_array_val[0],
strlen (passArgs.arg_array_val[0]));
-#ifdef CREATE_INFERIOR_HOOK
- CREATE_INFERIOR_HOOK (pid);
-#endif
-
push_target (&vx_run_ops);
inferior_pid = taskStart.pid;
stop_soon_quietly = 0;
/* insert_step_breakpoint (); FIXME, do we need this? */
- proceed(-1, -1, 0);
+ proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
}
/* Fill ARGSTRUCT in argc/argv form with the arguments from the
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 */
to the debugged task.
Returns -1 if remote wait failed, task status otherwise. */
-int
+static int
net_wait (pEvent)
RDB_EVENT *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);
/* Suspend the remote task.
Returns -1 if suspend fails on target system, 0 otherwise. */
-int
+static int
net_quit ()
{
int pid;
/* Read a register or registers from the remote system. */
-int
+static void
vx_read_register (regno)
int regno;
{
int status;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
- struct regs inferior_registers;
- struct fp_status inferior_fp_registers;
+ C_bytes in_data;
+ 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) &inferior_registers;
+ ptrace_out.info.more_data = (caddr_t) &out_data;
+ 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);
if (status)
error (rpcerr);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
- return -1;
+ perror_with_name ("net_ptrace_clnt_call(PTRACE_GETREGS)");
}
-#ifdef I80960
-
- bcopy ((char *) inferior_registers.r_lreg,
- ®isters[REGISTER_BYTE (R0_REGNUM)], 16 * sizeof (int));
- bcopy ((char *) inferior_registers.r_greg,
- ®isters[REGISTER_BYTE (G0_REGNUM)], 16 * sizeof (int));
-
- /* Don't assume that a location in registers[] is properly aligned. */
-
- bcopy ((char *) &inferior_registers.r_pcw,
- ®isters[REGISTER_BYTE (PCW_REGNUM)], sizeof (int));
- bcopy ((char *) &inferior_registers.r_acw,
- ®isters[REGISTER_BYTE (ACW_REGNUM)], sizeof (int));
- bcopy ((char *) &inferior_registers.r_lreg[2], /* r2 (RIP) -> IP */
- ®isters[REGISTER_BYTE (IP_REGNUM)], sizeof (int));
- bcopy ((char *) &inferior_registers.r_tcw,
- ®isters[REGISTER_BYTE (TCW_REGNUM)], sizeof (int));
-
- /* 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. */
-
- 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;
- return -1;
- }
-
- 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);
- }
-
-#else /* not 960, thus must be 68000: FIXME! */
-
- bcopy (&inferior_registers, registers, 16 * 4);
- *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
- *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
+#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. */
if (target_has_fp)
{
ptrace_in.pid = inferior_pid;
- ptrace_out.info.more_data = (caddr_t) &inferior_fp_registers;
+ ptrace_out.info.more_data = (caddr_t) &out_data;
+ 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);
if (status)
error (rpcerr);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
- return -1;
+ perror_with_name ("net_ptrace_clnt_call(PTRACE_GETFPREGS)");
}
-
- bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)],
- sizeof inferior_fp_registers.fps_regs);
- bcopy (&inferior_fp_registers.fps_control,
- ®isters[REGISTER_BYTE (FPC_REGNUM)],
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
}
else
{
- bzero (®isters[REGISTER_BYTE (FP0_REGNUM)],
- sizeof inferior_fp_registers.fps_regs);
- bzero (®isters[REGISTER_BYTE (FPC_REGNUM)],
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+ memset (®isters[REGISTER_BYTE (FP0_REGNUM)], '\0', VX_SIZE_FPREGS);
}
-#endif /* various architectures */
-
- return 0;
+#endif /* VX_SIZE_FPREGS */
}
/* Prepare to store registers. Since we will store all of them,
read out their current values now. */
-void
+static void
vx_prepare_to_store ()
{
- vx_read_register (-1);
+ /* Fetch all registers, if any of them are not yet fetched. */
+ read_register_bytes (0, NULL, REGISTER_BYTES);
}
Otherwise, REGNO specifies which register (so we can save time). */
/* FIXME, look at REGNO to save time here */
+static void
vx_write_register (regno)
int regno;
{
- struct regs inferior_registers;
- struct fp_status inferior_fp_registers;
+ C_bytes in_data;
+ C_bytes out_data;
extern char registers[];
int status;
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));
-#ifdef I80960
-
- bcopy (®isters[REGISTER_BYTE (R0_REGNUM)],
- (char *) inferior_registers.r_lreg, 16 * sizeof (int));
- bcopy (®isters[REGISTER_BYTE (G0_REGNUM)],
- (char *) inferior_registers.r_greg, 16 * sizeof (int));
-
- /* Don't assume that a location in registers[] is properly aligned. */
-
- bcopy (®isters[REGISTER_BYTE (PCW_REGNUM)],
- (char *) &inferior_registers.r_pcw, sizeof (int));
- bcopy (®isters[REGISTER_BYTE (ACW_REGNUM)],
- (char *) &inferior_registers.r_acw, sizeof (int));
- bcopy (®isters[REGISTER_BYTE (TCW_REGNUM)],
- (char *) &inferior_registers.r_tcw, sizeof (int));
-
-#else /* not 960 -- assume 68k -- FIXME */
-
- bcopy (registers, &inferior_registers, 16 * 4);
- inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)];
- inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)];
+ ptrace_in.pid = inferior_pid;
+ ptrace_in.info.ttype = DATA;
+ ptrace_in.info.more_data = (caddr_t) &in_data;
-#endif /* Different register sets */
+ in_data.bytes = registers;
- ptrace_in.pid = inferior_pid;
- ptrace_in.info.ttype = REGS;
- ptrace_in.info.more_data = (caddr_t) &inferior_registers;
+ in_data.len = VX_NUM_REGS * REGISTER_SIZE;
/* XXX change second param to be a proc number */
status = net_ptrace_clnt_call (PTRACE_SETREGS, &ptrace_in, &ptrace_out);
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
- return -1;
+ 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)
{
-#ifdef I80960
-
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
- sizeof inferior_fp_registers.fps_regs);
-
-#else /* not 960 -- assume 68k -- FIXME */
-
- bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
- sizeof inferior_fp_registers.fps_regs);
- bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)],
- &inferior_fp_registers.fps_control,
- sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs);
+ ptrace_in.pid = inferior_pid;
+ ptrace_in.info.ttype = DATA;
+ ptrace_in.info.more_data = (caddr_t) &in_data;
-#endif /* Different register sets */
- ptrace_in.pid = inferior_pid;
- ptrace_in.info.ttype = FPREGS;
- ptrace_in.info.more_data = (caddr_t) &inferior_fp_registers;
+ in_data.bytes = ®isters[REGISTER_BYTE (FP0_REGNUM)];
+ in_data.len = VX_SIZE_FPREGS;
status = net_ptrace_clnt_call (PTRACE_SETFPREGS, &ptrace_in, &ptrace_out);
if (status)
if (ptrace_out.status == -1)
{
errno = ptrace_out.errno;
- return -1;
+ perror_with_name ("net_ptrace_clnt_call(PTRACE_SETFPREGS)");
}
}
- return 0;
+#endif /* VX_SIZE_FPREGS */
}
/* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
handle the current address but can handle one N bytes further, but
vxworks doesn't give us that information. */
-int
+static int
vx_xfer_memory (memaddr, myaddr, len, write, target)
CORE_ADDR memaddr;
char *myaddr;
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 */
return len; /* Moved *all* the bytes */
}
-void
+static void
vx_files_info ()
{
- printf ("\tAttached to host `%s'", vx_host);
- printf (", which has %sfloating point", target_has_fp? "": "no ");
- printf (".\n");
+ printf_unfiltered ("\tAttached to host `%s'", vx_host);
+ printf_unfiltered (", which has %sfloating point", target_has_fp? "": "no ");
+ printf_unfiltered (".\n");
}
-void
+static void
vx_run_files_info ()
{
- printf ("\tRunning %s VxWorks process %s",
- vx_running? "child": "attached",
- local_hex_string(inferior_pid));
+ printf_unfiltered ("\tRunning %s VxWorks process %s",
+ vx_running ? "child" : "attached",
+ local_hex_string (inferior_pid));
if (vx_running)
- printf (", function `%s'", vx_running);
- printf(".\n");
+ printf_unfiltered (", function `%s'", vx_running);
+ printf_unfiltered(".\n");
}
-void
-vx_resume (step, siggnal)
+static void
+vx_resume (pid, step, siggnal)
+ int pid;
int step;
- int siggnal;
+ enum target_signal siggnal;
{
int status;
Rptrace ptrace_in;
Ptrace_return ptrace_out;
+ if (pid == -1)
+ pid = inferior_pid;
+
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 */
}
}
-void
+static void
vx_mourn_inferior ()
{
pop_target (); /* Pop back to no-child state */
\f
/* This function allows the addition of incrementally linked object files. */
-void
+static void
vx_load_command (arg_string, from_tty)
char* arg_string;
int from_tty;
immediate_quit--;
/* FIXME, for now we ignore data_addr and bss_addr. */
- symbol_file_add (arg_string, from_tty, text_addr, 0);
+ symbol_file_add (arg_string, from_tty, text_addr, 0, 0, 0);
}
#ifdef FIXME /* Not ready for prime time */
NULL, memory for the buffer will be allocated by XDR.
Returns -1 if rpc failed, 0 otherwise. */
-int
+static int
net_get_boot_file (pBootFile)
char **pBootFile;
{
There's no way to check if the returned loadTable is correct.
VxWorks doesn't check it. */
-int
+static int
net_get_symbols (pLoadTable)
ldtabl *pLoadTable; /* return pointer to ldtabl here */
{
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;
struct complaint cant_contact_target =
{"Lost contact with VxWorks target", 0, 0};
-int
+static int
vx_lookup_symbol (name, pAddr)
char *name; /* symbol name */
CORE_ADDR *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);
if (status != RPC_SUCCESS) {
- complain (&cant_contact_target, 0);
+ complain (&cant_contact_target);
return -1;
}
Returns 1 if target has floating point processor, 0 otherwise.
Calls error() if rpc fails. */
-int
+static int
net_check_for_fp ()
{
enum clnt_stat status;
/* Establish an RPC connection with the VxWorks target system.
Calls error () if unable to establish connection. */
-void
+static void
net_connect (host)
char *host;
{
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. */
*/
static int
-vx_wait (status)
- int *status;
+vx_wait (pid_to_wait_for, status)
+ int pid_to_wait_for;
+ struct target_waitstatus *status;
{
register int pid;
- WAITTYPE w;
RDB_EVENT rdbEvent;
int quit_failed;
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(pid));
+ fatal ("Bad pid for debugged task: %s\n",
+ local_hex_string((unsigned long) pid));
} while (pid == 0);
- /* FIXME, eventually do more then SIGTRAP on everything... */
+ /* The mostly likely kind. */
+ status->kind = TARGET_WAITKIND_STOPPED;
+
switch (rdbEvent.eventType)
{
case EVENT_EXIT:
- WSETEXIT (w, 0);
+ status->kind = TARGET_WAITKIND_EXITED;
/* FIXME is it possible to distinguish between a
- XXX normal vs abnormal exit in VxWorks? */
+ normal vs abnormal exit in VxWorks? */
+ status->value.integer = 0;
break;
- case EVENT_START: /* Task was just started. */
- WSETSTOP (w, SIGTRAP);
+ case EVENT_START:
+ /* Task was just started. */
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case EVENT_STOP:
- WSETSTOP (w, SIGTRAP);
+ status->value.sig = TARGET_SIGNAL_TRAP;
/* XXX was it stopped by a signal? act accordingly */
break;
case EVENT_BREAK: /* Breakpoint was hit. */
- WSETSTOP (w, SIGTRAP);
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case EVENT_SUSPEND: /* Task was suspended, probably by ^C. */
- WSETSTOP (w, SIGINT);
+ status->value.sig = TARGET_SIGNAL_INT;
break;
case EVENT_BUS_ERR: /* Task made evil nasty reference. */
- WSETSTOP (w, SIGBUS);
+ status->value.sig = TARGET_SIGNAL_BUS;
break;
case EVENT_ZERO_DIV: /* Division by zero */
- WSETSTOP (w, SIGFPE); /* Like Unix, call it a float exception. */
+ status->value.sig = TARGET_SIGNAL_FPE;
+ break;
case EVENT_SIGNAL:
- /* The target is not running Unix, and its
- faults/traces do not map nicely into Unix signals.
- Make sure they do not get confused with Unix signals
- by numbering them with values higher than the highest
- legal Unix signal. code in the arch-dependent PRINT_RANDOM_SIGNAL
- routine will interpret the value for wait_for_inferior. */
- WSETSTOP (w, rdbEvent.sigType + NSIG);
+#ifdef I80960
+ 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. */
+ status->value.sig = TARGET_SIGNAL_UNKNOWN;
+#endif
break;
} /* switch */
- *status = *(int *)&w; /* Grumble union wait crap Grumble */
return pid;
}
\f
{
struct ldfile *pLoadFile = (struct ldfile *)arg;
- printf("\t%s: ", pLoadFile->name);
- symbol_file_add (pLoadFile->name, 0, pLoadFile->txt_addr, 0);
- printf ("ok\n");
+ printf_unfiltered("\t%s: ", pLoadFile->name);
+ symbol_file_add (pLoadFile->name, 0, pLoadFile->txt_addr, 0, 0, 0);
+ printf_unfiltered ("ok\n");
return 1;
}
/* Target command for VxWorks target systems.
target_preopen (from_tty);
unpush_target (&vx_ops);
- printf ("Attaching remote machine across net...\n");
- fflush (stdout);
+ printf_unfiltered ("Attaching remote machine across net...\n");
+ gdb_flush (gdb_stdout);
/* Allow the user to kill the connect attempt by typing ^C.
Wait until the call to target_has_fp () completes before
{
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");
+ printf_unfiltered ("VxWorks kernel symbols not loaded.\n");
}
else
error ("Can't retrieve boot file name from target machine.");
/* 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");
error ("Invalid process-id -- give a single number in decimal or 0xhex");
if (from_tty)
- printf ("Attaching pid %s.\n", local_hex_string(pid));
+ printf_unfiltered ("Attaching pid %s.\n",
+ local_hex_string((unsigned long) 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 ();
}
error ("Argument given to VxWorks \"detach\".");
if (from_tty)
- printf ("Detaching pid %s.\n", local_hex_string(inferior_pid));
+ printf_unfiltered ("Detaching pid %s.\n",
+ local_hex_string((unsigned long) inferior_pid));
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);
/* vx_kill -- takes a running task and wipes it out. */
static void
-vx_kill (args, from_tty)
- char *args;
- int from_tty;
+vx_kill ()
{
Rptrace ptrace_in;
Ptrace_return ptrace_out;
int status;
- if (args)
- error ("Argument given to VxWorks \"kill\".");
-
- if (from_tty)
- printf ("Killing pid %s.\n", local_hex_string(inferior_pid));
+ printf_unfiltered ("Killing pid %s.\n", local_hex_string((unsigned long) 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 */
}
/* Clean up from the VxWorks process target as it goes away. */
-void
+static void
vx_proc_close (quitting)
int quitting;
{
vx_running = 0;
}
\f
-/* Cross-net conversion of floats to and from extended form.
- (This is needed because different target machines have different
- extended floating point formats.) */
-
-/* Convert from an extended float to a double.
-
- The extended float is stored as raw data pointed to by FROM.
- Return the converted value as raw data in the double pointed to by TO.
-*/
-
-static void
-vx_convert_to_virtual (regno, from, to)
- int regno;
- char *from;
- char *to;
-{
- enum clnt_stat status;
-
- if (REGISTER_CONVERTIBLE (regno))
- {
- if (!target_has_fp) {
- *(double *)to = 0.0; /* Skip the trouble if no float anyway */
- return;
- }
-
- status = net_clnt_call (VX_CONV_FROM_68881, xdr_ext_fp, from,
- xdr_double, to);
-
- if (status == RPC_SUCCESS)
- return;
- else
- error (rpcerr);
- }
- else
- bcopy (from, to, REGISTER_VIRTUAL_SIZE (regno));
-}
-
-
-/* The converse: convert from a double to an extended float.
-
- The double is stored as raw data pointed to by FROM.
- Return the converted value as raw data in the extended
- float pointed to by TO.
-*/
-
-static void
-vx_convert_from_virtual (regno, from, to)
- int regno;
- char *from;
- char *to;
-{
- enum clnt_stat status;
-
- if (REGISTER_CONVERTIBLE (regno))
- {
- if (!target_has_fp) {
- bzero (to, REGISTER_RAW_SIZE (FP0_REGNUM)); /* Shrug */
- return;
- }
-
- status = net_clnt_call (VX_CONV_TO_68881, xdr_double, from,
- xdr_ext_fp, to);
- if (status == RPC_SUCCESS)
- return;
- else
- error (rpcerr);
- }
- else
- bcopy (from, to, REGISTER_VIRTUAL_SIZE (regno));
-}
-\f
/* Make an RPC call to the VxWorks target.
Returns RPC status. */
/* Clean up before losing control. */
-void
+static void
vx_close (quitting)
int quitting;
{
vx_open, vx_close, vx_attach, 0, /* vx_detach, */
0, 0, /* resume, wait */
0, 0, /* read_reg, write_reg */
- 0, vx_convert_to_virtual, vx_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 */
0, /* vx_kill, */
vx_load_command,
- 0, /* call_function */
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, vx_convert_to_virtual, vx_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_kill,
vx_load_command,
- call_function_by_hand, /* FIXME, calling fns is maybe botched? */
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 / deliverable / binutils-gdb.git / blobdiff