Boston, MA 02111-1307, USA. */
#include "defs.h"
+#include "command.h"
#include "frame.h"
+#include "gdbcore.h"
#include "inferior.h"
-#include "target.h"
-#include "gdb_string.h"
#include "regcache.h"
+#include "target.h"
+#include "gdb_assert.h"
#include "gdb_wait.h"
-
-#include "command.h"
-
-#ifdef USG
-#include <sys/types.h>
-#endif
+#include "gdb_string.h"
#include <sys/param.h>
#include "gdb_dirent.h"
#include <signal.h>
#include <sys/ioctl.h>
-#ifdef HAVE_PTRACE_H
-#include <ptrace.h>
-#else
-#ifdef HAVE_SYS_PTRACE_H
-#include <sys/ptrace.h>
-#endif
-#endif
+#include "gdb_ptrace.h"
-#if !defined (PT_READ_I)
-#define PT_READ_I 1 /* Read word from text space */
-#endif
-#if !defined (PT_READ_D)
-#define PT_READ_D 2 /* Read word from data space */
-#endif
-#if !defined (PT_READ_U)
-#define PT_READ_U 3 /* Read word from kernel user struct */
-#endif
-#if !defined (PT_WRITE_I)
-#define PT_WRITE_I 4 /* Write word to text space */
-#endif
-#if !defined (PT_WRITE_D)
-#define PT_WRITE_D 5 /* Write word to data space */
-#endif
-#if !defined (PT_WRITE_U)
-#define PT_WRITE_U 6 /* Write word to kernel user struct */
-#endif
-#if !defined (PT_CONTINUE)
-#define PT_CONTINUE 7 /* Continue after signal */
-#endif
-#if !defined (PT_STEP)
-#define PT_STEP 9 /* Set flag for single stepping */
-#endif
-#if !defined (PT_KILL)
-#define PT_KILL 8 /* Send child a SIGKILL signal */
-#endif
-
-#include "gdbcore.h"
#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
#endif
-#if 0
-/* Don't think this is used anymore. On the sequent (not sure whether it's
- dynix or ptx or both), it is included unconditionally by sys/user.h and
- not protected against multiple inclusion. */
-#include "gdb_stat.h"
-#endif
#if !defined (FETCH_INFERIOR_REGISTERS)
#include <sys/user.h> /* Probably need to poke the user structure */
static void udot_info (char *, int);
#endif
-#if !defined (FETCH_INFERIOR_REGISTERS)
-static void fetch_register (int);
-static void store_register (int);
-#endif
-
void _initialize_infptrace (void);
\f
/* Wait for a process to finish, possibly running a target-specific
hook before returning. */
+/* NOTE: cagney: 2004-09-29: Dependant on the native configuration,
+ "hppah-nat.c" may either call this or infttrace.c's implementation
+ of ptrace_wait. See "hppahpux.mh". */
+
int
ptrace_wait (ptid_t ptid, int *status)
{
int wstate;
wstate = wait (status);
- target_post_wait (pid_to_ptid (wstate), *status);
return wstate;
}
-#ifndef KILL_INFERIOR
+#ifndef DEPRECATED_KILL_INFERIOR
+/* NOTE: cagney/2004-09-12: Instead of definining this macro, code
+ should call inf_ptrace_target to get a basic ptrace target and then
+ locally update any necessary methods. See ppcnbsd-nat.c. */
+
void
kill_inferior (void)
{
The kill call causes problems under hpux10, so it's been removed;
if this causes problems we'll deal with them as they arise. */
ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3) 0, 0);
- ptrace_wait (null_ptid, &status);
+ wait (&status);
target_mourn_inferior ();
}
-#endif /* KILL_INFERIOR */
+#endif /* DEPRECATED_KILL_INFERIOR */
-#ifndef CHILD_RESUME
+#ifndef DEPRECATED_CHILD_RESUME
+/* NOTE: cagney/2004-09-12: Instead of definining this macro, code
+ should call inf_ptrace_target to get a basic ptrace target and then
+ locally update any necessary methods. See ppcnbsd-nat.c. */
/* Resume execution of the inferior process.
If STEP is nonzero, single-step it.
void
child_resume (ptid_t ptid, int step, enum target_signal signal)
{
+ int request = PT_CONTINUE;
int pid = PIDGET (ptid);
- errno = 0;
-
if (pid == -1)
/* Resume all threads. */
/* I think this only gets used in the non-threaded case, where "resume
all threads" and "resume inferior_ptid" are the same. */
pid = PIDGET (inferior_ptid);
- /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from where
- it was. (If GDB wanted it to start some other way, we have already
- written a new PC value to the child.)
-
- If this system does not support PT_STEP, a higher level function will
- have called single_step() to transmute the step request into a
- continue request (by setting breakpoints on all possible successor
- instructions), so we don't have to worry about that here. */
-
if (step)
{
- if (SOFTWARE_SINGLE_STEP_P ())
- internal_error (__FILE__, __LINE__, "failed internal consistency check"); /* Make sure this doesn't happen. */
- else
- ptrace (PT_STEP, pid, (PTRACE_TYPE_ARG3) 1,
- target_signal_to_host (signal));
+ /* If this system does not support PT_STEP, a higher level
+ function will have called single_step() to transmute the step
+ request into a continue request (by setting breakpoints on
+ all possible successor instructions), so we don't have to
+ worry about that here. */
+
+ gdb_assert (!SOFTWARE_SINGLE_STEP_P ());
+ request = PT_STEP;
}
- else
- ptrace (PT_CONTINUE, pid, (PTRACE_TYPE_ARG3) 1,
- target_signal_to_host (signal));
- if (errno)
- {
- perror_with_name ("ptrace");
- }
+ /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
+ where it was. If GDB wanted it to start some other way, we have
+ already written a new PC value to the child. */
+
+ errno = 0;
+ ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal));
+ if (errno != 0)
+ perror_with_name ("ptrace");
}
-#endif /* CHILD_RESUME */
+#endif /* DEPRECATED_CHILD_RESUME */
\f
+
/* Start debugging the process whose number is PID. */
+
int
attach (int pid)
{
- errno = 0;
-#ifndef PT_ATTACH
-#ifdef PTRACE_ATTACH
-#define PT_ATTACH PTRACE_ATTACH
-#endif
-#endif
#ifdef PT_ATTACH
+ errno = 0;
ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3) 0, 0);
- if (errno)
+ if (errno != 0)
perror_with_name ("ptrace");
attach_flag = 1;
return pid;
#endif
}
-/* Stop debugging the process whose number is PID
- and continue it with signal number SIGNAL.
- SIGNAL = 0 means just continue it. */
+/* Stop debugging the process whose number is PID and continue it with
+ signal number SIGNAL. SIGNAL = 0 means just continue it. */
void
detach (int signal)
{
- errno = 0;
-#ifndef PT_DETACH
-#ifdef PTRACE_DETACH
-#define PT_DETACH PTRACE_DETACH
-#endif
-#endif
#ifdef PT_DETACH
- ptrace (PT_DETACH, PIDGET (inferior_ptid), (PTRACE_TYPE_ARG3) 1,
- signal);
- if (errno)
- print_sys_errmsg ("ptrace", errno);
+ int pid = PIDGET (inferior_ptid);
+
+ errno = 0;
+ ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3) 1, signal);
+ if (errno != 0)
+ perror_with_name ("ptrace");
attach_flag = 0;
#else
error ("This system does not support detaching from a process");
#endif
}
\f
-/* Default the type of the ptrace transfer to int. */
-#ifndef PTRACE_XFER_TYPE
-#define PTRACE_XFER_TYPE int
-#endif
-#if !defined (FETCH_INFERIOR_REGISTERS)
+#ifndef FETCH_INFERIOR_REGISTERS
-#if !defined (offsetof)
+/* U_REGS_OFFSET is the offset of the registers within the u area. */
+#ifndef U_REGS_OFFSET
+
+#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
#endif
-/* U_REGS_OFFSET is the offset of the registers within the u area. */
-#if !defined (U_REGS_OFFSET)
#define U_REGS_OFFSET \
ptrace (PT_READ_U, PIDGET (inferior_ptid), \
(PTRACE_TYPE_ARG3) (offsetof (struct user, u_ar0)), 0) \
- KERNEL_U_ADDR
#endif
-/* Fetch one register. */
+/* Fetch register REGNUM from the inferior. */
static void
-fetch_register (int regno)
+fetch_register (int regnum)
{
- /* This isn't really an address. But ptrace thinks of it as one. */
- CORE_ADDR regaddr;
- char mess[128]; /* For messages */
- int i;
- unsigned int offset; /* Offset of registers within the u area. */
- char buf[MAX_REGISTER_SIZE];
- int tid;
+ CORE_ADDR addr;
+ size_t size;
+ PTRACE_TYPE_RET *buf;
+ int tid, i;
- if (CANNOT_FETCH_REGISTER (regno))
+ if (CANNOT_FETCH_REGISTER (regnum))
{
- regcache_raw_supply (current_regcache, regno, NULL);
+ regcache_raw_supply (current_regcache, regnum, NULL);
return;
}
- /* Overload thread id onto process id */
- if ((tid = TIDGET (inferior_ptid)) == 0)
- tid = PIDGET (inferior_ptid); /* no thread id, just use process id */
+ /* GNU/Linux LWP ID's are process ID's. */
+ tid = TIDGET (inferior_ptid);
+ if (tid == 0)
+ tid = PIDGET (inferior_ptid); /* Not a threaded program. */
- offset = U_REGS_OFFSET;
+ /* This isn't really an address. But ptrace thinks of it as one. */
+ addr = register_addr (regnum, U_REGS_OFFSET);
+ size = register_size (current_gdbarch, regnum);
+
+ gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
+ buf = alloca (size);
- regaddr = register_addr (regno, offset);
- for (i = 0; i < register_size (current_gdbarch, regno); i += sizeof (PTRACE_XFER_TYPE))
+ /* Read the register contents from the inferior a chuck at the time. */
+ for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
{
errno = 0;
- *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
- (PTRACE_TYPE_ARG3) regaddr, 0);
- regaddr += sizeof (PTRACE_XFER_TYPE);
+ buf[i] = ptrace (PT_READ_U, tid, (PTRACE_TYPE_ARG3) addr, 0);
if (errno != 0)
- {
- sprintf (mess, "reading register %s (#%d)",
- REGISTER_NAME (regno), regno);
- perror_with_name (mess);
- }
+ error ("Couldn't read register %s (#%d): %s.", REGISTER_NAME (regnum),
+ regnum, safe_strerror (errno));
+
+ addr += sizeof (PTRACE_TYPE_RET);
}
- regcache_raw_supply (current_regcache, regno, buf);
+ regcache_raw_supply (current_regcache, regnum, buf);
}
-
-/* Fetch register values from the inferior.
- If REGNO is negative, do this for all registers.
- Otherwise, REGNO specifies which register (so we can save time). */
+/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
+ for all registers. */
void
-fetch_inferior_registers (int regno)
+fetch_inferior_registers (int regnum)
{
- if (regno >= 0)
- {
- fetch_register (regno);
- }
+ if (regnum == -1)
+ for (regnum = 0; regnum < NUM_REGS; regnum++)
+ fetch_register (regnum);
else
- {
- for (regno = 0; regno < NUM_REGS; regno++)
- {
- fetch_register (regno);
- }
- }
+ fetch_register (regnum);
}
-/* Store one register. */
+/* Store register REGNUM into the inferior. */
static void
-store_register (int regno)
+store_register (int regnum)
{
- /* This isn't really an address. But ptrace thinks of it as one. */
- CORE_ADDR regaddr;
- char mess[128]; /* For messages */
- int i;
- unsigned int offset; /* Offset of registers within the u area. */
- int tid;
- char buf[MAX_REGISTER_SIZE];
-
- if (CANNOT_STORE_REGISTER (regno))
- {
- return;
- }
+ CORE_ADDR addr;
+ size_t size;
+ PTRACE_TYPE_RET *buf;
+ int tid, i;
- /* Overload thread id onto process id */
- if ((tid = TIDGET (inferior_ptid)) == 0)
- tid = PIDGET (inferior_ptid); /* no thread id, just use process id */
+ if (CANNOT_STORE_REGISTER (regnum))
+ return;
- offset = U_REGS_OFFSET;
+ /* GNU/Linux LWP ID's are process ID's. */
+ tid = TIDGET (inferior_ptid);
+ if (tid == 0)
+ tid = PIDGET (inferior_ptid); /* Not a threaded program. */
- regaddr = register_addr (regno, offset);
+ /* This isn't really an address. But ptrace thinks of it as one. */
+ addr = register_addr (regnum, U_REGS_OFFSET);
+ size = register_size (current_gdbarch, regnum);
- /* Put the contents of regno into a local buffer */
- regcache_raw_collect (current_regcache, regno, buf);
+ gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
+ buf = alloca (size);
- /* Store the local buffer into the inferior a chunk at the time. */
- for (i = 0; i < register_size (current_gdbarch, regno); i += sizeof (PTRACE_XFER_TYPE))
+ /* Write the register contents into the inferior a chunk at the time. */
+ regcache_raw_collect (current_regcache, regnum, buf);
+ for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
{
errno = 0;
- ptrace (PT_WRITE_U, tid, (PTRACE_TYPE_ARG3) regaddr,
- *(PTRACE_XFER_TYPE *) (buf + i));
- regaddr += sizeof (PTRACE_XFER_TYPE);
+ ptrace (PT_WRITE_U, tid, (PTRACE_TYPE_ARG3) addr, buf[i]);
if (errno != 0)
- {
- sprintf (mess, "writing register %s (#%d)",
- REGISTER_NAME (regno), regno);
- perror_with_name (mess);
- }
+ error ("Couldn't write register %s (#%d): %s.", REGISTER_NAME (regnum),
+ regnum, safe_strerror (errno));
+
+ addr += sizeof (PTRACE_TYPE_RET);
}
}
-/* Store our register values back into the inferior.
- If REGNO is negative, do this for all registers.
- Otherwise, REGNO specifies which register (so we can save time). */
+/* Store register REGNUM back into the inferior. If REGNUM is -1, do
+ this for all registers (including the floating point registers). */
void
-store_inferior_registers (int regno)
+store_inferior_registers (int regnum)
{
- if (regno >= 0)
- {
- store_register (regno);
- }
+ if (regnum == -1)
+ for (regnum = 0; regnum < NUM_REGS; regnum++)
+ store_register (regnum);
else
- {
- for (regno = 0; regno < NUM_REGS; regno++)
- {
- store_register (regno);
- }
- }
+ store_register (regnum);
}
-#endif /* !defined (FETCH_INFERIOR_REGISTERS). */
+
+#endif /* not FETCH_INFERIOR_REGISTERS. */
\f
/* Set an upper limit on alloca. */
projects / deliverable / binutils-gdb.git / blobdiff