-/* Copyright (C) 2008 Free Software Foundation, Inc.
+/* Copyright (C) 2008, 2009 Free Software Foundation, Inc.
This file is part of GDB.
/* The dec-thread target_ops structure. */
static struct target_ops dec_thread_ops;
-/* A copy of the target_ops over which our dec_thread_ops is pushed. */
-static struct target_ops base_target;
-
/* Print a debug trace if DEBUG_DEC_THREAD is set (its value is adjusted
by the user using "set debug dec-thread ..."). */
return;
}
- base_target = current_target;
push_target (&dec_thread_ops);
dec_thread_active = 1;
/* The "to_detach" method of the dec_thread_ops. */
static void
-dec_thread_detach (char *args, int from_tty)
+dec_thread_detach (struct target_ops *ops, char *args, int from_tty)
{
+ struct target_ops *beneath = find_target_beneath (ops);
+
debug ("dec_thread_detach");
disable_dec_thread ();
- base_target.to_detach (args, from_tty);
+ beneath->to_detach (beneath, args, from_tty);
}
/* Return the ptid of the thread that is currently active. */
/* 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;
+ struct target_ops *beneath = find_target_beneath (ops);
debug ("dec_thread_wait");
- ptid = base_target.to_wait (ptid, status);
+ ptid = beneath->to_wait (beneath, 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
- ptid. */
+ /* The ptid returned by the target beneath us is the ptid of the process.
+ We need to find which thread is currently active and return its ptid. */
resync_thread_list ();
active_ptid = get_active_ptid ();
if (ptid_equal (active_ptid, null_ptid))
res = pthreadDebugThdGetReg (debug_context, tid, ®s);
if (res != ESUCCESS)
{
- debug ("dec_thread_fetch_registers: pthreadDebugThdGetReg -> %d", res);
+ debug ("dec_thread_get_regsets: pthreadDebugThdGetReg -> %d", res);
return -1;
}
memcpy (gregset->regs, ®s, sizeof (regs));
res = pthreadDebugThdGetFreg (debug_context, tid, &fregs);
if (res != ESUCCESS)
{
- debug ("dec_thread_fetch_registers: pthreadDebugThdGetFreg -> %d", res);
+ debug ("dec_thread_get_regsets: pthreadDebugThdGetFreg -> %d", res);
return -1;
}
memcpy (fpregset->regs, &fregs, sizeof (fregs));
registers. */
static void
-dec_thread_fetch_registers (struct regcache *regcache, int regno)
+dec_thread_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
pthreadDebugId_t tid = ptid_get_tid (inferior_ptid);
gregset_t gregset;
if (tid == 0 || ptid_equal (inferior_ptid, get_active_ptid ()))
{
- base_target.to_fetch_registers (regcache, regno);
+ struct target_ops *beneath = find_target_beneath (ops);
+
+ beneath->to_fetch_registers (beneath, regcache, regno);
return;
}
res = pthreadDebugThdSetReg (debug_context, tid, ®s);
if (res != ESUCCESS)
{
- debug ("dec_thread_fetch_registers: pthreadDebugThdSetReg -> %d", res);
+ debug ("dec_thread_set_regsets: pthreadDebugThdSetReg -> %d", res);
return -1;
}
res = pthreadDebugThdSetFreg (debug_context, tid, &fregs);
if (res != ESUCCESS)
{
- debug ("dec_thread_fetch_registers: pthreadDebugThdSetFreg -> %d", res);
+ debug ("dec_thread_set_regsets: pthreadDebugThdSetFreg -> %d", res);
return -1;
}
just one register, we store all the registers. */
static void
-dec_thread_store_registers (struct regcache *regcache, int regno)
+dec_thread_store_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
pthreadDebugId_t tid = ptid_get_tid (inferior_ptid);
gregset_t gregset;
if (tid == 0 || ptid_equal (inferior_ptid, get_active_ptid ()))
{
- base_target.to_store_registers (regcache, regno);
+ struct target_ops *beneath = find_target_beneath (ops);
+
+ beneath->to_store_registers (beneath, regcache, regno);
return;
}
/* The "to_mourn_inferior" method of the dec_thread_ops. */
static void
-dec_thread_mourn_inferior (void)
+dec_thread_mourn_inferior (struct target_ops *ops)
{
+ struct target_ops *beneath = find_target_beneath (ops);
+
debug ("dec_thread_mourn_inferior");
disable_dec_thread ();
- base_target.to_mourn_inferior ();
+ beneath->to_mourn_inferior (beneath);
}
/* The "to_thread_alive" method of the dec_thread_ops. */
static int
-dec_thread_thread_alive (ptid_t ptid)
+dec_thread_thread_alive (struct target_ops *ops, ptid_t ptid)
{
debug ("dec_thread_thread_alive (tid=%ld)", ptid_get_tid (ptid));
/* 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);
+ {
+ struct target_ops *beneath = find_target_beneath (ops);
+
+ return beneath->to_pid_to_str (beneath, ptid);
+ }
/* Free previous return value; a new one will be allocated by
xstrprintf(). */
disable_dec_thread ();
}
+/* The "to_get_ada_task_ptid" method of the dec_thread_ops. */
+
+static ptid_t
+dec_thread_get_ada_task_ptid (long lwp, long thread)
+{
+ int i;
+ struct dec_thread_info *info;
+
+ debug ("dec_thread_get_ada_task_ptid (lwp=0x%lx, thread=0x%lx)",
+ lwp, thread);
+
+ for (i = 0; VEC_iterate (dec_thread_info_s, dec_thread_list, i, info);
+ i++)
+ if (info->info.teb == (pthread_t) thread)
+ return ptid_build_from_info (*info);
+
+ warning (_("Could not find thread id from THREAD = 0x%lx\n"), thread);
+ return inferior_ptid;
+}
+
static void
init_dec_thread_ops (void)
{
dec_thread_ops.to_thread_alive = dec_thread_thread_alive;
dec_thread_ops.to_pid_to_str = dec_thread_pid_to_str;
dec_thread_ops.to_stratum = thread_stratum;
+ dec_thread_ops.to_get_ada_task_ptid = dec_thread_get_ada_task_ptid;
dec_thread_ops.to_magic = OPS_MAGIC;
}
projects / deliverable / binutils-gdb.git / blobdiff