GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.1/gdb/gdbthread.h
Go to the documentation of this file.
1/* Multi-process/thread control defs for GDB, the GNU debugger.
2 Copyright (C) 1987-2023 Free Software Foundation, Inc.
3 Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
4
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21#ifndef GDBTHREAD_H
22#define GDBTHREAD_H
23
24struct symtab;
25
26#include "breakpoint.h"
27#include "frame.h"
28#include "ui-out.h"
29#include "btrace.h"
30#include "target/waitstatus.h"
31#include "cli/cli-utils.h"
32#include "gdbsupport/refcounted-object.h"
33#include "gdbsupport/common-gdbthread.h"
34#include "gdbsupport/forward-scope-exit.h"
35#include "displaced-stepping.h"
36#include "gdbsupport/intrusive_list.h"
37#include "thread-fsm.h"
38
39struct inferior;
41
42/* When true, print debug messages related to GDB thread creation and
43 deletion. */
44
45extern bool debug_threads;
46
47/* Print a "threads" debug statement. */
48
49#define threads_debug_printf(fmt, ...) \
50 debug_prefixed_printf_cond (debug_threads, "threads", fmt, ##__VA_ARGS__)
51
52/* Frontend view of the thread state. Possible extensions: stepping,
53 finishing, until(ling),...
54
55 NOTE: Since the thread state is not a boolean, most times, you do
56 not want to check it with negation. If you really want to check if
57 the thread is stopped,
58
59 use (good):
60
61 if (tp->state == THREAD_STOPPED)
62
63 instead of (bad):
64
65 if (tp->state != THREAD_RUNNING)
66
67 The latter is also true for exited threads, most likely not what
68 you want. */
70{
71 /* In the frontend's perpective, the thread is stopped. */
73
74 /* In the frontend's perpective, the thread is running. */
76
77 /* The thread is listed, but known to have exited. We keep it
78 listed (but not visible) until it's safe to delete it. */
80};
81
82/* STEP_OVER_ALL means step over all subroutine calls.
83 STEP_OVER_UNDEBUGGABLE means step over calls to undebuggable functions.
84 STEP_OVER_NONE means don't step over any subroutine calls. */
85
87 {
91 };
92
93/* Inferior thread specific part of `struct infcall_control_state'.
94
95 Inferior process counterpart is `struct inferior_control_state'. */
96
98{
99 /* User/external stepping state. */
100
101 /* Step-resume or longjmp-resume breakpoint. */
103
104 /* Exception-resume breakpoint. */
106
107 /* Breakpoints used for software single stepping. Plural, because
108 it may have multiple locations. E.g., if stepping over a
109 conditional branch instruction we can't decode the condition for,
110 we'll need to put a breakpoint at the branch destination, and
111 another at the instruction after the branch. */
113
114 /* Range to single step within.
115
116 If this is nonzero, respond to a single-step signal by continuing
117 to step if the pc is in this range.
118
119 If step_range_start and step_range_end are both 1, it means to
120 step for a single instruction (FIXME: it might clean up
121 wait_for_inferior in a minor way if this were changed to the
122 address of the instruction and that address plus one. But maybe
123 not). */
124 CORE_ADDR step_range_start = 0; /* Inclusive */
125 CORE_ADDR step_range_end = 0; /* Exclusive */
126
127 /* Function the thread was in as of last it started stepping. */
128 struct symbol *step_start_function = nullptr;
129
130 /* If GDB issues a target step request, and this is nonzero, the
131 target should single-step this thread once, and then continue
132 single-stepping it without GDB core involvement as long as the
133 thread stops in the step range above. If this is zero, the
134 target should ignore the step range, and only issue one single
135 step. */
137
138 /* Stack frame address as of when stepping command was issued.
139 This is how we know when we step into a subroutine call, and how
140 to set the frame for the breakpoint used to step out. */
142
143 /* Similarly, the frame ID of the underlying stack frame (skipping
144 any inlined frames). */
146
147 /* True if the the thread is presently stepping over a breakpoint or
148 a watchpoint, either with an inline step over or a displaced (out
149 of line) step, and we're now expecting it to report a trap for
150 the finished single step. */
152
153 /* Nonzero if the thread is being proceeded for a "finish" command
154 or a similar situation when return value should be printed. */
156
157 /* Nonzero if the thread is being proceeded for an inferior function
158 call. */
159 int in_infcall = 0;
160
162
163 /* Nonzero if stopped due to a step command. */
164 int stop_step = 0;
165
166 /* Chain containing status of breakpoint(s) the thread stopped
167 at. */
168 bpstat *stop_bpstat = nullptr;
169
170 /* Whether the command that started the thread was a stepping
171 command. This is used to decide whether "set scheduler-locking
172 step" behaves like "on" or "off". */
174};
175
176/* Inferior thread specific part of `struct infcall_suspend_state'. */
177
179{
180 /* Last signal that the inferior received (why it stopped). When
181 the thread is resumed, this signal is delivered. Note: the
182 target should not check whether the signal is in pass state,
183 because the signal may have been explicitly passed with the
184 "signal" command, which overrides "handle nopass". If the signal
185 should be suppressed, the core will take care of clearing this
186 before the target is resumed. */
187 enum gdb_signal stop_signal = GDB_SIGNAL_0;
188
189 /* The reason the thread last stopped, if we need to track it
190 (breakpoint, watchpoint, etc.) */
192
193 /* The waitstatus for this thread's last event. */
195 /* If true WAITSTATUS hasn't been handled yet. */
197
198 /* Record the pc of the thread the last time it stopped. (This is
199 not the current thread's PC as that may have changed since the
200 last stop, e.g., "return" command, or "p $pc = 0xf000").
201
202 - If the thread's PC has not changed since the thread last
203 stopped, then proceed skips a breakpoint at the current PC,
204 otherwise we let the thread run into the breakpoint.
205
206 - If the thread has an unprocessed event pending, as indicated by
207 waitstatus_pending_p, this is used in coordination with
208 stop_reason: if the thread's PC has changed since the thread
209 last stopped, a pending breakpoint waitstatus is discarded.
210
211 - If the thread is running, then this field has its value removed by
212 calling stop_pc.reset() (see thread_info::set_executing()).
213 Attempting to read a gdb::optional with no value is undefined
214 behaviour and will trigger an assertion error when _GLIBCXX_DEBUG is
215 defined, which should make error easier to track down. */
216 gdb::optional<CORE_ADDR> stop_pc;
217};
218
219/* Base class for target-specific thread data. */
221{
222 virtual ~private_thread_info () = 0;
223};
224
225/* Threads are intrusively refcounted objects. Being the
226 user-selected thread is normally considered an implicit strong
227 reference and is thus not accounted in the refcount, unlike
228 inferior objects. This is necessary, because there's no "current
229 thread" pointer. Instead the current thread is inferred from the
230 inferior_ptid global. However, when GDB needs to remember the
231 selected thread to later restore it, GDB bumps the thread object's
232 refcount, to prevent something deleting the thread object before
233 reverting back (e.g., due to a "kill" command). If the thread
234 meanwhile exits before being re-selected, then the thread object is
235 left listed in the thread list, but marked with state
236 THREAD_EXITED. (See scoped_restore_current_thread and
237 delete_thread). All other thread references are considered weak
238 references. Placing a thread in the thread list is an implicit
239 strong reference, and is thus not accounted for in the thread's
240 refcount.
241
242 The intrusive_list_node base links threads in a per-inferior list. */
243
244class thread_info : public refcounted_object,
245 public intrusive_list_node<thread_info>
246{
247public:
248 explicit thread_info (inferior *inf, ptid_t ptid);
249 ~thread_info ();
250
251 bool deletable () const;
252
253 /* Mark this thread as running and notify observers. */
254 void set_running (bool running);
255
256 ptid_t ptid; /* "Actual process id";
257 In fact, this may be overloaded with
258 kernel thread id, etc. */
259
260 /* Each thread has two GDB IDs.
261
262 a) The thread ID (Id). This consists of the pair of:
263
264 - the number of the thread's inferior and,
265
266 - the thread's thread number in its inferior, aka, the
267 per-inferior thread number. This number is unique in the
268 inferior but not unique between inferiors.
269
270 b) The global ID (GId). This is a a single integer unique
271 between all inferiors.
272
273 E.g.:
274
275 (gdb) info threads -gid
276 Id GId Target Id Frame
277 * 1.1 1 Thread A 0x16a09237 in foo () at foo.c:10
278 1.2 3 Thread B 0x15ebc6ed in bar () at foo.c:20
279 1.3 5 Thread C 0x15ebc6ed in bar () at foo.c:20
280 2.1 2 Thread A 0x16a09237 in foo () at foo.c:10
281 2.2 4 Thread B 0x15ebc6ed in bar () at foo.c:20
282 2.3 6 Thread C 0x15ebc6ed in bar () at foo.c:20
283
284 Above, both inferiors 1 and 2 have threads numbered 1-3, but each
285 thread has its own unique global ID. */
286
287 /* The thread's global GDB thread number. This is exposed to MI,
288 Python/Scheme, visible with "info threads -gid", and is also what
289 the $_gthread convenience variable is bound to. */
291
292 /* The per-inferior thread number. This is unique in the inferior
293 the thread belongs to, but not unique between inferiors. This is
294 what the $_thread convenience variable is bound to. */
296
297 /* The inferior this thread belongs to. */
298 struct inferior *inf;
299
300 /* The user-given name of the thread.
301
302 Returns nullptr if the thread does not have a user-given name. */
303 const char *name () const
304 {
305 return m_name.get ();
306 }
307
308 /* Set the user-given name of the thread.
309
310 Pass nullptr to clear the name. */
311 void set_name (gdb::unique_xmalloc_ptr<char> name)
312 {
313 m_name = std::move (name);
314 }
315
316 bool executing () const
317 { return m_executing; }
318
319 /* Set the thread's 'm_executing' field from EXECUTING, and if EXECUTING
320 is true also clears the thread's stop_pc. */
321 void set_executing (bool executing);
322
323 bool resumed () const
324 { return m_resumed; }
325
326 /* Set the thread's 'm_resumed' field from RESUMED. The thread may also
327 be added to (when RESUMED is true), or removed from (when RESUMED is
328 false), the list of threads with a pending wait status. */
329 void set_resumed (bool resumed);
330
331 /* Frontend view of the thread state. Note that the THREAD_RUNNING/
332 THREAD_STOPPED states are different from EXECUTING. When the
333 thread is stopped internally while handling an internal event,
334 like a software single-step breakpoint, EXECUTING will be false,
335 but STATE will still be THREAD_RUNNING. */
337
338 /* State of GDB control of inferior thread execution.
339 See `struct thread_control_state'. */
341
342 /* Save M_SUSPEND to SUSPEND. */
343
345 {
346 suspend = m_suspend;
347 }
348
349 /* Restore M_SUSPEND from SUSPEND. */
350
352 {
353 m_suspend = suspend;
354 }
355
356 /* Return this thread's stop PC. This should only be called when it is
357 known that stop_pc has a value. If this function is being used in a
358 situation where a thread may not have had a stop_pc assigned, then
359 stop_pc_p() can be used to check if the stop_pc is defined. */
360
361 CORE_ADDR stop_pc () const
362 {
363 gdb_assert (m_suspend.stop_pc.has_value ());
364 return *m_suspend.stop_pc;
365 }
366
367 /* Set this thread's stop PC. */
368
369 void set_stop_pc (CORE_ADDR stop_pc)
370 {
371 m_suspend.stop_pc = stop_pc;
372 }
373
374 /* Remove the stop_pc stored on this thread. */
375
377 {
378 m_suspend.stop_pc.reset ();
379 }
380
381 /* Return true if this thread has a cached stop pc value, otherwise
382 return false. */
383
384 bool stop_pc_p () const
385 {
386 return m_suspend.stop_pc.has_value ();
387 }
388
389 /* Return true if this thread has a pending wait status. */
390
392 {
394 }
395
396 /* Get this thread's pending wait status.
397
398 May only be called if has_pending_waitstatus returns true. */
399
401 {
402 gdb_assert (this->has_pending_waitstatus ());
403
404 return m_suspend.waitstatus;
405 }
406
407 /* Set this thread's pending wait status.
408
409 May only be called if has_pending_waitstatus returns false. */
410
411 void set_pending_waitstatus (const target_waitstatus &ws);
412
413 /* Clear this thread's pending wait status.
414
415 May only be called if has_pending_waitstatus returns true. */
416
417 void clear_pending_waitstatus ();
418
419 /* Return this thread's stop signal. */
420
421 gdb_signal stop_signal () const
422 {
423 return m_suspend.stop_signal;
424 }
425
426 /* Set this thread's stop signal. */
427
428 void set_stop_signal (gdb_signal sig)
429 {
431 }
432
433 /* Return this thread's stop reason. */
434
436 {
437 return m_suspend.stop_reason;
438 }
439
440 /* Set this thread's stop reason. */
441
443 {
444 m_suspend.stop_reason = reason;
445 }
446
447 /* Get the FSM associated with the thread. */
448
449 struct thread_fsm *thread_fsm () const
450 {
451 return m_thread_fsm.get ();
452 }
453
454 /* Get the owning reference to the FSM associated with the thread.
455
456 After a call to this method, "thread_fsm () == nullptr". */
457
458 std::unique_ptr<struct thread_fsm> release_thread_fsm ()
459 {
460 return std::move (m_thread_fsm);
461 }
462
463 /* Set the FSM associated with the current thread.
464
465 It is invalid to set the FSM if another FSM is already installed. */
466
467 void set_thread_fsm (std::unique_ptr<struct thread_fsm> fsm)
468 {
469 gdb_assert (m_thread_fsm == nullptr);
470 m_thread_fsm = std::move (fsm);
471 }
472
474 struct symtab *current_symtab = NULL;
475
476 /* Internal stepping state. */
477
478 /* Record the pc of the thread the last time it was resumed. (It
479 can't be done on stop as the PC may change since the last stop,
480 e.g., "return" command, or "p $pc = 0xf000"). This is maintained
481 by proceed and keep_going, and among other things, it's used in
482 adjust_pc_after_break to distinguish a hardware single-step
483 SIGTRAP from a breakpoint SIGTRAP. */
484 CORE_ADDR prev_pc = 0;
485
486 /* Did we set the thread stepping a breakpoint instruction? This is
487 used in conjunction with PREV_PC to decide whether to adjust the
488 PC. */
490
491 /* Should we step over breakpoint next time keep_going is called? */
493
494 /* Should we step over a watchpoint next time keep_going is called?
495 This is needed on targets with non-continuable, non-steppable
496 watchpoints. */
498
499 /* Set to TRUE if we should finish single-stepping over a breakpoint
500 after hitting the current step-resume breakpoint. The context here
501 is that GDB is to do `next' or `step' while signal arrives.
502 When stepping over a breakpoint and signal arrives, GDB will attempt
503 to skip signal handler, so it inserts a step_resume_breakpoint at the
504 signal return address, and resume inferior.
505 step_after_step_resume_breakpoint is set to TRUE at this moment in
506 order to keep GDB in mind that there is still a breakpoint to step over
507 when GDB gets back SIGTRAP from step_resume_breakpoint. */
509
510 /* This is used to remember when a fork or vfork event was caught by
511 a catchpoint, and thus the event is to be followed at the next
512 resume of the thread, and not immediately. */
514
515 /* True if this thread has been explicitly requested to stop. */
517
518 /* The initiating frame of a nexting operation, used for deciding
519 which exceptions to intercept. If it is null_frame_id no
520 bp_longjmp or bp_exception but longjmp has been caught just for
521 bp_longjmp_call_dummy. */
523
524 /* Private data used by the target vector implementation. */
525 std::unique_ptr<private_thread_info> priv;
526
527 /* Branch trace information for this thread. */
529
530 /* Flag which indicates that the stack temporaries should be stored while
531 evaluating expressions. */
533
534 /* Values that are stored as temporaries on stack while evaluating
535 expressions. */
536 std::vector<struct value *> stack_temporaries;
537
538 /* Step-over chain. A thread is in the step-over queue if this node is
539 linked. */
540 intrusive_list_node<thread_info> step_over_list_node;
541
542 /* Node for list of threads that are resumed and have a pending wait status.
543
544 The list head for this is in process_stratum_target, hence all threads in
545 this list belong to that process target. */
546 intrusive_list_node<thread_info> resumed_with_pending_wait_status_node;
547
548 /* Displaced-step state for this thread. */
550
551private:
552 /* True if this thread is resumed from infrun's perspective.
553 Note that a thread can be marked both as not-executing and
554 resumed at the same time. This happens if we try to resume a
555 thread that has a wait status pending. We shouldn't let the
556 thread really run until that wait status has been processed, but
557 we should not process that wait status if we didn't try to let
558 the thread run. */
559 bool m_resumed = false;
560
561 /* True means the thread is executing. Note: this is different
562 from saying that there is an active target and we are stopped at
563 a breakpoint, for instance. This is a real indicator whether the
564 thread is off and running. */
565 bool m_executing = false;
566
567 /* State of inferior thread to restore after GDB is done with an inferior
568 call. See `struct thread_suspend_state'. */
570
571 /* The user-given name of the thread.
572
573 Nullptr if the thread does not have a user-given name. */
574 gdb::unique_xmalloc_ptr<char> m_name;
575
576 /* Pointer to the state machine manager object that handles what is
577 left to do for the thread's execution command after the target
578 stops. Several execution commands use it. */
579 std::unique_ptr<struct thread_fsm> m_thread_fsm;
580};
581
583 = intrusive_member_node<thread_info,
586 = intrusive_list<thread_info,
588
589/* A gdb::ref_ptr pointer to a thread_info. */
590
592 = gdb::ref_ptr<struct thread_info, refcounted_object_ref_policy>;
593
594/* A gdb::ref_ptr pointer to an inferior. This would ideally be in
595 inferior.h, but it can't due to header dependencies (inferior.h
596 includes gdbthread.h). */
597
599 = gdb::ref_ptr<struct inferior, refcounted_object_ref_policy>;
600
601/* Create an empty thread list, or empty the existing one. */
602extern void init_thread_list (void);
603
604/* Add a thread to the thread list, print a message
605 that a new thread is found, and return the pointer to
606 the new thread. Caller my use this pointer to
607 initialize the private thread data. */
608extern struct thread_info *add_thread (process_stratum_target *targ,
609 ptid_t ptid);
610
611/* Same as add_thread, but does not print a message about new
612 thread. */
614 ptid_t ptid);
615
616/* Same as add_thread, and sets the private info. */
618 ptid_t ptid,
620
621/* Delete thread THREAD and notify of thread exit. If the thread is
622 currently not deletable, don't actually delete it but still tag it
623 as exited and do the notification. */
624extern void delete_thread (struct thread_info *thread);
625
626/* Like delete_thread, but be quiet about it. Used when the process
627 this thread belonged to has already exited, for example. */
628extern void delete_thread_silent (struct thread_info *thread);
629
630/* Mark the thread exited, but don't delete it or remove it from the
631 inferior thread list. */
632extern void set_thread_exited (thread_info *tp, bool silent);
633
634/* Delete a step_resume_breakpoint from the thread database. */
635extern void delete_step_resume_breakpoint (struct thread_info *);
636
637/* Delete an exception_resume_breakpoint from the thread database. */
639
640/* Delete the single-step breakpoints of thread TP, if any. */
641extern void delete_single_step_breakpoints (struct thread_info *tp);
642
643/* Check if the thread has software single stepping breakpoints
644 set. */
646
647/* Check whether the thread has software single stepping breakpoints
648 set at PC. */
650 const address_space *aspace,
651 CORE_ADDR addr);
652
653/* Returns whether to show inferior-qualified thread IDs, or plain
654 thread numbers. Inferior-qualified IDs are shown whenever we have
655 multiple inferiors, or the only inferior left has number > 1. */
656extern int show_inferior_qualified_tids (void);
657
658/* Return a string version of THR's thread ID. If there are multiple
659 inferiors, then this prints the inferior-qualifier form, otherwise
660 it only prints the thread number. The result is stored in a
661 circular static buffer, NUMCELLS deep. */
662const char *print_thread_id (struct thread_info *thr);
663
664/* Boolean test for an already-known ptid. */
665extern bool in_thread_list (process_stratum_target *targ, ptid_t ptid);
666
667/* Boolean test for an already-known global thread id (GDB's homegrown
668 global id, not the system's). */
669extern int valid_global_thread_id (int global_id);
670
671/* Find (non-exited) thread PTID of inferior INF. */
672extern thread_info *find_thread_ptid (inferior *inf, ptid_t ptid);
673
674/* Search function to lookup a (non-exited) thread by 'ptid'. */
676 ptid_t ptid);
677
678/* Find thread by GDB global thread ID. */
679struct thread_info *find_thread_global_id (int global_id);
680
681/* Find thread by thread library specific handle in inferior INF. */
683 (gdb::array_view<const gdb_byte> handle, struct inferior *inf);
684
685/* Finds the first thread of the specified inferior. */
687
688/* Returns any thread of inferior INF, giving preference to the
689 current thread. */
691
692/* Returns any non-exited thread of inferior INF, giving preference to
693 the current thread, and to not executing threads. */
695
696/* Change the ptid of thread OLD_PTID to NEW_PTID. */
698 ptid_t old_ptid, ptid_t new_ptid);
699
700/* Iterator function to call a user-provided callback function
701 once for each known thread. */
702typedef int (*thread_callback_func) (struct thread_info *, void *);
704
705/* Pull in the internals of the inferiors/threads ranges and
706 iterators. Must be done after struct thread_info is defined. */
707#include "thread-iter.h"
708
709/* Return a range that can be used to walk over threads, with
710 range-for.
711
712 Used like this, it walks over all threads of all inferiors of all
713 targets:
714
715 for (thread_info *thr : all_threads ())
716 { .... }
717
718 FILTER_PTID can be used to filter out threads that don't match.
719 FILTER_PTID can be:
720
721 - minus_one_ptid, meaning walk all threads of all inferiors of
722 PROC_TARGET. If PROC_TARGET is NULL, then of all targets.
723
724 - A process ptid, in which case walk all threads of the specified
725 process. PROC_TARGET must be non-NULL in this case.
726
727 - A thread ptid, in which case walk that thread only. PROC_TARGET
728 must be non-NULL in this case.
729*/
730
732all_threads (process_stratum_target *proc_target = nullptr,
733 ptid_t filter_ptid = minus_one_ptid)
734{
735 return all_matching_threads_range (proc_target, filter_ptid);
736}
737
738/* Return a range that can be used to walk over all non-exited threads
739 of all inferiors, with range-for. Arguments are like all_threads
740 above. */
741
744 ptid_t filter_ptid = minus_one_ptid)
745{
746 return all_non_exited_threads_range (proc_target, filter_ptid);
747}
748
749/* Return a range that can be used to walk over all threads of all
750 inferiors, with range-for, safely. I.e., it is safe to delete the
751 currently-iterated thread. When combined with range-for, this
752 allow convenient patterns like this:
753
754 for (thread_info *t : all_threads_safe ())
755 if (some_condition ())
756 delete f;
757*/
758
761{
763}
764
765extern int thread_count (process_stratum_target *proc_target);
766
767/* Return true if we have any thread in any inferior. */
768extern bool any_thread_p ();
769
770/* Switch context to thread THR. Also sets the STOP_PC global. */
771extern void switch_to_thread (struct thread_info *thr);
772
773/* Switch context to no thread selected. */
774extern void switch_to_no_thread ();
775
776/* Switch from one thread to another. Does not read registers. */
777extern void switch_to_thread_no_regs (struct thread_info *thread);
778
779/* Marks or clears thread(s) PTID of TARG as resumed. If PTID is
780 MINUS_ONE_PTID, applies to all threads of TARG. If
781 ptid_is_pid(PTID) is true, applies to all threads of the process
782 pointed at by {TARG,PTID}. */
783extern void set_resumed (process_stratum_target *targ,
784 ptid_t ptid, bool resumed);
785
786/* Marks thread PTID of TARG as running, or as stopped. If PTID is
787 minus_one_ptid, marks all threads of TARG. */
788extern void set_running (process_stratum_target *targ,
789 ptid_t ptid, bool running);
790
791/* Marks or clears thread(s) PTID of TARG as having been requested to
792 stop. If PTID is MINUS_ONE_PTID, applies to all threads of TARG.
793 If ptid_is_pid(PTID) is true, applies to all threads of the process
794 pointed at by {TARG, PTID}. If STOP, then the
795 THREAD_STOP_REQUESTED observer is called with PTID as argument. */
797 ptid_t ptid, bool stop);
798
799/* Marks thread PTID of TARG as executing, or not. If PTID is
800 minus_one_ptid, marks all threads of TARG.
801
802 Note that this is different from the running state. See the
803 description of state and executing fields of struct
804 thread_info. */
805extern void set_executing (process_stratum_target *targ,
806 ptid_t ptid, bool executing);
807
808/* True if any (known or unknown) thread of TARG is or may be
809 executing. */
811
812/* Merge the executing property of thread PTID of TARG over to its
813 thread state property (frontend running/stopped view).
814
815 "not executing" -> "stopped"
816 "executing" -> "running"
817 "exited" -> "exited"
818
819 If PTID is minus_one_ptid, go over all threads of TARG.
820
821 Notifications are only emitted if the thread state did change. */
822extern void finish_thread_state (process_stratum_target *targ, ptid_t ptid);
823
824/* Calls finish_thread_state on scope exit, unless release() is called
825 to disengage. */
827 = FORWARD_SCOPE_EXIT (finish_thread_state);
828
829/* Commands with a prefix of `thread'. */
830extern struct cmd_list_element *thread_cmd_list;
831
832extern void thread_command (const char *tidstr, int from_tty);
833
834/* Print notices on thread events (attach, detach, etc.), set with
835 `set print thread-events'. */
836extern bool print_thread_events;
837
838/* Prints the list of threads and their details on UIOUT. If
839 REQUESTED_THREADS, a list of GDB ids/ranges, is not NULL, only
840 print threads whose ID is included in the list. If PID is not -1,
841 only print threads from the process PID. Otherwise, threads from
842 all attached PIDs are printed. If both REQUESTED_THREADS is not
843 NULL and PID is not -1, then the thread is printed if it belongs to
844 the specified process. Otherwise, an error is raised. */
845extern void print_thread_info (struct ui_out *uiout,
846 const char *requested_threads,
847 int pid);
848
849/* Save/restore current inferior/thread/frame. */
850
852{
853public:
856
858
859 /* Cancel restoring on scope exit. */
860 void dont_restore () { m_dont_restore = true; }
861
862private:
863 void restore ();
864
865 bool m_dont_restore = false;
868
872 /* Save/restore the language as well, because selecting a frame
873 changes the current language to the frame's language if "set
874 language auto". */
876};
877
878/* Returns a pointer into the thread_info corresponding to
879 INFERIOR_PTID. INFERIOR_PTID *must* be in the thread list. */
880extern struct thread_info* inferior_thread (void);
881
882extern void update_thread_list (void);
883
884/* Delete any thread the target says is no longer alive. */
885
886extern void prune_threads (void);
887
888/* Delete threads marked THREAD_EXITED. Unlike prune_threads, this
889 does not consult the target about whether the thread is alive right
890 now. */
891extern void delete_exited_threads (void);
892
893/* Return true if PC is in the stepping range of THREAD. */
894
895int pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread);
896
897/* Enable storing stack temporaries for thread THR and disable and
898 clear the stack temporaries on destruction. Holds a strong
899 reference to THR. */
900
902{
903public:
904
906 : m_thr (thread_info_ref::new_reference (thr))
907 {
908 m_thr->stack_temporaries_enabled = true;
909 m_thr->stack_temporaries.clear ();
910 }
911
913 {
914 m_thr->stack_temporaries_enabled = false;
915 m_thr->stack_temporaries.clear ();
916 }
917
919
920private:
921
923};
924
925extern bool thread_stack_temporaries_enabled_p (struct thread_info *tp);
926
927extern void push_thread_stack_temporary (struct thread_info *tp, struct value *v);
928
930
931extern bool value_in_thread_stack_temporaries (struct value *,
932 struct thread_info *thr);
933
934/* Thread step-over list type. */
936 = intrusive_member_node<thread_info, &thread_info::step_over_list_node>;
938 = intrusive_list<thread_info, thread_step_over_list_node>;
940 = reference_to_pointer_iterator<thread_step_over_list::iterator>;
942 = basic_safe_iterator<thread_step_over_list_iterator>;
944 = iterator_range<thread_step_over_list_safe_iterator>;
945
948{
951 list.end ()),
953 list.end ()));
954}
955
956/* Add TP to the end of the global pending step-over chain. */
957
959
960/* Append the thread step over list LIST to the global thread step over
961 chain. */
962
964 (thread_step_over_list &&list);
965
966/* Remove TP from the global pending step-over chain. */
967
969
970/* Return true if TP is in any step-over chain. */
971
972extern int thread_is_in_step_over_chain (struct thread_info *tp);
973
974/* Return the length of the the step over chain TP is in.
975
976 If TP is non-nullptr, the thread must be in a step over chain.
977 TP may be nullptr, in which case it denotes an empty list, so a length of
978 0. */
979
981
982/* Cancel any ongoing execution command. */
983
984extern void thread_cancel_execution_command (struct thread_info *thr);
985
986/* Check whether it makes sense to access a register of the current
987 thread at this point. If not, throw an error (e.g., the thread is
988 executing). */
989extern void validate_registers_access (void);
990
991/* Check whether it makes sense to access a register of THREAD at this point.
992 Returns true if registers may be accessed; false otherwise. */
993extern bool can_access_registers_thread (struct thread_info *thread);
994
995/* Returns whether to show which thread hit the breakpoint, received a
996 signal, etc. and ended up causing a user-visible stop. This is
997 true iff we ever detected multiple threads. */
998extern int show_thread_that_caused_stop (void);
999
1000/* Print the message for a thread or/and frame selected. */
1001extern void print_selected_thread_frame (struct ui_out *uiout,
1002 user_selected_what selection);
1003
1004/* Helper for the CLI's "thread" command and for MI's -thread-select.
1005 Selects thread THR. TIDSTR is the original string the thread ID
1006 was parsed from. This is used in the error message if THR is not
1007 alive anymore. */
1008extern void thread_select (const char *tidstr, class thread_info *thr);
1009
1010/* Return THREAD's name.
1011
1012 If THREAD has a user-given name, return it. Otherwise, query the thread's
1013 target to get the name. May return nullptr. */
1014extern const char *thread_name (thread_info *thread);
1015
1016/* Switch to thread TP if it is alive. Returns true if successfully
1017 switched, false otherwise. */
1018
1019extern bool switch_to_thread_if_alive (thread_info *thr);
1020
1021/* Assuming that THR is the current thread, execute CMD.
1022 If ADA_TASK is not empty, it is the Ada task ID, and will
1023 be printed instead of the thread information.
1024 FLAGS.QUIET controls the printing of the thread information.
1025 FLAGS.CONT and FLAGS.SILENT control how to handle errors. Can throw an
1026 exception if !FLAGS.SILENT and !FLAGS.CONT and CMD fails. */
1027
1028extern void thread_try_catch_cmd (thread_info *thr,
1029 gdb::optional<int> ada_task,
1030 const char *cmd, int from_tty,
1031 const qcs_flags &flags);
1032
1033/* Return a string representation of STATE. */
1034
1035extern const char *thread_state_string (enum thread_state state);
1036
1037#endif /* GDBTHREAD_H */
const char *const name
Definition: aarch64-tdep.c:67
enable_thread_stack_temporaries(struct thread_info *thr)
Definition: gdbthread.h:905
DISABLE_COPY_AND_ASSIGN(enable_thread_stack_temporaries)
DISABLE_COPY_AND_ASSIGN(scoped_restore_current_thread)
thread_info_ref m_thread
Definition: gdbthread.h:866
int stepping_over_watchpoint
Definition: gdbthread.h:497
bool stop_pc_p() const
Definition: gdbthread.h:384
thread_suspend_state m_suspend
Definition: gdbthread.h:569
std::vector< struct value * > stack_temporaries
Definition: gdbthread.h:536
CORE_ADDR stop_pc() const
Definition: gdbthread.h:361
void set_thread_fsm(std::unique_ptr< struct thread_fsm > fsm)
Definition: gdbthread.h:467
void clear_stop_pc()
Definition: gdbthread.h:376
std::unique_ptr< struct thread_fsm > release_thread_fsm()
Definition: gdbthread.h:458
intrusive_list_node< thread_info > resumed_with_pending_wait_status_node
Definition: gdbthread.h:546
intrusive_list_node< thread_info > step_over_list_node
Definition: gdbthread.h:540
enum thread_state state
Definition: gdbthread.h:336
struct symtab * current_symtab
Definition: gdbthread.h:474
int per_inf_num
Definition: gdbthread.h:295
int global_num
Definition: gdbthread.h:290
ptid_t ptid
Definition: gdbthread.h:256
void restore_suspend_from(const thread_suspend_state &suspend)
Definition: gdbthread.h:351
void set_name(gdb::unique_xmalloc_ptr< char > name)
Definition: gdbthread.h:311
gdb_signal stop_signal() const
Definition: gdbthread.h:421
std::unique_ptr< private_thread_info > priv
Definition: gdbthread.h:525
void save_suspend_to(thread_suspend_state &suspend) const
Definition: gdbthread.h:344
bool resumed() const
Definition: gdbthread.h:323
int current_line
Definition: gdbthread.h:473
bool has_pending_waitstatus() const
Definition: gdbthread.h:391
gdb::unique_xmalloc_ptr< char > m_name
Definition: gdbthread.h:574
void set_stop_reason(target_stop_reason reason)
Definition: gdbthread.h:442
struct frame_id initiating_frame
Definition: gdbthread.h:522
struct target_waitstatus pending_follow
Definition: gdbthread.h:513
const target_waitstatus & pending_waitstatus() const
Definition: gdbthread.h:400
bool m_resumed
Definition: gdbthread.h:559
target_stop_reason stop_reason() const
Definition: gdbthread.h:435
int step_after_step_resume_breakpoint
Definition: gdbthread.h:508
int stepping_over_breakpoint
Definition: gdbthread.h:492
bool m_executing
Definition: gdbthread.h:565
bool deletable() const
Definition: thread.c:332
struct thread_fsm * thread_fsm() const
Definition: gdbthread.h:449
std::unique_ptr< struct thread_fsm > m_thread_fsm
Definition: gdbthread.h:579
displaced_step_thread_state displaced_step_state
Definition: gdbthread.h:549
bool executing() const
Definition: gdbthread.h:316
bool stack_temporaries_enabled
Definition: gdbthread.h:532
int stepped_breakpoint
Definition: gdbthread.h:489
int stop_requested
Definition: gdbthread.h:516
struct inferior * inf
Definition: gdbthread.h:298
void set_stop_pc(CORE_ADDR stop_pc)
Definition: gdbthread.h:369
void set_stop_signal(gdb_signal sig)
Definition: gdbthread.h:428
CORE_ADDR prev_pc
Definition: gdbthread.h:484
const char * name() const
Definition: gdbthread.h:303
thread_control_state control
Definition: gdbthread.h:340
Definition: ui-out.h:160
language
Definition: defs.h:211
const struct frame_id null_frame_id
Definition: frame.c:664
struct thread_info * any_live_thread_of_inferior(inferior *inf)
Definition: thread.c:644
bool switch_to_thread_if_alive(thread_info *thr)
Definition: thread.c:697
all_threads_safe_range all_threads_safe()
Definition: gdbthread.h:760
int thread_step_over_chain_length(const thread_step_over_list &l)
Definition: thread.c:410
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
Definition: thread.c:303
void global_thread_step_over_chain_remove(thread_info *tp)
Definition: thread.c:443
const char * thread_state_string(enum thread_state state)
Definition: thread.c:2064
void global_thread_step_over_chain_enqueue_chain(thread_step_over_list &&list)
Definition: thread.c:435
int thread_count(process_stratum_target *proc_target)
Definition: thread.c:586
struct cmd_list_element * thread_cmd_list
Definition: thread.c:2143
struct thread_info * add_thread_silent(process_stratum_target *targ, ptid_t ptid)
Definition: thread.c:263
all_matching_threads_range all_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
Definition: gdbthread.h:732
intrusive_member_node< thread_info, &thread_info::step_over_list_node > thread_step_over_list_node
Definition: gdbthread.h:936
void thread_select(const char *tidstr, class thread_info *thr)
Definition: thread.c:1945
bool value_in_thread_stack_temporaries(struct value *, struct thread_info *thr)
Definition: thread.c:766
thread_info * find_thread_ptid(inferior *inf, ptid_t ptid)
Definition: thread.c:528
struct thread_info * first_thread_of_inferior(inferior *inf)
Definition: thread.c:620
int(* thread_callback_func)(struct thread_info *, void *)
Definition: gdbthread.h:702
void print_selected_thread_frame(struct ui_out *uiout, user_selected_what selection)
Definition: thread.c:1960
iterator_range< thread_step_over_list_safe_iterator > thread_step_over_list_safe_range
Definition: gdbthread.h:944
void switch_to_thread_no_regs(struct thread_info *thread)
Definition: thread.c:1303
all_non_exited_threads_range all_non_exited_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
Definition: gdbthread.h:743
int show_inferior_qualified_tids(void)
Definition: thread.c:1419
void validate_registers_access(void)
Definition: thread.c:930
void delete_thread(struct thread_info *thread)
Definition: thread.c:483
thread_state
Definition: gdbthread.h:70
@ THREAD_STOPPED
Definition: gdbthread.h:72
@ THREAD_RUNNING
Definition: gdbthread.h:75
@ THREAD_EXITED
Definition: gdbthread.h:79
int valid_global_thread_id(int global_id)
Definition: thread.c:602
bool debug_threads
Definition: thread.c:54
int show_thread_that_caused_stop(void)
Definition: thread.c:1411
static thread_step_over_list_safe_range make_thread_step_over_list_safe_range(thread_step_over_list &list)
Definition: gdbthread.h:947
bool any_thread_p()
Definition: thread.c:578
void set_stop_requested(process_stratum_target *targ, ptid_t ptid, bool stop)
Definition: thread.c:903
struct thread_info * find_thread_global_id(int global_id)
Definition: thread.c:495
void global_thread_step_over_chain_enqueue(thread_info *tp)
Definition: thread.c:423
intrusive_list< thread_info, thread_info_resumed_with_pending_wait_status_node > thread_info_resumed_with_pending_wait_status_list
Definition: gdbthread.h:587
int pc_in_thread_step_range(CORE_ADDR pc, struct thread_info *thread)
Definition: thread.c:972
void finish_thread_state(process_stratum_target *targ, ptid_t ptid)
Definition: thread.c:915
intrusive_member_node< thread_info, &thread_info::resumed_with_pending_wait_status_node > thread_info_resumed_with_pending_wait_status_node
Definition: gdbthread.h:584
void update_thread_list(void)
Definition: thread.c:2037
void set_executing(process_stratum_target *targ, ptid_t ptid, bool executing)
Definition: thread.c:880
struct thread_info * inferior_thread(void)
Definition: thread.c:83
void set_thread_exited(thread_info *tp, bool silent)
Definition: thread.c:195
void switch_to_thread(struct thread_info *thr)
Definition: thread.c:1335
void thread_command(const char *tidstr, int from_tty)
Definition: thread.c:1811
void thread_try_catch_cmd(thread_info *thr, gdb::optional< int > ada_task, const char *cmd, int from_tty, const qcs_flags &flags)
Definition: thread.c:1471
void set_running(process_stratum_target *targ, ptid_t ptid, bool running)
Definition: thread.c:863
int thread_has_single_step_breakpoint_here(struct thread_info *tp, const address_space *aspace, CORE_ADDR addr)
Definition: thread.c:148
void delete_step_resume_breakpoint(struct thread_info *)
Definition: thread.c:102
value * get_last_thread_stack_temporary(struct thread_info *tp)
Definition: thread.c:780
bool can_access_registers_thread(struct thread_info *thread)
Definition: thread.c:954
struct thread_info * add_thread_with_info(process_stratum_target *targ, ptid_t ptid, private_thread_info *)
Definition: thread.c:288
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:565
bool print_thread_events
Definition: thread.c:1932
void push_thread_stack_temporary(struct thread_info *tp, struct value *v)
Definition: thread.c:756
void thread_change_ptid(process_stratum_target *targ, ptid_t old_ptid, ptid_t new_ptid)
Definition: thread.c:792
basic_safe_iterator< thread_step_over_list_iterator > thread_step_over_list_safe_iterator
Definition: gdbthread.h:942
FORWARD_SCOPE_EXIT(finish_thread_state) scoped_finish_thread_state
Definition: gdbthread.h:827
struct thread_info * any_thread_of_inferior(inferior *inf)
Definition: thread.c:629
void set_resumed(process_stratum_target *targ, ptid_t ptid, bool resumed)
Definition: thread.c:819
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
Definition: thread.c:140
const char * thread_name(thread_info *thread)
Definition: thread.c:2046
int thread_is_in_step_over_chain(struct thread_info *tp)
Definition: thread.c:402
bool thread_stack_temporaries_enabled_p(struct thread_info *tp)
Definition: thread.c:745
void prune_threads(void)
Definition: thread.c:718
void delete_exception_resume_breakpoint(struct thread_info *)
Definition: thread.c:109
struct thread_info * find_thread_by_handle(gdb::array_view< const gdb_byte > handle, struct inferior *inf)
Definition: thread.c:542
step_over_calls_kind
Definition: gdbthread.h:87
@ STEP_OVER_NONE
Definition: gdbthread.h:88
@ STEP_OVER_UNDEBUGGABLE
Definition: gdbthread.h:90
@ STEP_OVER_ALL
Definition: gdbthread.h:89
gdb::ref_ptr< struct thread_info, refcounted_object_ref_policy > thread_info_ref
Definition: gdbthread.h:592
intrusive_list< thread_info, thread_step_over_list_node > thread_step_over_list
Definition: gdbthread.h:938
bool threads_are_executing(process_stratum_target *targ)
Definition: thread.c:897
void delete_single_step_breakpoints(struct thread_info *tp)
Definition: thread.c:118
bool in_thread_list(process_stratum_target *targ, ptid_t ptid)
Definition: thread.c:612
void delete_thread_silent(struct thread_info *thread)
Definition: thread.c:489
void switch_to_no_thread()
Definition: thread.c:1320
void print_thread_info(struct ui_out *uiout, const char *requested_threads, int pid)
Definition: thread.c:1226
void thread_cancel_execution_command(struct thread_info *thr)
Definition: thread.c:161
const char * print_thread_id(struct thread_info *thr)
Definition: thread.c:1431
reference_to_pointer_iterator< thread_step_over_list::iterator > thread_step_over_list_iterator
Definition: gdbthread.h:940
void delete_exited_threads(void)
Definition: thread.c:734
void init_thread_list(void)
Definition: thread.c:233
gdb::ref_ptr< struct inferior, refcounted_object_ref_policy > inferior_ref
Definition: gdbthread.h:599
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1862
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1792
#define thread_info
Definition: gnu-nat.h:26
Definition: gnu-nat.c:154
virtual ~private_thread_info()=0
CORE_ADDR step_range_start
Definition: gdbthread.h:124
CORE_ADDR step_range_end
Definition: gdbthread.h:125
bpstat * stop_bpstat
Definition: gdbthread.h:168
enum step_over_calls_kind step_over_calls
Definition: gdbthread.h:161
struct symbol * step_start_function
Definition: gdbthread.h:128
struct breakpoint * exception_resume_breakpoint
Definition: gdbthread.h:105
struct breakpoint * step_resume_breakpoint
Definition: gdbthread.h:102
struct breakpoint * single_step_breakpoints
Definition: gdbthread.h:112
struct target_waitstatus waitstatus
Definition: gdbthread.h:194
gdb::optional< CORE_ADDR > stop_pc
Definition: gdbthread.h:216
enum gdb_signal stop_signal
Definition: gdbthread.h:187
enum target_stop_reason stop_reason
Definition: gdbthread.h:191
Definition: value.c:181
iterator_range< all_threads_safe_iterator > all_threads_safe_range
Definition: thread-iter.h:198
target_stop_reason
Definition: waitstatus.h:428
@ TARGET_STOPPED_BY_NO_REASON
Definition: waitstatus.h:431