/* BSD user-level threads support.
- Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2005-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbthread.h"
#include "inferior.h"
#include "objfiles.h"
-#include "observer.h"
+#include "observable.h"
#include "regcache.h"
#include "solib.h"
#include "solist.h"
#include "symfile.h"
#include "target.h"
-#include "gdb_assert.h"
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"
#include "bsd-uthread.h"
-/* HACK: Save the bsd_uthreads ops returned by bsd_uthread_target. */
-static struct target_ops *bsd_uthread_ops_hack;
+static const target_info bsd_uthread_target_info = {
+ "bsd-uthreads",
+ N_("BSD user-level threads"),
+ N_("BSD user-level threads")
+};
+
+struct bsd_uthread_target final : public target_ops
+{
+ const target_info &info () const override
+ { return bsd_uthread_target_info; }
+
+ strata stratum () const override { return thread_stratum; }
+
+ void close () override;
+
+ void mourn_inferior () override;
+
+ void fetch_registers (struct regcache *, int) override;
+ void store_registers (struct regcache *, int) override;
+
+ ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
+ void resume (ptid_t, int, enum gdb_signal) override;
+
+ bool thread_alive (ptid_t ptid) override;
+
+ void update_thread_list () override;
+
+ const char *extra_thread_info (struct thread_info *) override;
+
+ std::string pid_to_str (ptid_t) override;
+};
+
+static bsd_uthread_target bsd_uthread_ops;
\f
/* Architecture-specific operations. */
void (*supply_uthread) (struct regcache *,
int, CORE_ADDR))
{
- struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct bsd_uthread_ops *ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+
ops->supply_uthread = supply_uthread;
}
void (*collect_uthread) (const struct regcache *,
int, CORE_ADDR))
{
- struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct bsd_uthread_ops *ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+
ops->collect_uthread = collect_uthread;
}
static void
bsd_uthread_check_magic (CORE_ADDR addr)
{
- ULONGEST magic = read_memory_unsigned_integer (addr, 4);
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+ ULONGEST magic = read_memory_unsigned_integer (addr, 4, byte_order);
if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
error (_("Bad magic"));
#define BSD_UTHREAD_PS_RUNNING 0
#define BSD_UTHREAD_PS_DEAD 18
-/* Address of the pointer to the the thread structure for the running
+/* Address of the pointer to the thread structure for the running
thread. */
static CORE_ADDR bsd_uthread_thread_run_addr;
static CORE_ADDR
bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
{
- struct minimal_symbol *sym;
+ struct bound_minimal_symbol sym;
sym = lookup_minimal_symbol (name, NULL, objfile);
- if (sym)
- return SYMBOL_VALUE_ADDRESS (sym);
+ if (sym.minsym)
+ return BMSYMBOL_VALUE_ADDRESS (sym);
return 0;
}
static int
bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR addr;
addr = bsd_uthread_lookup_address (name, objfile);
if (addr == 0)
return 0;
- return read_memory_unsigned_integer (addr, 4);
+ return read_memory_unsigned_integer (addr, 4, byte_order);
}
static CORE_ADDR
bsd_uthread_read_memory_address (CORE_ADDR addr)
{
- struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
return read_memory_typed_address (addr, ptr_type);
}
static int
bsd_uthread_activate (struct objfile *objfile)
{
- struct gdbarch *gdbarch = current_gdbarch;
- struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct gdbarch *gdbarch = target_gdbarch ();
+ struct bsd_uthread_ops *ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
/* Skip if the thread stratum has already been activated. */
if (bsd_uthread_active)
bsd_uthread_thread_ctx_offset =
bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);
- push_target (bsd_uthread_ops_hack);
+ current_inferior ()->push_target (&bsd_uthread_ops);
bsd_uthread_active = 1;
return 1;
}
/* Cleanup due to deactivation. */
-static void
-bsd_uthread_close (int quitting)
+void
+bsd_uthread_target::close ()
{
bsd_uthread_active = 0;
bsd_uthread_thread_run_addr = 0;
if (!bsd_uthread_active)
return;
- unpush_target (bsd_uthread_ops_hack);
+ current_inferior ()->unpush_target (&bsd_uthread_ops);
}
-void
-bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
+static void
+bsd_uthread_inferior_created (inferior *inf)
{
bsd_uthread_activate (NULL);
}
/* Likely candidates for the threads library. */
-static const char *bsd_uthread_solib_names[] =
+static const char * const bsd_uthread_solib_names[] =
{
"/usr/lib/libc_r.so", /* FreeBSD */
"/usr/lib/libpthread.so", /* OpenBSD */
NULL
};
-void
+static void
bsd_uthread_solib_loaded (struct so_list *so)
{
- const char **names = bsd_uthread_solib_names;
+ const char * const *names = bsd_uthread_solib_names;
for (names = bsd_uthread_solib_names; *names; names++)
{
- if (strncmp (so->so_original_name, *names, strlen (*names)) == 0)
+ if (startswith (so->so_original_name, *names))
{
- solib_read_symbols (so, so->from_tty);
+ solib_read_symbols (so, 0);
if (bsd_uthread_activate (so->objfile))
{
}
}
-void
+static void
bsd_uthread_solib_unloaded (struct so_list *so)
{
if (!bsd_uthread_solib_name)
bsd_uthread_deactivate ();
}
-static void
-bsd_uthread_mourn_inferior (void)
+void
+bsd_uthread_target::mourn_inferior ()
{
- find_target_beneath (bsd_uthread_ops_hack)->to_mourn_inferior ();
+ beneath ()->mourn_inferior ();
bsd_uthread_deactivate ();
}
-static void
-bsd_uthread_fetch_registers (struct regcache *regcache, int regnum)
+void
+bsd_uthread_target::fetch_registers (struct regcache *regcache, int regnum)
{
- 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);
+ struct gdbarch *gdbarch = regcache->arch ();
+ struct bsd_uthread_ops *uthread_ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+ ptid_t ptid = regcache->ptid ();
+ CORE_ADDR addr = ptid.tid ();
CORE_ADDR active_addr;
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
+
+ /* We are doing operations (e.g. reading memory) that rely on
+ inferior_ptid. */
+ inferior_ptid = ptid;
/* Always fetch the appropriate registers from the layer beneath. */
- find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (regcache, regnum);
+ beneath ()->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
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)
+void
+bsd_uthread_target::store_registers (struct regcache *regcache, int regnum)
{
- 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);
+ struct gdbarch *gdbarch = regcache->arch ();
+ struct bsd_uthread_ops *uthread_ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+ ptid_t ptid = regcache->ptid ();
+ CORE_ADDR addr = ptid.tid ();
CORE_ADDR active_addr;
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
+
+ /* We are doing operations (e.g. reading memory) that rely on
+ inferior_ptid. */
+ inferior_ptid = ptid;
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);
+ request to the layer beneath. */
+ beneath ()->store_registers (regcache, regnum);
}
}
-/* FIXME: This function is only there because otherwise GDB tries to
- invoke deprecate_xfer_memory. */
-
-static LONGEST
-bsd_uthread_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf,
- ULONGEST offset, LONGEST len)
-{
- gdb_assert (ops->beneath->to_xfer_partial);
- return ops->beneath->to_xfer_partial (ops->beneath, object, annex, readbuf,
- writebuf, offset, len);
-}
-
-static ptid_t
-bsd_uthread_wait (ptid_t ptid, struct target_waitstatus *status)
+ptid_t
+bsd_uthread_target::wait (ptid_t ptid, struct target_waitstatus *status,
+ target_wait_flags options)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
CORE_ADDR addr;
+ process_stratum_target *beneath
+ = as_process_stratum_target (this->beneath ());
/* Pass the request to the layer beneath. */
- ptid = find_target_beneath (bsd_uthread_ops_hack)->to_wait (ptid, status);
+ ptid = beneath->wait (ptid, status, options);
/* 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)
+ if (status->kind () == TARGET_WAITKIND_SIGNALLED
+ || status->kind () == TARGET_WAITKIND_EXITED)
return ptid;
/* Fetch the corresponding thread ID, and augment the returned
gdb_byte buf[4];
/* FIXME: For executables linked statically with the threads
- library, we end up here before the program has actually been
- executed. In that case ADDR will be garbage since it has
- been read from the wrong virtual memory image. */
+ library, we end up here before the program has actually been
+ executed. In that case ADDR will be garbage since it has
+ been read from the wrong virtual memory image. */
if (target_read_memory (addr, buf, 4) == 0)
{
- ULONGEST magic = extract_unsigned_integer (buf, 4);
+ ULONGEST magic = extract_unsigned_integer (buf, 4, byte_order);
if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
- ptid = ptid_build (ptid_get_pid (ptid), 0, addr);
+ ptid = ptid_t (ptid.pid (), 0, addr);
}
}
/* 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);
+ if (inferior_ptid.tid () == 0
+ && ptid.tid () != 0 && !in_thread_list (beneath, ptid))
+ thread_change_ptid (beneath, 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);
+ thread_info *thread = find_thread_ptid (beneath, ptid);
+ if (thread == NULL || thread->state == THREAD_EXITED)
+ add_thread (beneath, ptid);
return ptid;
}
-static void
-bsd_uthread_resume (ptid_t ptid, int step, enum target_signal sig)
+void
+bsd_uthread_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
{
/* Pass the request to the layer beneath. */
- find_target_beneath (bsd_uthread_ops_hack)->to_resume (ptid, step, sig);
+ beneath ()->resume (ptid, step, sig);
}
-static int
-bsd_uthread_thread_alive (ptid_t ptid)
+bool
+bsd_uthread_target::thread_alive (ptid_t ptid)
{
- CORE_ADDR addr = ptid_get_tid (inferior_ptid);
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+ CORE_ADDR addr = ptid.tid ();
if (addr != 0)
{
bsd_uthread_check_magic (addr);
- state = read_memory_unsigned_integer (addr + offset, 4);
+ state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
if (state == BSD_UTHREAD_PS_DEAD)
- return 0;
+ return false;
}
- return find_target_beneath (bsd_uthread_ops_hack)->to_thread_alive (ptid);
+ return beneath ()->thread_alive (ptid);
}
-static void
-bsd_uthread_find_new_threads (void)
+void
+bsd_uthread_target::update_thread_list ()
{
- pid_t pid = ptid_get_pid (inferior_ptid);
+ pid_t pid = inferior_ptid.pid ();
int offset = bsd_uthread_thread_next_offset;
CORE_ADDR addr;
+ prune_threads ();
+
addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
while (addr != 0)
{
- ptid_t ptid = ptid_build (pid, 0, addr);
+ ptid_t ptid = ptid_t (pid, 0, addr);
- if (!in_thread_list (ptid) || is_exited (ptid))
+ process_stratum_target *proc_target
+ = as_process_stratum_target (this->beneath ());
+ thread_info *thread = find_thread_ptid (proc_target, ptid);
+ if (thread == nullptr || thread->state == THREAD_EXITED)
{
/* 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);
+ if (inferior_ptid.tid () == 0)
+ thread_change_ptid (proc_target, inferior_ptid, ptid);
else
- add_thread (ptid);
+ add_thread (proc_target, ptid);
}
addr = bsd_uthread_read_memory_address (addr + offset);
}
/* Possible states a thread can be in. */
-static char *bsd_uthread_state[] =
+static const char * const bsd_uthread_state[] =
{
"RUNNING",
"SIGTHREAD",
/* Return a string describing th state of the thread specified by
INFO. */
-static char *
-bsd_uthread_extra_thread_info (struct thread_info *info)
+const char *
+bsd_uthread_target::extra_thread_info (thread_info *info)
{
- CORE_ADDR addr = ptid_get_tid (info->ptid);
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+ CORE_ADDR addr = info->ptid.tid ();
if (addr != 0)
{
int offset = bsd_uthread_thread_state_offset;
ULONGEST state;
- state = read_memory_unsigned_integer (addr + offset, 4);
+ state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
if (state < ARRAY_SIZE (bsd_uthread_state))
return bsd_uthread_state[state];
}
return NULL;
}
-static char *
-bsd_uthread_pid_to_str (ptid_t ptid)
+std::string
+bsd_uthread_target::pid_to_str (ptid_t ptid)
{
- if (ptid_get_tid (ptid) != 0)
- {
- static char buf[64];
-
- xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
- ptid_get_pid (ptid), ptid_get_tid (ptid));
- return buf;
- }
+ if (ptid.tid () != 0)
+ return string_printf ("process %d, thread 0x%s",
+ ptid.pid (),
+ phex_nz (ptid.tid (), sizeof (ULONGEST)));
return normal_pid_to_str (ptid);
}
-struct target_ops *
-bsd_uthread_target (void)
-{
- struct target_ops *t = XZALLOC (struct target_ops);
-
- 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;
- t->to_xfer_partial = bsd_uthread_xfer_partial;
- t->to_wait = bsd_uthread_wait;
- t->to_resume = bsd_uthread_resume;
- t->to_thread_alive = bsd_uthread_thread_alive;
- t->to_find_new_threads = bsd_uthread_find_new_threads;
- t->to_extra_thread_info = bsd_uthread_extra_thread_info;
- t->to_pid_to_str = bsd_uthread_pid_to_str;
- t->to_stratum = thread_stratum;
- t->to_magic = OPS_MAGIC;
- bsd_uthread_ops_hack = t;
-
- return t;
-}
-
+void _initialize_bsd_uthread ();
void
-_initialize_bsd_uthread (void)
+_initialize_bsd_uthread ()
{
- add_target (bsd_uthread_target ());
-
bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);
- observer_attach_inferior_created (bsd_uthread_inferior_created);
- observer_attach_solib_loaded (bsd_uthread_solib_loaded);
- observer_attach_solib_unloaded (bsd_uthread_solib_unloaded);
+ gdb::observers::inferior_created.attach (bsd_uthread_inferior_created,
+ "bsd-uthread");
+ gdb::observers::solib_loaded.attach (bsd_uthread_solib_loaded,
+ "bsd-uthread");
+ gdb::observers::solib_unloaded.attach (bsd_uthread_solib_unloaded,
+ "bsd-uthread");
}