(linux_nat_pid_to_str): Adjust. Remove call to thread_db_init.
* linux-nat.h (thread_db_init): Delete declaration.
* linux-thread-db.c (target_beneath): Delete.
(thread_db_init): Delete.
(thread_db_detach): Use find_target_beneath.
(thread_db_wait): Adjust interface. Use find_target_beneath.
(thread_db_mourn_inferior): Use find_target_beneath.
(thread_db_can_async_p, thread_db_is_async_p, thread_db_async)
(thread_db_async_mask): Delete.
(thread_db_pid_to_str): Adjust interface. Use
find_target_beneath.
(thread_db_get_thread_local_address): Adjust interface. Use
find_target_beneath.
(init_thread_db_ops): Delete references to delete functions.
* target.c (update_current_target): Don't inherit or default
to_wait. Don't inherit to_pid_to_str and
to_get_thread_local_address.
(target_translate_tls_address): Look for a pushed target that
implements to_get_thread_local_address, and use it instead of
checking for target_get_thread_local_address_p.
(target_wait, target_pid_to_str): Reimplement as functions.
(dummy_pid_to_str): New.
(init_dummy_target): Register it.
(debug_to_wait): Delete.
* target.h (struct target_ops): Make to_wait, to_pid_to_str and
to_get_thread_local_address accept a pointer to struct target_ops.
(target_wait): Delete macro, and declare as function.
(target_pid_to_str): Likewise.
(target_get_thread_local_address)
(target_get_thread_local_address_p): Delete.
(noprocess): Add NORETURN and ATTR_NORETURN tags.
* inf-ptrace.c (inf_ptrace_wait): Adjust.
(inf_ptrace_pid_to_str): New.
(inf_ptrace_target): Use inf_ptrace_pid_to_str.
* aix-thread.c (aix_thread_wait, aix_thread_pid_to_str): Adjust.
* bsd-kvm.c (bsd_kvm_pid_to_str): Adjust.
* bsd-uthread.c (bsd_uthread_wait, bsd_uthread_pid_to_str):
Adjust.
* corelow.c (core_pid_to_str): Adjust.
* darwin-nat.c (darwin_wait, darwin_pid_to_str): Adjust.
* dec-thread.c (dec_thread_wait, dec_thread_pid_to_str): Adjust.
* gnu-nat.c (gnu_wait, gnu_pid_to_str): Adjust.
* go32-nat.c (go32_wait, go32_pid_to_str): Adjust.
* hpux-thread.c (hpux_thread_wait): Adjust.
* inf-ttrace.c (inf_ttrace_wait, inf_ttrace_pid_to_str): Adjust.
* monitor.c (monitor_wait, monitor_pid_to_str): Adjust.
* nto-procfs.c (procfs_wait, procfs_pid_to_str): Adjust.
* procfs.c (procfs_pid_to_str): Adjust.
* remote-m32r-sdi.c (m32r_wait, m32r_pid_to_str): Adjust.
* remote-mips.c (mips_wait): Adjust.
* remote-sim.c (gdbsim_wait, gdbsim_pid_to_str): Adjust.
* remote.c (remote_wait, remote_pid_to_str)
(remote_get_thread_local_address): Adjust.
* rs6000-nat.c (rs6000_wait): Adjust.
* sol-thread.c (procfs_pid_to_str): Adjust declaration.
(sol_thread_wait, solaris_pid_to_str): Adjust.
* spu-linux-nat.c (spu_child_wait): Adjust.
* windows-nat.c (windows_wait, windows_pid_to_str): Adjust.
+2009-02-06 Pedro Alves <pedro@codesourcery.com>
+
+ * linux-nat.c (linux_nat_wait): Adjust.
+ (linux_nat_pid_to_str): Adjust. Remove call to thread_db_init.
+ * linux-nat.h (thread_db_init): Delete declaration.
+ * linux-thread-db.c (target_beneath): Delete.
+ (thread_db_init): Delete.
+ (thread_db_detach): Use find_target_beneath.
+ (thread_db_wait): Adjust interface. Use find_target_beneath.
+ (thread_db_mourn_inferior): Use find_target_beneath.
+ (thread_db_can_async_p, thread_db_is_async_p, thread_db_async)
+ (thread_db_async_mask): Delete.
+ (thread_db_pid_to_str): Adjust interface. Use
+ find_target_beneath.
+ (thread_db_get_thread_local_address): Adjust interface. Use
+ find_target_beneath.
+ (init_thread_db_ops): Delete references to delete functions.
+ * target.c (update_current_target): Don't inherit or default
+ to_wait. Don't inherit to_pid_to_str and
+ to_get_thread_local_address.
+ (target_translate_tls_address): Look for a pushed target that
+ implements to_get_thread_local_address, and use it instead of
+ checking for target_get_thread_local_address_p.
+ (target_wait, target_pid_to_str): Reimplement as functions.
+ (dummy_pid_to_str): New.
+ (init_dummy_target): Register it.
+ (debug_to_wait): Delete.
+ * target.h (struct target_ops): Make to_wait, to_pid_to_str and
+ to_get_thread_local_address accept a pointer to struct target_ops.
+ (target_wait): Delete macro, and declare as function.
+ (target_pid_to_str): Likewise.
+ (target_get_thread_local_address)
+ (target_get_thread_local_address_p): Delete.
+ (noprocess): Add NORETURN and ATTR_NORETURN tags.
+ * inf-ptrace.c (inf_ptrace_wait): Adjust.
+ (inf_ptrace_pid_to_str): New.
+ (inf_ptrace_target): Use inf_ptrace_pid_to_str.
+ * aix-thread.c (aix_thread_wait, aix_thread_pid_to_str): Adjust.
+ * bsd-kvm.c (bsd_kvm_pid_to_str): Adjust.
+ * bsd-uthread.c (bsd_uthread_wait, bsd_uthread_pid_to_str):
+ Adjust.
+ * corelow.c (core_pid_to_str): Adjust.
+ * darwin-nat.c (darwin_wait, darwin_pid_to_str): Adjust.
+ * dec-thread.c (dec_thread_wait, dec_thread_pid_to_str): Adjust.
+ * gnu-nat.c (gnu_wait, gnu_pid_to_str): Adjust.
+ * go32-nat.c (go32_wait, go32_pid_to_str): Adjust.
+ * hpux-thread.c (hpux_thread_wait): Adjust.
+ * inf-ttrace.c (inf_ttrace_wait, inf_ttrace_pid_to_str): Adjust.
+ * monitor.c (monitor_wait, monitor_pid_to_str): Adjust.
+ * nto-procfs.c (procfs_wait, procfs_pid_to_str): Adjust.
+ * procfs.c (procfs_pid_to_str): Adjust.
+ * remote-m32r-sdi.c (m32r_wait, m32r_pid_to_str): Adjust.
+ * remote-mips.c (mips_wait): Adjust.
+ * remote-sim.c (gdbsim_wait, gdbsim_pid_to_str): Adjust.
+ * remote.c (remote_wait, remote_pid_to_str)
+ (remote_get_thread_local_address): Adjust.
+ * rs6000-nat.c (rs6000_wait): Adjust.
+ * sol-thread.c (procfs_pid_to_str): Adjust declaration.
+ (sol_thread_wait, solaris_pid_to_str): Adjust.
+ * spu-linux-nat.c (spu_child_wait): Adjust.
+ * windows-nat.c (windows_wait, windows_pid_to_str): Adjust.
+
2009-02-06 Tom Tromey <tromey@redhat.com>
* Makefile.in (SUBDIR_PYTHON_OBS): Add python-cmd.o.
thread. */
static ptid_t
-aix_thread_wait (ptid_t ptid, struct target_waitstatus *status)
+aix_thread_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
struct cleanup *cleanup = save_inferior_ptid ();
pid_to_prc (&ptid);
inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
- ptid = base_target.to_wait (ptid, status);
+ ptid = base_target.to_wait (&base_target, ptid, status);
do_cleanups (cleanup);
if (PIDGET (ptid) == -1)
"info threads" output. */
static char *
-aix_thread_pid_to_str (ptid_t ptid)
+aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char *ret = NULL;
if (!PD_TID (ptid))
- return base_target.to_pid_to_str (ptid);
+ return base_target.to_pid_to_str (&base_target, ptid);
/* Free previous return value; a new one will be allocated by
xstrprintf(). */
}
static char *
-bsd_kvm_pid_to_str (ptid_t ptid)
+bsd_kvm_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
xsnprintf (buf, sizeof buf, "<kvm>");
}
static ptid_t
-bsd_uthread_wait (ptid_t ptid, struct target_waitstatus *status)
+bsd_uthread_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
CORE_ADDR addr;
+ struct target_ops *beneath = find_target_beneath (bsd_uthread_ops_hack);
/* Pass the request to the layer beneath. */
- ptid = find_target_beneath (bsd_uthread_ops_hack)->to_wait (ptid, status);
+ ptid = beneath->to_wait (beneath, ptid, status);
/* If the process is no longer alive, there's no point in figuring
out the thread ID. It will fail anyway. */
}
static char *
-bsd_uthread_pid_to_str (ptid_t ptid)
+bsd_uthread_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
if (ptid_get_tid (ptid) != 0)
{
}
static char *
-core_pid_to_str (ptid_t ptid)
+core_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
static void darwin_resume (ptid_t ptid, int step,
enum target_signal signal);
-static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
-
static void darwin_mourn_inferior (struct target_ops *ops);
static int darwin_lookup_task (char *args, task_t * ptask, int *ppid);
static void darwin_files_info (struct target_ops *ops);
-static char *darwin_pid_to_str (ptid_t tpid);
-
static int darwin_thread_alive (ptid_t tpid);
/* Current inferior. */
}
static ptid_t
-darwin_wait (ptid_t ptid, struct target_waitstatus *status)
+darwin_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
kern_return_t kret;
mach_msg_header_t *hdr = &msgin.hdr;
}
static char *
-darwin_pid_to_str (ptid_t ptid)
+darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[128];
/* The "to_wait" method of the dec_thread_ops. */
static ptid_t
-dec_thread_wait (ptid_t ptid, struct target_waitstatus *status)
+dec_thread_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
ptid_t active_ptid;
debug ("dec_thread_wait");
- ptid = base_target.to_wait (ptid, status);
+ ptid = base_target.to_wait (&base_target, ptid, status);
/* The ptid returned by the base_target is the ptid of the process.
We need to find which thread is currently active and return its
/* The "to_pid_to_str" method of the dec_thread_ops. */
static char *
-dec_thread_pid_to_str (ptid_t ptid)
+dec_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char *ret = NULL;
if (ptid_get_tid (ptid) == 0)
- return base_target.to_pid_to_str (ptid);
+ return base_target.to_pid_to_str (&base_target, ptid);
/* Free previous return value; a new one will be allocated by
xstrprintf(). */
/* Wait for something to happen in the inferior, returning what in STATUS. */
static ptid_t
-gnu_wait (ptid_t ptid, struct target_waitstatus *status)
+gnu_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
struct msg
{
}
static char *
-gnu_pid_to_str (ptid_t ptid)
+gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
struct inf *inf = gnu_current_inf;
int tid = ptid_get_tid (ptid);
static void go32_detach (char *args, int from_tty);
static void go32_resume (ptid_t ptid, int step,
enum target_signal siggnal);
-static ptid_t go32_wait (ptid_t ptid,
- struct target_waitstatus *status);
static void go32_fetch_registers (struct regcache *, int regno);
static void store_register (const struct regcache *, int regno);
static void go32_store_registers (struct regcache *, int regno);
static char child_cwd[FILENAME_MAX];
static ptid_t
-go32_wait (ptid_t ptid, struct target_waitstatus *status)
+go32_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
int i;
unsigned char saved_opcode;
}
static char *
-go32_pid_to_str (ptid_t ptid)
+go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
xsnprintf (buf, sizeof buf, "Thread <main>");
to a LWP id, and vice versa on the way out. */
static ptid_t
-hpux_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+hpux_thread_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
ptid_t rtnval;
struct cleanup *old_chain;
if (!ptid_equal (ptid, minus_one_ptid))
ptid = main_ptid;
- rtnval = deprecated_child_ops.to_wait (ptid, ourstatus);
+ rtnval = deprecated_child_ops.to_wait (&deprecated_child_ops,
+ ptid, ourstatus);
rtnval = find_active_thread ();
the status in *OURSTATUS. */
static ptid_t
-inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+inf_ptrace_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
pid_t pid;
int status, save_errno;
target_pid_to_str (inferior_ptid));
}
+static char *
+inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+ return normal_pid_to_str (ptid);
+}
+
/* Create a prototype ptrace target. The client can override it with
local methods. */
#endif
t->to_mourn_inferior = inf_ptrace_mourn_inferior;
t->to_thread_alive = inf_ptrace_thread_alive;
- t->to_pid_to_str = normal_pid_to_str;
+ t->to_pid_to_str = inf_ptrace_pid_to_str;
t->to_stop = inf_ptrace_stop;
t->to_xfer_partial = inf_ptrace_xfer_partial;
}
static ptid_t
-inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+inf_ttrace_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
pid_t pid = ptid_get_pid (ptid);
lwpid_t lwpid = ptid_get_lwp (ptid);
}
static char *
-inf_ttrace_pid_to_str (ptid_t ptid)
+inf_ttrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
pid_t pid = ptid_get_pid (ptid);
lwpid_t lwpid = ptid_get_lwp (ptid);
}
static ptid_t
-linux_nat_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+linux_nat_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
struct lwp_info *lp = NULL;
int options = 0;
}
static char *
-linux_nat_pid_to_str (ptid_t ptid)
+linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
also want to be used for single-threaded processes. */
add_target (t);
-
- /* TODO: Eliminate this and have libthread_db use
- find_target_beneath. */
- thread_db_init (t);
}
/* Register a method to call whenever a new thread is attached. */
/* Attempt to initialize libthread_db. */
void check_for_thread_db (void);
-/* Tell the thread_db layer what native target operations to use. */
-void thread_db_init (struct target_ops *);
-
int thread_db_attach_lwp (ptid_t ptid);
/* Find process PID's pending signal set from /proc/pid/status. */
/* This module's target vector. */
static struct target_ops thread_db_ops;
-/* The target vector that we call for things this module can't handle. */
-static struct target_ops *target_beneath;
-
/* Non-zero if we're using this module's target vector. */
static int using_thread_db;
return 1;
}
-void
-thread_db_init (struct target_ops *target)
-{
- target_beneath = target;
-}
-
static void *
verbose_dlsym (void *handle, const char *name)
{
static void
thread_db_detach (struct target_ops *ops, char *args, int from_tty)
{
+ struct target_ops *target_beneath = find_target_beneath (ops);
+
disable_thread_event_reporting ();
/* Forget about the child's process ID. We shouldn't need it
}
static ptid_t
-thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+thread_db_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
- ptid = target_beneath->to_wait (ptid, ourstatus);
+ struct target_ops *beneath = find_target_beneath (ops);
+
+ ptid = beneath->to_wait (beneath, ptid, ourstatus);
if (ourstatus->kind == TARGET_WAITKIND_IGNORE)
return ptid;
static void
thread_db_mourn_inferior (struct target_ops *ops)
{
+ struct target_ops *target_beneath = find_target_beneath (ops);
+
/* Forget about the child's process ID. We shouldn't need it
anymore. */
proc_handle.pid = 0;
using_thread_db = 0;
}
-static int
-thread_db_can_async_p (void)
-{
- return target_beneath->to_can_async_p ();
-}
-
-static int
-thread_db_is_async_p (void)
-{
- return target_beneath->to_is_async_p ();
-}
-
-static void
-thread_db_async (void (*callback) (enum inferior_event_type event_type,
- void *context), void *context)
-{
- return target_beneath->to_async (callback, context);
-}
-
-static int
-thread_db_async_mask (int mask)
-{
- return target_beneath->to_async_mask (mask);
-}
-
static int
find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
{
}
static char *
-thread_db_pid_to_str (ptid_t ptid)
+thread_db_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
struct thread_info *thread_info = find_thread_pid (ptid);
+ struct target_ops *beneath;
if (thread_info != NULL && thread_info->private != NULL)
{
return buf;
}
- if (target_beneath->to_pid_to_str (ptid))
- return target_beneath->to_pid_to_str (ptid);
+ beneath = find_target_beneath (ops);
+ if (beneath->to_pid_to_str (beneath, ptid))
+ return beneath->to_pid_to_str (beneath, ptid);
return normal_pid_to_str (ptid);
}
is stored at OFFSET within the thread local storage for thread PTID. */
static CORE_ADDR
-thread_db_get_thread_local_address (ptid_t ptid,
+thread_db_get_thread_local_address (struct target_ops *ops,
+ ptid_t ptid,
CORE_ADDR lm,
CORE_ADDR offset)
{
struct thread_info *thread_info;
+ struct target_ops *beneath;
/* If we have not discovered any threads yet, check now. */
if (!have_threads ())
: (CORE_ADDR) (uintptr_t) address);
}
- if (target_beneath->to_get_thread_local_address)
- return target_beneath->to_get_thread_local_address (ptid, lm, offset);
+ beneath = find_target_beneath (ops);
+ if (beneath->to_get_thread_local_address)
+ return beneath->to_get_thread_local_address (beneath, ptid, lm, offset);
else
throw_error (TLS_GENERIC_ERROR,
_("TLS not supported on this target"));
thread_db_ops.to_get_thread_local_address
= thread_db_get_thread_local_address;
thread_db_ops.to_extra_thread_info = thread_db_extra_thread_info;
- thread_db_ops.to_can_async_p = thread_db_can_async_p;
- thread_db_ops.to_is_async_p = thread_db_is_async_p;
- thread_db_ops.to_async = thread_db_async;
- thread_db_ops.to_async_mask = thread_db_async_mask;
thread_db_ops.to_get_ada_task_ptid = thread_db_get_ada_task_ptid;
thread_db_ops.to_magic = OPS_MAGIC;
}
status just as `wait' would. */
static ptid_t
-monitor_wait (ptid_t ptid, struct target_waitstatus *status)
+monitor_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
int old_timeout = timeout;
char buf[TARGET_BUF_SIZE];
buffer. */
static char *
-monitor_pid_to_str (ptid_t ptid)
+monitor_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
static int procfs_can_run (void);
-static ptid_t procfs_wait (ptid_t, struct target_waitstatus *);
-
static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
struct mem_attrib *attrib,
struct target_ops *);
}
static ptid_t
-procfs_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+procfs_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
sigset_t set;
siginfo_t info;
}
char *
-procfs_pid_to_str (ptid_t ptid)
+procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[1024];
int pid, tid, n;
static void procfs_mourn_inferior (struct target_ops *ops);
static void procfs_create_inferior (struct target_ops *, char *,
char *, char **, int);
-static ptid_t procfs_wait (ptid_t, struct target_waitstatus *);
+static ptid_t procfs_wait (struct target_ops *,
+ ptid_t, struct target_waitstatus *);
static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
struct mem_attrib *attrib,
struct target_ops *);
static int procfs_thread_alive (ptid_t);
void procfs_find_new_threads (void);
-char *procfs_pid_to_str (ptid_t);
+char *procfs_pid_to_str (struct target_ops *, ptid_t);
static int proc_find_memory_regions (int (*) (CORE_ADDR,
unsigned long,
*/
static ptid_t
-procfs_wait (ptid_t ptid, struct target_waitstatus *status)
+procfs_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
/* First cut: loosely based on original version 2.1 */
procinfo *pi;
/* Convert PTID to a string. Returns the string in a static buffer. */
char *
-procfs_pid_to_str (ptid_t ptid)
+procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[80];
}
static ptid_t
-m32r_wait (ptid_t ptid, struct target_waitstatus *status)
+m32r_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
static RETSIGTYPE (*prev_sigint) ();
unsigned long bp_addr, pc_addr;
buffer. */
static char *
-m32r_pid_to_str (ptid_t ptid)
+m32r_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
static void mips_resume (ptid_t ptid, int step,
enum target_signal siggnal);
-static ptid_t mips_wait (ptid_t ptid,
- struct target_waitstatus *status);
-
static int mips_map_regno (struct gdbarch *, int);
static void mips_fetch_registers (struct regcache *regcache, int regno);
/* Wait until the remote stops, and return a wait status. */
static ptid_t
-mips_wait (ptid_t ptid, struct target_waitstatus *status)
+mips_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
int rstatus;
int err;
static void gdbsim_resume (ptid_t ptid, int step, enum target_signal siggnal);
-static ptid_t gdbsim_wait (ptid_t ptid, struct target_waitstatus *status);
-
static void gdbsim_prepare_to_store (struct regcache *regcache);
static void gdbsim_files_info (struct target_ops *target);
}
static ptid_t
-gdbsim_wait (ptid_t ptid, struct target_waitstatus *status)
+gdbsim_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
static RETSIGTYPE (*prev_sigint) ();
int sigrc = 0;
buffer. */
static char *
-gdbsim_pid_to_str (ptid_t ptid)
+gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
static int readchar (int timeout);
-static ptid_t remote_wait (ptid_t ptid,
- struct target_waitstatus *status);
-
static void remote_kill (void);
static int tohex (int nib);
STATUS just as `wait' would. */
static ptid_t
-remote_wait (ptid_t ptid, struct target_waitstatus *status)
+remote_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *status)
{
ptid_t event_ptid;
buffer. */
static char *
-remote_pid_to_str (ptid_t ptid)
+remote_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
struct remote_state *rs = get_remote_state ();
stored at OFFSET within the thread local storage for thread PTID. */
static CORE_ADDR
-remote_get_thread_local_address (ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
+remote_get_thread_local_address (struct target_ops *ops,
+ ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
{
if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE)
{
the status in *OURSTATUS. */
static ptid_t
-rs6000_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+rs6000_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
pid_t pid;
int status, save_errno;
extern int procfs_suppress_run;
extern struct target_ops procfs_ops; /* target vector for procfs.c */
extern struct target_ops core_ops; /* target vector for corelow.c */
-extern char *procfs_pid_to_str (ptid_t ptid);
+extern char *procfs_pid_to_str (struct target_ops *ops, ptid_t ptid);
/* Prototypes for supply_gregset etc. */
#include "gregset.h"
thread ID to an LWP ID, and vice versa on the way out. */
static ptid_t
-sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+sol_thread_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
ptid_t rtnval;
ptid_t save_ptid;
GET_THREAD (save_ptid));
}
- rtnval = procfs_ops.to_wait (ptid, ourstatus);
+ rtnval = procfs_ops.to_wait (&procfs_ops, ptid, ourstatus);
if (ourstatus->kind != TARGET_WAITKIND_EXITED)
{
/* Convert PTID to printable form. */
char *
-solaris_pid_to_str (ptid_t ptid)
+solaris_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[100];
/* In case init failed to resolve the libthread_db library. */
if (!procfs_suppress_run)
- return procfs_pid_to_str (ptid);
+ return procfs_pid_to_str (&procfs_ops, ptid);
if (is_thread (ptid))
{
/* Wait for child PTID to do something. Return id of the child,
minus_one_ptid in case of error; store status into *OURSTATUS. */
static ptid_t
-spu_child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+spu_child_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
int save_errno;
int status;
static void debug_to_resume (ptid_t, int, enum target_signal);
-static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
-
static void debug_to_fetch_registers (struct regcache *, int);
static void debug_to_store_registers (struct regcache *, int);
/* Do not inherit to_detach. */
/* Do not inherit to_disconnect. */
INHERIT (to_resume, t);
- INHERIT (to_wait, t);
+ /* Do not inherit to_wait. */
INHERIT (to_fetch_registers, t);
INHERIT (to_store_registers, t);
INHERIT (to_prepare_to_store, t);
INHERIT (to_insert_exec_catchpoint, t);
INHERIT (to_remove_exec_catchpoint, t);
INHERIT (to_has_exited, t);
- /* Do no inherit to_mourn_inferiour. */
+ /* Do not inherit to_mourn_inferiour. */
INHERIT (to_can_run, t);
INHERIT (to_notice_signals, t);
INHERIT (to_thread_alive, t);
INHERIT (to_find_new_threads, t);
- INHERIT (to_pid_to_str, t);
+ /* Do not inherit to_pid_to_str. */
INHERIT (to_extra_thread_info, t);
INHERIT (to_stop, t);
/* Do not inherit to_xfer_partial. */
INHERIT (to_async_mask, t);
INHERIT (to_find_memory_regions, t);
INHERIT (to_make_corefile_notes, t);
- INHERIT (to_get_thread_local_address, t);
+ /* Do not inherit to_get_thread_local_address. */
INHERIT (to_can_execute_reverse, t);
/* Do not inherit to_read_description. */
INHERIT (to_get_ada_task_ptid, t);
de_fault (to_resume,
(void (*) (ptid_t, int, enum target_signal))
noprocess);
- de_fault (to_wait,
- (ptid_t (*) (ptid_t, struct target_waitstatus *))
- noprocess);
de_fault (to_fetch_registers,
(void (*) (struct regcache *, int))
target_ignore);
target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
{
volatile CORE_ADDR addr = 0;
+ struct target_ops *target;
+
+ for (target = current_target.beneath;
+ target != NULL;
+ target = target->beneath)
+ {
+ if (target->to_get_thread_local_address != NULL)
+ break;
+ }
- if (target_get_thread_local_address_p ()
+ if (target != NULL
&& gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
{
ptid_t ptid = inferior_ptid;
throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
_("TLS load module not found"));
- addr = target_get_thread_local_address (ptid, lm_addr, offset);
+ addr = target->to_get_thread_local_address (target, ptid, lm_addr, offset);
}
/* If an error occurred, print TLS related messages here. Otherwise,
throw the error to some higher catcher. */
tcomplain ();
}
+ptid_t
+target_wait (ptid_t ptid, struct target_waitstatus *status)
+{
+ struct target_ops *t;
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_wait != NULL)
+ {
+ ptid_t retval = (*t->to_wait) (t, ptid, status);
+
+ if (targetdebug)
+ {
+ char *status_string;
+
+ status_string = target_waitstatus_to_string (status);
+ fprintf_unfiltered (gdb_stdlog,
+ "target_wait (%d, status) = %d, %s\n",
+ PIDGET (ptid), PIDGET (retval),
+ status_string);
+ xfree (status_string);
+ }
+
+ return retval;
+ }
+ }
+
+ noprocess ();
+}
+
+char *
+target_pid_to_str (ptid_t ptid)
+{
+ struct target_ops *t;
+
+ for (t = current_target.beneath; t != NULL; t = t->beneath)
+ {
+ if (t->to_pid_to_str != NULL)
+ return (*t->to_pid_to_str) (t, ptid);
+ }
+
+ return normal_pid_to_str (ptid);
+}
+
void
target_resume (ptid_t ptid, int step, enum target_signal signal)
{
return buf;
}
+char *
+dummy_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+ return normal_pid_to_str (ptid);
+}
+
/* Error-catcher for target_find_memory_regions */
static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
{
dummy_target.to_can_async_p = find_default_can_async_p;
dummy_target.to_is_async_p = find_default_is_async_p;
dummy_target.to_supports_non_stop = find_default_supports_non_stop;
- dummy_target.to_pid_to_str = normal_pid_to_str;
+ dummy_target.to_pid_to_str = dummy_pid_to_str;
dummy_target.to_stratum = dummy_stratum;
dummy_target.to_find_memory_regions = dummy_find_memory_regions;
dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
}
}
-static ptid_t
-debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
-{
- ptid_t retval;
- char *status_string;
-
- retval = debug_target.to_wait (ptid, status);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_wait (%d, status) = %d, ", PIDGET (ptid),
- PIDGET (retval));
-
- status_string = target_waitstatus_to_string (status);
- fprintf_unfiltered (gdb_stdlog, "%s\n", status_string);
- xfree (status_string);
-
- return retval;
-}
-
static void
debug_print_register (const char * func,
struct regcache *regcache, int regno)
current_target.to_open = debug_to_open;
current_target.to_post_attach = debug_to_post_attach;
current_target.to_resume = debug_to_resume;
- current_target.to_wait = debug_to_wait;
current_target.to_fetch_registers = debug_to_fetch_registers;
current_target.to_store_registers = debug_to_store_registers;
current_target.to_prepare_to_store = debug_to_prepare_to_store;
void (*to_detach) (struct target_ops *ops, char *, int);
void (*to_disconnect) (struct target_ops *, char *, int);
void (*to_resume) (ptid_t, int, enum target_signal);
- ptid_t (*to_wait) (ptid_t, struct target_waitstatus *);
+ ptid_t (*to_wait) (struct target_ops *,
+ ptid_t, struct target_waitstatus *);
void (*to_fetch_registers) (struct regcache *, int);
void (*to_store_registers) (struct regcache *, int);
void (*to_prepare_to_store) (struct regcache *);
void (*to_notice_signals) (ptid_t ptid);
int (*to_thread_alive) (ptid_t ptid);
void (*to_find_new_threads) (void);
- char *(*to_pid_to_str) (ptid_t);
+ char *(*to_pid_to_str) (struct target_ops *, ptid_t);
char *(*to_extra_thread_info) (struct thread_info *);
void (*to_stop) (ptid_t);
void (*to_rcmd) (char *command, struct ui_file *output);
or executable file given by OBJFILE. If that block of
thread-local storage hasn't been allocated yet, this function
may return an error. */
- CORE_ADDR (*to_get_thread_local_address) (ptid_t ptid,
+ CORE_ADDR (*to_get_thread_local_address) (struct target_ops *ops,
+ ptid_t ptid,
CORE_ADDR load_module_addr,
CORE_ADDR offset);
to the prompt with a debugging target but without the frame cache,
stop_pc, etc., set up. */
-#define target_wait(ptid, status) \
- (*current_target.to_wait) (ptid, status)
+extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status);
/* Fetch at least register REGNO, or all regs if regno == -1. No result. */
`process xyz', but on some systems it may contain
`process xyz thread abc'. */
-#undef target_pid_to_str
-#define target_pid_to_str(PID) current_target.to_pid_to_str (PID)
+extern char *target_pid_to_str (ptid_t ptid);
extern char *normal_pid_to_str (ptid_t ptid);
#define target_make_corefile_notes(BFD, SIZE_P) \
(current_target.to_make_corefile_notes) (BFD, SIZE_P)
-/* Thread-local values. */
-#define target_get_thread_local_address \
- (current_target.to_get_thread_local_address)
-#define target_get_thread_local_address_p() \
- (target_get_thread_local_address != NULL)
-
-
/* Hardware watchpoint interfaces. */
/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
extern void initialize_targets (void);
-extern void noprocess (void);
+extern NORETURN void noprocess (void) ATTR_NORETURN;
extern void target_require_runnable (void);
/* Wait for interesting events to occur in the target process. */
static ptid_t
-windows_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+windows_wait (struct target_ops *ops,
+ ptid_t ptid, struct target_waitstatus *ourstatus)
{
int pid = -1;
/* Convert pid to printable format. */
static char *
-windows_pid_to_str (ptid_t ptid)
+windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[80];
projects / thirdparty / binutils-gdb.git / commitdiff
