/* BSD user-level threads support.
- Copyright 2005 Free Software Foundation, Inc.
+ Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "gdbcore.h"
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. */
return 1;
}
-/* Deactivate the thread stratum implemented by this module. */
+/* Cleanup due to deactivation. */
static void
-bsd_uthread_deactivate (void)
+bsd_uthread_close (int quitting)
{
- /* Skip if the thread stratum has already been deactivated. */
- if (!bsd_uthread_active)
- return;
-
bsd_uthread_active = 0;
- unpush_target (bsd_uthread_ops_hack);
-
bsd_uthread_thread_run_addr = 0;
bsd_uthread_thread_list_addr = 0;
bsd_uthread_thread_state_offset = 0;
bsd_uthread_solib_name = NULL;
}
+/* Deactivate the thread stratum implemented by this module. */
+
+static void
+bsd_uthread_deactivate (void)
+{
+ /* Skip if the thread stratum has already been deactivated. */
+ if (!bsd_uthread_active)
+ return;
+
+ unpush_target (bsd_uthread_ops_hack);
+}
+
void
bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
{
if (bsd_uthread_activate (so->objfile))
{
- bsd_uthread_solib_name == so->so_original_name;
+ bsd_uthread_solib_name = so->so_original_name;
return;
}
}
}
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 (bsd_uthread_ops_hack);
+ beneath->to_mourn_inferior (beneath);
bsd_uthread_deactivate ();
}
static void
-bsd_uthread_fetch_registers (int regnum)
+bsd_uthread_fetch_registers (struct regcache *regcache, int regnum)
{
- struct gdbarch *gdbarch = current_gdbarch;
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
CORE_ADDR addr = ptid_get_tid (inferior_ptid);
CORE_ADDR active_addr;
/* Always fetch the appropriate registers from the layer beneath. */
- find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (regnum);
+ find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (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 (current_regcache, regnum,
+ ops->supply_uthread (regcache, regnum,
addr + bsd_uthread_thread_ctx_offset);
}
}
static void
-bsd_uthread_store_registers (int regnum)
+bsd_uthread_store_registers (struct regcache *regcache, int regnum)
{
- struct gdbarch *gdbarch = current_gdbarch;
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
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 (current_regcache, regnum,
+ 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 (regnum);
+ find_target_beneath (bsd_uthread_ops_hack)->to_store_registers (regcache, regnum);
}
}
/* Pass the request to the layer beneath. */
ptid = find_target_beneath (bsd_uthread_ops_hack)->to_wait (ptid, status);
+ /* If the process is no longer alive, there's no point in figuring
+ out the thread ID. It will fail anyway. */
+ if (status->kind == TARGET_WAITKIND_SIGNALLED
+ || status->kind == TARGET_WAITKIND_EXITED)
+ return ptid;
+
/* 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)
{
- char buf[4];
+ gdb_byte buf[4];
/* FIXME: For executables linked statically with the threads
library, we end up here before the program has actually been
}
}
- /* HACK: Twiddle INFERIOR_PTID such that the initial thread of a
- process isn't recognized as a new thread. */
- if (ptid_get_tid (ptid) != 0 && !in_thread_list (ptid)
- && ptid_get_tid (inferior_ptid) == 0)
- {
- add_thread (ptid);
- inferior_ptid = ptid;
- }
+ /* If INFERIOR_PTID doesn't have a tid member yet, and we now have a
+ ptid with tid set, then ptid is still the initial thread of
+ the process. Notify GDB core about it. */
+ if (ptid_get_tid (inferior_ptid) == 0
+ && ptid_get_tid (ptid) != 0 && !in_thread_list (ptid))
+ thread_change_ptid (inferior_ptid, ptid);
+
+ /* Don't let the core see a ptid without a corresponding thread. */
+ if (!in_thread_list (ptid) || is_exited (ptid))
+ add_thread (ptid);
return 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);
- if (!in_thread_list (ptid))
- add_thread (ptid);
+ if (!in_thread_list (ptid) || is_exited (ptid))
+ {
+ /* If INFERIOR_PTID doesn't have a tid member yet, then ptid
+ is still the initial thread of the process. Notify GDB
+ core about it. */
+ if (ptid_get_tid (inferior_ptid) == 0)
+ thread_change_ptid (inferior_ptid, ptid);
+ else
+ add_thread (ptid);
+ }
- addr = read_memory_typed_address (addr + offset,
- builtin_type_void_data_ptr);
+ addr = bsd_uthread_read_memory_address (addr + offset);
}
}
if (ptid_get_tid (ptid) != 0)
{
static char buf[64];
- int size;
- size = snprintf (buf, sizeof buf, "process %d, thread 0x%lx",
- ptid_get_pid (ptid), ptid_get_tid (ptid));
- gdb_assert (size < sizeof buf);
+ xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
+ ptid_get_pid (ptid), ptid_get_tid (ptid));
return buf;
}
t->to_shortname = "bsd-uthreads";
t->to_longname = "BSD user-level threads";
t->to_doc = "BSD user-level threads";
+ t->to_close = bsd_uthread_close;
t->to_mourn_inferior = bsd_uthread_mourn_inferior;
t->to_fetch_registers = bsd_uthread_fetch_registers;
t->to_store_registers = bsd_uthread_store_registers;