/* Solaris threads debugging interface.
- Copyright (C) 1996-2017 Free Software Foundation, Inc.
+ Copyright (C) 1996-2018 Free Software Foundation, Inc.
This file is part of GDB.
#include "regcache.h"
#include "solib.h"
#include "symfile.h"
-#include "observer.h"
+#include "observable.h"
#include "procfs.h"
#include "symtab.h"
#include "minsyms.h"
#include "objfiles.h"
-struct target_ops sol_thread_ops;
+static const target_info thread_db_target_info = {
+ "solaris-threads",
+ N_("Solaris threads and pthread."),
+ N_("Solaris threads and pthread support.")
+};
+
+class sol_thread_target final : public target_ops
+{
+public:
+ sol_thread_target ()
+ { this->to_stratum = thread_stratum; }
+
+ const target_info &info () const override
+ { return thread_db_target_info; }
+
+ void detach (inferior *, int) override;
+ ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+ void resume (ptid_t, int, enum gdb_signal) override;
+ void mourn_inferior () override;
+ const char *pid_to_str (ptid_t) override;
+ ptid_t get_ada_task_ptid (long lwp, long thread) override;
+
+ void fetch_registers (struct regcache *, int) override;
+ void store_registers (struct regcache *, int) override;
+
+ enum target_xfer_status xfer_partial (enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len) override;
+
+ bool thread_alive (ptid_t ptid) override;
+ void update_thread_list () override;
+};
+
+static sol_thread_target sol_thread_ops;
/* Prototypes for supply_gregset etc. */
#include "gregset.h"
struct string_map
{
int num;
- char *str;
+ const char *str;
};
static struct ps_prochandle main_ph;
static td_thragent_t *main_ta;
static int sol_thread_active = 0;
-static void init_sol_thread_ops (void);
-
/* Default definitions: These must be defined in tm.h if they are to
be shared with a process module such as procfs. */
/* Return the libthread_db error string associated with ERRCODE. If
ERRCODE is unknown, return an appropriate message. */
-static char *
+static const char *
td_err_string (td_err_e errcode)
{
static struct string_map td_err_table[] =
/* Return the libthread_db state string assicoated with STATECODE.
If STATECODE is unknown, return an appropriate message. */
-static char *
+static const char *
td_state_string (td_thr_state_e statecode)
{
static struct string_map td_thr_state_table[] =
process to have been previously attached. It *might* work if the
program was started via the normal ptrace (PTRACE_TRACEME). */
-static void
-sol_thread_detach (struct target_ops *ops, const char *args, int from_tty)
+void
+sol_thread_target::detach (inferior *inf, int from_tty)
{
- struct target_ops *beneath = find_target_beneath (ops);
+ struct target_ops *beneath = find_target_beneath (this);
sol_thread_active = 0;
inferior_ptid = pid_to_ptid (ptid_get_pid (main_ph.ptid));
- unpush_target (ops);
- beneath->to_detach (beneath, args, from_tty);
+ unpush_target (this);
+ beneath->detach (inf, from_tty);
}
/* Resume execution of process PTID. If STEP is nozero, then just
activated. We may have to convert PTID from a thread ID to an LWP
ID for procfs. */
-static void
-sol_thread_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum gdb_signal signo)
+void
+sol_thread_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
{
- struct cleanup *old_chain;
- struct target_ops *beneath = find_target_beneath (ops);
+ struct target_ops *beneath = find_target_beneath (this);
- old_chain = save_inferior_ptid ();
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
if (ptid_get_pid (inferior_ptid) == -1)
ptid_get_tid (save_ptid));
}
- beneath->to_resume (beneath, ptid, step, signo);
-
- do_cleanups (old_chain);
+ beneath->resume (ptid, step, signo);
}
/* Wait for any threads to stop. We may have to convert PTID from a
thread ID to an LWP ID, and vice versa on the way out. */
-static ptid_t
-sol_thread_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *ourstatus, int options)
+ptid_t
+sol_thread_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
+ int options)
{
ptid_t rtnval;
ptid_t save_ptid;
- struct target_ops *beneath = find_target_beneath (ops);
- struct cleanup *old_chain;
+ struct target_ops *beneath = find_target_beneath (this);
save_ptid = inferior_ptid;
- old_chain = save_inferior_ptid ();
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
if (ptid_get_pid (inferior_ptid) == -1)
ptid_get_tid (save_ptid));
}
- rtnval = beneath->to_wait (beneath, ptid, ourstatus, options);
+ rtnval = beneath->wait (ptid, ourstatus, options);
if (ourstatus->kind != TARGET_WAITKIND_EXITED)
{
package being initialized, since that can only happen after we've
found the shared libs. */
- do_cleanups (old_chain);
-
return rtnval;
}
-static void
-sol_thread_fetch_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+void
+sol_thread_target::fetch_registers (struct regcache *regcache, int regnum)
{
thread_t thread;
td_thrhandle_t thandle;
prfpregset_t fpregset;
gdb_gregset_t *gregset_p = &gregset;
gdb_fpregset_t *fpregset_p = &fpregset;
- struct target_ops *beneath = find_target_beneath (ops);
+ struct target_ops *beneath = find_target_beneath (this);
ptid_t ptid = regcache_get_ptid (regcache);
if (!ptid_tid_p (ptid))
{
/* It's an LWP; pass the request on to the layer beneath. */
- beneath->to_fetch_registers (beneath, regcache, regnum);
+ beneath->fetch_registers (regcache, regnum);
return;
}
supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
}
-static void
-sol_thread_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+void
+sol_thread_target::store_registers (struct regcache *regcache, int regnum)
{
thread_t thread;
td_thrhandle_t thandle;
if (!ptid_tid_p (ptid))
{
- struct target_ops *beneath = find_target_beneath (ops);
+ struct target_ops *beneath = find_target_beneath (this);
/* It's an LWP; pass the request on to the layer beneath. */
- beneath->to_store_registers (beneath, regcache, regnum);
+ beneath->store_registers (regcache, regnum);
return;
}
target_write_partial for details of each variant. One, and only
one, of readbuf or writebuf must be non-NULL. */
-static enum target_xfer_status
-sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf,
- ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
+enum target_xfer_status
+sol_thread_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
{
- enum target_xfer_status retval;
- struct cleanup *old_chain;
- struct target_ops *beneath = find_target_beneath (ops);
+ struct target_ops *beneath = find_target_beneath (this);
- old_chain = save_inferior_ptid ();
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
{
inferior_ptid = procfs_first_available ();
}
- retval = beneath->to_xfer_partial (beneath, object, annex, readbuf,
- writebuf, offset, len, xfered_len);
-
- do_cleanups (old_chain);
-
- return retval;
+ return beneath->xfer_partial (object, annex, readbuf,
+ writebuf, offset, len, xfered_len);
}
static void
ptid_t ptid;
/* Don't attempt to use thread_db for remote targets. */
- if (!(target_can_run (¤t_target) || core_bfd))
+ if (!(target_can_run () || core_bfd))
return;
/* Do nothing if we couldn't load libthread_db.so.1. */
/* Clean up after the inferior dies. */
-static void
-sol_thread_mourn_inferior (struct target_ops *ops)
+void
+sol_thread_target::mourn_inferior ()
{
- struct target_ops *beneath = find_target_beneath (ops);
+ struct target_ops *beneath = find_target_beneath (this);
sol_thread_active = 0;
- unpush_target (ops);
+ unpush_target (this);
- beneath->to_mourn_inferior (beneath);
+ beneath->mourn_inferior ();
}
/* Return true if PTID is still active in the inferior. */
-static int
-sol_thread_alive (struct target_ops *ops, ptid_t ptid)
+bool
+sol_thread_target::thread_alive (ptid_t ptid)
{
if (ptid_tid_p (ptid))
{
pid = ptid_get_tid (ptid);
if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
- return 0; /* Thread not found. */
+ return false; /* Thread not found. */
if ((val = p_td_thr_validate (&th)) != TD_OK)
- return 0; /* Thread not valid. */
- return 1; /* Known thread. */
+ return false; /* Thread not valid. */
+ return true; /* Known thread. */
}
else
{
- struct target_ops *beneath = find_target_beneath (ops);
+ struct target_ops *beneath = find_target_beneath (this);
/* It's an LPW; pass the request on to the layer below. */
- return beneath->to_thread_alive (beneath, ptid);
+ return beneath->thread_alive (ptid);
}
}
/* These routines implement the lower half of the thread_db interface,
i.e. the ps_* routines. */
-/* Various versions of <proc_service.h> have slightly different
- function prototypes. In particular, we have
-
- NEWER OLDER
- struct ps_prochandle * const struct ps_prochandle *
- void* char*
- const void* char*
- int size_t
-
- Which one you have depends on the Solaris version and what patches
- you've applied. On the theory that there are only two major
- variants, we have configure check the prototype of ps_pdwrite (),
- and use that info to make appropriate typedefs here. */
-
-#ifdef PROC_SERVICE_IS_OLD
-typedef const struct ps_prochandle *gdb_ps_prochandle_t;
-typedef char *gdb_ps_read_buf_t;
-typedef char *gdb_ps_write_buf_t;
-typedef int gdb_ps_size_t;
-typedef psaddr_t gdb_ps_addr_t;
-#else
-typedef struct ps_prochandle *gdb_ps_prochandle_t;
-typedef void *gdb_ps_read_buf_t;
-typedef const void *gdb_ps_write_buf_t;
-typedef size_t gdb_ps_size_t;
-typedef psaddr_t gdb_ps_addr_t;
-#endif
-
/* The next four routines are called by libthread_db to tell us to
stop and stop a particular process or lwp. Since GDB ensures that
these are all stopped by the time we call anything in thread_db,
/* Process stop. */
ps_err_e
-ps_pstop (gdb_ps_prochandle_t ph)
+ps_pstop (struct ps_prochandle *ph)
{
return PS_OK;
}
/* Process continue. */
ps_err_e
-ps_pcontinue (gdb_ps_prochandle_t ph)
+ps_pcontinue (struct ps_prochandle *ph)
{
return PS_OK;
}
/* LWP stop. */
ps_err_e
-ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid)
+ps_lstop (struct ps_prochandle *ph, lwpid_t lwpid)
{
return PS_OK;
}
/* LWP continue. */
ps_err_e
-ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid)
+ps_lcontinue (struct ps_prochandle *ph, lwpid_t lwpid)
{
return PS_OK;
}
/* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
ps_err_e
-ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
- const char *ld_symbol_name, gdb_ps_addr_t *ld_symbol_addr)
+ps_pglobal_lookup (struct ps_prochandle *ph, const char *ld_object_name,
+ const char *ld_symbol_name, psaddr_t *ld_symbol_addr)
{
struct bound_minimal_symbol ms;
/* Common routine for reading and writing memory. */
static ps_err_e
-rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
+rw_common (int dowrite, const struct ps_prochandle *ph, psaddr_t addr,
gdb_byte *buf, int size)
{
int ret;
- struct cleanup *old_chain;
- old_chain = save_inferior_ptid ();
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
{
else
ret = target_read_memory (addr, (gdb_byte *) buf, size);
- do_cleanups (old_chain);
-
return (ret == 0 ? PS_OK : PS_ERR);
}
/* Copies SIZE bytes from target process .data segment to debugger memory. */
ps_err_e
-ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
- gdb_ps_read_buf_t buf, gdb_ps_size_t size)
+ps_pdread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
{
return rw_common (0, ph, addr, (gdb_byte *) buf, size);
}
/* Copies SIZE bytes from debugger memory .data segment to target process. */
ps_err_e
-ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
- gdb_ps_write_buf_t buf, gdb_ps_size_t size)
+ps_pdwrite (struct ps_prochandle *ph, psaddr_t addr,
+ const void *buf, size_t size)
{
return rw_common (1, ph, addr, (gdb_byte *) buf, size);
}
/* Copies SIZE bytes from target process .text segment to debugger memory. */
ps_err_e
-ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
- gdb_ps_read_buf_t buf, gdb_ps_size_t size)
+ps_ptread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
{
return rw_common (0, ph, addr, (gdb_byte *) buf, size);
}
/* Copies SIZE bytes from debugger memory .text segment to target process. */
ps_err_e
-ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
- gdb_ps_write_buf_t buf, gdb_ps_size_t size)
+ps_ptwrite (struct ps_prochandle *ph, psaddr_t addr,
+ const void *buf, size_t size)
{
return rw_common (1, ph, addr, (gdb_byte *) buf, size);
}
/* Get general-purpose registers for LWP. */
ps_err_e
-ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
+ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid, prgregset_t gregset)
{
- struct cleanup *old_chain;
- struct regcache *regcache;
-
- old_chain = save_inferior_ptid ();
-
- inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
- regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
+ ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
target_fetch_registers (regcache, -1);
fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
- do_cleanups (old_chain);
-
return PS_OK;
}
/* Set general-purpose registers for LWP. */
ps_err_e
-ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
+ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid,
const prgregset_t gregset)
{
- struct cleanup *old_chain;
- struct regcache *regcache;
-
- old_chain = save_inferior_ptid ();
-
- inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
- regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
+ ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
supply_gregset (regcache, (const gdb_gregset_t *) gregset);
target_store_registers (regcache, -1);
- do_cleanups (old_chain);
-
return PS_OK;
}
/* Get size of extra register set. Currently a noop. */
ps_err_e
-ps_lgetxregsize (gdb_ps_prochandle_t ph, lwpid_t lwpid, int *xregsize)
+ps_lgetxregsize (struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize)
{
return PS_OK;
}
/* Get extra register set. Currently a noop. */
ps_err_e
-ps_lgetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
+ps_lgetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
{
return PS_OK;
}
/* Set extra register set. Currently a noop. */
ps_err_e
-ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
+ps_lsetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
{
return PS_OK;
}
/* Get floating-point registers for LWP. */
ps_err_e
-ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
+ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
prfpregset_t *fpregset)
{
- struct cleanup *old_chain;
- struct regcache *regcache;
-
- old_chain = save_inferior_ptid ();
-
- inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
- regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
+ ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
target_fetch_registers (regcache, -1);
fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
- do_cleanups (old_chain);
-
return PS_OK;
}
/* Set floating-point regs for LWP. */
ps_err_e
-ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
+ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
const prfpregset_t * fpregset)
{
- struct cleanup *old_chain;
- struct regcache *regcache;
-
- old_chain = save_inferior_ptid ();
-
- inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
- regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
+ ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
target_store_registers (regcache, -1);
- do_cleanups (old_chain);
-
return PS_OK;
}
(e.g. procfs) method, but this ought to work. */
ps_err_e
-ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
+ps_pdmodel (struct ps_prochandle *ph, int *data_model)
{
if (exec_bfd == 0)
*data_model = PR_MODEL_UNKNOWN;
of libthread_db would fail because of ps_lgetLDT being undefined. */
ps_err_e
-ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
+ps_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid,
struct ssd *pldt)
{
/* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
/* Convert PTID to printable form. */
-static char *
-solaris_pid_to_str (struct target_ops *ops, ptid_t ptid)
+const char *
+sol_thread_target::pid_to_str (ptid_t ptid)
{
static char buf[100];
return 0;
}
-static void
-sol_update_thread_list (struct target_ops *ops)
+void
+sol_thread_target::update_thread_list ()
{
- struct target_ops *beneath = find_target_beneath (ops);
+ struct target_ops *beneath = find_target_beneath (this);
/* Delete dead threads. */
prune_threads ();
/* Find any new LWP's. */
- beneath->to_update_thread_list (beneath);
+ beneath->update_thread_list ();
/* Then find any new user-level threads. */
p_td_ta_thr_iter (main_ta, sol_update_thread_list_callback, (void *) 0,
inferior. */
static void
-info_solthreads (char *args, int from_tty)
+info_solthreads (const char *args, int from_tty)
{
- p_td_ta_thr_iter (main_ta, info_cb, args,
+ p_td_ta_thr_iter (main_ta, info_cb, (void *) args,
TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
}
return 0;
}
-static ptid_t
-sol_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
+ptid_t
+sol_thread_target::get_ada_task_ptid (long lwp, long thread)
{
struct thread_info *thread_info =
iterate_over_threads (thread_db_find_thread_from_tid, &thread);
{
/* The list of threads is probably not up to date. Find any
thread that is missing from the list, and try again. */
- sol_update_thread_list (¤t_target);
+ update_thread_list ();
thread_info = iterate_over_threads (thread_db_find_thread_from_tid,
&thread);
}
return (thread_info->ptid);
}
-static void
-init_sol_thread_ops (void)
-{
- sol_thread_ops.to_shortname = "solaris-threads";
- sol_thread_ops.to_longname = "Solaris threads and pthread.";
- sol_thread_ops.to_doc = "Solaris threads and pthread support.";
- sol_thread_ops.to_detach = sol_thread_detach;
- sol_thread_ops.to_resume = sol_thread_resume;
- sol_thread_ops.to_wait = sol_thread_wait;
- sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
- sol_thread_ops.to_store_registers = sol_thread_store_registers;
- sol_thread_ops.to_xfer_partial = sol_thread_xfer_partial;
- sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
- sol_thread_ops.to_thread_alive = sol_thread_alive;
- sol_thread_ops.to_pid_to_str = solaris_pid_to_str;
- sol_thread_ops.to_update_thread_list = sol_update_thread_list;
- sol_thread_ops.to_stratum = thread_stratum;
- sol_thread_ops.to_get_ada_task_ptid = sol_get_ada_task_ptid;
- sol_thread_ops.to_magic = OPS_MAGIC;
-}
-
-/* Silence -Wmissing-prototypes. */
-extern void _initialize_sol_thread (void);
-
void
_initialize_sol_thread (void)
{
void *dlhandle;
- init_sol_thread_ops ();
-
dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
if (!dlhandle)
goto die;
resolve (td_thr_getgregs);
resolve (td_thr_setgregs);
- complete_target_initialization (&sol_thread_ops);
-
add_cmd ("sol-threads", class_maintenance, info_solthreads,
_("Show info on Solaris user threads."), &maintenanceinfolist);
/* Hook into new_objfile notification. */
- observer_attach_new_objfile (sol_thread_new_objfile);
+ gdb::observers::new_objfile.attach (sol_thread_new_objfile);
return;
die:
projects / deliverable / binutils-gdb.git / blobdiff