/* BSD user-level threads support.
- Copyright (C) 2005-2020 Free Software Foundation, Inc.
+ Copyright (C) 2005-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "symfile.h"
#include "target.h"
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"
#include "bsd-uthread.h"
void fetch_registers (struct regcache *, int) override;
void store_registers (struct regcache *, int) override;
- ptid_t wait (ptid_t, struct target_waitstatus *, 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;
sym = lookup_minimal_symbol (name, NULL, objfile);
if (sym.minsym)
- return BMSYMBOL_VALUE_ADDRESS (sym);
+ return sym.value_address ();
return 0;
}
bsd_uthread_thread_ctx_offset =
bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);
- push_target (&bsd_uthread_ops);
+ current_inferior ()->push_target (&bsd_uthread_ops);
bsd_uthread_active = 1;
return 1;
}
if (!bsd_uthread_active)
return;
- unpush_target (&bsd_uthread_ops);
+ current_inferior ()->unpush_target (&bsd_uthread_ops);
}
static void
-bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
+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 */
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++)
{
else
{
/* Updating the thread that is currently running; pass the
- request to the layer beneath. */
+ request to the layer beneath. */
beneath ()->store_registers (regcache, regnum);
}
}
ptid_t
bsd_uthread_target::wait (ptid_t ptid, struct target_waitstatus *status,
- int options)
+ 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 = beneath ()->wait (ptid, status, options);
+ 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, byte_order);
ptid with tid set, then ptid is still the initial thread of
the process. Notify GDB core about it. */
if (inferior_ptid.tid () == 0
- && ptid.tid () != 0 && !in_thread_list (ptid))
- thread_change_ptid (inferior_ptid, ptid);
+ && 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. */
- thread_info *thread = find_thread_ptid (ptid);
+ thread_info *thread = find_thread_ptid (beneath, ptid);
if (thread == NULL || thread->state == THREAD_EXITED)
- add_thread (ptid);
+ add_thread (beneath, ptid);
return ptid;
}
{
ptid_t ptid = ptid_t (pid, 0, addr);
- thread_info *thread = find_thread_ptid (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 (inferior_ptid.tid () == 0)
- thread_change_ptid (inferior_ptid, ptid);
+ 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 const char *bsd_uthread_state[] =
+static const char * const bsd_uthread_state[] =
{
"RUNNING",
"SIGTHREAD",
bsd_uthread_target::pid_to_str (ptid_t ptid)
{
if (ptid.tid () != 0)
- return string_printf ("process %d, thread 0x%lx",
- ptid.pid (), ptid.tid ());
+ return string_printf ("process %d, thread 0x%s",
+ ptid.pid (),
+ phex_nz (ptid.tid (), sizeof (ULONGEST)));
return normal_pid_to_str (ptid);
}
+void _initialize_bsd_uthread ();
void
-_initialize_bsd_uthread (void)
+_initialize_bsd_uthread ()
{
bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);
- gdb::observers::inferior_created.attach (bsd_uthread_inferior_created);
- gdb::observers::solib_loaded.attach (bsd_uthread_solib_loaded);
- gdb::observers::solib_unloaded.attach (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");
}
projects / binutils-gdb.git / blobdiff