/* Memory-access and commands for remote VxWorks processes, for GDB.
- Copyright (C) 1990-95, 1997-98, 1999, 2001 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.
This file is part of GDB.
#include "defs.h"
#include "frame.h"
#include "inferior.h"
-#include "gdb_wait.h"
#include "target.h"
#include "gdbcore.h"
#include "command.h"
#include "symfile.h"
#include "objfiles.h"
#include "gdb-stabs.h"
+#include "regcache.h"
#include "gdb_string.h"
#include <errno.h>
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);
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.
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. */
memset ((char *) pEvent, '\0', sizeof (RDB_EVENT));
- pid = inferior_pid;
+ pid = PIDGET (inferior_ptid);
status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT,
pEvent);
/* 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,
/* 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. */
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.more_data = (caddr_t) & in_data;
vx_prepare_to_store (void)
{
/* Fetch all registers, if any of them are not yet fetched. */
- read_register_bytes (0, NULL, REGISTER_BYTES);
+ deprecated_read_register_bytes (0, NULL, REGISTER_BYTES);
}
/* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR
static int
vx_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct mem_attrib *attrib ATTRIBUTE_UNUSED,
- struct target_ops *target ATTRIBUTE_UNUSED)
+ struct mem_attrib *attrib, struct target_ops *target)
{
int status;
Rptrace ptrace_in;
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.data = len; /* How many bytes */
{
printf_unfiltered ("\tRunning %s VxWorks process %s",
vx_running ? "child" : "attached",
- local_hex_string (inferior_pid));
+ local_hex_string (PIDGET (inferior_ptid)));
if (vx_running)
printf_unfiltered (", function `%s'", vx_running);
printf_unfiltered (".\n");
}
static void
-vx_resume (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;
- 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");
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
- ptrace_in.pid = pid;
+ ptrace_in.pid = PIDGET (ptid);
ptrace_in.addr = cont_addr; /* Target side insists on this, or it panics. */
if (step)
/* 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? "))
int step_status;
SOURCE_STEP source_step;
- source_step.taskId = inferior_pid;
+ source_step.taskId = PIDGET (inferior_ptid);
if (step_range_end)
{
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
vx_lookup_symbol (char *name, /* symbol name */
CORE_ADDR *pAddr)
xdr_SYMBOL_ADDR, &symbolAddr);
if (status != RPC_SUCCESS)
{
- complain (&cant_contact_target);
+ complaint (&symfile_complaints, "Lost contact with VxWorks target");
return -1;
}
perror_with_name ("select");
}
-static int
-vx_wait (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;
RDB_EVENT rdbEvent;
{
sleep_ms (200); /* FIXME Don't kill the network too badly */
}
- else if (pid != inferior_pid)
- internal_error ("Bad pid for debugged task: %s\n",
+ 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);
#endif
break;
} /* switch */
- return pid;
+ return pid_to_ptid (pid);
}
\f
static int
/* It worked... */
- inferior_pid = pid;
+ inferior_ptid = pid_to_ptid (pid);
push_target (&vx_run_ops);
if (vx_running)
if (from_tty)
printf_unfiltered ("Detaching pid %s.\n",
- local_hex_string ((unsigned long) inferior_pid));
+ local_hex_string (
+ (unsigned long) PIDGET (inferior_ptid)));
if (args) /* FIXME, should be possible to leave suspended */
signal = atoi (args);
memset ((char *) &ptrace_in, '\0', sizeof (ptrace_in));
memset ((char *) &ptrace_out, '\0', sizeof (ptrace_out));
- ptrace_in.pid = inferior_pid;
+ ptrace_in.pid = PIDGET (inferior_ptid);
status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out);
if (status == -1)
perror_with_name ("Detaching VxWorks process");
}
- inferior_pid = 0;
+ inferior_ptid = null_ptid;
pop_target (); /* go back to non-executing VxWorks connection */
}
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;
+ ptrace_in.pid = PIDGET (inferior_ptid);
status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out);
if (status == -1)
/* 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;
+ inferior_ptid = null_ptid;
pop_target (); /* go back to non-executing VxWorks connection */
}
static void
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)
xfree (vx_running);
vx_running = 0;
projects / deliverable / binutils-gdb.git / blobdiff