GDB (xrefs)
Loading...
Searching...
No Matches
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
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/* Unique pointer wrapper for private_thread_info. */
226using private_thread_info_up = std::unique_ptr<private_thread_info>;
227
228/* Threads are intrusively refcounted objects. Being the
229 user-selected thread is normally considered an implicit strong
230 reference and is thus not accounted in the refcount, unlike
231 inferior objects. This is necessary, because there's no "current
232 thread" pointer. Instead the current thread is inferred from the
233 inferior_ptid global. However, when GDB needs to remember the
234 selected thread to later restore it, GDB bumps the thread object's
235 refcount, to prevent something deleting the thread object before
236 reverting back (e.g., due to a "kill" command). If the thread
237 meanwhile exits before being re-selected, then the thread object is
238 left listed in the thread list, but marked with state
239 THREAD_EXITED. (See scoped_restore_current_thread and
240 delete_thread). All other thread references are considered weak
241 references. Placing a thread in the thread list is an implicit
242 strong reference, and is thus not accounted for in the thread's
243 refcount.
244
245 The intrusive_list_node base links threads in a per-inferior list. */
246
247class thread_info : public refcounted_object,
248 public intrusive_list_node<thread_info>
249{
250public:
251 explicit thread_info (inferior *inf, ptid_t ptid);
252 ~thread_info ();
253
254 bool deletable () const;
255
256 /* Mark this thread as running and notify observers. */
257 void set_running (bool running);
258
259 ptid_t ptid; /* "Actual process id";
260 In fact, this may be overloaded with
261 kernel thread id, etc. */
262
263 /* Each thread has two GDB IDs.
264
265 a) The thread ID (Id). This consists of the pair of:
266
267 - the number of the thread's inferior and,
268
269 - the thread's thread number in its inferior, aka, the
270 per-inferior thread number. This number is unique in the
271 inferior but not unique between inferiors.
272
273 b) The global ID (GId). This is a a single integer unique
274 between all inferiors.
275
276 E.g.:
277
278 (gdb) info threads -gid
279 Id GId Target Id Frame
280 * 1.1 1 Thread A 0x16a09237 in foo () at foo.c:10
281 1.2 3 Thread B 0x15ebc6ed in bar () at foo.c:20
282 1.3 5 Thread C 0x15ebc6ed in bar () at foo.c:20
283 2.1 2 Thread A 0x16a09237 in foo () at foo.c:10
284 2.2 4 Thread B 0x15ebc6ed in bar () at foo.c:20
285 2.3 6 Thread C 0x15ebc6ed in bar () at foo.c:20
286
287 Above, both inferiors 1 and 2 have threads numbered 1-3, but each
288 thread has its own unique global ID. */
289
290 /* The thread's global GDB thread number. This is exposed to MI,
291 Python/Scheme, visible with "info threads -gid", and is also what
292 the $_gthread convenience variable is bound to. */
294
295 /* The per-inferior thread number. This is unique in the inferior
296 the thread belongs to, but not unique between inferiors. This is
297 what the $_thread convenience variable is bound to. */
299
300 /* The inferior this thread belongs to. */
301 struct inferior *inf;
302
303 /* The user-given name of the thread.
304
305 Returns nullptr if the thread does not have a user-given name. */
306 const char *name () const
307 {
308 return m_name.get ();
309 }
310
311 /* Set the user-given name of the thread.
312
313 Pass nullptr to clear the name. */
314 void set_name (gdb::unique_xmalloc_ptr<char> name)
315 {
316 m_name = std::move (name);
317 }
318
319 bool executing () const
320 { return m_executing; }
321
322 /* Set the thread's 'm_executing' field from EXECUTING, and if EXECUTING
323 is true also clears the thread's stop_pc. */
324 void set_executing (bool executing);
325
326 bool resumed () const
327 { return m_resumed; }
328
329 /* Set the thread's 'm_resumed' field from RESUMED. The thread may also
330 be added to (when RESUMED is true), or removed from (when RESUMED is
331 false), the list of threads with a pending wait status. */
332 void set_resumed (bool resumed);
333
334 /* Frontend view of the thread state. Note that the THREAD_RUNNING/
335 THREAD_STOPPED states are different from EXECUTING. When the
336 thread is stopped internally while handling an internal event,
337 like a software single-step breakpoint, EXECUTING will be false,
338 but STATE will still be THREAD_RUNNING. */
340
341 /* State of GDB control of inferior thread execution.
342 See `struct thread_control_state'. */
344
345 /* Save M_SUSPEND to SUSPEND. */
346
348 {
349 suspend = m_suspend;
350 }
351
352 /* Restore M_SUSPEND from SUSPEND. */
353
355 {
356 m_suspend = suspend;
357 }
358
359 /* Return this thread's stop PC. This should only be called when it is
360 known that stop_pc has a value. If this function is being used in a
361 situation where a thread may not have had a stop_pc assigned, then
362 stop_pc_p() can be used to check if the stop_pc is defined. */
363
364 CORE_ADDR stop_pc () const
365 {
366 gdb_assert (m_suspend.stop_pc.has_value ());
367 return *m_suspend.stop_pc;
368 }
369
370 /* Set this thread's stop PC. */
371
372 void set_stop_pc (CORE_ADDR stop_pc)
373 {
374 m_suspend.stop_pc = stop_pc;
375 }
376
377 /* Remove the stop_pc stored on this thread. */
378
380 {
381 m_suspend.stop_pc.reset ();
382 }
383
384 /* Return true if this thread has a cached stop pc value, otherwise
385 return false. */
386
387 bool stop_pc_p () const
388 {
389 return m_suspend.stop_pc.has_value ();
390 }
391
392 /* Return true if this thread has a pending wait status. */
393
395 {
397 }
398
399 /* Get this thread's pending wait status.
400
401 May only be called if has_pending_waitstatus returns true. */
402
404 {
405 gdb_assert (this->has_pending_waitstatus ());
406
407 return m_suspend.waitstatus;
408 }
409
410 /* Set this thread's pending wait status.
411
412 May only be called if has_pending_waitstatus returns false. */
413
414 void set_pending_waitstatus (const target_waitstatus &ws);
415
416 /* Clear this thread's pending wait status.
417
418 May only be called if has_pending_waitstatus returns true. */
419
420 void clear_pending_waitstatus ();
421
422 /* Return this thread's stop signal. */
423
424 gdb_signal stop_signal () const
425 {
426 return m_suspend.stop_signal;
427 }
428
429 /* Set this thread's stop signal. */
430
431 void set_stop_signal (gdb_signal sig)
432 {
434 }
435
436 /* Return this thread's stop reason. */
437
439 {
440 return m_suspend.stop_reason;
441 }
442
443 /* Set this thread's stop reason. */
444
446 {
447 m_suspend.stop_reason = reason;
448 }
449
450 /* Get the FSM associated with the thread. */
451
452 struct thread_fsm *thread_fsm () const
453 {
454 return m_thread_fsm.get ();
455 }
456
457 /* Get the owning reference to the FSM associated with the thread.
458
459 After a call to this method, "thread_fsm () == nullptr". */
460
461 std::unique_ptr<struct thread_fsm> release_thread_fsm ()
462 {
463 return std::move (m_thread_fsm);
464 }
465
466 /* Set the FSM associated with the current thread.
467
468 It is invalid to set the FSM if another FSM is already installed. */
469
470 void set_thread_fsm (std::unique_ptr<struct thread_fsm> fsm)
471 {
472 gdb_assert (m_thread_fsm == nullptr);
473 m_thread_fsm = std::move (fsm);
474 }
475
477 struct symtab *current_symtab = NULL;
478
479 /* Internal stepping state. */
480
481 /* Record the pc of the thread the last time it was resumed. (It
482 can't be done on stop as the PC may change since the last stop,
483 e.g., "return" command, or "p $pc = 0xf000"). This is maintained
484 by proceed and keep_going, and among other things, it's used in
485 adjust_pc_after_break to distinguish a hardware single-step
486 SIGTRAP from a breakpoint SIGTRAP. */
487 CORE_ADDR prev_pc = 0;
488
489 /* Did we set the thread stepping a breakpoint instruction? This is
490 used in conjunction with PREV_PC to decide whether to adjust the
491 PC. */
493
494 /* Should we step over breakpoint next time keep_going is called? */
496
497 /* Should we step over a watchpoint next time keep_going is called?
498 This is needed on targets with non-continuable, non-steppable
499 watchpoints. */
501
502 /* Set to TRUE if we should finish single-stepping over a breakpoint
503 after hitting the current step-resume breakpoint. The context here
504 is that GDB is to do `next' or `step' while signal arrives.
505 When stepping over a breakpoint and signal arrives, GDB will attempt
506 to skip signal handler, so it inserts a step_resume_breakpoint at the
507 signal return address, and resume inferior.
508 step_after_step_resume_breakpoint is set to TRUE at this moment in
509 order to keep GDB in mind that there is still a breakpoint to step over
510 when GDB gets back SIGTRAP from step_resume_breakpoint. */
512
513 /* This is used to remember when a fork or vfork event was caught by
514 a catchpoint, and thus the event is to be followed at the next
515 resume of the thread, and not immediately. */
517
518 /* True if this thread has been explicitly requested to stop. */
520
521 /* The initiating frame of a nexting operation, used for deciding
522 which exceptions to intercept. If it is null_frame_id no
523 bp_longjmp or bp_exception but longjmp has been caught just for
524 bp_longjmp_call_dummy. */
526
527 /* Private data used by the target vector implementation. */
529
530 /* Branch trace information for this thread. */
532
533 /* Flag which indicates that the stack temporaries should be stored while
534 evaluating expressions. */
536
537 /* Values that are stored as temporaries on stack while evaluating
538 expressions. */
539 std::vector<struct value *> stack_temporaries;
540
541 /* Step-over chain. A thread is in the step-over queue if this node is
542 linked. */
543 intrusive_list_node<thread_info> step_over_list_node;
544
545 /* Node for list of threads that are resumed and have a pending wait status.
546
547 The list head for this is in process_stratum_target, hence all threads in
548 this list belong to that process target. */
549 intrusive_list_node<thread_info> resumed_with_pending_wait_status_node;
550
551 /* Displaced-step state for this thread. */
553
554private:
555 /* True if this thread is resumed from infrun's perspective.
556 Note that a thread can be marked both as not-executing and
557 resumed at the same time. This happens if we try to resume a
558 thread that has a wait status pending. We shouldn't let the
559 thread really run until that wait status has been processed, but
560 we should not process that wait status if we didn't try to let
561 the thread run. */
562 bool m_resumed = false;
563
564 /* True means the thread is executing. Note: this is different
565 from saying that there is an active target and we are stopped at
566 a breakpoint, for instance. This is a real indicator whether the
567 thread is off and running. */
568 bool m_executing = false;
569
570 /* State of inferior thread to restore after GDB is done with an inferior
571 call. See `struct thread_suspend_state'. */
573
574 /* The user-given name of the thread.
575
576 Nullptr if the thread does not have a user-given name. */
577 gdb::unique_xmalloc_ptr<char> m_name;
578
579 /* Pointer to the state machine manager object that handles what is
580 left to do for the thread's execution command after the target
581 stops. Several execution commands use it. */
582 std::unique_ptr<struct thread_fsm> m_thread_fsm;
583};
584
586 = intrusive_member_node<thread_info,
587 &thread_info::resumed_with_pending_wait_status_node>;
589 = intrusive_list<thread_info,
591
592/* A gdb::ref_ptr pointer to a thread_info. */
593
594using thread_info_ref
595 = gdb::ref_ptr<struct thread_info, refcounted_object_ref_policy>;
596
597/* A gdb::ref_ptr pointer to an inferior. This would ideally be in
598 inferior.h, but it can't due to header dependencies (inferior.h
599 includes gdbthread.h). */
600
601using inferior_ref
602 = gdb::ref_ptr<struct inferior, refcounted_object_ref_policy>;
603
604/* Create an empty thread list, or empty the existing one. */
605extern void init_thread_list (void);
606
607/* Add a thread to the thread list, print a message
608 that a new thread is found, and return the pointer to
609 the new thread. Caller my use this pointer to
610 initialize the private thread data. */
611extern struct thread_info *add_thread (process_stratum_target *targ,
612 ptid_t ptid);
613
614/* Same as add_thread, but does not print a message about new
615 thread. */
617 ptid_t ptid);
618
619/* Same as add_thread, and sets the private info. */
621 ptid_t ptid,
623
624/* Delete thread THREAD and notify of thread exit. If the thread is
625 currently not deletable, don't actually delete it but still tag it
626 as exited and do the notification. EXIT_CODE is the thread's exit
627 code. If SILENT, don't actually notify the CLI. THREAD must not
628 be NULL or an assertion will fail. */
629extern void delete_thread_with_exit_code (thread_info *thread,
630 ULONGEST exit_code,
631 bool silent = false);
632
633/* Delete thread THREAD and notify of thread exit. If the thread is
634 currently not deletable, don't actually delete it but still tag it
635 as exited and do the notification. THREAD must not be NULL or an
636 assertion will fail. */
637extern void delete_thread (thread_info *thread);
638
639/* Like delete_thread, but be quiet about it. Used when the process
640 this thread belonged to has already exited, for example. */
641extern void delete_thread_silent (struct thread_info *thread);
642
643/* Mark the thread exited, but don't delete it or remove it from the
644 inferior thread list. EXIT_CODE is the thread's exit code, if
645 available. If SILENT, then don't inform the CLI about the
646 exit. */
647extern void set_thread_exited (thread_info *tp,
648 gdb::optional<ULONGEST> exit_code = {},
649 bool silent = false);
650
651/* Delete a step_resume_breakpoint from the thread database. */
652extern void delete_step_resume_breakpoint (struct thread_info *);
653
654/* Delete an exception_resume_breakpoint from the thread database. */
656
657/* Delete the single-step breakpoints of thread TP, if any. */
658extern void delete_single_step_breakpoints (struct thread_info *tp);
659
660/* Check if the thread has software single stepping breakpoints
661 set. */
663
664/* Check whether the thread has software single stepping breakpoints
665 set at PC. */
667 const address_space *aspace,
668 CORE_ADDR addr);
669
670/* Returns whether to show inferior-qualified thread IDs, or plain
671 thread numbers. Inferior-qualified IDs are shown whenever we have
672 multiple inferiors, or the only inferior left has number > 1. */
673extern int show_inferior_qualified_tids (void);
674
675/* Return a string version of THR's thread ID. If there are multiple
676 inferiors, then this prints the inferior-qualifier form, otherwise
677 it only prints the thread number. The result is stored in a
678 circular static buffer, NUMCELLS deep. */
679const char *print_thread_id (struct thread_info *thr);
680
681/* Like print_thread_id, but always prints the inferior-qualified form,
682 even when there is only a single inferior. */
683const char *print_full_thread_id (struct thread_info *thr);
684
685/* Boolean test for an already-known ptid. */
686extern bool in_thread_list (process_stratum_target *targ, ptid_t ptid);
687
688/* Boolean test for an already-known global thread id (GDB's homegrown
689 global id, not the system's). */
690extern int valid_global_thread_id (int global_id);
691
692/* Find thread by GDB global thread ID. */
693struct thread_info *find_thread_global_id (int global_id);
694
695/* Find thread by thread library specific handle in inferior INF. */
697 (gdb::array_view<const gdb_byte> handle, struct inferior *inf);
698
699/* Finds the first thread of the specified inferior. */
701
702/* Returns any thread of inferior INF, giving preference to the
703 current thread. */
705
706/* Returns any non-exited thread of inferior INF, giving preference to
707 the current thread, and to not executing threads. */
709
710/* Change the ptid of thread OLD_PTID to NEW_PTID. */
712 ptid_t old_ptid, ptid_t new_ptid);
713
714/* Iterator function to call a user-provided callback function
715 once for each known thread. */
716typedef int (*thread_callback_func) (struct thread_info *, void *);
718
719/* Pull in the internals of the inferiors/threads ranges and
720 iterators. Must be done after struct thread_info is defined. */
721#include "thread-iter.h"
722
723/* Return a range that can be used to walk over threads, with
724 range-for.
725
726 Used like this, it walks over all threads of all inferiors of all
727 targets:
728
729 for (thread_info *thr : all_threads ())
730 { .... }
731
732 FILTER_PTID can be used to filter out threads that don't match.
733 FILTER_PTID can be:
734
735 - minus_one_ptid, meaning walk all threads of all inferiors of
736 PROC_TARGET. If PROC_TARGET is NULL, then of all targets.
737
738 - A process ptid, in which case walk all threads of the specified
739 process. PROC_TARGET must be non-NULL in this case.
740
741 - A thread ptid, in which case walk that thread only. PROC_TARGET
742 must be non-NULL in this case.
743*/
744
746all_threads (process_stratum_target *proc_target = nullptr,
747 ptid_t filter_ptid = minus_one_ptid)
748{
749 return all_matching_threads_range (proc_target, filter_ptid);
750}
751
752/* Return a range that can be used to walk over all non-exited threads
753 of all inferiors, with range-for. Arguments are like all_threads
754 above. */
755
757all_non_exited_threads (process_stratum_target *proc_target = nullptr,
758 ptid_t filter_ptid = minus_one_ptid)
759{
760 return all_non_exited_threads_range (proc_target, filter_ptid);
761}
762
763/* Return a range that can be used to walk over all threads of all
764 inferiors, with range-for, safely. I.e., it is safe to delete the
765 currently-iterated thread. When combined with range-for, this
766 allow convenient patterns like this:
767
768 for (thread_info *t : all_threads_safe ())
769 if (some_condition ())
770 delete f;
771*/
772
775{
777}
778
779extern int thread_count (process_stratum_target *proc_target);
780
781/* Return true if we have any thread in any inferior. */
782extern bool any_thread_p ();
783
784/* Switch context to thread THR. */
785extern void switch_to_thread (struct thread_info *thr);
786
787/* Switch context to no thread selected. */
788extern void switch_to_no_thread ();
789
790/* Switch from one thread to another. Does not read registers. */
791extern void switch_to_thread_no_regs (struct thread_info *thread);
792
793/* Marks or clears thread(s) PTID of TARG as resumed. If PTID is
794 MINUS_ONE_PTID, applies to all threads of TARG. If
795 ptid_is_pid(PTID) is true, applies to all threads of the process
796 pointed at by {TARG,PTID}. */
797extern void set_resumed (process_stratum_target *targ,
798 ptid_t ptid, bool resumed);
799
800/* Marks thread PTID of TARG as running, or as stopped. If PTID is
801 minus_one_ptid, marks all threads of TARG. */
802extern void set_running (process_stratum_target *targ,
803 ptid_t ptid, bool running);
804
805/* Marks or clears thread(s) PTID of TARG as having been requested to
806 stop. If PTID is MINUS_ONE_PTID, applies to all threads of TARG.
807 If ptid_is_pid(PTID) is true, applies to all threads of the process
808 pointed at by {TARG, PTID}. If STOP, then the
809 THREAD_STOP_REQUESTED observer is called with PTID as argument. */
811 ptid_t ptid, bool stop);
812
813/* Marks thread PTID of TARG as executing, or not. If PTID is
814 minus_one_ptid, marks all threads of TARG.
815
816 Note that this is different from the running state. See the
817 description of state and executing fields of struct
818 thread_info. */
819extern void set_executing (process_stratum_target *targ,
820 ptid_t ptid, bool executing);
821
822/* True if any (known or unknown) thread of TARG is or may be
823 executing. */
825
826/* Merge the executing property of thread PTID of TARG over to its
827 thread state property (frontend running/stopped view).
828
829 "not executing" -> "stopped"
830 "executing" -> "running"
831 "exited" -> "exited"
832
833 If PTID is minus_one_ptid, go over all threads of TARG.
834
835 Notifications are only emitted if the thread state did change. */
836extern void finish_thread_state (process_stratum_target *targ, ptid_t ptid);
837
838/* Calls finish_thread_state on scope exit, unless release() is called
839 to disengage. */
841 = FORWARD_SCOPE_EXIT (finish_thread_state);
842
843/* Commands with a prefix of `thread'. */
844extern struct cmd_list_element *thread_cmd_list;
845
846extern void thread_command (const char *tidstr, int from_tty);
847
848/* Print notices on thread events (attach, detach, etc.), set with
849 `set print thread-events'. */
850extern bool print_thread_events;
851
852/* Prints the list of threads and their details on UIOUT. If
853 REQUESTED_THREADS, a list of GDB ids/ranges, is not NULL, only
854 print threads whose ID is included in the list. If PID is not -1,
855 only print threads from the process PID. Otherwise, threads from
856 all attached PIDs are printed. If both REQUESTED_THREADS is not
857 NULL and PID is not -1, then the thread is printed if it belongs to
858 the specified process. Otherwise, an error is raised. */
859extern void print_thread_info (struct ui_out *uiout,
860 const char *requested_threads,
861 int pid);
862
863/* Save/restore current inferior/thread/frame. */
864
866{
867public:
870
872
874
875 /* Cancel restoring on scope exit. */
876 void dont_restore () { m_dont_restore = true; }
878private:
879 void restore ();
881 bool m_dont_restore = false;
884
887 bool m_was_stopped;
888 /* Save/restore the language as well, because selecting a frame
889 changes the current language to the frame's language if "set
890 language auto". */
891 enum language m_lang;
892};
893
894/* Returns a pointer into the thread_info corresponding to
895 INFERIOR_PTID. INFERIOR_PTID *must* be in the thread list. */
896extern struct thread_info* inferior_thread (void);
897
898extern void update_thread_list (void);
899
900/* Delete any thread the target says is no longer alive. */
901
902extern void prune_threads (void);
903
904/* Delete threads marked THREAD_EXITED. Unlike prune_threads, this
905 does not consult the target about whether the thread is alive right
906 now. */
907extern void delete_exited_threads (void);
908
909/* Return true if PC is in the stepping range of THREAD. */
910
911bool pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread);
913/* Enable storing stack temporaries for thread THR and disable and
914 clear the stack temporaries on destruction. Holds a strong
915 reference to THR. */
918{
919public:
920
921 explicit enable_thread_stack_temporaries (struct thread_info *thr)
922 : m_thr (thread_info_ref::new_reference (thr))
924 m_thr->stack_temporaries_enabled = true;
925 m_thr->stack_temporaries.clear ();
926 }
927
930 m_thr->stack_temporaries_enabled = false;
931 m_thr->stack_temporaries.clear ();
932 }
935
936private:
937
939};
940
941extern bool thread_stack_temporaries_enabled_p (struct thread_info *tp);
942
943extern void push_thread_stack_temporary (struct thread_info *tp, struct value *v);
944
948 struct thread_info *thr);
950/* Thread step-over list type. */
952 = intrusive_member_node<thread_info, &thread_info::step_over_list_node>;
954 = intrusive_list<thread_info, thread_step_over_list_node>;
956 = reference_to_pointer_iterator<thread_step_over_list::iterator>;
958 = basic_safe_iterator<thread_step_over_list_iterator>;
960 = iterator_range<thread_step_over_list_safe_iterator>;
961
964{
967 list.end ()),
969 list.end ()));
970}
971
972/* Add TP to the end of the global pending step-over chain. */
973
975
976/* Append the thread step over list LIST to the global thread step over
977 chain. */
978
980 (thread_step_over_list &&list);
981
982/* Remove TP from the global pending step-over chain. */
983
985
986/* Return true if TP is in any step-over chain. */
987
988extern int thread_is_in_step_over_chain (struct thread_info *tp);
989
990/* Return the length of the the step over chain TP is in.
991
992 If TP is non-nullptr, the thread must be in a step over chain.
993 TP may be nullptr, in which case it denotes an empty list, so a length of
994 0. */
995
997
998/* Cancel any ongoing execution command. */
999
1000extern void thread_cancel_execution_command (struct thread_info *thr);
1001
1002/* Check whether it makes sense to access a register of the current
1003 thread at this point. If not, throw an error (e.g., the thread is
1004 executing). */
1005extern void validate_registers_access (void);
1006
1007/* Check whether it makes sense to access a register of THREAD at this point.
1008 Returns true if registers may be accessed; false otherwise. */
1009extern bool can_access_registers_thread (struct thread_info *thread);
1010
1011/* Returns whether to show which thread hit the breakpoint, received a
1012 signal, etc. and ended up causing a user-visible stop. This is
1013 true iff we ever detected multiple threads. */
1014extern int show_thread_that_caused_stop (void);
1015
1016/* Print the message for a thread or/and frame selected. */
1017extern void print_selected_thread_frame (struct ui_out *uiout,
1018 user_selected_what selection);
1019
1020/* Helper for the CLI's "thread" command and for MI's -thread-select.
1021 Selects thread THR. TIDSTR is the original string the thread ID
1022 was parsed from. This is used in the error message if THR is not
1023 alive anymore. */
1024extern void thread_select (const char *tidstr, class thread_info *thr);
1025
1026/* Return THREAD's name.
1027
1028 If THREAD has a user-given name, return it. Otherwise, query the thread's
1029 target to get the name. May return nullptr. */
1030extern const char *thread_name (thread_info *thread);
1031
1032/* Switch to thread TP if it is alive. Returns true if successfully
1033 switched, false otherwise. */
1034
1035extern bool switch_to_thread_if_alive (thread_info *thr);
1036
1037/* Assuming that THR is the current thread, execute CMD.
1038 If ADA_TASK is not empty, it is the Ada task ID, and will
1039 be printed instead of the thread information.
1040 FLAGS.QUIET controls the printing of the thread information.
1041 FLAGS.CONT and FLAGS.SILENT control how to handle errors. Can throw an
1042 exception if !FLAGS.SILENT and !FLAGS.CONT and CMD fails. */
1043
1044extern void thread_try_catch_cmd (thread_info *thr,
1045 gdb::optional<int> ada_task,
1046 const char *cmd, int from_tty,
1047 const qcs_flags &flags);
1048
1049/* Return a string representation of STATE. */
1050
1051extern const char *thread_state_string (enum thread_state state);
1052
1053#endif /* GDBTHREAD_H */
const char *const name
enable_thread_stack_temporaries(struct thread_info *thr)
Definition gdbthread.h:916
DISABLE_COPY_AND_ASSIGN(enable_thread_stack_temporaries)
DISABLE_COPY_AND_ASSIGN(scoped_restore_current_thread)
int stepping_over_watchpoint
Definition gdbthread.h:500
bool stop_pc_p() const
Definition gdbthread.h:387
thread_suspend_state m_suspend
Definition gdbthread.h:572
std::vector< struct value * > stack_temporaries
Definition gdbthread.h:539
CORE_ADDR stop_pc() const
Definition gdbthread.h:364
void set_thread_fsm(std::unique_ptr< struct thread_fsm > fsm)
Definition gdbthread.h:470
void clear_stop_pc()
Definition gdbthread.h:379
std::unique_ptr< struct thread_fsm > release_thread_fsm()
Definition gdbthread.h:461
intrusive_list_node< thread_info > resumed_with_pending_wait_status_node
Definition gdbthread.h:549
intrusive_list_node< thread_info > step_over_list_node
Definition gdbthread.h:543
enum thread_state state
Definition gdbthread.h:339
struct symtab * current_symtab
Definition gdbthread.h:477
int per_inf_num
Definition gdbthread.h:298
ptid_t ptid
Definition gdbthread.h:259
void restore_suspend_from(const thread_suspend_state &suspend)
Definition gdbthread.h:354
void set_name(gdb::unique_xmalloc_ptr< char > name)
Definition gdbthread.h:314
gdb_signal stop_signal() const
Definition gdbthread.h:424
void save_suspend_to(thread_suspend_state &suspend) const
Definition gdbthread.h:347
bool resumed() const
Definition gdbthread.h:326
int current_line
Definition gdbthread.h:476
bool has_pending_waitstatus() const
Definition gdbthread.h:394
gdb::unique_xmalloc_ptr< char > m_name
Definition gdbthread.h:577
void set_stop_reason(target_stop_reason reason)
Definition gdbthread.h:445
struct frame_id initiating_frame
Definition gdbthread.h:525
struct target_waitstatus pending_follow
Definition gdbthread.h:516
const target_waitstatus & pending_waitstatus() const
Definition gdbthread.h:403
bool m_resumed
Definition gdbthread.h:562
target_stop_reason stop_reason() const
Definition gdbthread.h:438
int step_after_step_resume_breakpoint
Definition gdbthread.h:511
int stepping_over_breakpoint
Definition gdbthread.h:495
bool m_executing
Definition gdbthread.h:568
bool deletable() const
Definition thread.c:365
private_thread_info_up priv
Definition gdbthread.h:528
struct thread_fsm * thread_fsm() const
Definition gdbthread.h:452
std::unique_ptr< struct thread_fsm > m_thread_fsm
Definition gdbthread.h:582
displaced_step_thread_state displaced_step_state
Definition gdbthread.h:552
bool executing() const
Definition gdbthread.h:319
bool stack_temporaries_enabled
Definition gdbthread.h:535
int stepped_breakpoint
Definition gdbthread.h:492
int stop_requested
Definition gdbthread.h:519
struct inferior * inf
Definition gdbthread.h:301
void set_stop_pc(CORE_ADDR stop_pc)
Definition gdbthread.h:372
void set_stop_signal(gdb_signal sig)
Definition gdbthread.h:431
CORE_ADDR prev_pc
Definition gdbthread.h:487
const char * name() const
Definition gdbthread.h:306
thread_control_state control
Definition gdbthread.h:343
language
Definition defs.h:211
const struct frame_id null_frame_id
Definition frame.c:688
struct thread_info * any_live_thread_of_inferior(inferior *inf)
Definition thread.c:663
bool switch_to_thread_if_alive(thread_info *thr)
Definition thread.c:716
all_threads_safe_range all_threads_safe()
Definition gdbthread.h:770
int thread_step_over_chain_length(const thread_step_over_list &l)
Definition thread.c:443
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:336
void global_thread_step_over_chain_remove(thread_info *tp)
Definition thread.c:476
const char * thread_state_string(enum thread_state state)
Definition thread.c:2113
void global_thread_step_over_chain_enqueue_chain(thread_step_over_list &&list)
Definition thread.c:468
int thread_count(process_stratum_target *proc_target)
Definition thread.c:605
intrusive_list< thread_info, thread_info_resumed_with_pending_wait_status_node > thread_info_resumed_with_pending_wait_status_list
Definition gdbthread.h:587
struct cmd_list_element * thread_cmd_list
Definition thread.c:2192
struct thread_info * add_thread_silent(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:296
all_matching_threads_range all_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
Definition gdbthread.h:742
intrusive_member_node< thread_info, &thread_info::step_over_list_node > thread_step_over_list_node
Definition gdbthread.h:946
void thread_select(const char *tidstr, class thread_info *thr)
Definition thread.c:1994
bool value_in_thread_stack_temporaries(struct value *, struct thread_info *thr)
Definition thread.c:785
struct thread_info * first_thread_of_inferior(inferior *inf)
Definition thread.c:639
int(* thread_callback_func)(struct thread_info *, void *)
Definition gdbthread.h:712
void print_selected_thread_frame(struct ui_out *uiout, user_selected_what selection)
Definition thread.c:2009
void delete_thread(thread_info *thread)
Definition thread.c:527
iterator_range< thread_step_over_list_safe_iterator > thread_step_over_list_safe_range
Definition gdbthread.h:950
void switch_to_thread_no_regs(struct thread_info *thread)
Definition thread.c:1328
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:753
int show_inferior_qualified_tids(void)
Definition thread.c:1458
void validate_registers_access(void)
Definition thread.c:958
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:621
bool debug_threads
Definition thread.c:56
int show_thread_that_caused_stop(void)
Definition thread.c:1450
bool pc_in_thread_step_range(CORE_ADDR pc, struct thread_info *thread)
Definition thread.c:1000
intrusive_member_node< thread_info, &thread_info::resumed_with_pending_wait_status_node > thread_info_resumed_with_pending_wait_status_node
Definition gdbthread.h:585
static thread_step_over_list_safe_range make_thread_step_over_list_safe_range(thread_step_over_list &list)
Definition gdbthread.h:953
bool any_thread_p()
Definition thread.c:597
void set_stop_requested(process_stratum_target *targ, ptid_t ptid, bool stop)
Definition thread.c:931
struct thread_info * find_thread_global_id(int global_id)
Definition thread.c:539
void delete_thread_with_exit_code(thread_info *thread, ULONGEST exit_code, bool silent=false)
Definition thread.c:518
void global_thread_step_over_chain_enqueue(thread_info *tp)
Definition thread.c:456
const char * print_full_thread_id(struct thread_info *thr)
Definition thread.c:1485
void finish_thread_state(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:943
void update_thread_list(void)
Definition thread.c:2086
void set_executing(process_stratum_target *targ, ptid_t ptid, bool executing)
Definition thread.c:908
struct thread_info * inferior_thread(void)
Definition thread.c:85
void set_thread_exited(thread_info *tp, gdb::optional< ULONGEST > exit_code={}, bool silent=false)
Definition thread.c:218
void switch_to_thread(struct thread_info *thr)
Definition thread.c:1360
void thread_command(const char *tidstr, int from_tty)
Definition thread.c:1862
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:1523
void set_running(process_stratum_target *targ, ptid_t ptid, bool running)
Definition thread.c:891
int thread_has_single_step_breakpoint_here(struct thread_info *tp, const address_space *aspace, CORE_ADDR addr)
Definition thread.c:150
void delete_step_resume_breakpoint(struct thread_info *)
Definition thread.c:104
value * get_last_thread_stack_temporary(struct thread_info *tp)
Definition thread.c:799
bool can_access_registers_thread(struct thread_info *thread)
Definition thread.c:982
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition thread.c:584
bool print_thread_events
Definition thread.c:1981
void push_thread_stack_temporary(struct thread_info *tp, struct value *v)
Definition thread.c:775
void thread_change_ptid(process_stratum_target *targ, ptid_t old_ptid, ptid_t new_ptid)
Definition thread.c:811
basic_safe_iterator< thread_step_over_list_iterator > thread_step_over_list_safe_iterator
Definition gdbthread.h:949
std::unique_ptr< private_thread_info > private_thread_info_up
Definition gdbthread.h:226
FORWARD_SCOPE_EXIT(finish_thread_state) scoped_finish_thread_state
Definition gdbthread.h:836
struct thread_info * any_thread_of_inferior(inferior *inf)
Definition thread.c:648
void set_resumed(process_stratum_target *targ, ptid_t ptid, bool resumed)
Definition thread.c:838
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
Definition thread.c:142
const char * thread_name(thread_info *thread)
Definition thread.c:2095
int thread_is_in_step_over_chain(struct thread_info *tp)
Definition thread.c:435
bool thread_stack_temporaries_enabled_p(struct thread_info *tp)
Definition thread.c:764
void prune_threads(void)
Definition thread.c:737
void delete_exception_resume_breakpoint(struct thread_info *)
Definition thread.c:111
struct thread_info * add_thread_with_info(process_stratum_target *targ, ptid_t ptid, private_thread_info_up)
Definition thread.c:321
struct thread_info * find_thread_by_handle(gdb::array_view< const gdb_byte > handle, struct inferior *inf)
Definition thread.c:561
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:947
bool threads_are_executing(process_stratum_target *targ)
Definition thread.c:925
void delete_single_step_breakpoints(struct thread_info *tp)
Definition thread.c:120
bool in_thread_list(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:631
void delete_thread_silent(struct thread_info *thread)
Definition thread.c:533
void switch_to_no_thread()
Definition thread.c:1345
void print_thread_info(struct ui_out *uiout, const char *requested_threads, int pid)
Definition thread.c:1251
void thread_cancel_execution_command(struct thread_info *thr)
Definition thread.c:163
const char * print_thread_id(struct thread_info *thr)
Definition thread.c:1470
reference_to_pointer_iterator< thread_step_over_list::iterator > thread_step_over_list_iterator
Definition gdbthread.h:948
void delete_exited_threads(void)
Definition thread.c:753
void init_thread_list(void)
Definition thread.c:257
gdb::ref_ptr< struct inferior, refcounted_object_ref_policy > inferior_ref
Definition gdbthread.h:598
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:1861
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:1791
#define thread_info
Definition gnu-nat.h:26
Definition gnu-nat.c:153
virtual ~private_thread_info()=0
CORE_ADDR step_range_start
Definition gdbthread.h:124
CORE_ADDR step_range_end
Definition gdbthread.h:125
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.h:130
iterator_range< all_threads_safe_iterator > all_threads_safe_range
target_stop_reason
Definition waitstatus.h:428
@ TARGET_STOPPED_BY_NO_REASON
Definition waitstatus.h:431