/* Solaris threads debugging interface.
- Copyright (C) 1996-2018 Free Software Foundation, Inc.
+ Copyright (C) 1996-2021 Free Software Foundation, Inc.
This file is part of GDB.
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.
+ the thr_* and pthread_* (native and POSIX respectively) interfaces.
These are mostly implemented in user-space, with all thread context
kept in various structures that live in the user's heap. These
should not be confused with lightweight processes (LWPs), which are
class sol_thread_target final : public target_ops
{
public:
- sol_thread_target ()
- { this->to_stratum = thread_stratum; }
-
const target_info &info () const override
{ return thread_db_target_info; }
+ strata stratum () const override { return thread_stratum; }
+
void detach (inferior *, int) override;
- ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+ ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
void resume (ptid_t, int, enum gdb_signal) override;
void mourn_inferior () override;
- const char *pid_to_str (ptid_t) 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;
return buf;
}
-/* Return the libthread_db state string assicoated with STATECODE.
+/* Return the libthread_db state string associated with STATECODE.
If STATECODE is unknown, return an appropriate message. */
static const char *
td_thrhandle_t th;
td_err_e val;
- if (ptid_lwp_p (thread_id))
+ if (thread_id.lwp_p ())
return thread_id; /* It's already an LWP ID. */
/* It's a thread. Convert to LWP. */
- val = p_td_ta_map_id2thr (main_ta, ptid_get_tid (thread_id), &th);
+ val = p_td_ta_map_id2thr (main_ta, thread_id.tid (), &th);
if (val == TD_NOTHR)
- return pid_to_ptid (-1); /* Thread must have terminated. */
+ return ptid_t (-1); /* Thread must have terminated. */
else if (val != TD_OK)
error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
val = p_td_thr_get_info (&th, &ti);
if (val == TD_NOTHR)
- return pid_to_ptid (-1); /* Thread must have terminated. */
+ return ptid_t (-1); /* Thread must have terminated. */
else if (val != TD_OK)
error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
if (ti.ti_state != TD_THR_ACTIVE)
{
if (default_lwp != -1)
- return pid_to_ptid (default_lwp);
+ return ptid_t (default_lwp);
error (_("thread_to_lwp: thread state not active: %s"),
td_state_string (ti.ti_state));
}
- return ptid_build (ptid_get_pid (thread_id), ti.ti_lid, 0);
+ return ptid_t (thread_id.pid (), ti.ti_lid, 0);
}
/* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
td_thrhandle_t th;
td_err_e val;
- if (ptid_tid_p (lwp))
+ if (lwp.tid_p ())
return lwp; /* It's already a thread ID. */
/* It's an LWP. Convert it to a thread ID. */
if (!target_thread_alive (lwp))
- return pid_to_ptid (-1); /* Must be a defunct LPW. */
+ return ptid_t (-1); /* Must be a defunct LPW. */
- val = p_td_ta_map_lwp2thr (main_ta, ptid_get_lwp (lwp), &th);
+ val = p_td_ta_map_lwp2thr (main_ta, lwp.lwp (), &th);
if (val == TD_NOTHR)
- return pid_to_ptid (-1); /* Thread must have terminated. */
+ return ptid_t (-1); /* Thread must have terminated. */
else if (val != TD_OK)
error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
val = p_td_thr_get_info (&th, &ti);
if (val == TD_NOTHR)
- return pid_to_ptid (-1); /* Thread must have terminated. */
+ return ptid_t (-1); /* Thread must have terminated. */
else if (val != TD_OK)
error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
- return ptid_build (ptid_get_pid (lwp), 0 , ti.ti_tid);
+ return ptid_t (lwp.pid (), 0 , ti.ti_tid);
}
\f
target_ops *beneath = this->beneath ();
sol_thread_active = 0;
- inferior_ptid = pid_to_ptid (ptid_get_pid (main_ph.ptid));
- unpush_target (this);
+ inferior_ptid = ptid_t (main_ph.ptid.pid ());
+ inf->unpush_target (this);
beneath->detach (inf, from_tty);
}
-/* Resume execution of process PTID. If STEP is nozero, then just
+/* Resume execution of process PTID. If STEP is nonzero, then just
single step it. If SIGNAL is nonzero, restart it with that signal
activated. We may have to convert PTID from a thread ID to an LWP
ID for procfs. */
{
scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
- if (ptid_get_pid (inferior_ptid) == -1)
+ inferior_ptid = thread_to_lwp (inferior_ptid, main_ph.ptid.pid ());
+ if (inferior_ptid.pid () == -1)
inferior_ptid = procfs_first_available ();
- if (ptid_get_pid (ptid) != -1)
+ if (ptid.pid () != -1)
{
ptid_t save_ptid = ptid;
ptid = thread_to_lwp (ptid, -2);
- if (ptid_get_pid (ptid) == -2) /* Inactive thread. */
+ if (ptid.pid () == -2) /* Inactive thread. */
error (_("This version of Solaris can't start inactive threads."));
- if (info_verbose && ptid_get_pid (ptid) == -1)
+ if (info_verbose && ptid.pid () == -1)
warning (_("Specified thread %ld seems to have terminated"),
- ptid_get_tid (save_ptid));
+ save_ptid.tid ());
}
beneath ()->resume (ptid, step, signo);
ptid_t
sol_thread_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
- int options)
+ target_wait_flags options)
{
- ptid_t rtnval;
- ptid_t save_ptid;
-
- save_ptid = inferior_ptid;
- scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
-
- inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
- if (ptid_get_pid (inferior_ptid) == -1)
- inferior_ptid = procfs_first_available ();
-
- if (ptid_get_pid (ptid) != -1)
+ if (ptid.pid () != -1)
{
- ptid_t save_ptid = ptid;
+ ptid_t ptid_for_warning = ptid;
ptid = thread_to_lwp (ptid, -2);
- if (ptid_get_pid (ptid) == -2) /* Inactive thread. */
+ if (ptid.pid () == -2) /* Inactive thread. */
error (_("This version of Solaris can't start inactive threads."));
- if (info_verbose && ptid_get_pid (ptid) == -1)
+ if (info_verbose && ptid.pid () == -1)
warning (_("Specified thread %ld seems to have terminated"),
- ptid_get_tid (save_ptid));
+ ptid_for_warning.tid ());
}
- rtnval = beneath ()->wait (ptid, ourstatus, options);
+ ptid_t rtnval = beneath ()->wait (ptid, ourstatus, options);
if (ourstatus->kind != TARGET_WAITKIND_EXITED)
{
/* Map the LWP of interest back to the appropriate thread ID. */
- rtnval = lwp_to_thread (rtnval);
- if (ptid_get_pid (rtnval) == -1)
- rtnval = save_ptid;
+ ptid_t thr_ptid = lwp_to_thread (rtnval);
+ if (thr_ptid.pid () != -1)
+ rtnval = thr_ptid;
/* See if we have a new thread. */
- if (ptid_tid_p (rtnval)
- && !ptid_equal (rtnval, save_ptid)
- && (!in_thread_list (rtnval)
- || is_exited (rtnval)))
- add_thread (rtnval);
+ if (rtnval.tid_p ())
+ {
+ thread_info *thr = find_thread_ptid (current_inferior (), rtnval);
+ if (thr == NULL || thr->state == THREAD_EXITED)
+ {
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ add_thread (proc_target, rtnval);
+ }
+ }
}
/* During process initialization, we may get here without the thread
gdb_fpregset_t *fpregset_p = &fpregset;
ptid_t ptid = regcache->ptid ();
- if (!ptid_tid_p (ptid))
+ if (!ptid.tid_p ())
{
/* It's an LWP; pass the request on to the layer beneath. */
beneath ()->fetch_registers (regcache, regnum);
}
/* Solaris thread: convert PTID into a td_thrhandle_t. */
- thread = ptid_get_tid (ptid);
+ thread = ptid.tid ();
if (thread == 0)
error (_("sol_thread_fetch_registers: thread == 0"));
prfpregset_t fpregset;
ptid_t ptid = regcache->ptid ();
- if (!ptid_tid_p (ptid))
+ if (!ptid.tid_p ())
{
/* It's an LWP; pass the request on to the layer beneath. */
beneath ()->store_registers (regcache, regnum);
}
/* Solaris thread: convert PTID into a td_thrhandle_t. */
- thread = ptid_get_tid (ptid);
+ thread = ptid.tid ();
val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
if (val != TD_OK)
{
scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
+ 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.
+ LWP will do so use the first available.
NOTE: We don't need to call switch_to_thread; we're just
reading memory. */
printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
/* The thread library was detected. Activate the sol_thread target. */
- push_target (&sol_thread_ops);
+ current_inferior ()->push_target (&sol_thread_ops);
sol_thread_active = 1;
main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */
ptid = lwp_to_thread (inferior_ptid);
- if (ptid_get_pid (ptid) != -1)
+ if (ptid.pid () != -1)
inferior_ptid = ptid;
target_update_thread_list ();
sol_thread_active = 0;
- unpush_target (this);
+ current_inferior ()->unpush_target (this);
beneath->mourn_inferior ();
}
bool
sol_thread_target::thread_alive (ptid_t ptid)
{
- if (ptid_tid_p (ptid))
+ if (ptid.tid_p ())
{
/* It's a (user-level) thread. */
td_err_e val;
td_thrhandle_t th;
int pid;
- pid = ptid_get_tid (ptid);
- if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
+ pid = ptid.tid ();
+ val = p_td_ta_map_id2thr (main_ta, pid, &th);
+ if (val != TD_OK)
return false; /* Thread not found. */
- if ((val = p_td_thr_validate (&th)) != TD_OK)
+ val = p_td_thr_validate (&th);
+ if (val != TD_OK)
return false; /* Thread not valid. */
return true; /* Known thread. */
}
scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
- if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
+ 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.
+ LWP will do so use the first available.
NOTE: We 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)
+ if (bfd_get_arch_size (current_program_space->exec_bfd ()) == 32)
addr &= 0xffffffff;
#endif
ps_err_e
ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid, prgregset_t gregset)
{
- ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
+ ptid_t ptid = ptid_t (current_inferior ()->pid, lwpid, 0);
struct regcache *regcache
- = get_thread_arch_regcache (ptid, target_gdbarch ());
+ = get_thread_arch_regcache (current_inferior ()->process_target (),
+ ptid, target_gdbarch ());
target_fetch_registers (regcache, -1);
fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid,
const prgregset_t gregset)
{
- ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
+ ptid_t ptid = ptid_t (current_inferior ()->pid, lwpid, 0);
struct regcache *regcache
- = get_thread_arch_regcache (ptid, target_gdbarch ());
+ = get_thread_arch_regcache (current_inferior ()->process_target (),
+ ptid, target_gdbarch ());
supply_gregset (regcache, (const gdb_gregset_t *) gregset);
target_store_registers (regcache, -1);
ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
prfpregset_t *fpregset)
{
- ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
+ ptid_t ptid = ptid_t (current_inferior ()->pid, lwpid, 0);
struct regcache *regcache
- = get_thread_arch_regcache (ptid, target_gdbarch ());
+ = get_thread_arch_regcache (current_inferior ()->process_target (),
+ ptid, target_gdbarch ());
target_fetch_registers (regcache, -1);
fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
const prfpregset_t * fpregset)
{
- ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
+ ptid_t ptid = ptid_t (current_inferior ()->pid, lwpid, 0);
struct regcache *regcache
- = get_thread_arch_regcache (ptid, target_gdbarch ());
+ = get_thread_arch_regcache (current_inferior ()->process_target (),
+ ptid, target_gdbarch ());
supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
target_store_registers (regcache, -1);
return PS_OK;
}
-#ifdef PR_MODEL_LP64
/* 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)
+ if (current_program_space->exec_bfd () == 0)
*data_model = PR_MODEL_UNKNOWN;
- else if (bfd_get_arch_size (exec_bfd) == 32)
+ else if (bfd_get_arch_size (current_program_space->exec_bfd ()) == 32)
*data_model = PR_MODEL_ILP32;
else
*data_model = PR_MODEL_LP64;
return PS_OK;
}
-#endif /* PR_MODEL_LP64 */
-
-#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_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid,
- struct ssd *pldt)
-{
- /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
- struct ssd *ret;
-
- /* FIXME: can't I get the process ID from the prochandle or
- something? */
-
- if (ptid_get_pid (inferior_ptid) <= 0 || lwpid <= 0)
- return PS_BADLID;
-
- ret = procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid),
- lwpid, 0));
- if (ret)
- {
- memcpy (pldt, ret, sizeof (struct ssd));
- return PS_OK;
- }
- else
- /* LDT not found. */
- return PS_ERR;
-}
-#endif
\f
/* Convert PTID to printable form. */
-const char *
+std::string
sol_thread_target::pid_to_str (ptid_t ptid)
{
- static char buf[100];
-
- if (ptid_tid_p (ptid))
+ if (ptid.tid_p ())
{
ptid_t lwp;
lwp = thread_to_lwp (ptid, -2);
- if (ptid_get_pid (lwp) == -1)
- xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
- ptid_get_tid (ptid));
- else if (ptid_get_pid (lwp) != -2)
- xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
- ptid_get_tid (ptid), ptid_get_lwp (lwp));
+ if (lwp.pid () == -1)
+ return string_printf ("Thread %ld (defunct)",
+ ptid.tid ());
+ else if (lwp.pid () != -2)
+ return string_printf ("Thread %ld (LWP %ld)",
+ ptid.tid (), lwp.lwp ());
else
- xsnprintf (buf, sizeof (buf), "Thread %ld ",
- ptid_get_tid (ptid));
+ return string_printf ("Thread %ld ",
+ ptid.tid ());
}
- else if (ptid_get_lwp (ptid) != 0)
- xsnprintf (buf, sizeof (buf), "LWP %ld ", ptid_get_lwp (ptid));
+ else if (ptid.lwp () != 0)
+ return string_printf ("LWP %ld ", ptid.lwp ());
else
- xsnprintf (buf, sizeof (buf), "process %d ", ptid_get_pid (ptid));
-
- return buf;
+ return string_printf ("process %d ", ptid.pid ());
}
\f
{
td_err_e retval;
td_thrinfo_t ti;
- ptid_t ptid;
retval = p_td_thr_get_info (th, &ti);
if (retval != TD_OK)
return -1;
- ptid = ptid_build (ptid_get_pid (inferior_ptid), 0, ti.ti_tid);
- if (!in_thread_list (ptid) || is_exited (ptid))
- add_thread (ptid);
+ ptid_t ptid = ptid_t (current_inferior ()->pid, 0, ti.ti_tid);
+ thread_info *thr = find_thread_ptid (current_inferior (), ptid);
+ if (thr == NULL || thr->state == THREAD_EXITED)
+ {
+ process_stratum_target *proc_target
+ = current_inferior ()->process_target ();
+ add_thread (proc_target, ptid);
+ }
return 0;
}
printf_filtered (" startfunc=%s",
msym.minsym
- ? MSYMBOL_PRINT_NAME (msym.minsym)
+ ? msym.minsym->print_name ()
: paddress (target_gdbarch (), ti.ti_startfunc));
}
printf_filtered (" sleepfunc=%s",
msym.minsym
- ? MSYMBOL_PRINT_NAME (msym.minsym)
+ ? msym.minsym->print_name ()
: paddress (target_gdbarch (), ti.ti_pc));
}
{
long *tid = (long *) data;
- if (ptid_get_tid (thread->ptid) == *tid)
+ if (thread->ptid.tid () == *tid)
return 1;
return 0;
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. */
+ 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);
+ &thread);
}
gdb_assert (thread_info != NULL);
return (thread_info->ptid);
}
+void _initialize_sol_thread ();
void
-_initialize_sol_thread (void)
+_initialize_sol_thread ()
{
void *dlhandle;
_("Show info on Solaris user threads."), &maintenanceinfolist);
/* Hook into new_objfile notification. */
- gdb::observers::new_objfile.attach (sol_thread_new_objfile);
+ gdb::observers::new_objfile.attach (sol_thread_new_objfile, "sol-thread");
return;
die:
projects / deliverable / binutils-gdb.git / blobdiff