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
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. */
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
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. */
global id, not the system's). */
extern int valid_global_thread_id (int global_id);
-/* Find thread PTID of inferior INF. */
+/* Find (non-exited) thread PTID of inferior INF. */
extern thread_info *find_thread_ptid (inferior *inf, ptid_t ptid);
-/* Search function to lookup a thread by 'pid'. */
+/* 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 thread by 'ptid'. Only searches in
- threads of INF. */
+/* 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. */
projects / deliverable / binutils-gdb.git / blobdiff