/* Multi-process/thread control defs for GDB, the GNU debugger.
- Copyright (C) 1987-2018 Free Software Foundation, Inc.
+ Copyright (C) 1987-2021 Free Software Foundation, Inc.
Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
#include "breakpoint.h"
#include "frame.h"
#include "ui-out.h"
-#include "inferior.h"
#include "btrace.h"
-#include "common/vec.h"
#include "target/waitstatus.h"
#include "cli/cli-utils.h"
-#include "common/refcounted-object.h"
-#include "common-gdbthread.h"
+#include "gdbsupport/refcounted-object.h"
+#include "gdbsupport/common-gdbthread.h"
+#include "gdbsupport/forward-scope-exit.h"
+#include "displaced-stepping.h"
+
+struct inferior;
+struct process_stratum_target;
/* Frontend view of the thread state. Possible extensions: stepping,
- finishing, until(ling),... */
+ finishing, until(ling),...
+
+ NOTE: Since the thread state is not a boolean, most times, you do
+ not want to check it with negation. If you really want to check if
+ the thread is stopped,
+
+ use (good):
+
+ if (tp->state == THREAD_STOPPED)
+
+ instead of (bad):
+
+ if (tp->state != THREAD_RUNNING)
+
+ The latter is also true for exited threads, most likely not what
+ you want. */
enum thread_state
{
+ /* In the frontend's perpective, the thread is stopped. */
THREAD_STOPPED,
+
+ /* In the frontend's perpective, the thread is running. */
THREAD_RUNNING,
+
+ /* The thread is listed, but known to have exited. We keep it
+ listed (but not visible) until it's safe to delete it. */
THREAD_EXITED,
};
+/* STEP_OVER_ALL means step over all subroutine calls.
+ STEP_OVER_UNDEBUGGABLE means step over calls to undebuggable functions.
+ STEP_OVER_NONE means don't step over any subroutine calls. */
+
+enum step_over_calls_kind
+ {
+ STEP_OVER_NONE,
+ STEP_OVER_ALL,
+ STEP_OVER_UNDEBUGGABLE
+ };
+
/* Inferior thread specific part of `struct infcall_control_state'.
Inferior process counterpart is `struct inferior_control_state'. */
any inlined frames). */
struct frame_id step_stack_frame_id {};
- /* Nonzero if we are presently stepping over a breakpoint.
-
- If we hit a breakpoint or watchpoint, and then continue, we need
- to single step the current thread with breakpoints disabled, to
- avoid hitting the same breakpoint or watchpoint again. And we
- should step just a single thread and keep other threads stopped,
- so that other threads don't miss breakpoints while they are
- removed.
-
- So, this variable simultaneously means that we need to single
- step the current thread, keep other threads stopped, and that
- breakpoints should be removed while we step.
-
- This variable is set either:
- - in proceed, when we resume inferior on user's explicit request
- - in keep_going, if handle_inferior_event decides we need to
- step over breakpoint.
-
- The variable is cleared in normal_stop. The proceed calls
- wait_for_inferior, which calls handle_inferior_event in a loop,
- and until wait_for_inferior exits, this variable is changed only
- by keep_going. */
+ /* True if the the thread is presently stepping over a breakpoint or
+ a watchpoint, either with an inline step over or a displaced (out
+ of line) step, and we're now expecting it to report a trap for
+ the finished single step. */
int trap_expected = 0;
/* Nonzero if the thread is being proceeded for a "finish" command
reverting back (e.g., due to a "kill" command). If the thread
meanwhile exits before being re-selected, then the thread object is
left listed in the thread list, but marked with state
- THREAD_EXITED. (See make_cleanup_restore_current_thread and
+ THREAD_EXITED. (See scoped_restore_current_thread and
delete_thread). All other thread references are considered weak
references. Placing a thread in the thread list is an implicit
strong reference, and is thus not accounted for in the thread's
explicit thread_info (inferior *inf, ptid_t ptid);
~thread_info ();
- bool deletable () const
- {
- /* If this is the current thread, or there's code out there that
- relies on it existing (refcount > 0) we can't delete yet. */
- return (refcount () == 0 && ptid != inferior_ptid);
- }
+ bool deletable () const;
/* Mark this thread as running and notify observers. */
void set_running (bool running);
a) The thread ID (Id). This consists of the pair of:
- - the number of the thread's inferior and,
+ - the number of the thread's inferior and,
- - the thread's thread number in its inferior, aka, the
- per-inferior thread number. This number is unique in the
- inferior but not unique between inferiors.
+ - the thread's thread number in its inferior, aka, the
+ per-inferior thread number. This number is unique in the
+ inferior but not unique between inferiors.
b) The global ID (GId). This is a a single integer unique
- between all inferiors.
+ between all inferiors.
E.g.:
if the thread does not have a user-given name. */
char *name = NULL;
- /* Non-zero means the thread is executing. Note: this is different
+ /* True means the thread is executing. Note: this is different
from saying that there is an active target and we are stopped at
a breakpoint, for instance. This is a real indicator whether the
thread is off and running. */
- int executing = 0;
+ bool executing = false;
- /* Non-zero if this thread is resumed from infrun's perspective.
+ /* True if this thread is resumed from infrun's perspective.
Note that a thread can be marked both as not-executing and
resumed at the same time. This happens if we try to resume a
thread that has a wait status pending. We shouldn't let the
thread really run until that wait status has been processed, but
we should not process that wait status if we didn't try to let
the thread run. */
- int resumed = 0;
+ bool resumed = false;
/* Frontend view of the thread state. Note that the THREAD_RUNNING/
THREAD_STOPPED states are different from EXECUTING. When the
fields point to self. */
struct thread_info *step_over_prev = NULL;
struct thread_info *step_over_next = NULL;
+
+ /* Displaced-step state for this thread. */
+ displaced_step_thread_state displaced_step_state;
};
/* A gdb::ref_ptr pointer to a thread_info. */
using thread_info_ref
= gdb::ref_ptr<struct thread_info, refcounted_object_ref_policy>;
+/* A gdb::ref_ptr pointer to an inferior. This would ideally be in
+ inferior.h, but it can't due to header dependencies (inferior.h
+ includes gdbthread.h). */
+
+using inferior_ref
+ = gdb::ref_ptr<struct inferior, refcounted_object_ref_policy>;
+
/* Create an empty thread list, or empty the existing one. */
extern void init_thread_list (void);
that a new thread is found, and return the pointer to
the new thread. Caller my use this pointer to
initialize the private thread data. */
-extern struct thread_info *add_thread (ptid_t ptid);
+extern struct thread_info *add_thread (process_stratum_target *targ,
+ ptid_t ptid);
-/* Same as add_thread, but does not print a message
- about new thread. */
-extern struct thread_info *add_thread_silent (ptid_t ptid);
+/* Same as add_thread, but does not print a message about new
+ thread. */
+extern struct thread_info *add_thread_silent (process_stratum_target *targ,
+ ptid_t ptid);
/* Same as add_thread, and sets the private info. */
-extern struct thread_info *add_thread_with_info (ptid_t ptid,
- struct private_thread_info *);
+extern struct thread_info *add_thread_with_info (process_stratum_target *targ,
+ ptid_t ptid,
+ private_thread_info *);
-/* Delete an existing thread list entry. */
+/* Delete thread THREAD and notify of thread exit. If the thread is
+ currently not deletable, don't actually delete it but still tag it
+ as exited and do the notification. */
extern void delete_thread (struct thread_info *thread);
-/* Delete an existing thread list entry, and be quiet about it. Used
- after the process this thread having belonged to having already
- exited, for example. */
+/* Like delete_thread, but be quiet about it. Used when the process
+ this thread belonged to has already exited, for example. */
extern void delete_thread_silent (struct thread_info *thread);
/* Delete a step_resume_breakpoint from the thread database. */
const char *print_thread_id (struct thread_info *thr);
/* Boolean test for an already-known ptid. */
-extern int in_thread_list (ptid_t ptid);
+extern bool in_thread_list (process_stratum_target *targ, ptid_t ptid);
/* Boolean test for an already-known global thread id (GDB's homegrown
global id, not the system's). */
extern int valid_global_thread_id (int global_id);
-/* Search function to lookup a thread by 'pid'. */
-extern struct thread_info *find_thread_ptid (ptid_t ptid);
+/* Find (non-exited) thread PTID of inferior INF. */
+extern thread_info *find_thread_ptid (inferior *inf, ptid_t ptid);
+
+/* Search function to lookup a (non-exited) thread by 'ptid'. */
+extern struct thread_info *find_thread_ptid (process_stratum_target *targ,
+ ptid_t ptid);
+
+/* Search function to lookup a (non-exited) thread by 'ptid'. Only
+ searches in threads of INF. */
+extern struct thread_info *find_thread_ptid (inferior *inf, ptid_t ptid);
/* Find thread by GDB global thread ID. */
struct thread_info *find_thread_global_id (int global_id);
/* Find thread by thread library specific handle in inferior INF. */
-struct thread_info *find_thread_by_handle (struct value *thread_handle,
- struct inferior *inf);
+struct thread_info *find_thread_by_handle
+ (gdb::array_view<const gdb_byte> handle, struct inferior *inf);
/* Finds the first thread of the specified inferior. */
extern struct thread_info *first_thread_of_inferior (inferior *inf);
extern struct thread_info *any_live_thread_of_inferior (inferior *inf);
/* Change the ptid of thread OLD_PTID to NEW_PTID. */
-void thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid);
+void thread_change_ptid (process_stratum_target *targ,
+ ptid_t old_ptid, ptid_t new_ptid);
/* Iterator function to call a user-provided callback function
once for each known thread. */
typedef int (*thread_callback_func) (struct thread_info *, void *);
extern struct thread_info *iterate_over_threads (thread_callback_func, void *);
-/* Traverse all threads. */
-#define ALL_THREADS(T) \
- for (T = thread_list; T; T = T->next) \
+/* Pull in the internals of the inferiors/threads ranges and
+ iterators. Must be done after struct thread_info is defined. */
+#include "thread-iter.h"
-/* Traverse over all threads, sorted by inferior. */
-#define ALL_THREADS_BY_INFERIOR(inf, tp) \
- ALL_INFERIORS (inf) \
- ALL_THREADS (tp) \
- if (inf == tp->inf)
+/* Return a range that can be used to walk over threads, with
+ range-for.
-/* Traverse all threads, except those that have THREAD_EXITED
- state. */
+ Used like this, it walks over all threads of all inferiors of all
+ targets:
-#define ALL_NON_EXITED_THREADS(T) \
- for (T = thread_list; T; T = T->next) \
- if ((T)->state != THREAD_EXITED)
+ for (thread_info *thr : all_threads ())
+ { .... }
-/* Traverse all threads, including those that have THREAD_EXITED
- state. Allows deleting the currently iterated thread. */
-#define ALL_THREADS_SAFE(T, TMP) \
- for ((T) = thread_list; \
- (T) != NULL ? ((TMP) = (T)->next, 1): 0; \
- (T) = (TMP))
+ FILTER_PTID can be used to filter out threads that don't match.
+ FILTER_PTID can be:
-extern int thread_count (void);
+ - minus_one_ptid, meaning walk all threads of all inferiors of
+ PROC_TARGET. If PROC_TARGET is NULL, then of all targets.
-/* Switch context to thread THR. Also sets the STOP_PC global. */
-extern void switch_to_thread (struct thread_info *thr);
+ - A process ptid, in which case walk all threads of the specified
+ process. PROC_TARGET must be non-NULL in this case.
-/* Switch context to no thread selected. */
-extern void switch_to_no_thread ();
-
-/* Switch from one thread to another. Does not read registers. */
-extern void switch_to_thread_no_regs (struct thread_info *thread);
-
-/* Marks or clears thread(s) PTID as resumed. If PTID is
- MINUS_ONE_PTID, applies to all threads. If ptid_is_pid(PTID) is
- true, applies to all threads of the process pointed at by PTID. */
-extern void set_resumed (ptid_t ptid, int resumed);
+ - A thread ptid, in which case walk that thread only. PROC_TARGET
+ must be non-NULL in this case.
+*/
-/* Marks thread PTID is running, or stopped.
- If PTID is minus_one_ptid, marks all threads. */
-extern void set_running (ptid_t ptid, int running);
+inline all_matching_threads_range
+all_threads (process_stratum_target *proc_target = nullptr,
+ ptid_t filter_ptid = minus_one_ptid)
+{
+ return all_matching_threads_range (proc_target, filter_ptid);
+}
-/* Marks or clears thread(s) PTID as having been requested to stop.
- If PTID is MINUS_ONE_PTID, applies to all threads. If
- ptid_is_pid(PTID) is true, applies to all threads of the process
- pointed at by PTID. If STOP, then the THREAD_STOP_REQUESTED
- observer is called with PTID as argument. */
-extern void set_stop_requested (ptid_t ptid, int stop);
+/* Return a range that can be used to walk over all non-exited threads
+ of all inferiors, with range-for. Arguments are like all_threads
+ above. */
-/* NOTE: Since the thread state is not a boolean, most times, you do
- not want to check it with negation. If you really want to check if
- the thread is stopped,
+inline all_non_exited_threads_range
+all_non_exited_threads (process_stratum_target *proc_target = nullptr,
+ ptid_t filter_ptid = minus_one_ptid)
+{
+ return all_non_exited_threads_range (proc_target, filter_ptid);
+}
- use (good):
+/* Return a range that can be used to walk over all threads of all
+ inferiors, with range-for, safely. I.e., it is safe to delete the
+ currently-iterated thread. When combined with range-for, this
+ allow convenient patterns like this:
- if (is_stopped (ptid))
+ for (thread_info *t : all_threads_safe ())
+ if (some_condition ())
+ delete f;
+*/
- instead of (bad):
+inline all_threads_safe_range
+all_threads_safe ()
+{
+ return {};
+}
- if (!is_running (ptid))
+extern int thread_count (process_stratum_target *proc_target);
- The latter also returns true on exited threads, most likelly not
- what you want. */
+/* Return true if we have any thread in any inferior. */
+extern bool any_thread_p ();
-/* Reports if in the frontend's perpective, thread PTID is running. */
-extern int is_running (ptid_t ptid);
+/* Switch context to thread THR. Also sets the STOP_PC global. */
+extern void switch_to_thread (struct thread_info *thr);
-/* Is this thread listed, but known to have exited? We keep it listed
- (but not visible) until it's safe to delete. */
-extern int is_exited (ptid_t ptid);
+/* Switch context to no thread selected. */
+extern void switch_to_no_thread ();
-/* In the frontend's perpective, is this thread stopped? */
-extern int is_stopped (ptid_t ptid);
+/* Switch from one thread to another. Does not read registers. */
+extern void switch_to_thread_no_regs (struct thread_info *thread);
-/* Marks thread PTID as executing, or not. If PTID is minus_one_ptid,
- marks all threads.
+/* Marks or clears thread(s) PTID of TARG as resumed. If PTID is
+ MINUS_ONE_PTID, applies to all threads of TARG. If
+ ptid_is_pid(PTID) is true, applies to all threads of the process
+ pointed at by {TARG,PTID}. */
+extern void set_resumed (process_stratum_target *targ,
+ ptid_t ptid, bool resumed);
+
+/* Marks thread PTID of TARG as running, or as stopped. If PTID is
+ minus_one_ptid, marks all threads of TARG. */
+extern void set_running (process_stratum_target *targ,
+ ptid_t ptid, bool running);
+
+/* Marks or clears thread(s) PTID of TARG as having been requested to
+ stop. If PTID is MINUS_ONE_PTID, applies to all threads of TARG.
+ If ptid_is_pid(PTID) is true, applies to all threads of the process
+ pointed at by {TARG, PTID}. If STOP, then the
+ THREAD_STOP_REQUESTED observer is called with PTID as argument. */
+extern void set_stop_requested (process_stratum_target *targ,
+ ptid_t ptid, bool stop);
+
+/* Marks thread PTID of TARG as executing, or not. If PTID is
+ minus_one_ptid, marks all threads of TARG.
Note that this is different from the running state. See the
description of state and executing fields of struct
thread_info. */
-extern void set_executing (ptid_t ptid, int executing);
+extern void set_executing (process_stratum_target *targ,
+ ptid_t ptid, bool executing);
-/* True if any (known or unknown) thread is or may be executing. */
-extern int threads_are_executing (void);
+/* True if any (known or unknown) thread of TARG is or may be
+ executing. */
+extern bool threads_are_executing (process_stratum_target *targ);
-/* Merge the executing property of thread PTID over to its thread
- state property (frontend running/stopped view).
+/* Merge the executing property of thread PTID of TARG over to its
+ thread state property (frontend running/stopped view).
"not executing" -> "stopped"
"executing" -> "running"
"exited" -> "exited"
- If PTID is minus_one_ptid, go over all threads.
+ If PTID is minus_one_ptid, go over all threads of TARG.
Notifications are only emitted if the thread state did change. */
-extern void finish_thread_state (ptid_t ptid);
+extern void finish_thread_state (process_stratum_target *targ, ptid_t ptid);
/* Calls finish_thread_state on scope exit, unless release() is called
to disengage. */
-class scoped_finish_thread_state
-{
-public:
- explicit scoped_finish_thread_state (ptid_t ptid)
- : m_ptid (ptid)
- {}
-
- ~scoped_finish_thread_state ()
- {
- if (!m_released)
- finish_thread_state (m_ptid);
- }
-
- /* Disengage. */
- void release ()
- {
- m_released = true;
- }
-
- DISABLE_COPY_AND_ASSIGN (scoped_finish_thread_state);
-
-private:
- bool m_released = false;
- ptid_t m_ptid;
-};
+using scoped_finish_thread_state
+ = FORWARD_SCOPE_EXIT (finish_thread_state);
/* Commands with a prefix of `thread'. */
extern struct cmd_list_element *thread_cmd_list;
/* Print notices on thread events (attach, detach, etc.), set with
`set print thread-events'. */
-extern int print_thread_events;
+extern bool print_thread_events;
/* Prints the list of threads and their details on UIOUT. If
REQUESTED_THREADS, a list of GDB ids/ranges, is not NULL, only
all attached PIDs are printed. If both REQUESTED_THREADS is not
NULL and PID is not -1, then the thread is printed if it belongs to
the specified process. Otherwise, an error is raised. */
-extern void print_thread_info (struct ui_out *uiout, char *requested_threads,
+extern void print_thread_info (struct ui_out *uiout,
+ const char *requested_threads,
int pid);
/* Save/restore current inferior/thread/frame. */
DISABLE_COPY_AND_ASSIGN (scoped_restore_current_thread);
+ /* Cancel restoring on scope exit. */
+ void dont_restore () { m_dont_restore = true; }
+
private:
- /* Use the "class" keyword here, because of a clash with a "thread_info"
- function in the Darwin API. */
- class thread_info *m_thread;
- inferior *m_inf;
+ void restore ();
+
+ bool m_dont_restore = false;
+ thread_info_ref m_thread;
+ inferior_ref m_inf;
+
frame_id m_selected_frame_id;
int m_selected_frame_level;
bool m_was_stopped;
+ /* Save/restore the language as well, because selecting a frame
+ changes the current language to the frame's language if "set
+ language auto". */
+ enum language m_lang;
};
/* Returns a pointer into the thread_info corresponding to
public:
explicit enable_thread_stack_temporaries (struct thread_info *thr)
- : m_thr (thr)
+ : m_thr (thread_info_ref::new_reference (thr))
{
- gdb_assert (m_thr != NULL);
-
- m_thr->incref ();
-
m_thr->stack_temporaries_enabled = true;
m_thr->stack_temporaries.clear ();
}
{
m_thr->stack_temporaries_enabled = false;
m_thr->stack_temporaries.clear ();
-
- m_thr->decref ();
}
DISABLE_COPY_AND_ASSIGN (enable_thread_stack_temporaries);
private:
- struct thread_info *m_thr;
+ thread_info_ref m_thr;
};
extern bool thread_stack_temporaries_enabled_p (struct thread_info *tp);
extern bool value_in_thread_stack_temporaries (struct value *,
struct thread_info *thr);
-/* Add TP to the end of its inferior's pending step-over chain. */
+/* Add TP to the end of the global pending step-over chain. */
+
+extern void global_thread_step_over_chain_enqueue (thread_info *tp);
-extern void thread_step_over_chain_enqueue (struct thread_info *tp);
+/* Append the thread step over chain CHAIN_HEAD to the global thread step over
+ chain. */
-/* Remove TP from its inferior's pending step-over chain. */
+extern void global_thread_step_over_chain_enqueue_chain
+ (thread_info *chain_head);
-extern void thread_step_over_chain_remove (struct thread_info *tp);
+/* Remove TP from step-over chain LIST_P. */
-/* Return the next thread in the step-over chain starting at TP. NULL
- if TP is the last entry in the chain. */
+extern void thread_step_over_chain_remove (thread_info **list_p,
+ thread_info *tp);
-extern struct thread_info *thread_step_over_chain_next (struct thread_info *tp);
+/* Remove TP from the global pending step-over chain. */
-/* Return true if TP is in the step-over chain. */
+extern void global_thread_step_over_chain_remove (thread_info *tp);
+
+/* Return the thread following TP in the step-over chain whose head is
+ CHAIN_HEAD. Return NULL if TP is the last entry in the chain. */
+
+extern thread_info *thread_step_over_chain_next (thread_info *chain_head,
+ thread_info *tp);
+
+/* Return the thread following TP in the global step-over chain, or NULL if TP
+ is the last entry in the chain. */
+
+extern thread_info *global_thread_step_over_chain_next (thread_info *tp);
+
+/* Return true if TP is in any step-over chain. */
extern int thread_is_in_step_over_chain (struct thread_info *tp);
+/* Return the length of the the step over chain TP is in.
+
+ If TP is non-nullptr, the thread must be in a step over chain.
+ TP may be nullptr, in which case it denotes an empty list, so a length of
+ 0. */
+
+extern int thread_step_over_chain_length (thread_info *tp);
+
/* Cancel any ongoing execution command. */
extern void thread_cancel_execution_command (struct thread_info *thr);
alive anymore. */
extern void thread_select (const char *tidstr, class thread_info *thr);
-extern struct thread_info *thread_list;
-
#endif /* GDBTHREAD_H */
projects / binutils-gdb.git / blobdiff