/* BSD user-level threads support.
- Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GDB.
return read_memory_unsigned_integer (addr, 4);
}
+static CORE_ADDR
+bsd_uthread_read_memory_address (CORE_ADDR addr)
+{
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ return read_memory_typed_address (addr, ptr_type);
+}
+
/* If OBJFILE contains the symbols corresponding to one of the
supported user-level threads libraries, activate the thread stratum
implemented by this module. */
unpush_target (bsd_uthread_ops_hack);
}
-void
+static void
bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
{
bsd_uthread_activate (NULL);
NULL
};
-void
+static void
bsd_uthread_solib_loaded (struct so_list *so)
{
const char **names = bsd_uthread_solib_names;
}
}
-void
+static void
bsd_uthread_solib_unloaded (struct so_list *so)
{
if (!bsd_uthread_solib_name)
}
static void
-bsd_uthread_mourn_inferior (void)
+bsd_uthread_mourn_inferior (struct target_ops *ops)
{
- find_target_beneath (bsd_uthread_ops_hack)->to_mourn_inferior ();
+ struct target_ops *beneath = find_target_beneath (ops);
+ beneath->to_mourn_inferior (beneath);
bsd_uthread_deactivate ();
}
static void
-bsd_uthread_fetch_registers (struct regcache *regcache, int regnum)
+bsd_uthread_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
CORE_ADDR addr = ptid_get_tid (inferior_ptid);
+ struct target_ops *beneath = find_target_beneath (ops);
CORE_ADDR active_addr;
/* Always fetch the appropriate registers from the layer beneath. */
- find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (regcache, regnum);
+ beneath->to_fetch_registers (beneath, regcache, regnum);
/* FIXME: That might have gotten us more than we asked for. Make
sure we overwrite all relevant registers with values from the
thread structure. This can go once we fix the underlying target. */
regnum = -1;
- active_addr = read_memory_typed_address (bsd_uthread_thread_run_addr,
- builtin_type_void_data_ptr);
+ active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
if (addr != 0 && addr != active_addr)
{
bsd_uthread_check_magic (addr);
- ops->supply_uthread (regcache, regnum,
- addr + bsd_uthread_thread_ctx_offset);
+ uthread_ops->supply_uthread (regcache, regnum,
+ addr + bsd_uthread_thread_ctx_offset);
}
}
static void
-bsd_uthread_store_registers (struct regcache *regcache, int regnum)
+bsd_uthread_store_registers (struct target_ops *ops,
+ struct regcache *regcache, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct target_ops *beneath = find_target_beneath (ops);
CORE_ADDR addr = ptid_get_tid (inferior_ptid);
CORE_ADDR active_addr;
- active_addr = read_memory_typed_address (bsd_uthread_thread_run_addr,
- builtin_type_void_data_ptr);
+ active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
if (addr != 0 && addr != active_addr)
{
bsd_uthread_check_magic (addr);
- ops->collect_uthread (regcache, regnum,
- addr + bsd_uthread_thread_ctx_offset);
+ uthread_ops->collect_uthread (regcache, regnum,
+ addr + bsd_uthread_thread_ctx_offset);
}
else
{
/* Updating the thread that is currently running; pass the
request to the layer beneath. */
- find_target_beneath (bsd_uthread_ops_hack)->to_store_registers (regcache, regnum);
+ beneath->to_store_registers (beneath, regcache, regnum);
}
}
}
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 (ops);
/* 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. */
/* Fetch the corresponding thread ID, and augment the returned
process ID with it. */
- addr = read_memory_typed_address (bsd_uthread_thread_run_addr,
- builtin_type_void_data_ptr);
+ addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
if (addr != 0)
{
gdb_byte buf[4];
}
static void
-bsd_uthread_resume (ptid_t ptid, int step, enum target_signal sig)
+bsd_uthread_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal sig)
{
/* Pass the request to the layer beneath. */
- find_target_beneath (bsd_uthread_ops_hack)->to_resume (ptid, step, sig);
+ struct target_ops *beneath = find_target_beneath (ops);
+ beneath->to_resume (beneath, ptid, step, sig);
}
static int
-bsd_uthread_thread_alive (ptid_t ptid)
+bsd_uthread_thread_alive (struct target_ops *ops, ptid_t ptid)
{
+ struct target_ops *beneath = find_target_beneath (ops);
CORE_ADDR addr = ptid_get_tid (inferior_ptid);
if (addr != 0)
return 0;
}
- return find_target_beneath (bsd_uthread_ops_hack)->to_thread_alive (ptid);
+ return beneath->to_thread_alive (beneath, ptid);
}
static void
-bsd_uthread_find_new_threads (void)
+bsd_uthread_find_new_threads (struct target_ops *ops)
{
pid_t pid = ptid_get_pid (inferior_ptid);
int offset = bsd_uthread_thread_next_offset;
CORE_ADDR addr;
- addr = read_memory_typed_address (bsd_uthread_thread_list_addr,
- builtin_type_void_data_ptr);
+ addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
while (addr != 0)
{
ptid_t ptid = ptid_build (pid, 0, addr);
add_thread (ptid);
}
- addr = read_memory_typed_address (addr + offset,
- builtin_type_void_data_ptr);
+ addr = bsd_uthread_read_memory_address (addr + offset);
}
}
}
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)
{
return normal_pid_to_str (ptid);
}
-struct target_ops *
+static struct target_ops *
bsd_uthread_target (void)
{
struct target_ops *t = XZALLOC (struct target_ops);
return t;
}
+/* Provide a prototype to silence -Wmissing-prototypes. */
+extern initialize_file_ftype _initialize_bsd_uthread;
+
void
_initialize_bsd_uthread (void)
{
projects / deliverable / binutils-gdb.git / blobdiff