-/* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
- Copyright 1996 Free Software Foundation, Inc.
+/* Solaris threads debugging interface.
-This file is part of GDB.
+ Copyright (C) 1996-2019 Free Software Foundation, Inc.
-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
-(at your option) any later version.
+ This file is part of GDB.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ 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 3 of the License, or
+ (at your option) any later version.
-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. */
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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, 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 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
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"
-
-/* Undefine gregset_t and fpregset_t to avoid conflict with defs in xm file. */
-
-#ifdef gregset_t
-#undef gregset_t
-#endif
-
-#ifdef fpregset_t
-#undef fpregset_t
-#endif
-
#include <thread.h>
#include <proc_service.h>
#include <thread_db.h>
#include "target.h"
#include "inferior.h"
#include <fcntl.h>
-#include <unistd.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.")
+};
-extern struct target_ops sol_thread_ops; /* Forward declaration */
-
-extern int procfs_suppress_run;
-extern struct target_ops procfs_ops; /* target vector for procfs.c */
+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; }
+
+ 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;
+
+ 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;
+};
-/* 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;
+ 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 ((int 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));
-
-#define THREAD_FLAG 0x80000000
-#define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
-#define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
-#define GET_LWP(LWP_ID) (TIDGET(LWP_ID))
-#define GET_THREAD(THREAD_ID) (((THREAD_ID) >> 16) & 0x7fff)
-#define BUILD_LWP(LWP_ID, PID) ((LWP_ID) << 16 | (PID))
-#define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
+/* 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)
-DESCRIPTION
+/* Return the libthread_db error string associated with ERRCODE. If
+ ERRCODE is unknown, return an appropriate message. */
- 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[] = {
- {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"}
- };
+ 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 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;
static char buf[50];
for (i = 0; i < td_err_size; 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
+/* Return the libthread_db state string assicoated with STATECODE.
+ If STATECODE is unknown, return an appropriate message. */
-SYNOPSIS
-
- char * td_state_string (statecode)
-
-DESCRIPTION
-
- Return the thread_db state string associated with statecode. If
- statecode is unknown, then return a 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[] = {
- {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);
+ 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" }
+ };
+ const int td_thr_state_table_size =
+ sizeof td_thr_state_table / sizeof (struct string_map);
int i;
static char buf[50];
for (i = 0; i < td_thr_state_table_size; i++)
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
-
- thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
-
-SYNOPSIS
-
- int thread_to_lwp (thread_id, default_lwp)
-DESCRIPTION
+/* 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.
- 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.
+ NOTE: This function probably shouldn't call error(). */
-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;
- int pid;
- int lwp;
-
- if (is_lwp (thread_id))
- return thread_id; /* It's already an LWP id */
- /* It's a thread. Convert to lwp */
+ if (thread_id.lwp_p ())
+ return thread_id; /* It's already an LWP ID. */
- pid = PIDGET (thread_id);
- thread_id = GET_THREAD(thread_id);
+ /* It's a thread. Convert to LWP. */
- val = td_ta_map_id2thr (main_ta, thread_id, &th);
- if (val != TD_OK)
- error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val));
-
- val = td_thr_get_info (&th, &ti);
+ val = p_td_ta_map_id2thr (main_ta, thread_id.tid (), &th);
+ if (val == TD_NOTHR)
+ 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));
- if (val != TD_OK)
- error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val));
+ val = p_td_thr_get_info (&th, &ti);
+ if (val == TD_NOTHR)
+ 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));
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));
}
-
- lwp = BUILD_LWP (ti.ti_lid, pid);
- return lwp;
+ return ptid_t (thread_id.pid (), ti.ti_lid, 0);
}
-\f
-/*
-
-LOCAL FUNCTION
-
- lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
-
-SYNOPSIS
- int lwp_to_thread (lwp_id)
+/* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
+ doesn't exists, that's an error.
-DESCRIPTION
+ NOTE: This function probably shouldn't call error(). */
- 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;
- int pid;
- int thread_id;
- 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. */
-
- pid = PIDGET (lwp);
- lwp = GET_LWP (lwp);
-
- val = td_ta_map_lwp2thr (main_ta, lwp, &th);
- if (val != TD_OK)
- error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val));
-
- val = td_thr_get_info (&th, &ti);
-
- if (val != TD_OK)
- error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val));
-
- thread_id = BUILD_THREAD (ti.ti_tid, pid);
-
- return thread_id;
-}
-\f
-/*
+ /* It's an LWP. Convert it to a thread ID. */
-LOCAL FUNCTION
+ if (!target_thread_alive (lwp))
+ return ptid_t (-1); /* Must be a defunct LPW. */
- 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.
-
- */
+ val = p_td_ta_map_lwp2thr (main_ta, lwp.lwp (), &th);
+ if (val == TD_NOTHR)
+ 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));
+ val = p_td_thr_validate (&th);
+ if (val == TD_NOTHR)
+ 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));
-static struct cleanup *
-save_inferior_pid ()
-{
- return make_cleanup (restore_inferior_pid, inferior_pid);
-}
+ val = p_td_thr_get_info (&th, &ti);
+ if (val == TD_NOTHR)
+ 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));
-static void
-restore_inferior_pid (pid)
- int pid;
-{
- inferior_pid = 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. */
-
-
-/* ARGSUSED */
-static void
-sol_thread_open (arg, from_tty)
- char *arg;
- int from_tty;
-{
- procfs_ops.to_open (arg, from_tty);
-}
+/* 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. */
-/* Attach to process PID, then initialize for debugging it
- and wait for the trace-trap that results from attaching. */
+/* 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). */
-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);
-
- /* 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;
-{
- 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 nozero, 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);
+ 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)
{
- pid = thread_to_lwp (pid, -2);
- if (pid == -2) /* Inactive thread */
- error ("This version of Solaris can't start inactive threads.");
+ 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;
-
- save_pid = inferior_pid;
- old_chain = save_inferior_pid ();
+ ptid_t rtnval;
+ ptid_t save_ptid;
- inferior_pid = thread_to_lwp (inferior_pid, main_ph.pid);
+ save_ptid = inferior_ptid;
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- if (pid != -1)
- pid = thread_to_lwp (pid, -1);
+ inferior_ptid = thread_to_lwp (inferior_ptid, main_ph.ptid.pid ());
+ if (inferior_ptid.pid () == -1)
+ inferior_ptid = procfs_first_available ();
- rtnval = procfs_ops.to_wait (pid, ourstatus);
-
- if (rtnval != save_pid
- && !in_thread_list (rtnval))
+ if (ptid.pid () != -1)
{
- fprintf_unfiltered (gdb_stderr, "[New %s]\n",
- target_pid_to_str (rtnval));
- add_thread (rtnval);
+ 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 ());
}
- /* 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. */
+ rtnval = beneath ()->wait (ptid, ourstatus, options);
- /* Map the LWP of interest back to the appropriate thread ID */
+ if (ourstatus->kind != TARGET_WAITKIND_EXITED)
+ {
+ /* Map the LWP of interest back to the appropriate thread ID. */
+ rtnval = lwp_to_thread (rtnval);
+ if (rtnval.pid () == -1)
+ rtnval = save_ptid;
- rtnval = lwp_to_thread (rtnval);
+ /* See if we have a new thread. */
+ if (rtnval.tid_p () && rtnval != save_ptid)
+ {
+ thread_info *thr = find_thread_ptid (rtnval);
+ if (thr == NULL || thr->state == THREAD_EXITED)
+ add_thread (rtnval);
+ }
+ }
- 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
-
- /* Convert inferior_pid into a td_thrhandle_t */
+ gdb_gregset_t *gregset_p = &gregset;
+ gdb_fpregset_t *fpregset_p = &fpregset;
+ ptid_t ptid = regcache->ptid ();
- thread = GET_THREAD (inferior_pid);
+ 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 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 = td_ta_map_id2thr (main_ta, thread, &thandle);
+ 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 = td_thr_getgregs (&thandle, gregset);
- if (val != TD_OK
- && val != TD_PARTIALREG)
- error ("sol_thread_fetch_registers: td_thr_getgregs %s",
+ val = p_td_thr_getgregs (&thandle, gregset);
+ 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 = td_thr_getfpregs (&thandle, &fpregset);
- if (val != TD_OK
- && val != TD_NOFPREGS)
- error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
+ val = p_td_thr_getfpregs (&thandle, &fpregset);
+ 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. */
+ /* 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. */
- 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));
-
- 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 ();
- /* Convert inferior_pid into a td_thrhandle_t */
+ if (!ptid.tid_p ())
+ {
+ /* It's an LWP; pass the request on to the layer beneath. */
+ beneath ()->store_registers (regcache, regnum);
+ return;
+ }
- thread = GET_THREAD (inferior_pid);
+ /* Solaris thread: convert PTID into a td_thrhandle_t. */
+ thread = ptid.tid ();
- val = td_ta_map_id2thr (main_ta, thread, &thandle);
+ 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 */
- val = 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 = td_thr_getfpregs (&thandle, &fpregset);
+ 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));
-
-#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 = 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 = td_thr_setfpregs (&thandle, &fpregset);
+ val = p_td_thr_setfpregs (&thandle, &fpregset);
if (val != TD_OK)
- 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",
+ error (_("sol_thread_store_registers: td_thr_setfpregs %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. */
-
-static void
-sol_thread_prepare_to_store ()
-{
- procfs_ops.to_prepare_to_store ();
-}
+/* 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 int
-sol_thread_xfer_memory (memaddr, myaddr, len, dowrite, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int dowrite;
- struct target_ops *target; /* ignored */
+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)
{
- int retval;
- struct cleanup *old_chain;
-
- old_chain = save_inferior_pid ();
-
- if (is_thread (inferior_pid))
- inferior_pid = main_ph.pid; /* It's a thread. Convert to lwp */
-
- retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len, dowrite, target);
+ scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- do_cleanups (old_chain);
-
- return retval;
-}
+ 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.
-/* Print status information about what we're accessing. */
+ NOTE: We don't need to call switch_to_thread; we're just
+ reading memory. */
+ inferior_ptid = procfs_first_available ();
+ }
-static void
-sol_thread_files_info (ignore)
- struct target_ops *ignore;
-{
- procfs_ops.to_files_info (ignore);
+ return beneath ()->xfer_partial (object, annex, readbuf,
+ writebuf, offset, len, xfered_len);
}
static void
-sol_thread_kill_inferior ()
+check_for_thread_db (void)
{
- procfs_ops.to_kill ();
-}
+ td_err_e err;
+ ptid_t ptid;
-static void
-sol_thread_notice_signals (pid)
- int pid;
-{
- procfs_ops.to_notice_signals (pid);
-}
-
-void target_new_objfile PARAMS ((struct objfile *objfile));
-
-/* Fork an inferior process, and start debugging it with /proc. */
+ /* Don't attempt to use thread_db for remote targets. */
+ if (!(target_can_run () || core_bfd))
+ 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);
+ /* Do nothing if we couldn't load libthread_db.so.1. */
+ if (p_td_ta_new == NULL)
+ return;
if (sol_thread_active)
- {
- main_ph.pid = inferior_pid; /* Save for xfer_memory */
-
- push_target (&sol_thread_ops);
+ /* Nothing to do. The thread library was already detected and the
+ target vector was already activated. */
+ return;
- inferior_pid = lwp_to_thread (inferior_pid);
+ /* 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. */
- add_thread (inferior_pid);
+ err = p_td_init ();
+ if (err != TD_OK)
+ {
+ 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. */
-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;
+ case TD_NOLIBTHREAD:
+ /* No thread library was detected. */
+ break;
- return;
- }
+ 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 = td_init ();
- if (val != TD_OK)
- error ("target_new_objfile: td_init: %s", td_err_string (val));
+ main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */
+ ptid = lwp_to_thread (inferior_ptid);
+ if (ptid.pid () != -1)
+ inferior_ptid = ptid;
- val = td_ta_new (&main_ph, &main_ta);
- if (val == TD_NOLIBTHREAD)
- return;
- else if (val != TD_OK)
- error ("target_new_objfile: td_ta_new: %s", td_err_string (val));
+ target_update_thread_list ();
+ break;
- sol_thread_active = 1;
+ 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)
{
- 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 ();
-static int
-sol_thread_alive (pid)
- int pid;
-{
- return 1;
+ sol_thread_active = 0;
+
+ unpush_target (this);
+
+ beneath->mourn_inferior ();
}
-static void
-sol_thread_stop ()
+/* Return true if PTID is still active in the inferior. */
+
+bool
+sol_thread_target::thread_alive (ptid_t ptid)
{
- procfs_ops.to_stop ();
+ if (ptid.tid_p ())
+ {
+ /* It's a (user-level) thread. */
+ td_err_e val;
+ td_thrhandle_t th;
+ int pid;
+
+ 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
+ {
+ /* It's an LPW; pass the request on to the layer below. */
+ return beneath ()->thread_alive (ptid);
+ }
}
+
\f
-/* These routines implement the lower half of the thread_db interface. Ie: the
- ps_* routines. */
+/* 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. */
ps_err_e
-ps_pstop (const struct ps_prochandle *ph)
+ps_pstop (struct ps_prochandle *ph)
{
return PS_OK;
}
+/* Process continue. */
+
ps_err_e
-ps_pcontinue (const struct ps_prochandle *ph)
+ps_pcontinue (struct ps_prochandle *ph)
{
return PS_OK;
}
+/* LWP stop. */
+
ps_err_e
-ps_lstop (const struct ps_prochandle *ph, lwpid_t lwpid)
+ps_lstop (struct ps_prochandle *ph, lwpid_t lwpid)
{
return PS_OK;
}
+/* LWP continue. */
+
ps_err_e
-ps_lcontinue (const struct ps_prochandle *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 (const struct ps_prochandle *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))
- inferior_pid = main_ph.pid; /* It's a thread. Convert to lwp */
+ 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;
+ /* It's either a thread or an LWP that isn't alive. Any live
+ LWP will do so use the first available.
- cc = procfs_ops.to_xfer_memory (addr, buf, size, dowrite, &procfs_ops);
-
- if (cc < 0)
- {
- if (dowrite == 0)
- print_sys_errmsg ("ps_pdread (): read", errno);
- else
- print_sys_errmsg ("ps_pdread (): 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
- return PS_OK;
+ if (dowrite)
+ ret = target_write_memory (addr, (gdb_byte *) buf, size);
+ else
+ ret = target_read_memory (addr, (gdb_byte *) buf, size);
+
+ return (ret == 0 ? PS_OK : PS_ERR);
}
+/* Copies SIZE bytes from target process .data segment to debugger memory. */
+
ps_err_e
-ps_pdread (const struct ps_prochandle *ph, paddr_t addr, char *buf, int 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 (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
+ps_pdwrite (struct ps_prochandle *ph, psaddr_t addr,
+ const void *buf, size_t size)
{
- return rw_common (1, ph, addr, 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 (const struct ps_prochandle *ph, paddr_t addr, char *buf, int 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 (const struct ps_prochandle *ph, paddr_t addr, char *buf, int size)
+ps_ptwrite (struct ps_prochandle *ph, psaddr_t addr,
+ const void *buf, size_t size)
{
- return rw_common (1, ph, addr, buf, size);
+ return rw_common (1, ph, addr, (gdb_byte *) buf, size);
}
-/* Get integer regs */
+/* Get general-purpose registers for LWP. */
ps_err_e
-ps_lgetregs (const struct ps_prochandle *ph, lwpid_t lwpid,
- prgregset_t gregset)
+ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid, prgregset_t gregset)
{
- struct cleanup *old_chain;
-
- old_chain = save_inferior_pid ();
-
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
-
- procfs_ops.to_fetch_registers (-1);
- fill_gregset (gregset, -1);
+ ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
- do_cleanups (old_chain);
+ target_fetch_registers (regcache, -1);
+ fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
return PS_OK;
}
-/* Set integer regs */
+/* Set general-purpose registers for LWP. */
ps_err_e
-ps_lsetregs (const struct ps_prochandle *ph, lwpid_t lwpid,
+ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid,
const 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));
-
- supply_gregset (gregset);
- procfs_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, ...)
{
/* Get size of extra register set. Currently a noop. */
ps_err_e
-ps_lgetxregsize (const struct ps_prochandle *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;
+ return PS_OK;
+}
- val = get_lwp_fd (ph, lwpid, &lwp_fd);
- if (val != PS_OK)
- return val;
+/* Get extra register set. Currently a noop. */
- 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 */
+ps_err_e
+ps_lgetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
+{
+ return PS_OK;
+}
- print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno);
- return PS_ERR;
- }
-#endif
+/* Set extra register set. Currently a noop. */
+ps_err_e
+ps_lsetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
+{
return PS_OK;
}
-/* Get extra register set. Currently a noop. */
+/* Get floating-point registers for LWP. */
ps_err_e
-ps_lgetxregs (const struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
+ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
+ prfpregset_t *fpregset)
{
-#if 0
- int lwp_fd;
- ps_err_e val;
-
- val = get_lwp_fd (ph, lwpid, &lwp_fd);
- if (val != PS_OK)
- return val;
+ ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
- if (ioctl (lwp_fd, PIOCGXREG, xregset))
- {
- print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno);
- return PS_ERR;
- }
-#endif
+ target_fetch_registers (regcache, -1);
+ fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
return PS_OK;
}
-/* Set extra register set. Currently a noop. */
+/* Set floating-point regs for LWP. */
ps_err_e
-ps_lsetxregs (const struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
+ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
+ const prfpregset_t * fpregset)
{
-#if 0
- int lwp_fd;
- ps_err_e val;
+ ptid_t ptid = ptid_t (inferior_ptid.pid (), lwpid, 0);
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch ());
- val = get_lwp_fd (ph, lwpid, &lwp_fd);
- if (val != PS_OK)
- return val;
+ supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
+ target_store_registers (regcache, -1);
- if (ioctl (lwp_fd, PIOCSXREG, xregset))
- {
- print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno);
- return PS_ERR;
- }
-#endif
+ return PS_OK;
+}
+
+/* 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. */
+
+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;
}
-/* Get floating-point regs. */
+#if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
+
+/* 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_lgetfpregs (const struct ps_prochandle *ph, lwpid_t lwpid,
- prfpregset_t *fpregset)
+ps_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid, struct ssd *pldt) /* ARI: editCase function */
{
- struct cleanup *old_chain;
+ /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
+ struct ssd *ret;
- old_chain = save_inferior_pid ();
+ /* FIXME: can't I get the process ID from the prochandle or
+ something? */
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+ if (inferior_ptid.pid () <= 0 || lwpid <= 0)
+ return PS_BADLID;
- procfs_ops.to_fetch_registers (-1);
- fill_fpregset (*fpregset, -1);
+ ret = procfs_find_LDT_entry (ptid_t (inferior_ptid.pid (),
+ lwpid, 0));
+ if (ret)
+ {
+ memcpy (pldt, ret, sizeof (struct ssd));
+ return PS_OK;
+ }
+ else
+ /* LDT not found. */
+ return PS_ERR;
+}
+#endif
+\f
- do_cleanups (old_chain);
+/* Convert PTID to printable form. */
- return PS_OK;
+std::string
+sol_thread_target::pid_to_str (ptid_t ptid)
+{
+ if (ptid.tid_p ())
+ {
+ ptid_t lwp;
+
+ lwp = thread_to_lwp (ptid, -2);
+
+ 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
+ return string_printf ("Thread %ld ",
+ ptid.tid ());
+ }
+ else if (ptid.lwp () != 0)
+ return string_printf ("LWP %ld ", ptid.lwp ());
+ else
+ return string_printf ("process %d ", ptid.pid ());
}
+\f
-/* Set floating-point regs. */
+/* Worker bee for update_thread_list. Callback function that gets
+ called once per user-level thread (i.e. not for LWP's). */
-ps_err_e
-ps_lsetfpregs (const struct ps_prochandle *ph, lwpid_t lwpid,
- const prfpregset_t *fpregset)
+static int
+sol_update_thread_list_callback (const td_thrhandle_t *th, void *ignored)
{
- struct cleanup *old_chain;
+ td_err_e retval;
+ td_thrinfo_t ti;
- old_chain = save_inferior_pid ();
+ retval = p_td_thr_get_info (th, &ti);
+ if (retval != TD_OK)
+ return -1;
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
-
- supply_fpregset (*fpregset);
- procfs_ops.to_store_registers (-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);
- do_cleanups (old_chain);
+ return 0;
+}
- return PS_OK;
+void
+sol_thread_target::update_thread_list ()
+{
+ /* Delete dead threads. */
+ prune_threads ();
+
+ /* 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);
}
-\f
-/* Convert a pid to printable form. */
-char *
-solaris_pid_to_str (pid)
- int pid;
+/* 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 (const td_thrhandle_t *th, void *s)
{
- static char buf[100];
+ td_err_e ret;
+ td_thrinfo_t ti;
- if (is_thread (pid))
+ ret = p_td_thr_get_info (th, &ti);
+ if (ret == TD_OK)
{
- int lwp;
+ printf_filtered ("%s thread #%d, lwp %d, ",
+ ti.ti_type == TD_THR_SYSTEM ? "system" : "user ",
+ ti.ti_tid, ti.ti_lid);
+ switch (ti.ti_state)
+ {
+ default:
+ case TD_THR_UNKNOWN:
+ printf_filtered ("<unknown state>");
+ break;
+ case TD_THR_STOPPED:
+ printf_filtered ("(stopped)");
+ break;
+ case TD_THR_RUN:
+ printf_filtered ("(run) ");
+ break;
+ case TD_THR_ACTIVE:
+ printf_filtered ("(active) ");
+ break;
+ case TD_THR_ZOMBIE:
+ printf_filtered ("(zombie) ");
+ break;
+ case TD_THR_SLEEP:
+ printf_filtered ("(asleep) ");
+ break;
+ case TD_THR_STOPPED_ASLEEP:
+ printf_filtered ("(stopped asleep)");
+ break;
+ }
+ /* Print thr_create start function. */
+ if (ti.ti_startfunc != 0)
+ {
+ const struct bound_minimal_symbol msym
+ = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
+
+ printf_filtered (" startfunc=%s",
+ msym.minsym
+ ? MSYMBOL_PRINT_NAME (msym.minsym)
+ : paddress (target_gdbarch (), ti.ti_startfunc));
+ }
- lwp = thread_to_lwp (pid, -2);
+ /* If thread is asleep, print function that went to sleep. */
+ if (ti.ti_state == TD_THR_SLEEP)
+ {
+ const struct bound_minimal_symbol msym
+ = lookup_minimal_symbol_by_pc (ti.ti_pc);
- if (lwp != -2)
- sprintf (buf, "Thread %d (LWP %d)", GET_THREAD (pid), GET_LWP (lwp));
- else
- sprintf (buf, "Thread %d ", GET_THREAD (pid));
+ printf_filtered (" sleepfunc=%s",
+ msym.minsym
+ ? MSYMBOL_PRINT_NAME (msym.minsym)
+ : paddress (target_gdbarch (), ti.ti_pc));
+ }
+
+ printf_filtered ("\n");
}
else
- sprintf (buf, "LWP %d ", GET_LWP (pid));
+ warning (_("info sol-thread: failed to get info for thread."));
- return buf;
+ return 0;
}
-\f
-struct target_ops sol_thread_ops = {
- "solaris-threads", /* to_shortname */
- "Solaris threads and pthread.", /* to_longname */
- "Solaris threads and pthread support.", /* to_doc */
- sol_thread_open, /* to_open */
- 0, /* to_close */
- sol_thread_attach, /* to_attach */
- sol_thread_detach, /* to_detach */
- sol_thread_resume, /* to_resume */
- sol_thread_wait, /* to_wait */
- sol_thread_fetch_registers, /* to_fetch_registers */
- sol_thread_store_registers, /* to_store_registers */
- sol_thread_prepare_to_store, /* to_prepare_to_store */
- sol_thread_xfer_memory, /* to_xfer_memory */
- sol_thread_files_info, /* to_files_info */
- memory_insert_breakpoint, /* to_insert_breakpoint */
- memory_remove_breakpoint, /* to_remove_breakpoint */
- terminal_init_inferior, /* to_terminal_init */
- terminal_inferior, /* to_terminal_inferior */
- terminal_ours_for_output, /* to_terminal_ours_for_output */
- terminal_ours, /* to_terminal_ours */
- child_terminal_info, /* to_terminal_info */
- sol_thread_kill_inferior, /* to_kill */
- 0, /* to_load */
- 0, /* to_lookup_symbol */
- sol_thread_create_inferior, /* to_create_inferior */
- sol_thread_mourn_inferior, /* to_mourn_inferior */
- sol_thread_can_run, /* to_can_run */
- sol_thread_notice_signals, /* to_notice_signals */
- sol_thread_alive, /* to_thread_alive */
- sol_thread_stop, /* to_stop */
- process_stratum, /* to_stratum */
- 0, /* to_next */
- 1, /* to_has_all_memory */
- 1, /* to_has_memory */
- 1, /* to_has_stack */
- 1, /* to_has_registers */
- 1, /* to_has_execution */
- 0, /* sections */
- 0, /* sections_end */
- OPS_MAGIC /* to_magic */
-};
-void
-_initialize_sol_thread ()
+/* List some state about each Solaris user-level thread in the
+ inferior. */
+
+static void
+info_solthreads (const char *args, int from_tty)
+{
+ 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
+thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
{
- add_target (&sol_thread_ops);
+ long *tid = (long *) data;
+
+ if (thread->ptid.tid () == *tid)
+ return 1;
- procfs_suppress_run = 1;
+ return 0;
+}
+
+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);
+
+ 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);
+ }
+
+ gdb_assert (thread_info != NULL);
+
+ return (thread_info->ptid);
+}
+
+void
+_initialize_sol_thread (void)
+{
+ void *dlhandle;
+
+ dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
+ if (!dlhandle)
+ goto die;
+
+#define resolve(X) \
+ if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
+ goto die;
+
+ resolve (td_log);
+ resolve (td_ta_new);
+ resolve (td_ta_delete);
+ resolve (td_init);
+ resolve (td_ta_get_ph);
+ resolve (td_ta_get_nthreads);
+ resolve (td_ta_tsd_iter);
+ resolve (td_ta_thr_iter);
+ resolve (td_thr_validate);
+ resolve (td_thr_tsd);
+ resolve (td_thr_get_info);
+ resolve (td_thr_getfpregs);
+ resolve (td_thr_getxregsize);
+ resolve (td_thr_getxregs);
+ resolve (td_thr_sigsetmask);
+ resolve (td_thr_setprio);
+ resolve (td_thr_setsigpending);
+ resolve (td_thr_setfpregs);
+ resolve (td_thr_setxregs);
+ resolve (td_ta_map_id2thr);
+ resolve (td_ta_map_lwp2thr);
+ resolve (td_thr_getgregs);
+ resolve (td_thr_setgregs);
+
+ add_cmd ("sol-threads", class_maintenance, info_solthreads,
+ _("Show info on Solaris user threads."), &maintenanceinfolist);
+
+ /* 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 ());
+
+ if (dlhandle)
+ dlclose (dlhandle);
+
+ return;
}
projects / deliverable / binutils-gdb.git / blobdiff