/* Solaris threads debugging interface.
- Copyright (C) 1996-2018 Free Software Foundation, Inc.
+ Copyright (C) 1996-2022 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;
- ptid_t get_ada_task_ptid (long lwp, long thread) override;
+ std::string pid_to_str (ptid_t) override;
+ ptid_t get_ada_task_ptid (long lwp, ULONGEST thread) override;
void fetch_registers (struct regcache *, int) override;
void store_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 *
sol_thread_active = 0;
inferior_ptid = ptid_t (main_ph.ptid.pid ());
- unpush_target (this);
+ 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. */
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, main_ph.ptid.pid ());
- if (inferior_ptid.pid () == -1)
- inferior_ptid = procfs_first_available ();
-
if (ptid.pid () != -1)
{
- ptid_t save_ptid = ptid;
+ 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"),
- save_ptid.tid ());
+ ptid_for_warning.tid ());
}
- rtnval = beneath ()->wait (ptid, ourstatus, options);
+ ptid_t rtnval = beneath ()->wait (ptid, ourstatus, options);
- if (ourstatus->kind != TARGET_WAITKIND_EXITED)
+ 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;
+ ptid_t thr_ptid = lwp_to_thread (rtnval);
+ if (thr_ptid.pid () != -1)
+ rtnval = thr_ptid;
/* See if we have a new thread. */
- if (rtnval.tid_p ()
- && 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
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. */
break;
case TD_OK:
- printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
+ gdb_printf (_("[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. */
sol_thread_active = 0;
- unpush_target (this);
+ current_inferior ()->unpush_target (this);
beneath->mourn_inferior ();
}
if (!ms.minsym)
return PS_NOSYM;
- *ld_symbol_addr = BMSYMBOL_VALUE_ADDRESS (ms);
+ *ld_symbol_addr = ms.value_address ();
return PS_OK;
}
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_t (inferior_ptid.pid (), 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_t (inferior_ptid.pid (), 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);
va_start (args, fmt);
- vfprintf_filtered (gdb_stderr, fmt, args);
+ gdb_vprintf (gdb_stderr, fmt, args);
}
/* Get size of extra register set. Currently a noop. */
ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
prfpregset_t *fpregset)
{
- ptid_t ptid = ptid_t (inferior_ptid.pid (), 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_t (inferior_ptid.pid (), 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);
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;
}
-
-#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) /* ARI: editCase function */
-{
- /* 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 (inferior_ptid.pid () <= 0 || lwpid <= 0)
- return PS_BADLID;
-
- 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
/* 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_t lwp;
lwp = thread_to_lwp (ptid, -2);
if (lwp.pid () == -1)
- xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
- ptid.tid ());
+ return string_printf ("Thread %ld (defunct)",
+ ptid.tid ());
else if (lwp.pid () != -2)
- xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
- ptid.tid (), lwp.lwp ());
+ return string_printf ("Thread %ld (LWP %ld)",
+ ptid.tid (), lwp.lwp ());
else
- xsnprintf (buf, sizeof (buf), "Thread %ld ",
- ptid.tid ());
+ return string_printf ("Thread %ld ",
+ ptid.tid ());
}
else if (ptid.lwp () != 0)
- xsnprintf (buf, sizeof (buf), "LWP %ld ", ptid.lwp ());
+ return string_printf ("LWP %ld ", ptid.lwp ());
else
- xsnprintf (buf, sizeof (buf), "process %d ", ptid.pid ());
-
- 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_t (inferior_ptid.pid (), 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;
}
ret = p_td_thr_get_info (th, &ti);
if (ret == TD_OK)
{
- printf_filtered ("%s thread #%d, lwp %d, ",
- ti.ti_type == TD_THR_SYSTEM ? "system" : "user ",
- ti.ti_tid, ti.ti_lid);
+ gdb_printf ("%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>");
+ gdb_printf ("<unknown state>");
break;
case TD_THR_STOPPED:
- printf_filtered ("(stopped)");
+ gdb_printf ("(stopped)");
break;
case TD_THR_RUN:
- printf_filtered ("(run) ");
+ gdb_printf ("(run) ");
break;
case TD_THR_ACTIVE:
- printf_filtered ("(active) ");
+ gdb_printf ("(active) ");
break;
case TD_THR_ZOMBIE:
- printf_filtered ("(zombie) ");
+ gdb_printf ("(zombie) ");
break;
case TD_THR_SLEEP:
- printf_filtered ("(asleep) ");
+ gdb_printf ("(asleep) ");
break;
case TD_THR_STOPPED_ASLEEP:
- printf_filtered ("(stopped asleep)");
+ gdb_printf ("(stopped asleep)");
break;
}
/* Print thr_create start function. */
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));
+ gdb_printf (" startfunc=%s",
+ msym.minsym
+ ? msym.minsym->print_name ()
+ : paddress (target_gdbarch (), ti.ti_startfunc));
}
/* If thread is asleep, print function that went to sleep. */
const struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (ti.ti_pc);
- printf_filtered (" sleepfunc=%s",
- msym.minsym
- ? MSYMBOL_PRINT_NAME (msym.minsym)
- : paddress (target_gdbarch (), ti.ti_pc));
+ gdb_printf (" sleepfunc=%s",
+ msym.minsym
+ ? msym.minsym->print_name ()
+ : paddress (target_gdbarch (), ti.ti_pc));
}
- printf_filtered ("\n");
+ gdb_printf ("\n");
}
else
warning (_("info sol-thread: failed to get info for thread."));
static int
thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
{
- long *tid = (long *) data;
+ ULONGEST *tid = (ULONGEST *) data;
if (thread->ptid.tid () == *tid)
return 1;
}
ptid_t
-sol_thread_target::get_ada_task_ptid (long lwp, long thread)
+sol_thread_target::get_ada_task_ptid (long lwp, ULONGEST 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. */
+ 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:
- fprintf_unfiltered (gdb_stderr, "\
+ gdb_printf (gdb_stderr, "\
[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
if (dlhandle)
projects / binutils-gdb.git / blobdiff