/* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
- Copyright 1996, 1997, 1998 Free Software Foundation, Inc.
+ Copyright 1996, 1997, 1998, 1999, 2000, 2001
+ Free Software Foundation, Inc.
This file is part of GDB.
#include <sys/stat.h>
#include <dlfcn.h>
#include "gdbcmd.h"
+#include "gdbcore.h"
+#include "regcache.h"
extern struct target_ops sol_thread_ops; /* Forward declaration */
extern struct target_ops sol_core_ops; /* Forward declaration */
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));
-
-/* 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. */
-
-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));
+extern char *procfs_pid_to_str (ptid_t ptid);
+
+/* 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
struct ps_prochandle
{
- pid_t pid;
+ ptid_t ptid;
};
struct string_map
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 char *td_err_string (td_err_e errcode);
+static char *td_state_string (td_thr_state_e statecode);
+static ptid_t thread_to_lwp (ptid_t thread_id, int default_lwp);
+static void sol_thread_resume (ptid_t ptid, int step, enum target_signal signo);
+static ptid_t lwp_to_thread (ptid_t lwp);
+static int sol_thread_alive (ptid_t ptid);
+static void sol_core_close (int quitting);
-static void init_sol_thread_ops PARAMS ((void));
-static void init_sol_core_ops PARAMS ((void));
+static void init_sol_thread_ops (void);
+static void init_sol_core_ops (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 GET_PID(ptid) ptid_get_pid (ptid)
+#define GET_LWP(ptid) ptid_get_lwp (ptid)
+#define GET_THREAD(ptid) ptid_get_tid (ptid)
+
+#define is_lwp(ptid) (GET_LWP (ptid) != 0)
+#define is_thread(ptid) (GET_THREAD (ptid) != 0)
-#define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
+#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
+#define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
/* 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);
-\f
+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);
+
/*
LOCAL FUNCTION
*/
static char *
-td_err_string (errcode)
- td_err_e errcode;
+td_err_string (td_err_e errcode)
{
static struct string_map
td_err_table[] =
{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_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);
*/
static char *
-td_state_string (statecode)
- td_thr_state_e statecode;
+td_state_string (td_thr_state_e statecode)
{
static struct string_map
td_thr_state_table[] =
SYNOPSIS
- int thread_to_lwp (thread_id, default_lwp)
+ tpid_t thread_to_lwp (thread_id, default_lwp)
DESCRIPTION
*/
-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;
val = p_td_ta_map_id2thr (main_ta, GET_THREAD (thread_id), &th);
if (val == TD_NOTHR)
- return -1; /* thread must have terminated */
+ return pid_to_ptid (-1); /* thread must have terminated */
else if (val != TD_OK)
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 pid_to_ptid (-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;
+ return pid_to_ptid (default_lwp);
error ("thread_to_lwp: thread state not active: %s",
td_state_string (ti.ti_state));
}
*/
-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;
/* It's an lwp. Convert it to a thread id. */
if (!sol_thread_alive (lwp))
- return -1; /* defunct lwp */
+ return pid_to_ptid (-1); /* defunct lwp */
val = p_td_ta_map_lwp2thr (main_ta, GET_LWP (lwp), &th);
if (val == TD_NOTHR)
- return -1; /* thread must have terminated */
+ return pid_to_ptid (-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; /* libthread doesn't know about it, just return lwp */
+ return lwp; /* libthread doesn't know about it;
+ just return lwp */
else if (val != TD_OK)
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 pid_to_ptid (-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.
-
- */
-
-
-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;
-}
-\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;
+sol_thread_open (char *arg, int from_tty)
{
procfs_ops.to_open (arg, from_tty);
}
and wait for the trace-trap that results from attaching. */
static void
-sol_thread_attach (args, from_tty)
- char *args;
- int from_tty;
+sol_thread_attach (char *args, 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 */
+ main_ph.ptid = inferior_ptid; /* 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;
+ inferior_ptid = lwp_to_thread (inferior_ptid);
+ if (PIDGET (inferior_ptid) == -1)
+ inferior_ptid = main_ph.ptid;
else
- add_thread (inferior_pid);
+ add_thread (inferior_ptid);
}
/* XXX - might want to iterate over all the threads and register them. */
}
started via the normal ptrace (PTRACE_TRACEME). */
static void
-sol_thread_detach (args, from_tty)
- char *args;
- int from_tty;
+sol_thread_detach (char *args, int from_tty)
{
- inferior_pid = PIDGET (main_ph.pid);
+ inferior_ptid = pid_to_ptid (PIDGET (main_ph.ptid));
unpush_target (&sol_thread_ops);
procfs_ops.to_detach (args, from_tty);
}
for procfs. */
static void
-sol_thread_resume (pid, step, signo)
- int pid;
- int step;
- enum target_signal signo;
+sol_thread_resume (ptid_t ptid, int step, enum target_signal signo)
{
struct cleanup *old_chain;
- old_chain = save_inferior_pid ();
+ old_chain = save_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, PIDGET (main_ph.ptid));
+ if (PIDGET (inferior_ptid) == -1)
+ inferior_ptid = procfs_first_available ();
- if (pid != -1)
+ if (PIDGET (ptid) != -1)
{
- int save_pid = pid;
+ ptid_t save_ptid = ptid;
- pid = thread_to_lwp (pid, -2);
- if (pid == -2) /* Inactive thread */
+ ptid = thread_to_lwp (ptid, -2);
+ if (PIDGET (ptid) == -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));
+ if (info_verbose && PIDGET (ptid) == -1)
+ warning ("Specified thread %ld seems to have terminated",
+ GET_THREAD (save_ptid));
}
- procfs_ops.to_resume (pid, step, signo);
+ procfs_ops.to_resume (ptid, step, signo);
do_cleanups (old_chain);
}
/* 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. */
-static int
-sol_thread_wait (pid, ourstatus)
- int pid;
- struct target_waitstatus *ourstatus;
+static ptid_t
+sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
{
- int rtnval;
- int save_pid;
+ ptid_t rtnval;
+ ptid_t save_ptid;
struct cleanup *old_chain;
- save_pid = inferior_pid;
- old_chain = save_inferior_pid ();
+ save_ptid = inferior_ptid;
+ old_chain = save_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, PIDGET (main_ph.ptid));
+ if (PIDGET (inferior_ptid) == -1)
+ inferior_ptid = procfs_first_available ();
- if (pid != -1)
+ if (PIDGET (ptid) != -1)
{
- int save_pid = pid;
+ ptid_t save_ptid = ptid;
- pid = thread_to_lwp (pid, -2);
- if (pid == -2) /* Inactive thread */
+ ptid = thread_to_lwp (ptid, -2);
+ if (PIDGET (ptid) == -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));
+ if (info_verbose && PIDGET (ptid) == -1)
+ warning ("Specified thread %ld seems to have terminated",
+ GET_THREAD (save_ptid));
}
- rtnval = procfs_ops.to_wait (pid, ourstatus);
+ rtnval = procfs_ops.to_wait (ptid, ourstatus);
if (ourstatus->kind != TARGET_WAITKIND_EXITED)
{
/* Map the LWP of interest back to the appropriate thread ID */
rtnval = lwp_to_thread (rtnval);
- if (rtnval == -1)
- rtnval = save_pid;
+ if (PIDGET (rtnval) == -1)
+ rtnval = save_ptid;
/* See if we have a new thread */
if (is_thread (rtnval)
- && rtnval != save_pid
+ && !ptid_equal (rtnval, save_ptid)
&& !in_thread_list (rtnval))
{
printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));
}
static void
-sol_thread_fetch_registers (regno)
- int regno;
+sol_thread_fetch_registers (int regno)
{
thread_t thread;
td_thrhandle_t thandle;
caddr_t xregset;
#endif
- if (!is_thread (inferior_pid))
+ if (!is_thread (inferior_ptid))
{ /* LWP: pass the request on to procfs.c */
if (target_has_execution)
procfs_ops.to_fetch_registers (regno);
return;
}
- /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
+ /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
- thread = GET_THREAD (inferior_pid);
+ thread = GET_THREAD (inferior_ptid);
if (thread == 0)
error ("sol_thread_fetch_registers: thread == 0");
because the td routines call ps_lget* which affect the values stored in the
registers array. */
- supply_gregset (gregset);
- supply_fpregset (&fpregset);
+ supply_gregset ((gdb_gregset_t *) &gregset);
+ supply_fpregset ((gdb_fpregset_t *) &fpregset);
#if 0
/* thread_db doesn't seem to handle this right */
}
static void
-sol_thread_store_registers (regno)
- int regno;
+sol_thread_store_registers (int regno)
{
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
- if (!is_thread (inferior_pid))
+ if (!is_thread (inferior_ptid))
{ /* LWP: pass the request on to procfs.c */
procfs_ops.to_store_registers (regno);
return;
}
- /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
+ /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
- thread = GET_THREAD (inferior_pid);
+ thread = GET_THREAD (inferior_ptid);
val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
if (val != TD_OK)
if (regno != -1)
{ /* Not writing all the regs */
/* save new register value */
- char old_value[REGISTER_SIZE];
+ char* old_value = (char*) alloca (REGISTER_SIZE);
memcpy (old_value, ®isters[REGISTER_BYTE (regno)], REGISTER_SIZE);
- val = p_td_thr_getgregs (&thandle, regset);
+ val = p_td_thr_getgregs (&thandle, gregset);
if (val != TD_OK)
error ("sol_thread_store_registers: td_thr_getgregs %s",
td_err_string (val));
#endif
}
- fill_gregset (regset, regno);
- fill_fpregset (&fpregset, regno);
+ fill_gregset ((gdb_gregset_t *) &gregset, regno);
+ fill_fpregset ((gdb_fpregset_t *) &fpregset, regno);
- 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",
td_err_string (val));
debugged. */
static void
-sol_thread_prepare_to_store ()
+sol_thread_prepare_to_store (void)
{
procfs_ops.to_prepare_to_store ();
}
+/* Transfer LEN bytes between GDB address MYADDR and target address
+ MEMADDR. If DOWRITE is non-zero, transfer them to the target,
+ otherwise transfer them from the target. TARGET is unused.
+
+ Returns the number of bytes transferred. */
+
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 */
+sol_thread_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite,
+ struct mem_attrib *attrib,
+ struct target_ops *target)
{
int retval;
struct cleanup *old_chain;
- old_chain = save_inferior_pid ();
+ old_chain = save_inferior_ptid ();
- 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. */
+ if (is_thread (inferior_ptid) || /* A thread */
+ !target_thread_alive (inferior_ptid)) /* An lwp, but not alive */
+ inferior_ptid = 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);
+ retval = procfs_ops.to_xfer_memory (memaddr, myaddr, len,
+ dowrite, attrib, target);
else
retval = orig_core_ops.to_xfer_memory (memaddr, myaddr, len,
- dowrite, target);
+ dowrite, attrib, target);
do_cleanups (old_chain);
/* Print status information about what we're accessing. */
static void
-sol_thread_files_info (ignore)
- struct target_ops *ignore;
+sol_thread_files_info (struct target_ops *ignore)
{
procfs_ops.to_files_info (ignore);
}
static void
-sol_thread_kill_inferior ()
+sol_thread_kill_inferior (void)
{
procfs_ops.to_kill ();
}
static void
-sol_thread_notice_signals (pid)
- int pid;
+sol_thread_notice_signals (ptid_t ptid)
{
- procfs_ops.to_notice_signals (PIDGET (pid));
+ procfs_ops.to_notice_signals (pid_to_ptid (PIDGET (ptid)));
}
/* Fork an inferior process, and start debugging it with /proc. */
static void
-sol_thread_create_inferior (exec_file, allargs, env)
- char *exec_file;
- char *allargs;
- char **env;
+sol_thread_create_inferior (char *exec_file, char *allargs, char **env)
{
procfs_ops.to_create_inferior (exec_file, allargs, env);
- if (sol_thread_active && inferior_pid != 0)
+ if (sol_thread_active && !ptid_equal (inferior_ptid, null_ptid))
{
- main_ph.pid = inferior_pid; /* Save for xfer_memory */
+ main_ph.ptid = inferior_ptid; /* 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;
+ inferior_ptid = lwp_to_thread (inferior_ptid);
+ if (PIDGET (inferior_ptid) == -1)
+ inferior_ptid = main_ph.ptid;
- add_thread (inferior_pid);
+ if (!in_thread_list (inferior_ptid))
+ add_thread (inferior_ptid);
}
}
*/
/* Saved pointer to previous owner of the new_objfile event. */
-static void (*target_new_objfile_chain) PARAMS ((struct objfile *));
+static void (*target_new_objfile_chain) (struct objfile *);
void
-sol_thread_new_objfile (objfile)
- struct objfile *objfile;
+sol_thread_new_objfile (struct objfile *objfile)
{
td_err_e val;
/* Clean up after the inferior dies. */
static void
-sol_thread_mourn_inferior ()
+sol_thread_mourn_inferior (void)
{
unpush_target (&sol_thread_ops);
procfs_ops.to_mourn_inferior ();
/* Mark our target-struct as eligible for stray "run" and "attach" commands. */
static int
-sol_thread_can_run ()
+sol_thread_can_run (void)
{
return procfs_suppress_run;
}
SYNOPSIS
- static bool sol_thread_alive (int pid);
+ static bool sol_thread_alive (ptid_t ptid);
DESCRIPTION
*/
static int
-sol_thread_alive (pid)
- int pid;
+sol_thread_alive (ptid_t ptid)
{
- if (is_thread (pid)) /* non-kernel thread */
+ if (is_thread (ptid)) /* non-kernel thread */
{
td_err_e val;
td_thrhandle_t th;
+ int pid;
- pid = GET_THREAD (pid);
+ pid = GET_THREAD (ptid);
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)
/* kernel thread (LWP): let procfs test it */
{
if (target_has_execution)
- return procfs_ops.to_thread_alive (pid);
+ return procfs_ops.to_thread_alive (ptid);
else
- return orig_core_ops.to_thread_alive (pid);
+ return orig_core_ops.to_thread_alive (ptid);
}
}
static void
-sol_thread_stop ()
+sol_thread_stop (void)
{
procfs_ops.to_stop ();
}
typedef char *gdb_ps_read_buf_t;
typedef char *gdb_ps_write_buf_t;
typedef int gdb_ps_size_t;
+typedef paddr_t gdb_ps_addr_t;
#else
typedef struct ps_prochandle *gdb_ps_prochandle_t;
typedef void *gdb_ps_read_buf_t;
typedef const void *gdb_ps_write_buf_t;
typedef size_t gdb_ps_size_t;
+typedef psaddr_t gdb_ps_addr_t;
#endif
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)
+ const char *ld_symbol_name, gdb_ps_addr_t * ld_symbol_addr)
{
struct minimal_symbol *ms;
/* Common routine for reading and writing memory. */
static ps_err_e
-rw_common (int dowrite, const struct ps_prochandle *ph, paddr_t addr,
+rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
char *buf, int size)
{
struct cleanup *old_chain;
- old_chain = save_inferior_pid ();
+ old_chain = save_inferior_ptid ();
- 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. */
+ if (is_thread (inferior_ptid) || /* A thread */
+ !target_thread_alive (inferior_ptid)) /* An lwp, but not alive */
+ inferior_ptid = procfs_first_available (); /* Find any live lwp. */
/* Note: don't need to call switch_to_thread; we're just reading memory. */
+#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
+
while (size > 0)
{
int cc;
+ /* FIXME: passing 0 as attrib argument. */
if (target_has_execution)
- cc = procfs_ops.to_xfer_memory (addr, buf, size, dowrite, &procfs_ops);
+ cc = procfs_ops.to_xfer_memory (addr, buf, size,
+ dowrite, 0, &procfs_ops);
else
- cc = orig_core_ops.to_xfer_memory (addr, buf, size, dowrite, &core_ops);
+ cc = orig_core_ops.to_xfer_memory (addr, buf, size,
+ dowrite, 0, &core_ops);
if (cc < 0)
{
return PS_ERR;
}
+ else if (cc == 0)
+ {
+ if (dowrite == 0)
+ warning ("rw_common (): unable to read at addr 0x%lx",
+ (long) addr);
+ else
+ warning ("rw_common (): unable to write at addr 0x%lx",
+ (long) addr);
+
+ do_cleanups (old_chain);
+
+ return PS_ERR;
+ }
+
size -= cc;
buf += cc;
}
/* Copies SIZE bytes from target process .data segment to debugger memory. */
ps_err_e
-ps_pdread (gdb_ps_prochandle_t ph, paddr_t addr,
+ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
gdb_ps_read_buf_t buf, gdb_ps_size_t size)
{
return rw_common (0, ph, addr, 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,
+ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
gdb_ps_write_buf_t buf, gdb_ps_size_t size)
{
return rw_common (1, ph, addr, (char *) 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,
+ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
gdb_ps_read_buf_t buf, gdb_ps_size_t size)
{
return rw_common (0, ph, addr, 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,
+ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
gdb_ps_write_buf_t buf, gdb_ps_size_t size)
{
return rw_common (1, ph, addr, (char *) buf, size);
{
struct cleanup *old_chain;
- old_chain = save_inferior_pid ();
+ old_chain = save_inferior_ptid ();
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+ inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
if (target_has_execution)
procfs_ops.to_fetch_registers (-1);
else
orig_core_ops.to_fetch_registers (-1);
- fill_gregset (gregset, -1);
+ fill_gregset ((gdb_gregset_t *) gregset, -1);
do_cleanups (old_chain);
{
struct cleanup *old_chain;
- old_chain = save_inferior_pid ();
+ old_chain = save_inferior_ptid ();
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+ inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
- supply_gregset (gregset);
+ supply_gregset ((gdb_gregset_t *) gregset);
if (target_has_execution)
procfs_ops.to_store_registers (-1);
else
{
struct cleanup *old_chain;
- old_chain = save_inferior_pid ();
+ old_chain = save_inferior_ptid ();
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+ inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
if (target_has_execution)
procfs_ops.to_fetch_registers (-1);
else
orig_core_ops.to_fetch_registers (-1);
- fill_fpregset (fpregset, -1);
+ fill_fpregset ((gdb_fpregset_t *) fpregset, -1);
do_cleanups (old_chain);
{
struct cleanup *old_chain;
- old_chain = save_inferior_pid ();
+ old_chain = save_inferior_ptid ();
- inferior_pid = BUILD_LWP (lwpid, PIDGET (inferior_pid));
+ inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
- supply_fpregset (fpregset);
+ supply_fpregset ((gdb_fpregset_t *) fpregset);
if (target_has_execution)
procfs_ops.to_store_registers (-1);
else
return PS_OK;
}
-#ifdef TM_I386SOL2_H
+#ifdef PR_MODEL_LP64
+/* Identify process as 32-bit or 64-bit.
+ At the moment I'm using bfd to do this.
+ There might be a more solaris-specific (eg. procfs) method,
+ but this ought to work. */
-/* Get local descriptor table. */
+ps_err_e
+ps_pdmodel (gdb_ps_prochandle_t 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;
-#include <sys/procfs.h>
-#include <sys/reg.h>
-#include <sys/sysi86.h>
+ return PS_OK;
+}
+#endif /* PR_MODEL_LP64 */
-static int nldt_allocated = 0;
-static struct ssd *ldt_bufp = NULL;
+#ifdef TM_I386SOL2_H
/* Reads the local descriptor table of a LWP. */
ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
struct ssd *pldt)
{
- 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 */
+ extern struct ssd *procfs_find_LDT_entry (ptid_t);
+ 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 (PIDGET (inferior_ptid) <= 0 || lwpid <= 0)
+ return PS_BADLID;
- if (nldt_allocated < nldt)
+ ret = procfs_find_LDT_entry (BUILD_LWP (lwpid, PIDGET (inferior_ptid)));
+ 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 */
\f
/* Convert a pid to printable form. */
char *
-solaris_pid_to_str (pid)
- int pid;
+solaris_pid_to_str (ptid_t ptid)
{
static char buf[100];
/* in case init failed to resolve the libthread_db library */
if (!procfs_suppress_run)
- return procfs_pid_to_str (pid);
+ return procfs_pid_to_str (ptid);
- if (is_thread (pid))
+ if (is_thread (ptid))
{
- 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 (PIDGET (lwp) == -1)
+ sprintf (buf, "Thread %ld (defunct)", GET_THREAD (ptid));
+ else if (PIDGET (lwp) != -2)
+ sprintf (buf, "Thread %ld (LWP %ld)", GET_THREAD (ptid), GET_LWP (lwp));
else
- sprintf (buf, "Thread %d ", GET_THREAD (pid));
+ sprintf (buf, "Thread %ld ", GET_THREAD (ptid));
}
- else if (GET_LWP (pid) != 0)
- sprintf (buf, "LWP %d ", GET_LWP (pid));
+ else if (GET_LWP (ptid) != 0)
+ sprintf (buf, "LWP %ld ", GET_LWP (ptid));
else
- sprintf (buf, "process %d ", PIDGET (pid));
+ sprintf (buf, "process %d ", PIDGET (ptid));
return buf;
}
kernel) thread. */
static int
-sol_find_new_threads_callback (th, ignored)
- const td_thrhandle_t *th;
- void *ignored;
+sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
{
td_err_e retval;
td_thrinfo_t ti;
- int pid;
+ ptid_t ptid;
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);
+ ptid = BUILD_THREAD (ti.ti_tid, PIDGET (inferior_ptid));
+ if (!in_thread_list (ptid))
+ add_thread (ptid);
return 0;
}
static void
-sol_find_new_threads ()
+sol_find_new_threads (void)
{
/* don't do anything if init failed to resolve the libthread_db library */
if (!procfs_suppress_run)
return;
- if (inferior_pid == -1)
+ if (PIDGET (inferior_ptid) == -1)
{
printf_filtered ("No process.\n");
return;
}
- procfs_find_new_threads (); /* first find new kernel threads. */
+ procfs_ops.to_find_new_threads (); /* first find new kernel threads */
p_td_ta_thr_iter (main_ta, sol_find_new_threads_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;
+sol_core_open (char *filename, int from_tty)
{
orig_core_ops.to_open (filename, from_tty);
}
static void
-sol_core_close (quitting)
- int quitting;
+sol_core_close (int quitting)
{
orig_core_ops.to_close (quitting);
}
static void
-sol_core_detach (args, from_tty)
- char *args;
- int from_tty;
+sol_core_detach (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;
+sol_core_files_info (struct target_ops *t)
{
orig_core_ops.to_files_info (t);
}
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;
/* List some state about each Solaris user thread in the inferior. */
static void
-info_solthreads (args, from_tty)
- char *args;
- int from_tty;
+info_solthreads (char *args, int from_tty)
{
p_td_ta_thr_iter (main_ta, info_cb, args,
TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
}
static int
-ignore (addr, contents)
- CORE_ADDR addr;
- char *contents;
+ignore (CORE_ADDR addr, char *contents)
{
return 0;
}
static void
-init_sol_thread_ops ()
+init_sol_thread_ops (void)
{
sol_thread_ops.to_shortname = "solaris-threads";
sol_thread_ops.to_longname = "Solaris threads and pthread.";
static void
-init_sol_core_ops ()
+init_sol_core_ops (void)
{
sol_core_ops.to_shortname = "solaris-core";
sol_core_ops.to_longname = "Solaris core threads and pthread.";
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_thread_alive = sol_thread_alive;
sol_core_ops.to_pid_to_str = solaris_pid_to_str;
+ /* On Solaris/x86, when debugging a threaded core file from process <n>,
+ the following causes "info threads" to produce "procfs: couldn't find pid
+ <n> in procinfo list" where <n> is the pid of the process that produced
+ the core file. Disable it for now. */
+ /* sol_core_ops.to_find_new_threads = sol_find_new_threads; */
sol_core_ops.to_sections = 0;
sol_core_ops.to_sections_end = 0;
sol_core_ops.to_magic = OPS_MAGIC;
int coreops_suppress_target = 1;
void
-_initialize_sol_thread ()
+_initialize_sol_thread (void)
{
void *dlhandle;
projects / deliverable / binutils-gdb.git / blobdiff