-/* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
- Copyright 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Solaris threads debugging interface.
+
+ Copyright (C) 1996-2019 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/>. */
/* This module implements a sort of half target that sits between the
- machine-independent parts of GDB and the /proc interface (procfs.c) to
- provide access to the Solaris user-mode thread implementation.
-
- Solaris threads are true user-mode threads, which are invoked via the thr_*
- and pthread_* (native and Posix respectivly) interfaces. These are mostly
- implemented in user-space, with all thread context kept in various
- structures that live in the user's heap. These should not be confused with
- lightweight processes (LWPs), which are implemented by the kernel, and
- scheduled without explicit intervention by the process.
-
- Just to confuse things a little, Solaris threads (both native and Posix) are
- actually implemented using LWPs. In general, there are going to be more
- threads than LWPs. There is no fixed correspondence between a thread and an
- LWP. When a thread wants to run, it gets scheduled onto the first available
- LWP and can therefore migrate from one LWP to another as time goes on. A
+ machine-independent parts of GDB and the /proc interface (procfs.c)
+ to provide access to the Solaris user-mode thread implementation.
+
+ Solaris threads are true user-mode threads, which are invoked via
+ the thr_* and pthread_* (native and POSIX respectively) interfaces.
+ These are mostly implemented in user-space, with all thread context
+ kept in various structures that live in the user's heap. These
+ should not be confused with lightweight processes (LWPs), which are
+ implemented by the kernel, and scheduled without explicit
+ intervention by the process.
+
+ Just to confuse things a little, Solaris threads (both native and
+ POSIX) are actually implemented using LWPs. In general, there are
+ going to be more threads than LWPs. There is no fixed
+ correspondence between a thread and an LWP. When a thread wants to
+ run, it gets scheduled onto the first available LWP and can
+ therefore migrate from one LWP to another as time goes on. A
sleeping thread may not be associated with an LWP at all!
- To make it possible to mess with threads, Sun provides a library called
- libthread_db.so.1 (not to be confused with libthread_db.so.0, which doesn't
- have a published interface). This interface has an upper part, which it
- provides, and a lower part which I provide. The upper part consists of the
- td_* routines, which allow me to find all the threads, query their state,
- etc... The lower part consists of all of the ps_*, which are used by the
- td_* routines to read/write memory, manipulate LWPs, lookup symbols, etc...
- The ps_* routines actually do most of their work by calling functions in
- procfs.c. */
+ To make it possible to mess with threads, Sun provides a library
+ called libthread_db.so.1 (not to be confused with
+ libthread_db.so.0, which doesn't have a published interface). This
+ interface has an upper part, which it provides, and a lower part
+ which we provide. The upper part consists of the td_* routines,
+ which allow us to find all the threads, query their state, etc...
+ The lower part consists of all of the ps_*, which are used by the
+ td_* routines to read/write memory, manipulate LWPs, lookup
+ symbols, etc... The ps_* routines actually do most of their work
+ by calling functions in procfs.c. */
#include "defs.h"
#include <thread.h>
#include <sys/stat.h>
#include <dlfcn.h>
#include "gdbcmd.h"
+#include "gdbcore.h"
+#include "regcache.h"
+#include "solib.h"
+#include "symfile.h"
+#include "observable.h"
+#include "procfs.h"
+#include "symtab.h"
+#include "minsyms.h"
+#include "objfiles.h"
+
+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:
+ const target_info &info () const override
+ { return thread_db_target_info; }
+
+ strata stratum () const override { return thread_stratum; }
-extern struct target_ops sol_thread_ops; /* Forward declaration */
-extern struct target_ops sol_core_ops; /* Forward declaration */
+ 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;
+ std::string pid_to_str (ptid_t) override;
+ ptid_t get_ada_task_ptid (long lwp, long thread) override;
-/* place to store core_ops before we overwrite it */
-static struct target_ops orig_core_ops;
+ void fetch_registers (struct regcache *, int) override;
+ void store_registers (struct regcache *, int) override;
-struct target_ops sol_thread_ops;
-struct target_ops sol_core_ops;
+ 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;
-extern int procfs_suppress_run;
-extern struct target_ops procfs_ops; /* target vector for procfs.c */
-extern struct target_ops core_ops; /* target vector for corelow.c */
-extern char *procfs_pid_to_str PARAMS ((int pid));
+ bool thread_alive (ptid_t ptid) override;
+ void update_thread_list () override;
+};
-/* Note that these prototypes differ slightly from those used in procfs.c
- for of two reasons. One, we can't use gregset_t, as that's got a whole
- different meaning under Solaris (also, see above). Two, we can't use the
- pointer form here as these are actually arrays of ints (for Sparc's at
- least), and are automatically coerced into pointers to ints when used as
- parameters. That makes it impossible to avoid a compiler warning when
- passing pr{g fp}regset_t's from a parameter to an argument of one of
- these functions. */
+static sol_thread_target sol_thread_ops;
-extern void supply_gregset PARAMS ((const prgregset_t));
-extern void fill_gregset PARAMS ((prgregset_t, int));
-extern void supply_fpregset PARAMS ((const prfpregset_t *));
-extern void fill_fpregset PARAMS ((prfpregset_t *, int));
+/* Prototypes for supply_gregset etc. */
+#include "gregset.h"
-/* This struct is defined by us, but mainly used for the proc_service interface.
- We don't have much use for it, except as a handy place to get a real pid
- for memory accesses. */
+/* This struct is defined by us, but mainly used for the proc_service
+ interface. We don't have much use for it, except as a handy place
+ to get a real PID for memory accesses. */
struct ps_prochandle
- {
- pid_t pid;
- };
+{
+ ptid_t ptid;
+};
struct string_map
- {
- int num;
- char *str;
- };
+{
+ int num;
+ const char *str;
+};
static struct ps_prochandle main_ph;
static td_thragent_t *main_ta;
static int sol_thread_active = 0;
-static struct cleanup *save_inferior_pid PARAMS ((void));
-static void restore_inferior_pid PARAMS ((void *pid));
-static char *td_err_string PARAMS ((td_err_e errcode));
-static char *td_state_string PARAMS ((td_thr_state_e statecode));
-static int thread_to_lwp PARAMS ((int thread_id, int default_lwp));
-static void sol_thread_resume PARAMS ((int pid, int step,
- enum target_signal signo));
-static int lwp_to_thread PARAMS ((int lwp));
-static int sol_thread_alive PARAMS ((int pid));
-static void sol_core_close PARAMS ((int quitting));
-
-static void init_sol_thread_ops PARAMS ((void));
-static void init_sol_core_ops PARAMS ((void));
-
-/* Default definitions: These must be defined in tm.h
- if they are to be shared with a process module such as procfs. */
-
-#define THREAD_FLAG 0x80000000
-#define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
-#define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
-#define GET_LWP(PID) TIDGET (PID)
-#define GET_THREAD(PID) (((PID) >> 16) & 0x7fff)
-#define BUILD_LWP(TID, PID) ((TID) << 16 | (PID))
-
-#define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
-
-/* Pointers to routines from lithread_db resolved by dlopen() */
-
-static void
- (*p_td_log) (const int on_off);
-static td_err_e
- (*p_td_ta_new) (const struct ps_prochandle * ph_p, td_thragent_t ** ta_pp);
-static td_err_e
- (*p_td_ta_delete) (td_thragent_t * ta_p);
-static td_err_e
- (*p_td_init) (void);
-static td_err_e
- (*p_td_ta_get_ph) (const td_thragent_t * ta_p, struct ps_prochandle ** ph_pp);
-static td_err_e
- (*p_td_ta_get_nthreads) (const td_thragent_t * ta_p, int *nthread_p);
-static td_err_e
- (*p_td_ta_tsd_iter) (const td_thragent_t * ta_p, td_key_iter_f * cb, void *cbdata_p);
-static td_err_e
- (*p_td_ta_thr_iter) (const td_thragent_t * ta_p, td_thr_iter_f * cb, void *cbdata_p, td_thr_state_e state,
- int ti_pri, sigset_t * ti_sigmask_p, unsigned ti_user_flags);
-static td_err_e
- (*p_td_thr_validate) (const td_thrhandle_t * th_p);
-static td_err_e
- (*p_td_thr_tsd) (const td_thrhandle_t * th_p, const thread_key_t key, void **data_pp);
-static td_err_e
- (*p_td_thr_get_info) (const td_thrhandle_t * th_p, td_thrinfo_t * ti_p);
-static td_err_e
- (*p_td_thr_getfpregs) (const td_thrhandle_t * th_p, prfpregset_t * fpregset);
-static td_err_e
- (*p_td_thr_getxregsize) (const td_thrhandle_t * th_p, int *xregsize);
-static td_err_e
- (*p_td_thr_getxregs) (const td_thrhandle_t * th_p, const caddr_t xregset);
-static td_err_e
- (*p_td_thr_sigsetmask) (const td_thrhandle_t * th_p, const sigset_t ti_sigmask);
-static td_err_e
- (*p_td_thr_setprio) (const td_thrhandle_t * th_p, const int ti_pri);
-static td_err_e
- (*p_td_thr_setsigpending) (const td_thrhandle_t * th_p, const uchar_t ti_pending_flag, const sigset_t ti_pending);
-static td_err_e
- (*p_td_thr_setfpregs) (const td_thrhandle_t * th_p, const prfpregset_t * fpregset);
-static td_err_e
- (*p_td_thr_setxregs) (const td_thrhandle_t * th_p, const caddr_t xregset);
-static td_err_e
- (*p_td_ta_map_id2thr) (const td_thragent_t * ta_p, thread_t tid, td_thrhandle_t * th_p);
-static td_err_e
- (*p_td_ta_map_lwp2thr) (const td_thragent_t * ta_p, lwpid_t lwpid, td_thrhandle_t * th_p);
-static td_err_e
- (*p_td_thr_getgregs) (const td_thrhandle_t * th_p, prgregset_t regset);
-static td_err_e
- (*p_td_thr_setgregs) (const td_thrhandle_t * th_p, const prgregset_t regset);
+/* Default definitions: These must be defined in tm.h if they are to
+ be shared with a process module such as procfs. */
+
+/* Types of the libthread_db functions. */
+
+typedef void (td_log_ftype)(const int on_off);
+typedef td_err_e (td_ta_new_ftype)(const struct ps_prochandle *ph_p,
+ td_thragent_t **ta_pp);
+typedef td_err_e (td_ta_delete_ftype)(td_thragent_t *ta_p);
+typedef td_err_e (td_init_ftype)(void);
+typedef td_err_e (td_ta_get_ph_ftype)(const td_thragent_t *ta_p,
+ struct ps_prochandle **ph_pp);
+typedef td_err_e (td_ta_get_nthreads_ftype)(const td_thragent_t *ta_p,
+ int *nthread_p);
+typedef td_err_e (td_ta_tsd_iter_ftype)(const td_thragent_t *ta_p,
+ td_key_iter_f *cb, void *cbdata_p);
+typedef td_err_e (td_ta_thr_iter_ftype)(const td_thragent_t *ta_p,
+ td_thr_iter_f *cb, void *cbdata_p,
+ td_thr_state_e state, int ti_pri,
+ sigset_t *ti_sigmask_p,
+ unsigned ti_user_flags);
+typedef td_err_e (td_thr_validate_ftype)(const td_thrhandle_t *th_p);
+typedef td_err_e (td_thr_tsd_ftype)(const td_thrhandle_t * th_p,
+ const thread_key_t key, void **data_pp);
+typedef td_err_e (td_thr_get_info_ftype)(const td_thrhandle_t *th_p,
+ td_thrinfo_t *ti_p);
+typedef td_err_e (td_thr_getfpregs_ftype)(const td_thrhandle_t *th_p,
+ prfpregset_t *fpregset);
+typedef td_err_e (td_thr_getxregsize_ftype)(const td_thrhandle_t *th_p,
+ int *xregsize);
+typedef td_err_e (td_thr_getxregs_ftype)(const td_thrhandle_t *th_p,
+ const caddr_t xregset);
+typedef td_err_e (td_thr_sigsetmask_ftype)(const td_thrhandle_t *th_p,
+ const sigset_t ti_sigmask);
+typedef td_err_e (td_thr_setprio_ftype)(const td_thrhandle_t *th_p,
+ const int ti_pri);
+typedef td_err_e (td_thr_setsigpending_ftype)(const td_thrhandle_t *th_p,
+ const uchar_t ti_pending_flag,
+ const sigset_t ti_pending);
+typedef td_err_e (td_thr_setfpregs_ftype)(const td_thrhandle_t *th_p,
+ const prfpregset_t *fpregset);
+typedef td_err_e (td_thr_setxregs_ftype)(const td_thrhandle_t *th_p,
+ const caddr_t xregset);
+typedef td_err_e (td_ta_map_id2thr_ftype)(const td_thragent_t *ta_p,
+ thread_t tid,
+ td_thrhandle_t *th_p);
+typedef td_err_e (td_ta_map_lwp2thr_ftype)(const td_thragent_t *ta_p,
+ lwpid_t lwpid,
+ td_thrhandle_t *th_p);
+typedef td_err_e (td_thr_getgregs_ftype)(const td_thrhandle_t *th_p,
+ prgregset_t regset);
+typedef td_err_e (td_thr_setgregs_ftype)(const td_thrhandle_t *th_p,
+ const prgregset_t regset);
+
+/* Pointers to routines from libthread_db resolved by dlopen(). */
+
+static td_log_ftype *p_td_log;
+static td_ta_new_ftype *p_td_ta_new;
+static td_ta_delete_ftype *p_td_ta_delete;
+static td_init_ftype *p_td_init;
+static td_ta_get_ph_ftype *p_td_ta_get_ph;
+static td_ta_get_nthreads_ftype *p_td_ta_get_nthreads;
+static td_ta_tsd_iter_ftype *p_td_ta_tsd_iter;
+static td_ta_thr_iter_ftype *p_td_ta_thr_iter;
+static td_thr_validate_ftype *p_td_thr_validate;
+static td_thr_tsd_ftype *p_td_thr_tsd;
+static td_thr_get_info_ftype *p_td_thr_get_info;
+static td_thr_getfpregs_ftype *p_td_thr_getfpregs;
+static td_thr_getxregsize_ftype *p_td_thr_getxregsize;
+static td_thr_getxregs_ftype *p_td_thr_getxregs;
+static td_thr_sigsetmask_ftype *p_td_thr_sigsetmask;
+static td_thr_setprio_ftype *p_td_thr_setprio;
+static td_thr_setsigpending_ftype *p_td_thr_setsigpending;
+static td_thr_setfpregs_ftype *p_td_thr_setfpregs;
+static td_thr_setxregs_ftype *p_td_thr_setxregs;
+static td_ta_map_id2thr_ftype *p_td_ta_map_id2thr;
+static td_ta_map_lwp2thr_ftype *p_td_ta_map_lwp2thr;
+static td_thr_getgregs_ftype *p_td_thr_getgregs;
+static td_thr_setgregs_ftype *p_td_thr_setgregs;
\f
-/*
-
- LOCAL FUNCTION
-
- td_err_string - Convert a thread_db error code to a string
-
- SYNOPSIS
- char * td_err_string (errcode)
+/* Return the libthread_db error string associated with ERRCODE. If
+ ERRCODE is unknown, return an appropriate message. */
- DESCRIPTION
-
- Return the thread_db error string associated with errcode. If errcode
- is unknown, then return a message.
-
- */
-
-static char *
-td_err_string (errcode)
- td_err_e errcode;
+static const char *
+td_err_string (td_err_e errcode)
{
- static struct string_map
- td_err_table[] =
+ static struct string_map td_err_table[] =
{
- {TD_OK, "generic \"call succeeded\""},
- {TD_ERR, "generic error."},
- {TD_NOTHR, "no thread can be found to satisfy query"},
- {TD_NOSV, "no synch. variable can be found to satisfy query"},
- {TD_NOLWP, "no lwp can be found to satisfy query"},
- {TD_BADPH, "invalid process handle"},
- {TD_BADTH, "invalid thread handle"},
- {TD_BADSH, "invalid synchronization handle"},
- {TD_BADTA, "invalid thread agent"},
- {TD_BADKEY, "invalid key"},
- {TD_NOMSG, "td_thr_event_getmsg() called when there was no message"},
- {TD_NOFPREGS, "FPU register set not available for given thread"},
- {TD_NOLIBTHREAD, "application not linked with libthread"},
- {TD_NOEVENT, "requested event is not supported"},
- {TD_NOCAPAB, "capability not available"},
- {TD_DBERR, "Debugger service failed"},
- {TD_NOAPLIC, "Operation not applicable to"},
- {TD_NOTSD, "No thread specific data for this thread"},
- {TD_MALLOC, "Malloc failed"},
- {TD_PARTIALREG, "Only part of register set was writen/read"},
- {TD_NOXREGS, "X register set not available for given thread"}
+ { TD_OK, "generic \"call succeeded\"" },
+ { TD_ERR, "generic error." },
+ { TD_NOTHR, "no thread can be found to satisfy query" },
+ { TD_NOSV, "no synch. variable can be found to satisfy query" },
+ { TD_NOLWP, "no lwp can be found to satisfy query" },
+ { TD_BADPH, "invalid process handle" },
+ { TD_BADTH, "invalid thread handle" },
+ { TD_BADSH, "invalid synchronization handle" },
+ { TD_BADTA, "invalid thread agent" },
+ { TD_BADKEY, "invalid key" },
+ { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
+ { TD_NOFPREGS, "FPU register set not available for given thread" },
+ { TD_NOLIBTHREAD, "application not linked with libthread" },
+ { TD_NOEVENT, "requested event is not supported" },
+ { TD_NOCAPAB, "capability not available" },
+ { TD_DBERR, "Debugger service failed" },
+ { TD_NOAPLIC, "Operation not applicable to" },
+ { TD_NOTSD, "No thread specific data for this thread" },
+ { TD_MALLOC, "Malloc failed" },
+ { TD_PARTIALREG, "Only part of register set was written/read" },
+ { TD_NOXREGS, "X register set not available for given thread" }
};
const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
int i;
if (td_err_table[i].num == errcode)
return td_err_table[i].str;
- sprintf (buf, "Unknown thread_db error code: %d", errcode);
+ xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d",
+ errcode);
return buf;
}
-\f
-/*
-
- LOCAL FUNCTION
-
- td_state_string - Convert a thread_db state code to a string
-
- SYNOPSIS
-
- char * td_state_string (statecode)
-
- DESCRIPTION
-
- Return the thread_db state string associated with statecode. If
- statecode is unknown, then return a message.
- */
+/* Return the libthread_db state string associated with STATECODE.
+ If STATECODE is unknown, return an appropriate message. */
-static char *
-td_state_string (statecode)
- td_thr_state_e statecode;
+static const char *
+td_state_string (td_thr_state_e statecode)
{
- static struct string_map
- td_thr_state_table[] =
+ static struct string_map td_thr_state_table[] =
{
- {TD_THR_ANY_STATE, "any state"},
- {TD_THR_UNKNOWN, "unknown"},
- {TD_THR_STOPPED, "stopped"},
- {TD_THR_RUN, "run"},
- {TD_THR_ACTIVE, "active"},
- {TD_THR_ZOMBIE, "zombie"},
- {TD_THR_SLEEP, "sleep"},
- {TD_THR_STOPPED_ASLEEP, "stopped asleep"}
+ { TD_THR_ANY_STATE, "any state" },
+ { TD_THR_UNKNOWN, "unknown" },
+ { TD_THR_STOPPED, "stopped" },
+ { TD_THR_RUN, "run" },
+ { TD_THR_ACTIVE, "active" },
+ { TD_THR_ZOMBIE, "zombie" },
+ { TD_THR_SLEEP, "sleep" },
+ { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
};
- const int td_thr_state_table_size = sizeof td_thr_state_table / sizeof (struct string_map);
+ const int td_thr_state_table_size =
+ sizeof td_thr_state_table / sizeof (struct string_map);
int i;
static char buf[50];
if (td_thr_state_table[i].num == statecode)
return td_thr_state_table[i].str;
- sprintf (buf, "Unknown thread_db state code: %d", statecode);
+ xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d",
+ statecode);
return buf;
}
\f
-/*
- LOCAL FUNCTION
+/* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
+ doesn't exist, that's an error. If it's an inactive thread, return
+ DEFAULT_LWP.
- thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
+ NOTE: This function probably shouldn't call error(). */
- SYNOPSIS
-
- int thread_to_lwp (thread_id, default_lwp)
-
- DESCRIPTION
-
- This function converts a Posix or Solaris thread id to a lightweight
- process id. If thread_id is non-existent, that's an error. If it's
- an inactive thread, then we return default_lwp.
-
- NOTES
-
- This function probably shouldn't call error()...
-
- */
-
-static int
-thread_to_lwp (thread_id, default_lwp)
- int thread_id;
- int default_lwp;
+static ptid_t
+thread_to_lwp (ptid_t thread_id, int default_lwp)
{
td_thrinfo_t ti;
td_thrhandle_t th;
td_err_e val;
- if (is_lwp (thread_id))
- return thread_id; /* It's already an LWP id */
+ if (thread_id.lwp_p ())
+ return thread_id; /* It's already an LWP ID. */
- /* It's a thread. Convert to lwp */
+ /* It's a thread. Convert to LWP. */
- val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
+ val = p_td_ta_map_id2thr (main_ta, thread_id.tid (), &th);
if (val == TD_NOTHR)
- return -1; /* thread must have terminated */
+ return ptid_t (-1); /* Thread must have terminated. */
else if (val != TD_OK)
- error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val));
+ error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
val = p_td_thr_get_info (&th, &ti);
if (val == TD_NOTHR)
- return -1; /* thread must have terminated */
+ return ptid_t (-1); /* Thread must have terminated. */
else if (val != TD_OK)
- error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val));
+ error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
if (ti.ti_state != TD_THR_ACTIVE)
{
if (default_lwp != -1)
- return default_lwp;
- error ("thread_to_lwp: thread state not active: %s",
+ return ptid_t (default_lwp);
+ error (_("thread_to_lwp: thread state not active: %s"),
td_state_string (ti.ti_state));
}
- return BUILD_LWP (ti.ti_lid, PIDGET (thread_id));
+ return ptid_t (thread_id.pid (), ti.ti_lid, 0);
}
-\f
-/*
- LOCAL FUNCTION
+/* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
+ doesn't exists, that's an error.
- lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
+ NOTE: This function probably shouldn't call error(). */
- SYNOPSIS
-
- int lwp_to_thread (lwp_id)
-
- DESCRIPTION
-
- This function converts a lightweight process id to a Posix or Solaris
- thread id. If thread_id is non-existent, that's an error.
-
- NOTES
-
- This function probably shouldn't call error()...
-
- */
-
-static int
-lwp_to_thread (lwp)
- int lwp;
+static ptid_t
+lwp_to_thread (ptid_t lwp)
{
td_thrinfo_t ti;
td_thrhandle_t th;
td_err_e val;
- if (is_thread (lwp))
- return lwp; /* It's already a thread id */
+ if (lwp.tid_p ())
+ return lwp; /* It's already a thread ID. */
- /* It's an lwp. Convert it to a thread id. */
+ /* It's an LWP. Convert it to a thread ID. */
- if (!sol_thread_alive (lwp))
- return -1; /* defunct lwp */
+ if (!target_thread_alive (lwp))
+ return ptid_t (-1); /* Must be a defunct LPW. */
- val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
+ val = p_td_ta_map_lwp2thr (main_ta, lwp.lwp (), &th);
if (val == TD_NOTHR)
- return -1; /* thread must have terminated */
+ return ptid_t (-1); /* Thread must have terminated. */
else if (val != TD_OK)
- error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val));
+ error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
val = p_td_thr_validate (&th);
if (val == TD_NOTHR)
- return lwp; /* libthread doesn't know about it, just return lwp */
+ return lwp; /* Unknown to libthread; just return LPW, */
else if (val != TD_OK)
- error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val));
+ error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
val = p_td_thr_get_info (&th, &ti);
if (val == TD_NOTHR)
- return -1; /* thread must have terminated */
+ return ptid_t (-1); /* Thread must have terminated. */
else if (val != TD_OK)
- error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val));
-
- return BUILD_THREAD (ti.ti_tid, PIDGET (lwp));
-}
-\f
-/*
-
- LOCAL FUNCTION
-
- save_inferior_pid - Save inferior_pid on the cleanup list
- restore_inferior_pid - Restore inferior_pid from the cleanup list
-
- SYNOPSIS
-
- struct cleanup *save_inferior_pid ()
- void restore_inferior_pid (int pid)
-
- DESCRIPTION
-
- These two functions act in unison to restore inferior_pid in
- case of an error.
-
- NOTES
-
- inferior_pid is a global variable that needs to be changed by many of
- these routines before calling functions in procfs.c. In order to
- guarantee that inferior_pid gets restored (in case of errors), you
- need to call save_inferior_pid before changing it. At the end of the
- function, you should invoke do_cleanups to restore it.
+ error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
- */
-
-
-static struct cleanup *
-save_inferior_pid ()
-{
- return make_cleanup (restore_inferior_pid, (void *) inferior_pid);
-}
-
-static void
-restore_inferior_pid (pid)
- void *pid;
-{
- inferior_pid = (int) pid;
+ return ptid_t (lwp.pid (), 0 , ti.ti_tid);
}
\f
-/* Most target vector functions from here on actually just pass through to
- procfs.c, as they don't need to do anything specific for threads. */
+/* Most target vector functions from here on actually just pass
+ through to the layer beneath, as they don't need to do anything
+ specific for threads. */
+/* Take a program previously attached to and detaches it. The program
+ resumes execution and will no longer stop on signals, etc. We'd
+ better not have left any breakpoints in the program or it'll die
+ when it hits one. For this to work, it may be necessary for the
+ process to have been previously attached. It *might* work if the
+ program was started via the normal ptrace (PTRACE_TRACEME). */
-/* ARGSUSED */
-static void
-sol_thread_open (arg, from_tty)
- char *arg;
- int from_tty;
-{
- procfs_ops.to_open (arg, from_tty);
-}
-
-/* Attach to process PID, then initialize for debugging it
- and wait for the trace-trap that results from attaching. */
-
-static void
-sol_thread_attach (args, from_tty)
- char *args;
- int from_tty;
+void
+sol_thread_target::detach (inferior *inf, int from_tty)
{
- procfs_ops.to_attach (args, from_tty);
- /* Must get symbols from solibs before libthread_db can run! */
- SOLIB_ADD ((char *) 0, from_tty, (struct target_ops *) 0);
- if (sol_thread_active)
- {
- printf_filtered ("sol-thread active.\n");
- main_ph.pid = inferior_pid; /* Save for xfer_memory */
- push_target (&sol_thread_ops);
- inferior_pid = lwp_to_thread (inferior_pid);
- if (inferior_pid == -1)
- inferior_pid = main_ph.pid;
- else
- add_thread (inferior_pid);
- }
- /* XXX - might want to iterate over all the threads and register them. */
-}
-
-/* Take a program previously attached to and detaches it.
- The program resumes execution and will no longer stop
- on signals, etc. We'd better not have left any breakpoints
- in the program or it'll die when it hits one. For this
- to work, it may be necessary for the process to have been
- previously attached. It *might* work if the program was
- started via the normal ptrace (PTRACE_TRACEME). */
+ target_ops *beneath = this->beneath ();
-static void
-sol_thread_detach (args, from_tty)
- char *args;
- int from_tty;
-{
- inferior_pid = PIDGET (main_ph.pid);
- unpush_target (&sol_thread_ops);
- procfs_ops.to_detach (args, from_tty);
+ sol_thread_active = 0;
+ inferior_ptid = ptid_t (main_ph.ptid.pid ());
+ unpush_target (this);
+ beneath->detach (inf, from_tty);
}
-/* Resume execution of process PID. If STEP is nozero, then
- just single step it. If SIGNAL is nonzero, restart it with that
- signal activated. We may have to convert pid from a thread-id to an LWP id
- for procfs. */
+/* Resume execution of process PTID. If STEP is nonzero, then just
+ single step it. If SIGNAL is nonzero, restart it with that signal
+ activated. We may have to convert PTID from a thread ID to an LWP
+ ID for procfs. */
-static void
-sol_thread_resume (pid, step, signo)
- int pid;
- int step;
- enum target_signal signo;
+void
+sol_thread_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
{
- struct cleanup *old_chain;
-
- old_chain = save_inferior_pid ();
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
- if (inferior_pid == -1)
- inferior_pid = procfs_first_available ();
+ inferior_ptid = thread_to_lwp (inferior_ptid, main_ph.ptid.pid ());
+ if (inferior_ptid.pid () == -1)
+ inferior_ptid = procfs_first_available ();
- if (pid != -1)
+ if (ptid.pid () != -1)
{
- int save_pid = pid;
-
- pid = thread_to_lwp (pid, -2);
- if (pid == -2) /* Inactive thread */
- error ("This version of Solaris can't start inactive threads.");
- if (info_verbose && pid == -1)
- warning ("Specified thread %d seems to have terminated",
- GET_THREAD (save_pid));
+ ptid_t save_ptid = ptid;
+
+ ptid = thread_to_lwp (ptid, -2);
+ if (ptid.pid () == -2) /* Inactive thread. */
+ error (_("This version of Solaris can't start inactive threads."));
+ if (info_verbose && ptid.pid () == -1)
+ warning (_("Specified thread %ld seems to have terminated"),
+ save_ptid.tid ());
}
- procfs_ops.to_resume (pid, step, signo);
-
- do_cleanups (old_chain);
+ beneath ()->resume (ptid, step, signo);
}
-/* Wait for any threads to stop. We may have to convert PID from a thread id
- to a LWP id, and vice versa on the way out. */
+/* 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 int
-sol_thread_wait (pid, ourstatus)
- int pid;
- struct target_waitstatus *ourstatus;
+ptid_t
+sol_thread_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
+ int options)
{
- int rtnval;
- int save_pid;
- struct cleanup *old_chain;
+ ptid_t rtnval;
+ ptid_t save_ptid;
- save_pid = inferior_pid;
- old_chain = save_inferior_pid ();
+ save_ptid = inferior_ptid;
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
- if (inferior_pid == -1)
- inferior_pid = procfs_first_available ();
+ inferior_ptid = thread_to_lwp (inferior_ptid, main_ph.ptid.pid ());
+ if (inferior_ptid.pid () == -1)
+ inferior_ptid = procfs_first_available ();
- if (pid != -1)
+ if (ptid.pid () != -1)
{
- int save_pid = pid;
-
- pid = thread_to_lwp (pid, -2);
- if (pid == -2) /* Inactive thread */
- error ("This version of Solaris can't start inactive threads.");
- if (info_verbose && pid == -1)
- warning ("Specified thread %d seems to have terminated",
- GET_THREAD (save_pid));
+ ptid_t ptid_for_warning = ptid;
+
+ ptid = thread_to_lwp (ptid, -2);
+ if (ptid.pid () == -2) /* Inactive thread. */
+ error (_("This version of Solaris can't start inactive threads."));
+ if (info_verbose && ptid.pid () == -1)
+ warning (_("Specified thread %ld seems to have terminated"),
+ ptid_for_warning.tid ());
}
- rtnval = procfs_ops.to_wait (pid, ourstatus);
+ rtnval = beneath ()->wait (ptid, ourstatus, options);
if (ourstatus->kind != TARGET_WAITKIND_EXITED)
{
- /* Map the LWP of interest back to the appropriate thread ID */
+ /* Map the LWP of interest back to the appropriate thread ID. */
rtnval = lwp_to_thread (rtnval);
- if (rtnval == -1)
- rtnval = save_pid;
+ if (rtnval.pid () == -1)
+ rtnval = save_ptid;
- /* See if we have a new thread */
- if (is_thread (rtnval)
- && rtnval != save_pid
- && !in_thread_list (rtnval))
+ /* See if we have a new thread. */
+ if (rtnval.tid_p () && rtnval != save_ptid)
{
- printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));
- add_thread (rtnval);
+ thread_info *thr = find_thread_ptid (rtnval);
+ if (thr == NULL || thr->state == THREAD_EXITED)
+ add_thread (rtnval);
}
}
- /* During process initialization, we may get here without the thread package
- being initialized, since that can only happen after we've found the shared
- libs. */
-
- do_cleanups (old_chain);
+ /* During process initialization, we may get here without the thread
+ package being initialized, since that can only happen after we've
+ found the shared libs. */
return rtnval;
}
-static void
-sol_thread_fetch_registers (regno)
- int regno;
+void
+sol_thread_target::fetch_registers (struct regcache *regcache, int regnum)
{
thread_t thread;
td_thrhandle_t thandle;
td_err_e val;
prgregset_t gregset;
prfpregset_t fpregset;
-#if 0
- int xregsize;
- caddr_t xregset;
-#endif
+ gdb_gregset_t *gregset_p = &gregset;
+ gdb_fpregset_t *fpregset_p = &fpregset;
+ ptid_t ptid = regcache->ptid ();
- if (!is_thread (inferior_pid))
- { /* LWP: pass the request on to procfs.c */
- if (target_has_execution)
- procfs_ops.to_fetch_registers (regno);
- else
- orig_core_ops.to_fetch_registers (regno);
+ if (!ptid.tid_p ())
+ {
+ /* It's an LWP; pass the request on to the layer beneath. */
+ beneath ()->fetch_registers (regcache, regnum);
return;
}
- /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
-
- thread = GET_THREAD (inferior_pid);
-
+ /* Solaris thread: convert PTID into a td_thrhandle_t. */
+ thread = ptid.tid ();
if (thread == 0)
- error ("sol_thread_fetch_registers: thread == 0");
+ error (_("sol_thread_fetch_registers: thread == 0"));
val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
if (val != TD_OK)
- error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
+ error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
td_err_string (val));
- /* Get the integer regs */
+ /* Get the general-purpose registers. */
val = p_td_thr_getgregs (&thandle, gregset);
- if (val != TD_OK
- && val != TD_PARTIALREG)
- error ("sol_thread_fetch_registers: td_thr_getgregs %s",
+ if (val != TD_OK && val != TD_PARTIALREG)
+ error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
td_err_string (val));
- /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
- are saved (by a thread context switch). */
+ /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
+ and %sp are saved (by a thread context switch). */
- /* And, now the fp regs */
+ /* And, now the floating-point registers. */
val = p_td_thr_getfpregs (&thandle, &fpregset);
- if (val != TD_OK
- && val != TD_NOFPREGS)
- error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
+ if (val != TD_OK && val != TD_NOFPREGS)
+ error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
td_err_string (val));
-/* Note that we must call supply_{g fp}regset *after* calling the td routines
- because the td routines call ps_lget* which affect the values stored in the
- registers array. */
-
- supply_gregset (gregset);
- supply_fpregset (&fpregset);
-
-#if 0
-/* thread_db doesn't seem to handle this right */
- val = td_thr_getxregsize (&thandle, &xregsize);
- if (val != TD_OK && val != TD_NOXREGS)
- error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
- td_err_string (val));
+ /* Note that we must call supply_gregset and supply_fpregset *after*
+ calling the td routines because the td routines call ps_lget*
+ which affect the values stored in the registers array. */
- if (val == TD_OK)
- {
- xregset = alloca (xregsize);
- val = td_thr_getxregs (&thandle, xregset);
- if (val != TD_OK)
- error ("sol_thread_fetch_registers: td_thr_getxregs %s",
- td_err_string (val));
- }
-#endif
+ supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
+ supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
}
-static void
-sol_thread_store_registers (regno)
- int regno;
+void
+sol_thread_target::store_registers (struct regcache *regcache, int regnum)
{
thread_t thread;
td_thrhandle_t thandle;
td_err_e val;
- prgregset_t regset;
+ prgregset_t gregset;
prfpregset_t fpregset;
-#if 0
- int xregsize;
- caddr_t xregset;
-#endif
+ ptid_t ptid = regcache->ptid ();
- if (!is_thread (inferior_pid))
- { /* LWP: pass the request on to procfs.c */
- procfs_ops.to_store_registers (regno);
+ if (!ptid.tid_p ())
+ {
+ /* It's an LWP; pass the request on to the layer beneath. */
+ beneath ()->store_registers (regcache, regnum);
return;
}
- /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
-
- thread = GET_THREAD (inferior_pid);
+ /* Solaris thread: convert PTID into a td_thrhandle_t. */
+ thread = ptid.tid ();
val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_ta_map_id2thr %s",
+ error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
td_err_string (val));
- if (regno != -1)
- { /* Not writing all the regs */
- /* save new register value */
- char old_value[REGISTER_SIZE];
- memcpy (old_value, ®isters[REGISTER_BYTE (regno)], REGISTER_SIZE);
-
- val = p_td_thr_getgregs (&thandle, regset);
+ if (regnum != -1)
+ {
+ val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_thr_getgregs %s",
+ error (_("sol_thread_store_registers: td_thr_getgregs %s"),
td_err_string (val));
val = p_td_thr_getfpregs (&thandle, &fpregset);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_thr_getfpregs %s",
+ error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
td_err_string (val));
-
- /* restore new register value */
- memcpy (®isters[REGISTER_BYTE (regno)], old_value, REGISTER_SIZE);
-
-#if 0
-/* thread_db doesn't seem to handle this right */
- val = td_thr_getxregsize (&thandle, &xregsize);
- if (val != TD_OK && val != TD_NOXREGS)
- error ("sol_thread_store_registers: td_thr_getxregsize %s",
- td_err_string (val));
-
- if (val == TD_OK)
- {
- xregset = alloca (xregsize);
- val = td_thr_getxregs (&thandle, xregset);
- if (val != TD_OK)
- error ("sol_thread_store_registers: td_thr_getxregs %s",
- td_err_string (val));
- }
-#endif
}
- fill_gregset (regset, regno);
- fill_fpregset (&fpregset, regno);
+ fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
+ fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
- val = p_td_thr_setgregs (&thandle, regset);
+ val = p_td_thr_setgregs (&thandle, gregset);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_thr_setgregs %s",
+ error (_("sol_thread_store_registers: td_thr_setgregs %s"),
td_err_string (val));
val = p_td_thr_setfpregs (&thandle, &fpregset);
if (val != TD_OK)
- error ("sol_thread_store_registers: td_thr_setfpregs %s",
+ error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
td_err_string (val));
-
-#if 0
-/* thread_db doesn't seem to handle this right */
- val = td_thr_getxregsize (&thandle, &xregsize);
- if (val != TD_OK && val != TD_NOXREGS)
- error ("sol_thread_store_registers: td_thr_getxregsize %s",
- td_err_string (val));
-
- /* Should probably do something about writing the xregs here, but what are
- they? */
-#endif
}
-/* Get ready to modify the registers array. On machines which store
- individual registers, this doesn't need to do anything. On machines
- which store all the registers in one fell swoop, this makes sure
- that registers contains all the registers from the program being
- debugged. */
+/* Perform partial transfers on OBJECT. See target_read_partial and
+ target_write_partial for details of each variant. One, and only
+ one, of readbuf or writebuf must be non-NULL. */
-static void
-sol_thread_prepare_to_store ()
+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)
{
- procfs_ops.to_prepare_to_store ();
-}
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
-static int
-sol_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int dowrite;
- struct target_ops *target; /* ignored */
-{
- int retval;
- struct cleanup *old_chain;
-
- old_chain = save_inferior_pid ();
-
- if (is_thread (inferior_pid) || /* A thread */
- !target_thread_alive (inferior_pid)) /* An lwp, but not alive */
- inferior_pid = procfs_first_available (); /* Find any live lwp. */
- /* Note: don't need to call switch_to_thread; we're just reading memory. */
-
- if (target_has_execution)
- retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, target);
- else
- retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len,
- dowrite, target);
+ if (inferior_ptid.tid_p () || !target_thread_alive (inferior_ptid))
+ {
+ /* It's either a thread or an LWP that isn't alive. Any live
+ LWP will do so use the first available.
- do_cleanups (old_chain);
+ NOTE: We don't need to call switch_to_thread; we're just
+ reading memory. */
+ inferior_ptid = procfs_first_available ();
+ }
- return retval;
+ return beneath ()->xfer_partial (object, annex, readbuf,
+ writebuf, offset, len, xfered_len);
}
-/* Print status information about what we're accessing. */
-
static void
-sol_thread_files_info (ignore)
- struct target_ops *ignore;
+check_for_thread_db (void)
{
- procfs_ops.to_files_info (ignore);
-}
+ td_err_e err;
+ ptid_t ptid;
-static void
-sol_thread_kill_inferior ()
-{
- procfs_ops.to_kill ();
-}
+ /* Don't attempt to use thread_db for remote targets. */
+ if (!(target_can_run () || core_bfd))
+ return;
-static void
-sol_thread_notice_signals (pid)
- int pid;
-{
- procfs_ops.to_notice_signals (PIDGET (pid));
-}
+ /* Do nothing if we couldn't load libthread_db.so.1. */
+ if (p_td_ta_new == NULL)
+ return;
-/* Fork an inferior process, and start debugging it with /proc. */
+ if (sol_thread_active)
+ /* Nothing to do. The thread library was already detected and the
+ target vector was already activated. */
+ return;
-static void
-sol_thread_create_inferior (exec_file, allargs, env)
- char *exec_file;
- char *allargs;
- char **env;
-{
- procfs_ops.to_create_inferior (exec_file, allargs, env);
+ /* Now, initialize libthread_db. This needs to be done after the
+ shared libraries are located because it needs information from
+ the user's thread library. */
- if (sol_thread_active && inferior_pid != 0)
+ err = p_td_init ();
+ if (err != TD_OK)
{
- main_ph.pid = inferior_pid; /* Save for xfer_memory */
-
- push_target (&sol_thread_ops);
-
- inferior_pid = lwp_to_thread (inferior_pid);
- if (inferior_pid == -1)
- inferior_pid = main_ph.pid;
-
- add_thread (inferior_pid);
+ warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));
+ return;
}
-}
-
-/* This routine is called whenever a new symbol table is read in, or when all
- symbol tables are removed. libthread_db can only be initialized when it
- finds the right variables in libthread.so. Since it's a shared library,
- those variables don't show up until the library gets mapped and the symbol
- table is read in. */
-
-/* This new_objfile event is now managed by a chained function pointer.
- * It is the callee's responsability to call the next client on the chain.
- */
-/* Saved pointer to previous owner of the new_objfile event. */
-static void (*target_new_objfile_chain) PARAMS ((struct objfile *));
-
-void
-sol_thread_new_objfile (objfile)
- struct objfile *objfile;
-{
- td_err_e val;
-
- if (!objfile)
+ /* Now attempt to open a connection to the thread library. */
+ err = p_td_ta_new (&main_ph, &main_ta);
+ switch (err)
{
- sol_thread_active = 0;
- goto quit;
- }
+ case TD_NOLIBTHREAD:
+ /* No thread library was detected. */
+ break;
- /* don't do anything if init failed to resolve the libthread_db library */
- if (!procfs_suppress_run)
- goto quit;
+ case TD_OK:
+ printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
- /* Now, initialize the thread debugging library. This needs to be done after
- the shared libraries are located because it needs information from the
- user's thread library. */
+ /* The thread library was detected. Activate the sol_thread target. */
+ push_target (&sol_thread_ops);
+ sol_thread_active = 1;
- val = p_td_init ();
- if (val != TD_OK)
- {
- warning ("sol_thread_new_objfile: td_init: %s", td_err_string (val));
- goto quit;
- }
+ main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */
+ ptid = lwp_to_thread (inferior_ptid);
+ if (ptid.pid () != -1)
+ inferior_ptid = ptid;
- val = p_td_ta_new (&main_ph, &main_ta);
- if (val == TD_NOLIBTHREAD)
- goto quit;
- else if (val != TD_OK)
- {
- warning ("sol_thread_new_objfile: td_ta_new: %s", td_err_string (val));
- goto quit;
- }
+ target_update_thread_list ();
+ break;
- sol_thread_active = 1;
-quit:
- /* Call predecessor on chain, if any. */
- if (target_new_objfile_chain)
- target_new_objfile_chain (objfile);
+ default:
+ warning (_("Cannot initialize thread debugging library: %s"),
+ td_err_string (err));
+ break;
+ }
}
-/* Clean up after the inferior dies. */
+/* This routine is called whenever a new symbol table is read in, or
+ when all symbol tables are removed. libthread_db can only be
+ initialized when it finds the right variables in libthread.so.
+ Since it's a shared library, those variables don't show up until
+ the library gets mapped and the symbol table is read in. */
static void
-sol_thread_mourn_inferior ()
+sol_thread_new_objfile (struct objfile *objfile)
{
- unpush_target (&sol_thread_ops);
- procfs_ops.to_mourn_inferior ();
+ if (objfile != NULL)
+ check_for_thread_db ();
}
-/* Mark our target-struct as eligible for stray "run" and "attach" commands. */
+/* Clean up after the inferior dies. */
-static int
-sol_thread_can_run ()
+void
+sol_thread_target::mourn_inferior ()
{
- return procfs_suppress_run;
-}
+ target_ops *beneath = this->beneath ();
-/*
+ sol_thread_active = 0;
- LOCAL FUNCTION
+ unpush_target (this);
- sol_thread_alive - test thread for "aliveness"
-
- SYNOPSIS
-
- static bool sol_thread_alive (int pid);
-
- DESCRIPTION
-
- returns true if thread still active in inferior.
+ beneath->mourn_inferior ();
+}
- */
+/* Return true if PTID is still active in the inferior. */
-static int
-sol_thread_alive (pid)
- int pid;
+bool
+sol_thread_target::thread_alive (ptid_t ptid)
{
- if (is_thread (pid)) /* non-kernel thread */
+ if (ptid.tid_p ())
{
+ /* It's a (user-level) thread. */
td_err_e val;
td_thrhandle_t th;
+ int pid;
- pid = GET_THREAD (pid);
- if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
- return 0; /* thread not found */
- if ((val = p_td_thr_validate (&th)) != TD_OK)
- return 0; /* thread not valid */
- return 1; /* known thread: return true */
+ pid = ptid.tid ();
+ val = p_td_ta_map_id2thr (main_ta, pid, &th);
+ if (val != TD_OK)
+ return false; /* Thread not found. */
+ val = p_td_thr_validate (&th);
+ if (val != TD_OK)
+ return false; /* Thread not valid. */
+ return true; /* Known thread. */
}
else
- /* kernel thread (LWP): let procfs test it */
{
- if (target_has_execution)
- return procfs_ops.to_thread_alive (pid);
- else
- return orig_core_ops.to_thread_alive (pid);
+ /* It's an LPW; pass the request on to the layer below. */
+ return beneath ()->thread_alive (ptid);
}
}
-static void
-sol_thread_stop ()
-{
- procfs_ops.to_stop ();
-}
\f
-/* These routines implement the lower half of the thread_db interface. Ie: 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 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;
-#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;
-#endif
+/* These routines implement the lower half of the thread_db interface,
+ i.e. the ps_* routines. */
+/* 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,
+ these routines need to do nothing. */
-/* The next four routines are called by thread_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, these routines need to do
- nothing. */
-
-/* Process stop */
+/* Process stop. */
ps_err_e
-ps_pstop (gdb_ps_prochandle_t ph)
+ps_pstop (struct ps_prochandle *ph)
{
return PS_OK;
}
-/* Process continue */
+/* Process continue. */
ps_err_e
-ps_pcontinue (gdb_ps_prochandle_t ph)
+ps_pcontinue (struct ps_prochandle *ph)
{
return PS_OK;
}
-/* LWP stop */
+/* 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 */
+/* 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, paddr_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 minimal_symbol *ms;
+ struct bound_minimal_symbol ms;
ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
-
- if (!ms)
+ if (!ms.minsym)
return PS_NOSYM;
- *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
-
+ *ld_symbol_addr = BMSYMBOL_VALUE_ADDRESS (ms);
return PS_OK;
}
/* Common routine for reading and writing memory. */
static ps_err_e
-rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr,
- char *buf, int size)
+rw_common (int dowrite, const struct ps_prochandle *ph, psaddr_t addr,
+ gdb_byte *buf, int size)
{
- struct cleanup *old_chain;
-
- old_chain = save_inferior_pid ();
+ int ret;
- if (is_thread (inferior_pid) || /* A thread */
- !target_thread_alive (inferior_pid)) /* An lwp, but not alive */
- inferior_pid = procfs_first_available (); /* Find any live lwp. */
- /* Note: don't need to call switch_to_thread; we're just reading memory. */
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- while (size > 0)
+ if (inferior_ptid.tid_p () || !target_thread_alive (inferior_ptid))
{
- int cc;
-
- if (target_has_execution)
- cc = procfs_ops.to_xfer_memory (addr, buf, size, dowrite, &procfs_ops);
- else
- cc = orig_core_ops.to_xfer_memory (addr, buf, size, dowrite, &core_ops);
+ /* It's either a thread or an LWP that isn't alive. Any live
+ LWP will do so use the first available.
- if (cc < 0)
- {
- if (dowrite == 0)
- print_sys_errmsg ("rw_common (): read", errno);
- else
- print_sys_errmsg ("rw_common (): write", errno);
-
- do_cleanups (old_chain);
-
- return PS_ERR;
- }
- size -= cc;
- buf += cc;
+ NOTE: We don't need to call switch_to_thread; we're just
+ reading memory. */
+ inferior_ptid = procfs_first_available ();
}
- do_cleanups (old_chain);
+#if defined (__sparcv9)
+ /* For Sparc64 cross Sparc32, make sure the address has not been
+ accidentally sign-extended (or whatever) to beyond 32 bits. */
+ if (bfd_get_arch_size (exec_bfd) == 32)
+ addr &= 0xffffffff;
+#endif
+
+ if (dowrite)
+ ret = target_write_memory (addr, (gdb_byte *) buf, size);
+ else
+ ret = target_read_memory (addr, (gdb_byte *) buf, size);
- return PS_OK;
+ 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, paddr_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, buf, 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, paddr_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, (char *) buf, 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, paddr_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, buf, 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, paddr_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, (char *) buf, size);
+ return rw_common (1, ph, addr, (gdb_byte *) buf, size);
}
-/* Get integer regs for LWP */
+/* 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;
+ ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
- old_chain = save_inferior_pid ();
-
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
-
- if (target_has_execution)
- procfs_ops.to_fetch_registers (-1);
- else
- orig_core_ops.to_fetch_registers (-1);
- fill_gregset (gregset, -1);
-
- do_cleanups (old_chain);
+ target_fetch_registers (regcache, -1);
+ fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
return PS_OK;
}
-/* Set integer regs for LWP */
+/* 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;
-
- old_chain = save_inferior_pid ();
+ ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
-
- supply_gregset (gregset);
- if (target_has_execution)
- procfs_ops.to_store_registers (-1);
- else
- orig_core_ops.to_store_registers (-1);
-
- do_cleanups (old_chain);
+ supply_gregset (regcache, (const gdb_gregset_t *) gregset);
+ target_store_registers (regcache, -1);
return PS_OK;
}
/* Log a message (sends to gdb_stderr). */
void
-ps_plog (const char *fmt,...)
+ps_plog (const char *fmt, ...)
{
va_list args;
/* 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)
{
-#if 0
- int lwp_fd;
- int regsize;
- ps_err_e val;
-
- val = get_lwp_fd (ph, lwpid, &lwp_fd);
- if (val != PS_OK)
- return val;
-
- if (ioctl (lwp_fd, PIOCGXREGSIZE, ®size))
- {
- if (errno == EINVAL)
- return PS_NOFREGS; /* XXX Wrong code, but this is the closest
- thing in proc_service.h */
-
- print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno);
- return PS_ERR;
- }
-#endif
-
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)
{
-#if 0
- int lwp_fd;
- ps_err_e val;
-
- val = get_lwp_fd (ph, lwpid, &lwp_fd);
- if (val != PS_OK)
- return val;
-
- if (ioctl (lwp_fd, PIOCGXREG, xregset))
- {
- print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno);
- return PS_ERR;
- }
-#endif
-
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)
{
-#if 0
- int lwp_fd;
- ps_err_e val;
-
- val = get_lwp_fd (ph, lwpid, &lwp_fd);
- if (val != PS_OK)
- return val;
-
- if (ioctl (lwp_fd, PIOCSXREG, xregset))
- {
- print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno);
- return PS_ERR;
- }
-#endif
-
return PS_OK;
}
-/* Get floating-point regs for LWP */
+/* Get floating-point registers for LWP. */
ps_err_e
-ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
- prfpregset_t * fpregset)
+ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
+ prfpregset_t *fpregset)
{
- struct cleanup *old_chain;
-
- old_chain = save_inferior_pid ();
+ ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
-
- if (target_has_execution)
- procfs_ops.to_fetch_registers (-1);
- else
- orig_core_ops.to_fetch_registers (-1);
- fill_fpregset (fpregset, -1);
-
- do_cleanups (old_chain);
+ target_fetch_registers (regcache, -1);
+ fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
return PS_OK;
}
-/* Set floating-point regs for LWP */
+/* 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;
+ ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
- old_chain = save_inferior_pid ();
+ supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
+ target_store_registers (regcache, -1);
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+ return PS_OK;
+}
- supply_fpregset (fpregset);
- if (target_has_execution)
- procfs_ops.to_store_registers (-1);
- else
- orig_core_ops.to_store_registers (-1);
+/* Identify process as 32-bit or 64-bit. At the moment we're using
+ BFD to do this. There might be a more Solaris-specific
+ (e.g. procfs) method, but this ought to work. */
- do_cleanups (old_chain);
+ps_err_e
+ps_pdmodel (struct ps_prochandle *ph, int *data_model)
+{
+ if (exec_bfd == 0)
+ *data_model = PR_MODEL_UNKNOWN;
+ else if (bfd_get_arch_size (exec_bfd) == 32)
+ *data_model = PR_MODEL_ILP32;
+ else
+ *data_model = PR_MODEL_LP64;
return PS_OK;
}
-#ifdef TM_I386SOL2_H
-
-/* Get local descriptor table. */
+#if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
-#include <sys/procfs.h>
-#include <sys/reg.h>
-#include <sys/sysi86.h>
+/* Reads the local descriptor table of a LWP.
-static int nldt_allocated = 0;
-static struct ssd *ldt_bufp = NULL;
-
-/* Reads the local descriptor table of a LWP. */
+ This function is necessary on x86-solaris only. Without it, the loading
+ of libthread_db would fail because of ps_lgetLDT being undefined. */
ps_err_e
-ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
- struct ssd *pldt)
+ps_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid, struct ssd *pldt) /* ARI: editCase function */
{
- gregset_t gregset;
- int lwp_fd;
- ps_err_e val;
- int nldt;
- int i;
+ /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
+ struct ssd *ret;
- /* Get procfs file descriptor for the LWP. */
- lwp_fd = procfs_get_pid_fd (BUILD_LWP (lwpid, PIDGET (inferior_pid)));
- if (lwp_fd < 0)
- return PS_BADLID;
-
- /* Fetch registers und LDT descriptors. */
- if (ioctl (lwp_fd, PIOCGREG, &gregset) == -1)
- return PS_ERR;
+ /* FIXME: can't I get the process ID from the prochandle or
+ something? */
- if (ioctl (lwp_fd, PIOCNLDT, &nldt) == -1)
- return PS_ERR;
+ if (inferior_ptid.pid () <= 0 || lwpid <= 0)
+ return PS_BADLID;
- if (nldt_allocated < nldt)
+ ret = procfs_find_LDT_entry (ptid_t (inferior_ptid.pid (),
+ lwpid, 0));
+ if (ret)
{
- ldt_bufp
- = (struct ssd *) xrealloc (ldt_bufp, (nldt + 1) * sizeof (struct ssd));
- nldt_allocated = nldt;
+ memcpy (pldt, ret, sizeof (struct ssd));
+ return PS_OK;
}
-
- if (ioctl (lwp_fd, PIOCLDT, ldt_bufp) == -1)
+ else
+ /* LDT not found. */
return PS_ERR;
-
- /* Search LDT for the LWP via register GS. */
- for (i = 0; i < nldt; i++)
- {
- if (ldt_bufp[i].sel == (gregset[GS] & 0xffff))
- {
- *pldt = ldt_bufp[i];
- return PS_OK;
- }
- }
-
- /* LDT not found. */
- return PS_ERR;
}
-#endif /* TM_I386SOL2_H */
+#endif
\f
-/* Convert a pid to printable form. */
-char *
-solaris_pid_to_str (pid)
- int pid;
-{
- static char buf[100];
-
- /* in case init failed to resolve the libthread_db library */
- if (!procfs_suppress_run)
- return procfs_pid_to_str (pid);
+/* Convert PTID to printable form. */
- if (is_thread (pid))
+std::string
+sol_thread_target::pid_to_str (ptid_t ptid)
+{
+ if (ptid.tid_p ())
{
- int lwp;
+ ptid_t lwp;
- lwp = thread_to_lwp (pid, -2);
+ lwp = thread_to_lwp (ptid, -2);
- if (lwp == -1)
- sprintf (buf, "Thread %d (defunct)", GET_THREAD (pid));
- else if (lwp != -2)
- sprintf (buf, "Thread %d (LWP %d)", GET_THREAD (pid), GET_LWP (lwp));
+ if (lwp.pid () == -1)
+ return string_printf ("Thread %ld (defunct)",
+ ptid.tid ());
+ else if (lwp.pid () != -2)
+ return string_printf ("Thread %ld (LWP %ld)",
+ ptid.tid (), lwp.lwp ());
else
- sprintf (buf, "Thread %d ", GET_THREAD (pid));
+ return string_printf ("Thread %ld ",
+ ptid.tid ());
}
- else if (GET_LWP (pid) != 0)
- sprintf (buf, "LWP %d ", GET_LWP (pid));
+ else if (ptid.lwp () != 0)
+ return string_printf ("LWP %ld ", ptid.lwp ());
else
- sprintf (buf, "process %d ", PIDGET (pid));
-
- return buf;
+ return string_printf ("process %d ", ptid.pid ());
}
\f
-/* Worker bee for find_new_threads
- Callback function that gets called once per USER thread (i.e., not
- kernel) thread. */
+/* Worker bee for update_thread_list. Callback function that gets
+ called once per user-level thread (i.e. not for LWP's). */
static int
-sol_find_new_threads_callback (th, ignored)
- const td_thrhandle_t *th;
- void *ignored;
+sol_update_thread_list_callback (const td_thrhandle_t *th, void *ignored)
{
td_err_e retval;
td_thrinfo_t ti;
- int pid;
- if ((retval = p_td_thr_get_info (th, &ti)) != TD_OK)
- {
- return -1;
- }
- pid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_pid));
- if (!in_thread_list (pid))
- add_thread (pid);
+ retval = p_td_thr_get_info (th, &ti);
+ if (retval != TD_OK)
+ return -1;
+
+ ptid_t ptid = ptid_t (inferior_ptid.pid (), 0, ti.ti_tid);
+ thread_info *thr = find_thread_ptid (ptid);
+ if (thr == NULL || thr->state == THREAD_EXITED)
+ add_thread (ptid);
return 0;
}
-static void
-sol_find_new_threads ()
+void
+sol_thread_target::update_thread_list ()
{
- /* don't do anything if init failed to resolve the libthread_db library */
- if (!procfs_suppress_run)
- return;
+ /* Delete dead threads. */
+ prune_threads ();
- if (inferior_pid == -1)
- {
- printf_filtered ("No process.\n");
- return;
- }
- p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
+ /* Find any new LWP's. */
+ 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,
TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
}
-static void
-sol_core_open (filename, from_tty)
- char *filename;
- int from_tty;
-{
- orig_core_ops.to_open (filename, from_tty);
-}
-
-static void
-sol_core_close (quitting)
- int quitting;
-{
- orig_core_ops.to_close (quitting);
-}
-
-static void
-sol_core_detach (args, from_tty)
- char *args;
- int from_tty;
-{
- unpush_target (&core_ops);
- orig_core_ops.to_detach (args, from_tty);
-}
-
-static void
-sol_core_files_info (t)
- struct target_ops *t;
-{
- orig_core_ops.to_files_info (t);
-}
-
-/* Worker bee for info sol-thread command. This is a callback function that
- gets called once for each Solaris thread (ie. not kernel thread) in the
- inferior. Print anything interesting that we can think of. */
+/* Worker bee for the "info sol-thread" command. This is a callback
+ function that gets called once for each Solaris user-level thread
+ (i.e. not for LWPs) in the inferior. Print anything interesting
+ that we can think of. */
static int
-info_cb (th, s)
- const td_thrhandle_t *th;
- void *s;
+info_cb (const td_thrhandle_t *th, void *s)
{
td_err_e ret;
td_thrinfo_t ti;
- if ((ret = p_td_thr_get_info (th, &ti)) == TD_OK)
+ ret = p_td_thr_get_info (th, &ti);
+ if (ret == TD_OK)
{
printf_filtered ("%s thread #%d, lwp %d, ",
ti.ti_type == TD_THR_SYSTEM ? "system" : "user ",
printf_filtered ("(stopped asleep)");
break;
}
- /* Print thr_create start function: */
+ /* Print thr_create start function. */
if (ti.ti_startfunc != 0)
{
- struct minimal_symbol *msym;
- msym = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
- if (msym)
- printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym));
- else
- printf_filtered (" startfunc: 0x%s\n", paddr (ti.ti_startfunc));
+ const struct bound_minimal_symbol msym
+ = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
+
+ printf_filtered (" startfunc=%s",
+ msym.minsym
+ ? msym.minsym->print_name ()
+ : paddress (target_gdbarch (), ti.ti_startfunc));
}
- /* If thread is asleep, print function that went to sleep: */
+ /* If thread is asleep, print function that went to sleep. */
if (ti.ti_state == TD_THR_SLEEP)
{
- struct minimal_symbol *msym;
- msym = lookup_minimal_symbol_by_pc (ti.ti_pc);
- if (msym)
- printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym));
- else
- printf_filtered (" - Sleep func: 0x%s\n", paddr (ti.ti_startfunc));
+ const struct bound_minimal_symbol msym
+ = lookup_minimal_symbol_by_pc (ti.ti_pc);
+
+ printf_filtered (" sleepfunc=%s",
+ msym.minsym
+ ? msym.minsym->print_name ()
+ : paddress (target_gdbarch (), ti.ti_pc));
}
- /* Wrap up line, if necessary */
- if (ti.ti_state != TD_THR_SLEEP && ti.ti_startfunc == 0)
- printf_filtered ("\n"); /* don't you hate counting newlines? */
+ printf_filtered ("\n");
}
else
- warning ("info sol-thread: failed to get info for thread.");
+ warning (_("info sol-thread: failed to get info for thread."));
return 0;
}
-/* List some state about each Solaris user thread in the inferior. */
+/* List some state about each Solaris user-level thread in the
+ inferior. */
static void
-info_solthreads (args, from_tty)
- 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);
}
+/* Callback routine used to find a thread based on the TID part of
+ its PTID. */
+
static int
-ignore (addr, contents)
- CORE_ADDR addr;
- char *contents;
+thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
{
+ long *tid = (long *) data;
+
+ if (thread->ptid.tid () == *tid)
+ return 1;
+
return 0;
}
-
-static void
-init_sol_thread_ops ()
+ptid_t
+sol_thread_target::get_ada_task_ptid (long lwp, long thread)
{
- 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_open = sol_thread_open;
- sol_thread_ops.to_close = 0;
- sol_thread_ops.to_attach = sol_thread_attach;
- 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_prepare_to_store = sol_thread_prepare_to_store;
- sol_thread_ops.to_xfer_memory = sol_thread_xfer_memory;
- sol_thread_ops.to_files_info = sol_thread_files_info;
- sol_thread_ops.to_insert_breakpoint = memory_insert_breakpoint;
- sol_thread_ops.to_remove_breakpoint = memory_remove_breakpoint;
- sol_thread_ops.to_terminal_init = terminal_init_inferior;
- sol_thread_ops.to_terminal_inferior = terminal_inferior;
- sol_thread_ops.to_terminal_ours_for_output = terminal_ours_for_output;
- sol_thread_ops.to_terminal_ours = terminal_ours;
- sol_thread_ops.to_terminal_info = child_terminal_info;
- sol_thread_ops.to_kill = sol_thread_kill_inferior;
- sol_thread_ops.to_load = 0;
- sol_thread_ops.to_lookup_symbol = 0;
- sol_thread_ops.to_create_inferior = sol_thread_create_inferior;
- sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
- sol_thread_ops.to_can_run = sol_thread_can_run;
- sol_thread_ops.to_notice_signals = sol_thread_notice_signals;
- sol_thread_ops.to_thread_alive = sol_thread_alive;
- sol_thread_ops.to_find_new_threads = sol_find_new_threads;
- sol_thread_ops.to_stop = sol_thread_stop;
- sol_thread_ops.to_stratum = process_stratum;
- sol_thread_ops.to_has_all_memory = 1;
- sol_thread_ops.to_has_memory = 1;
- sol_thread_ops.to_has_stack = 1;
- sol_thread_ops.to_has_registers = 1;
- sol_thread_ops.to_has_execution = 1;
- sol_thread_ops.to_has_thread_control = tc_none;
- sol_thread_ops.to_sections = 0;
- sol_thread_ops.to_sections_end = 0;
- sol_thread_ops.to_magic = OPS_MAGIC;
-}
+ struct thread_info *thread_info =
+ iterate_over_threads (thread_db_find_thread_from_tid, &thread);
+ if (thread_info == NULL)
+ {
+ /* The list of threads is probably not up to date. Find any
+ thread that is missing from the list, and try again. */
+ update_thread_list ();
+ thread_info = iterate_over_threads (thread_db_find_thread_from_tid,
+ &thread);
+ }
-static void
-init_sol_core_ops ()
-{
- sol_core_ops.to_shortname = "solaris-core";
- sol_core_ops.to_longname = "Solaris core threads and pthread.";
- sol_core_ops.to_doc = "Solaris threads and pthread support for core files.";
- sol_core_ops.to_open = sol_core_open;
- sol_core_ops.to_close = sol_core_close;
- sol_core_ops.to_attach = sol_thread_attach;
- sol_core_ops.to_detach = sol_core_detach;
- /* sol_core_ops.to_resume = 0; */
- /* sol_core_ops.to_wait = 0; */
- sol_core_ops.to_fetch_registers = sol_thread_fetch_registers;
- /* sol_core_ops.to_store_registers = 0; */
- /* sol_core_ops.to_prepare_to_store = 0; */
- sol_core_ops.to_xfer_memory = sol_thread_xfer_memory;
- sol_core_ops.to_files_info = sol_core_files_info;
- sol_core_ops.to_insert_breakpoint = ignore;
- sol_core_ops.to_remove_breakpoint = ignore;
- /* sol_core_ops.to_terminal_init = 0; */
- /* sol_core_ops.to_terminal_inferior = 0; */
- /* sol_core_ops.to_terminal_ours_for_output = 0; */
- /* sol_core_ops.to_terminal_ours = 0; */
- /* sol_core_ops.to_terminal_info = 0; */
- /* sol_core_ops.to_kill = 0; */
- /* sol_core_ops.to_load = 0; */
- /* sol_core_ops.to_lookup_symbol = 0; */
- sol_core_ops.to_create_inferior = sol_thread_create_inferior;
- sol_core_ops.to_stratum = core_stratum;
- sol_core_ops.to_has_all_memory = 0;
- sol_core_ops.to_has_memory = 1;
- sol_core_ops.to_has_stack = 1;
- sol_core_ops.to_has_registers = 1;
- sol_core_ops.to_has_execution = 0;
- sol_core_ops.to_has_thread_control = tc_none;
- sol_core_ops.to_sections = 0;
- sol_core_ops.to_sections_end = 0;
- sol_core_ops.to_magic = OPS_MAGIC;
-}
+ gdb_assert (thread_info != NULL);
-/* we suppress the call to add_target of core_ops in corelow because
- if there are two targets in the stratum core_stratum, find_core_target
- won't know which one to return. see corelow.c for an additonal
- comment on coreops_suppress_target. */
-int coreops_suppress_target = 1;
+ return (thread_info->ptid);
+}
void
-_initialize_sol_thread ()
+_initialize_sol_thread (void)
{
void *dlhandle;
- init_sol_thread_ops ();
- init_sol_core_ops ();
-
dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
if (!dlhandle)
goto die;
#define resolve(X) \
- if (!(p_##X = dlsym (dlhandle, #X))) \
+ if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
goto die;
resolve (td_log);
resolve (td_thr_getgregs);
resolve (td_thr_setgregs);
- add_target (&sol_thread_ops);
-
- procfs_suppress_run = 1;
-
add_cmd ("sol-threads", class_maintenance, info_solthreads,
- "Show info on Solaris user threads.\n", &maintenanceinfolist);
-
- memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops));
- memcpy (&core_ops, &sol_core_ops, sizeof (struct target_ops));
- add_target (&core_ops);
+ _("Show info on Solaris user threads."), &maintenanceinfolist);
- /* Hook into new_objfile notification. */
- target_new_objfile_chain = target_new_objfile_hook;
- target_new_objfile_hook = sol_thread_new_objfile;
+ /* Hook into new_objfile notification. */
+ gdb::observers::new_objfile.attach (sol_thread_new_objfile);
return;
-die:
-
- fprintf_unfiltered (gdb_stderr, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
+ die:
+ fprintf_unfiltered (gdb_stderr, "\
+[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
if (dlhandle)
dlclose (dlhandle);
- /* allow the user to debug non-threaded core files */
- add_target (&core_ops);
-
return;
}
projects / deliverable / binutils-gdb.git / blobdiff