/* Low level interface for debugging HPUX/DCE threads for GDB, the GNU
debugger.
- Copyright (C) 1996, 1998, 1999, 2000, 2001, 2004, 2007, 2008
+ Copyright (C) 1996, 1998, 1999, 2000, 2001, 2004, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GDB.
static CORE_ADDR P_cma__g_known_threads;
static CORE_ADDR P_cma__g_current_thread;
-static void hpux_thread_resume (ptid_t ptid, int step,
- enum target_signal signo);
-
static void init_hpux_thread_ops (void);
static struct target_ops hpux_thread_ops;
and wait for the trace-trap that results from attaching. */
static void
-hpux_thread_attach (char *args, int from_tty)
+hpux_thread_attach (struct target_ops *ops, char *args, int from_tty)
{
- deprecated_child_ops.to_attach (args, from_tty);
+ deprecated_child_ops.to_attach (&deprecated_child_ops, args, from_tty);
/* XXX - might want to iterate over all the threads and register them. */
}
started via the normal ptrace (PTRACE_TRACEME). */
static void
-hpux_thread_detach (char *args, int from_tty)
+hpux_thread_detach (struct target_ops *ops, char *args, int from_tty)
{
- deprecated_child_ops.to_detach (args, from_tty);
+ deprecated_child_ops.to_detach (&deprecated_child_ops, args, from_tty);
}
/* Resume execution of process PID. If STEP is nozero, then
for procfs. */
static void
-hpux_thread_resume (ptid_t ptid, int step, enum target_signal signo)
+hpux_thread_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal signo)
{
struct cleanup *old_chain;
ptid = main_ptid;
inferior_ptid = main_ptid;
- deprecated_child_ops.to_resume (ptid, step, signo);
+ deprecated_child_ops.to_resume (&deprecated_child_ops, ptid, step, signo);
cached_thread = 0;
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, int options)
{
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, options);
rtnval = find_active_thread ();
};
static void
-hpux_thread_fetch_registers (struct regcache *regcache, int regno)
+hpux_thread_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
cma__t_int_tcb tcb, *tcb_ptr;
struct cleanup *old_chain;
int i;
if (tcb_ptr->state == cma__c_state_running)
{
- deprecated_child_ops.to_fetch_registers (regcache, regno);
+ deprecated_child_ops.to_fetch_registers (&deprecated_child_ops,
+ regcache, regno);
do_cleanups (old_chain);
for (regno = first_regno; regno <= last_regno; regno++)
{
if (regmap[regno] == -1)
- deprecated_child_ops.to_fetch_registers (regcache, regno);
+ deprecated_child_ops.to_fetch_registers (&deprecated_child_ops,
+ regcache, regno);
else
{
unsigned char buf[MAX_REGISTER_SIZE];
/* Flags must be 0 to avoid bogus value for SS_INSYSCALL */
memset (buf, '\000', register_size (gdbarch, regno));
else if (regno == HPPA_SP_REGNUM)
- store_unsigned_integer (buf, sizeof sp, sp);
+ store_unsigned_integer (buf, sizeof sp, byte_order, sp);
else if (regno == HPPA_PCOQ_HEAD_REGNUM)
read_memory (sp - 20, buf, register_size (gdbarch, regno));
else
}
static void
-hpux_thread_store_registers (struct regcache *regcache, int regno)
+hpux_thread_store_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
cma__t_int_tcb tcb, *tcb_ptr;
if (tcb_ptr->state == cma__c_state_running)
{
- deprecated_child_ops.to_store_registers (regcache, regno);
+ deprecated_child_ops.to_store_registers (&deprecated_child_ops,
+ regcache, regno);
do_cleanups (old_chain);
sp = (CORE_ADDR) tcb_ptr->static_ctx.sp - 160;
if (regno == HPPA_FLAGS_REGNUM)
- deprecated_child_ops.to_store_registers (regcache, regno); /* Let lower layer handle this... */
+ {
+ /* Let lower layer handle this... */
+ deprecated_child_ops.to_store_registers
+ (&deprecated_child_ops, regcache, regno);
+ }
else if (regno == HPPA_SP_REGNUM)
{
regcache_raw_collect (regcache, regno, buf);
}
static void
-hpux_thread_kill_inferior (void)
+hpux_thread_kill_inferior (struct target_ops *ops)
{
- deprecated_child_ops.to_kill ();
+ deprecated_child_ops.to_kill (&deprecated_child_ops);
}
static void
/* Fork an inferior process, and start debugging it with /proc. */
static void
-hpux_thread_create_inferior (char *exec_file, char *allargs, char **env,
- int from_tty)
+hpux_thread_create_inferior (struct target_ops *ops, char *exec_file,
+ char *allargs, char **env, int from_tty)
{
- deprecated_child_ops.to_create_inferior (exec_file, allargs, env, from_tty);
+ deprecated_child_ops.to_create_inferior (&deprecated_child_ops,
+ exec_file, allargs, env, from_tty);
if (hpux_thread_active)
{
static void
hpux_thread_mourn_inferior (void)
{
- deprecated_child_ops.to_mourn_inferior ();
+ deprecated_child_ops.to_mourn_inferior (&deprecated_child_ops);
}
/* Mark our target-struct as eligible for stray "run" and "attach" commands. */
}
static int
-hpux_thread_alive (ptid_t ptid)
+hpux_thread_alive (struct target_ops *ops, ptid_t ptid)
{
return 1;
}
static void
-hpux_thread_stop (void)
+hpux_thread_stop (ptid_t ptid)
{
- deprecated_child_ops.to_stop ();
+ deprecated_child_ops.to_stop (ptid);
}
\f
/* Convert a pid to printable form. */
hpux_thread_ops.to_thread_alive = hpux_thread_alive;
hpux_thread_ops.to_stop = hpux_thread_stop;
hpux_thread_ops.to_stratum = process_stratum;
- hpux_thread_ops.to_has_all_memory = 1;
- hpux_thread_ops.to_has_memory = 1;
- hpux_thread_ops.to_has_stack = 1;
- hpux_thread_ops.to_has_registers = 1;
- hpux_thread_ops.to_has_execution = 1;
+ hpux_thread_ops.to_has_all_memory = default_child_has_all_memory;
+ hpux_thread_ops.to_has_memory = default_child_has_memory;
+ hpux_thread_ops.to_has_stack = default_child_has_stack;
+ hpux_thread_ops.to_has_registers = default_child_has_registers;
+ hpux_thread_ops.to_has_execution = default_child_has_execution;
hpux_thread_ops.to_magic = OPS_MAGIC;
}
projects / deliverable / binutils-gdb.git / blobdiff