1 /* Multi-process/thread control for GDB, the GNU debugger.
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
5 Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "gdbsupport/environ.h"
30 #include "gdbthread.h"
37 #include <sys/types.h>
40 #include "observable.h"
42 #include "cli/cli-decode.h"
43 #include "cli/cli-option.h"
44 #include "gdbsupport/gdb_regex.h"
45 #include "cli/cli-utils.h"
46 #include "thread-fsm.h"
47 #include "tid-parse.h"
49 #include "gdbsupport/gdb_optional.h"
50 #include "inline-frame.h"
54 /* See gdbthread.h. */
56 bool debug_threads
= false;
58 /* Implement 'show debug threads'. */
61 show_debug_threads (struct ui_file
*file
, int from_tty
,
62 struct cmd_list_element
*c
, const char *value
)
64 gdb_printf (file
, _("Thread debugging is \"%s\".\n"), value
);
67 /* Definition of struct thread_info exported to gdbthread.h. */
69 /* Prototypes for local functions. */
71 static int highest_thread_num
;
73 /* The current/selected thread. */
74 static thread_info
*current_thread_
;
76 /* Returns true if THR is the current thread. */
79 is_current_thread (const thread_info
*thr
)
81 return thr
== current_thread_
;
85 inferior_thread (void)
87 gdb_assert (current_thread_
!= nullptr);
88 return current_thread_
;
91 /* Delete the breakpoint pointed at by BP_P, if there's one. */
94 delete_thread_breakpoint (struct breakpoint
**bp_p
)
98 delete_breakpoint (*bp_p
);
104 delete_step_resume_breakpoint (struct thread_info
*tp
)
107 delete_thread_breakpoint (&tp
->control
.step_resume_breakpoint
);
111 delete_exception_resume_breakpoint (struct thread_info
*tp
)
114 delete_thread_breakpoint (&tp
->control
.exception_resume_breakpoint
);
117 /* See gdbthread.h. */
120 delete_single_step_breakpoints (struct thread_info
*tp
)
123 delete_thread_breakpoint (&tp
->control
.single_step_breakpoints
);
126 /* Delete the breakpoint pointed at by BP_P at the next stop, if
130 delete_at_next_stop (struct breakpoint
**bp
)
134 (*bp
)->disposition
= disp_del_at_next_stop
;
139 /* See gdbthread.h. */
142 thread_has_single_step_breakpoints_set (struct thread_info
*tp
)
144 return tp
->control
.single_step_breakpoints
!= NULL
;
147 /* See gdbthread.h. */
150 thread_has_single_step_breakpoint_here (struct thread_info
*tp
,
151 const address_space
*aspace
,
154 struct breakpoint
*ss_bps
= tp
->control
.single_step_breakpoints
;
156 return (ss_bps
!= NULL
157 && breakpoint_has_location_inserted_here (ss_bps
, aspace
, addr
));
160 /* See gdbthread.h. */
163 thread_cancel_execution_command (struct thread_info
*thr
)
165 if (thr
->thread_fsm () != nullptr)
167 std::unique_ptr
<thread_fsm
> fsm
= thr
->release_thread_fsm ();
173 clear_thread_inferior_resources (struct thread_info
*tp
)
175 /* NOTE: this will take care of any left-over step_resume breakpoints,
176 but not any user-specified thread-specific breakpoints. We can not
177 delete the breakpoint straight-off, because the inferior might not
178 be stopped at the moment. */
179 delete_at_next_stop (&tp
->control
.step_resume_breakpoint
);
180 delete_at_next_stop (&tp
->control
.exception_resume_breakpoint
);
181 delete_at_next_stop (&tp
->control
.single_step_breakpoints
);
183 delete_longjmp_breakpoint_at_next_stop (tp
->global_num
);
185 bpstat_clear (&tp
->control
.stop_bpstat
);
187 btrace_teardown (tp
);
189 thread_cancel_execution_command (tp
);
191 clear_inline_frame_state (tp
);
194 /* Notify interpreters and observers that thread T has exited. */
197 notify_thread_exited (thread_info
*t
, gdb::optional
<ULONGEST
> exit_code
,
200 if (!silent
&& print_thread_events
)
202 if (exit_code
.has_value ())
203 gdb_printf (_("[%s exited with code %s]\n"),
204 target_pid_to_str (t
->ptid
).c_str (),
205 pulongest (*exit_code
));
207 gdb_printf (_("[%s exited]\n"),
208 target_pid_to_str (t
->ptid
).c_str ());
211 interps_notify_thread_exited (t
, exit_code
, silent
);
212 gdb::observers::thread_exit
.notify (t
, exit_code
, silent
);
215 /* See gdbthread.h. */
218 set_thread_exited (thread_info
*tp
, gdb::optional
<ULONGEST
> exit_code
,
221 /* Dead threads don't need to step-over. Remove from chain. */
222 if (thread_is_in_step_over_chain (tp
))
223 global_thread_step_over_chain_remove (tp
);
225 if (tp
->state
!= THREAD_EXITED
)
227 process_stratum_target
*proc_target
= tp
->inf
->process_target ();
229 /* Some targets unpush themselves from the inferior's target stack before
230 clearing the inferior's thread list (which marks all threads as exited,
231 and therefore leads to this function). In this case, the inferior's
232 process target will be nullptr when we arrive here.
234 See also the comment in inferior::unpush_target. */
235 if (proc_target
!= nullptr)
236 proc_target
->maybe_remove_resumed_with_pending_wait_status (tp
);
238 notify_thread_exited (tp
, exit_code
, silent
);
240 /* Tag it as exited. */
241 tp
->state
= THREAD_EXITED
;
243 /* Clear breakpoints, etc. associated with this thread. */
244 clear_thread_inferior_resources (tp
);
246 /* Remove from the ptid_t map. We don't want for
247 inferior::find_thread to find exited threads. Also, the target
248 may reuse the ptid for a new thread, and there can only be
249 one value per key; adding a new thread with the same ptid_t
250 would overwrite the exited thread's ptid entry. */
251 size_t nr_deleted
= tp
->inf
->ptid_thread_map
.erase (tp
->ptid
);
252 gdb_assert (nr_deleted
== 1);
257 init_thread_list (void)
259 highest_thread_num
= 0;
261 for (inferior
*inf
: all_inferiors ())
262 inf
->clear_thread_list ();
265 /* Allocate a new thread of inferior INF with target id PTID and add
266 it to the thread list. */
268 static struct thread_info
*
269 new_thread (struct inferior
*inf
, ptid_t ptid
)
271 thread_info
*tp
= new thread_info (inf
, ptid
);
273 threads_debug_printf ("creating a new thread object, inferior %d, ptid %s",
274 inf
->num
, ptid
.to_string ().c_str ());
276 inf
->thread_list
.push_back (*tp
);
278 /* A thread with this ptid should not exist in the map yet. */
279 gdb_assert (inf
->ptid_thread_map
.find (ptid
) == inf
->ptid_thread_map
.end ());
281 inf
->ptid_thread_map
[ptid
] = tp
;
286 /* Notify interpreters and observers that thread T has been created. */
289 notify_new_thread (thread_info
*t
)
291 interps_notify_new_thread (t
);
292 gdb::observers::new_thread
.notify (t
);
296 add_thread_silent (process_stratum_target
*targ
, ptid_t ptid
)
298 gdb_assert (targ
!= nullptr);
300 inferior
*inf
= find_inferior_ptid (targ
, ptid
);
302 threads_debug_printf ("add thread to inferior %d, ptid %s, target %s",
303 inf
->num
, ptid
.to_string ().c_str (),
306 /* We may have an old thread with the same id in the thread list.
307 If we do, it must be dead, otherwise we wouldn't be adding a new
308 thread with the same id. The OS is reusing this id --- delete
309 the old thread, and create a new one. */
310 thread_info
*tp
= inf
->find_thread (ptid
);
314 tp
= new_thread (inf
, ptid
);
315 notify_new_thread (tp
);
321 add_thread_with_info (process_stratum_target
*targ
, ptid_t ptid
,
322 private_thread_info_up priv
)
324 thread_info
*result
= add_thread_silent (targ
, ptid
);
326 result
->priv
= std::move (priv
);
328 if (print_thread_events
)
329 gdb_printf (_("[New %s]\n"), target_pid_to_str (ptid
).c_str ());
331 annotate_new_thread ();
336 add_thread (process_stratum_target
*targ
, ptid_t ptid
)
338 return add_thread_with_info (targ
, ptid
, NULL
);
341 private_thread_info::~private_thread_info () = default;
343 thread_info::thread_info (struct inferior
*inf_
, ptid_t ptid_
)
344 : ptid (ptid_
), inf (inf_
)
346 gdb_assert (inf_
!= NULL
);
348 this->global_num
= ++highest_thread_num
;
349 this->per_inf_num
= ++inf_
->highest_thread_num
;
351 /* Nothing to follow yet. */
352 this->pending_follow
.set_spurious ();
355 /* See gdbthread.h. */
357 thread_info::~thread_info ()
359 threads_debug_printf ("thread %s", this->ptid
.to_string ().c_str ());
362 /* See gdbthread.h. */
365 thread_info::deletable () const
367 /* If this is the current thread, or there's code out there that
368 relies on it existing (refcount > 0) we can't delete yet. */
369 return refcount () == 0 && !is_current_thread (this);
372 /* See gdbthread.h. */
375 thread_info::set_executing (bool executing
)
377 m_executing
= executing
;
379 this->clear_stop_pc ();
382 /* See gdbthread.h. */
385 thread_info::set_resumed (bool resumed
)
387 if (resumed
== m_resumed
)
390 process_stratum_target
*proc_target
= this->inf
->process_target ();
392 /* If we transition from resumed to not resumed, we might need to remove
393 the thread from the resumed threads with pending statuses list. */
395 proc_target
->maybe_remove_resumed_with_pending_wait_status (this);
399 /* If we transition from not resumed to resumed, we might need to add
400 the thread to the resumed threads with pending statuses list. */
402 proc_target
->maybe_add_resumed_with_pending_wait_status (this);
405 /* See gdbthread.h. */
408 thread_info::set_pending_waitstatus (const target_waitstatus
&ws
)
410 gdb_assert (!this->has_pending_waitstatus ());
412 m_suspend
.waitstatus
= ws
;
413 m_suspend
.waitstatus_pending_p
= 1;
415 process_stratum_target
*proc_target
= this->inf
->process_target ();
416 proc_target
->maybe_add_resumed_with_pending_wait_status (this);
419 /* See gdbthread.h. */
422 thread_info::clear_pending_waitstatus ()
424 gdb_assert (this->has_pending_waitstatus ());
426 process_stratum_target
*proc_target
= this->inf
->process_target ();
427 proc_target
->maybe_remove_resumed_with_pending_wait_status (this);
429 m_suspend
.waitstatus_pending_p
= 0;
432 /* See gdbthread.h. */
435 thread_info::set_thread_options (gdb_thread_options thread_options
)
437 if (m_thread_options
== thread_options
)
440 m_thread_options
= thread_options
;
442 infrun_debug_printf ("[options for %s are now %s]",
443 this->ptid
.to_string ().c_str (),
444 to_string (thread_options
).c_str ());
447 /* See gdbthread.h. */
450 thread_is_in_step_over_chain (struct thread_info
*tp
)
452 return tp
->step_over_list_node
.is_linked ();
455 /* See gdbthread.h. */
458 thread_step_over_chain_length (const thread_step_over_list
&l
)
462 for (const thread_info
&thread ATTRIBUTE_UNUSED
: l
)
468 /* See gdbthread.h. */
471 global_thread_step_over_chain_enqueue (struct thread_info
*tp
)
473 infrun_debug_printf ("enqueueing thread %s in global step over chain",
474 tp
->ptid
.to_string ().c_str ());
476 gdb_assert (!thread_is_in_step_over_chain (tp
));
477 global_thread_step_over_list
.push_back (*tp
);
480 /* See gdbthread.h. */
483 global_thread_step_over_chain_enqueue_chain (thread_step_over_list
&&list
)
485 global_thread_step_over_list
.splice (std::move (list
));
488 /* See gdbthread.h. */
491 global_thread_step_over_chain_remove (struct thread_info
*tp
)
493 infrun_debug_printf ("removing thread %s from global step over chain",
494 tp
->ptid
.to_string ().c_str ());
496 gdb_assert (thread_is_in_step_over_chain (tp
));
497 auto it
= global_thread_step_over_list
.iterator_to (*tp
);
498 global_thread_step_over_list
.erase (it
);
501 /* Helper for the different delete_thread variants. */
504 delete_thread_1 (thread_info
*thr
, gdb::optional
<ULONGEST
> exit_code
,
507 gdb_assert (thr
!= nullptr);
509 threads_debug_printf ("deleting thread %s, exit_code = %s, silent = %d",
510 thr
->ptid
.to_string ().c_str (),
511 (exit_code
.has_value ()
512 ? pulongest (*exit_code
)
516 set_thread_exited (thr
, exit_code
, silent
);
518 if (!thr
->deletable ())
520 /* Will be really deleted some other time. */
524 auto it
= thr
->inf
->thread_list
.iterator_to (*thr
);
525 thr
->inf
->thread_list
.erase (it
);
530 /* See gdbthread.h. */
533 delete_thread_with_exit_code (thread_info
*thread
, ULONGEST exit_code
,
536 delete_thread_1 (thread
, exit_code
, silent
);
539 /* See gdbthread.h. */
542 delete_thread (thread_info
*thread
)
544 delete_thread_1 (thread
, {}, false /* not silent */);
548 delete_thread_silent (thread_info
*thread
)
550 delete_thread_1 (thread
, {}, true /* not silent */);
554 find_thread_global_id (int global_id
)
556 for (thread_info
*tp
: all_threads ())
557 if (tp
->global_num
== global_id
)
563 static struct thread_info
*
564 find_thread_id (struct inferior
*inf
, int thr_num
)
566 for (thread_info
*tp
: inf
->threads ())
567 if (tp
->per_inf_num
== thr_num
)
573 /* See gdbthread.h. */
576 find_thread_by_handle (gdb::array_view
<const gdb_byte
> handle
,
577 struct inferior
*inf
)
579 return target_thread_handle_to_thread_info (handle
.data (),
585 * Thread iterator function.
587 * Calls a callback function once for each thread, so long as
588 * the callback function returns false. If the callback function
589 * returns true, the iteration will end and the current thread
590 * will be returned. This can be useful for implementing a
591 * search for a thread with arbitrary attributes, or for applying
592 * some operation to every thread.
594 * FIXME: some of the existing functionality, such as
595 * "Thread apply all", might be rewritten using this functionality.
599 iterate_over_threads (int (*callback
) (struct thread_info
*, void *),
602 for (thread_info
*tp
: all_threads_safe ())
603 if ((*callback
) (tp
, data
))
609 /* See gdbthread.h. */
614 for (thread_info
*tp ATTRIBUTE_UNUSED
: all_threads ())
620 thread_count (process_stratum_target
*proc_target
)
622 auto rng
= all_threads (proc_target
);
623 return std::distance (rng
.begin (), rng
.end ());
626 /* Return the number of non-exited threads in the thread list. */
629 live_threads_count (void)
631 auto rng
= all_non_exited_threads ();
632 return std::distance (rng
.begin (), rng
.end ());
636 valid_global_thread_id (int global_id
)
638 for (thread_info
*tp
: all_threads ())
639 if (tp
->global_num
== global_id
)
646 in_thread_list (process_stratum_target
*targ
, ptid_t ptid
)
648 return targ
->find_thread (ptid
) != nullptr;
651 /* Finds the first thread of the inferior. */
654 first_thread_of_inferior (inferior
*inf
)
656 if (inf
->thread_list
.empty ())
659 return &inf
->thread_list
.front ();
663 any_thread_of_inferior (inferior
*inf
)
665 gdb_assert (inf
->pid
!= 0);
667 /* Prefer the current thread, if there's one. */
668 if (inf
== current_inferior () && inferior_ptid
!= null_ptid
)
669 return inferior_thread ();
671 for (thread_info
*tp
: inf
->non_exited_threads ())
678 any_live_thread_of_inferior (inferior
*inf
)
680 struct thread_info
*curr_tp
= NULL
;
681 struct thread_info
*tp_executing
= NULL
;
683 gdb_assert (inf
!= NULL
&& inf
->pid
!= 0);
685 /* Prefer the current thread if it's not executing. */
686 if (inferior_ptid
!= null_ptid
&& current_inferior () == inf
)
688 /* If the current thread is dead, forget it. If it's not
689 executing, use it. Otherwise, still choose it (below), but
690 only if no other non-executing thread is found. */
691 curr_tp
= inferior_thread ();
692 if (curr_tp
->state
== THREAD_EXITED
)
694 else if (!curr_tp
->executing ())
698 for (thread_info
*tp
: inf
->non_exited_threads ())
700 if (!tp
->executing ())
706 /* If both the current thread and all live threads are executing,
707 prefer the current thread. */
711 /* Otherwise, just return an executing thread, if any. */
715 /* Return true if TP is an active thread. */
717 thread_alive (thread_info
*tp
)
719 if (tp
->state
== THREAD_EXITED
)
722 /* Ensure we're looking at the right target stack. */
723 gdb_assert (tp
->inf
== current_inferior ());
725 return target_thread_alive (tp
->ptid
);
728 /* See gdbthreads.h. */
731 switch_to_thread_if_alive (thread_info
*thr
)
733 scoped_restore_current_thread restore_thread
;
735 /* Switch inferior first, so that we're looking at the right target
737 switch_to_inferior_no_thread (thr
->inf
);
739 if (thread_alive (thr
))
741 switch_to_thread (thr
);
742 restore_thread
.dont_restore ();
749 /* See gdbthreads.h. */
754 scoped_restore_current_thread restore_thread
;
756 for (thread_info
*tp
: all_threads_safe ())
758 switch_to_inferior_no_thread (tp
->inf
);
760 if (!thread_alive (tp
))
765 /* See gdbthreads.h. */
768 delete_exited_threads (void)
770 for (thread_info
*tp
: all_threads_safe ())
771 if (tp
->state
== THREAD_EXITED
)
775 /* Return true value if stack temporaries are enabled for the thread
779 thread_stack_temporaries_enabled_p (thread_info
*tp
)
784 return tp
->stack_temporaries_enabled
;
787 /* Push V on to the stack temporaries of the thread with id PTID. */
790 push_thread_stack_temporary (thread_info
*tp
, struct value
*v
)
792 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
793 tp
->stack_temporaries
.push_back (v
);
796 /* Return true if VAL is among the stack temporaries of the thread
797 TP. Return false otherwise. */
800 value_in_thread_stack_temporaries (struct value
*val
, thread_info
*tp
)
802 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
803 for (value
*v
: tp
->stack_temporaries
)
810 /* Return the last of the stack temporaries for thread with id PTID.
811 Return NULL if there are no stack temporaries for the thread. */
814 get_last_thread_stack_temporary (thread_info
*tp
)
816 struct value
*lastval
= NULL
;
818 gdb_assert (tp
!= NULL
);
819 if (!tp
->stack_temporaries
.empty ())
820 lastval
= tp
->stack_temporaries
.back ();
826 thread_change_ptid (process_stratum_target
*targ
,
827 ptid_t old_ptid
, ptid_t new_ptid
)
829 struct inferior
*inf
;
830 struct thread_info
*tp
;
832 /* It can happen that what we knew as the target inferior id
833 changes. E.g, target remote may only discover the remote process
834 pid after adding the inferior to GDB's list. */
835 inf
= find_inferior_ptid (targ
, old_ptid
);
836 inf
->pid
= new_ptid
.pid ();
838 tp
= inf
->find_thread (old_ptid
);
839 gdb_assert (tp
!= nullptr);
841 int num_erased
= inf
->ptid_thread_map
.erase (old_ptid
);
842 gdb_assert (num_erased
== 1);
845 inf
->ptid_thread_map
[new_ptid
] = tp
;
847 gdb::observers::thread_ptid_changed
.notify (targ
, old_ptid
, new_ptid
);
850 /* See gdbthread.h. */
853 set_resumed (process_stratum_target
*targ
, ptid_t ptid
, bool resumed
)
855 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
856 tp
->set_resumed (resumed
);
859 /* Helper for set_running, that marks one thread either running or
863 set_running_thread (struct thread_info
*tp
, bool running
)
865 bool started
= false;
867 if (running
&& tp
->state
== THREAD_STOPPED
)
869 tp
->state
= running
? THREAD_RUNNING
: THREAD_STOPPED
;
871 threads_debug_printf ("thread: %s, running? %d%s",
872 tp
->ptid
.to_string ().c_str (), running
,
873 (started
? " (started)" : ""));
877 /* If the thread is now marked stopped, remove it from
878 the step-over queue, so that we don't try to resume
879 it until the user wants it to. */
880 if (thread_is_in_step_over_chain (tp
))
881 global_thread_step_over_chain_remove (tp
);
887 /* Notify interpreters and observers that the target was resumed. */
890 notify_target_resumed (ptid_t ptid
)
892 interps_notify_target_resumed (ptid
);
893 gdb::observers::target_resumed
.notify (ptid
);
896 /* See gdbthread.h. */
899 thread_info::set_running (bool running
)
901 if (set_running_thread (this, running
))
902 notify_target_resumed (this->ptid
);
906 set_running (process_stratum_target
*targ
, ptid_t ptid
, bool running
)
908 /* We try not to notify the observer if no thread has actually
909 changed the running state -- merely to reduce the number of
910 messages to the MI frontend. A frontend is supposed to handle
911 multiple *running notifications just fine. */
912 bool any_started
= false;
914 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
915 if (set_running_thread (tp
, running
))
919 notify_target_resumed (ptid
);
923 set_executing (process_stratum_target
*targ
, ptid_t ptid
, bool executing
)
925 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
926 tp
->set_executing (executing
);
928 /* It only takes one running thread to spawn more threads. */
930 targ
->threads_executing
= true;
931 /* Only clear the flag if the caller is telling us everything is
933 else if (minus_one_ptid
== ptid
)
934 targ
->threads_executing
= false;
937 /* See gdbthread.h. */
940 threads_are_executing (process_stratum_target
*target
)
942 return target
->threads_executing
;
946 set_stop_requested (process_stratum_target
*targ
, ptid_t ptid
, bool stop
)
948 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
949 tp
->stop_requested
= stop
;
951 /* Call the stop requested observer so other components of GDB can
952 react to this request. */
954 gdb::observers::thread_stop_requested
.notify (ptid
);
958 finish_thread_state (process_stratum_target
*targ
, ptid_t ptid
)
960 bool any_started
= false;
962 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
963 if (set_running_thread (tp
, tp
->executing ()))
967 notify_target_resumed (ptid
);
970 /* See gdbthread.h. */
973 validate_registers_access (void)
975 /* No selected thread, no registers. */
976 if (inferior_ptid
== null_ptid
)
977 error (_("No thread selected."));
979 thread_info
*tp
= inferior_thread ();
981 /* Don't try to read from a dead thread. */
982 if (tp
->state
== THREAD_EXITED
)
983 error (_("The current thread has terminated"));
985 /* ... or from a spinning thread. FIXME: This isn't actually fully
986 correct. It'll allow an user-requested access (e.g., "print $pc"
987 at the prompt) when a thread is not executing for some internal
988 reason, but is marked running from the user's perspective. E.g.,
989 the thread is waiting for its turn in the step-over queue. */
990 if (tp
->executing ())
991 error (_("Selected thread is running."));
994 /* See gdbthread.h. */
997 can_access_registers_thread (thread_info
*thread
)
999 /* No thread, no registers. */
1003 /* Don't try to read from a dead thread. */
1004 if (thread
->state
== THREAD_EXITED
)
1007 /* ... or from a spinning thread. FIXME: see validate_registers_access. */
1008 if (thread
->executing ())
1015 pc_in_thread_step_range (CORE_ADDR pc
, struct thread_info
*thread
)
1017 return (pc
>= thread
->control
.step_range_start
1018 && pc
< thread
->control
.step_range_end
);
1021 /* Helper for print_thread_info. Returns true if THR should be
1022 printed. If REQUESTED_THREADS, a list of GDB ids/ranges, is not
1023 NULL, only print THR if its ID is included in the list. GLOBAL_IDS
1024 is true if REQUESTED_THREADS is list of global IDs, false if a list
1025 of per-inferior thread ids. If PID is not -1, only print THR if it
1026 is a thread from the process PID. Otherwise, threads from all
1027 attached PIDs are printed. If both REQUESTED_THREADS is not NULL
1028 and PID is not -1, then the thread is printed if it belongs to the
1029 specified process. Otherwise, an error is raised. */
1032 should_print_thread (const char *requested_threads
, int default_inf_num
,
1033 int global_ids
, int pid
, struct thread_info
*thr
)
1035 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1040 in_list
= number_is_in_list (requested_threads
, thr
->global_num
);
1042 in_list
= tid_is_in_list (requested_threads
, default_inf_num
,
1043 thr
->inf
->num
, thr
->per_inf_num
);
1048 if (pid
!= -1 && thr
->ptid
.pid () != pid
)
1050 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1051 error (_("Requested thread not found in requested process"));
1055 if (thr
->state
== THREAD_EXITED
)
1061 /* Return the string to display in "info threads"'s "Target Id"
1065 thread_target_id_str (thread_info
*tp
)
1067 std::string target_id
= target_pid_to_str (tp
->ptid
);
1068 const char *extra_info
= target_extra_thread_info (tp
);
1069 const char *name
= thread_name (tp
);
1071 if (extra_info
!= nullptr && name
!= nullptr)
1072 return string_printf ("%s \"%s\" (%s)", target_id
.c_str (), name
,
1074 else if (extra_info
!= nullptr)
1075 return string_printf ("%s (%s)", target_id
.c_str (), extra_info
);
1076 else if (name
!= nullptr)
1077 return string_printf ("%s \"%s\"", target_id
.c_str (), name
);
1082 /* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1083 whether REQUESTED_THREADS is a list of global or per-inferior
1087 print_thread_info_1 (struct ui_out
*uiout
, const char *requested_threads
,
1088 int global_ids
, int pid
,
1089 int show_global_ids
)
1091 int default_inf_num
= current_inferior ()->num
;
1093 update_thread_list ();
1095 /* Whether we saw any thread. */
1096 bool any_thread
= false;
1097 /* Whether the current thread is exited. */
1098 bool current_exited
= false;
1100 thread_info
*current_thread
= (inferior_ptid
!= null_ptid
1101 ? inferior_thread () : NULL
);
1104 /* For backward compatibility, we make a list for MI. A table is
1105 preferable for the CLI, though, because it shows table
1107 gdb::optional
<ui_out_emit_list
> list_emitter
;
1108 gdb::optional
<ui_out_emit_table
> table_emitter
;
1110 /* We'll be switching threads temporarily below. */
1111 scoped_restore_current_thread restore_thread
;
1113 if (uiout
->is_mi_like_p ())
1114 list_emitter
.emplace (uiout
, "threads");
1118 /* The width of the "Target Id" column. Grown below to
1119 accommodate the largest entry. */
1120 size_t target_id_col_width
= 17;
1122 for (thread_info
*tp
: all_threads ())
1124 if (!should_print_thread (requested_threads
, default_inf_num
,
1125 global_ids
, pid
, tp
))
1128 /* Switch inferiors so we're looking at the right
1130 switch_to_inferior_no_thread (tp
->inf
);
1133 = std::max (target_id_col_width
,
1134 thread_target_id_str (tp
).size ());
1141 if (requested_threads
== NULL
|| *requested_threads
== '\0')
1142 uiout
->message (_("No threads.\n"));
1144 uiout
->message (_("No threads match '%s'.\n"),
1149 table_emitter
.emplace (uiout
, show_global_ids
? 5 : 4,
1150 n_threads
, "threads");
1152 uiout
->table_header (1, ui_left
, "current", "");
1153 uiout
->table_header (4, ui_left
, "id-in-tg", "Id");
1154 if (show_global_ids
)
1155 uiout
->table_header (4, ui_left
, "id", "GId");
1156 uiout
->table_header (target_id_col_width
, ui_left
,
1157 "target-id", "Target Id");
1158 uiout
->table_header (1, ui_left
, "frame", "Frame");
1159 uiout
->table_body ();
1162 for (inferior
*inf
: all_inferiors ())
1163 for (thread_info
*tp
: inf
->threads ())
1168 if (tp
== current_thread
&& tp
->state
== THREAD_EXITED
)
1169 current_exited
= true;
1171 if (!should_print_thread (requested_threads
, default_inf_num
,
1172 global_ids
, pid
, tp
))
1175 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1177 if (!uiout
->is_mi_like_p ())
1179 if (tp
== current_thread
)
1180 uiout
->field_string ("current", "*");
1182 uiout
->field_skip ("current");
1184 uiout
->field_string ("id-in-tg", print_thread_id (tp
));
1187 if (show_global_ids
|| uiout
->is_mi_like_p ())
1188 uiout
->field_signed ("id", tp
->global_num
);
1190 /* Switch to the thread (and inferior / target). */
1191 switch_to_thread (tp
);
1193 /* For the CLI, we stuff everything into the target-id field.
1194 This is a gross hack to make the output come out looking
1195 correct. The underlying problem here is that ui-out has no
1196 way to specify that a field's space allocation should be
1197 shared by several fields. For MI, we do the right thing
1200 if (uiout
->is_mi_like_p ())
1202 uiout
->field_string ("target-id", target_pid_to_str (tp
->ptid
));
1204 const char *extra_info
= target_extra_thread_info (tp
);
1205 if (extra_info
!= nullptr)
1206 uiout
->field_string ("details", extra_info
);
1208 const char *name
= thread_name (tp
);
1210 uiout
->field_string ("name", name
);
1214 uiout
->field_string ("target-id", thread_target_id_str (tp
));
1217 if (tp
->state
== THREAD_RUNNING
)
1218 uiout
->text ("(running)\n");
1221 /* The switch above put us at the top of the stack (leaf
1223 print_stack_frame (get_selected_frame (NULL
),
1224 /* For MI output, print frame level. */
1225 uiout
->is_mi_like_p (),
1229 if (uiout
->is_mi_like_p ())
1231 const char *state
= "stopped";
1233 if (tp
->state
== THREAD_RUNNING
)
1235 uiout
->field_string ("state", state
);
1238 core
= target_core_of_thread (tp
->ptid
);
1239 if (uiout
->is_mi_like_p () && core
!= -1)
1240 uiout
->field_signed ("core", core
);
1243 /* This end scope restores the current thread and the frame
1244 selected before the "info threads" command, and it finishes the
1245 ui-out list or table. */
1248 if (pid
== -1 && requested_threads
== NULL
)
1250 if (uiout
->is_mi_like_p () && inferior_ptid
!= null_ptid
)
1251 uiout
->field_signed ("current-thread-id", current_thread
->global_num
);
1253 if (inferior_ptid
!= null_ptid
&& current_exited
)
1254 uiout
->message ("\n\
1255 The current thread <Thread ID %s> has terminated. See `help thread'.\n",
1256 print_thread_id (inferior_thread ()));
1257 else if (any_thread
&& inferior_ptid
== null_ptid
)
1258 uiout
->message ("\n\
1259 No selected thread. See `help thread'.\n");
1263 /* See gdbthread.h. */
1266 print_thread_info (struct ui_out
*uiout
, const char *requested_threads
,
1269 print_thread_info_1 (uiout
, requested_threads
, 1, pid
, 0);
1272 /* The options for the "info threads" command. */
1274 struct info_threads_opts
1277 bool show_global_ids
= false;
1280 static const gdb::option::option_def info_threads_option_defs
[] = {
1282 gdb::option::flag_option_def
<info_threads_opts
> {
1284 [] (info_threads_opts
*opts
) { return &opts
->show_global_ids
; },
1285 N_("Show global thread IDs."),
1290 /* Create an option_def_group for the "info threads" options, with
1291 IT_OPTS as context. */
1293 static inline gdb::option::option_def_group
1294 make_info_threads_options_def_group (info_threads_opts
*it_opts
)
1296 return {{info_threads_option_defs
}, it_opts
};
1299 /* Implementation of the "info threads" command.
1301 Note: this has the drawback that it _really_ switches
1302 threads, which frees the frame cache. A no-side
1303 effects info-threads command would be nicer. */
1306 info_threads_command (const char *arg
, int from_tty
)
1308 info_threads_opts it_opts
;
1310 auto grp
= make_info_threads_options_def_group (&it_opts
);
1311 gdb::option::process_options
1312 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
);
1314 print_thread_info_1 (current_uiout
, arg
, 0, -1, it_opts
.show_global_ids
);
1317 /* Completer for the "info threads" command. */
1320 info_threads_command_completer (struct cmd_list_element
*ignore
,
1321 completion_tracker
&tracker
,
1322 const char *text
, const char *word_ignored
)
1324 const auto grp
= make_info_threads_options_def_group (nullptr);
1326 if (gdb::option::complete_options
1327 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
))
1330 /* Convenience to let the user know what the option can accept. */
1333 gdb::option::complete_on_all_options (tracker
, grp
);
1334 /* Keep this "ID" in sync with what "help info threads"
1336 tracker
.add_completion (make_unique_xstrdup ("ID"));
1340 /* See gdbthread.h. */
1343 switch_to_thread_no_regs (struct thread_info
*thread
)
1345 gdb_assert (thread
!= nullptr);
1346 threads_debug_printf ("thread = %s", thread
->ptid
.to_string ().c_str ());
1348 struct inferior
*inf
= thread
->inf
;
1350 set_current_program_space (inf
->pspace
);
1351 set_current_inferior (inf
);
1353 current_thread_
= thread
;
1354 inferior_ptid
= current_thread_
->ptid
;
1357 /* See gdbthread.h. */
1360 switch_to_no_thread ()
1362 if (current_thread_
== nullptr)
1365 threads_debug_printf ("thread = NONE");
1367 current_thread_
= nullptr;
1368 inferior_ptid
= null_ptid
;
1369 reinit_frame_cache ();
1372 /* See gdbthread.h. */
1375 switch_to_thread (thread_info
*thr
)
1377 gdb_assert (thr
!= NULL
);
1379 if (is_current_thread (thr
))
1382 switch_to_thread_no_regs (thr
);
1384 reinit_frame_cache ();
1387 /* See gdbsupport/common-gdbthread.h. */
1390 switch_to_thread (process_stratum_target
*proc_target
, ptid_t ptid
)
1392 thread_info
*thr
= proc_target
->find_thread (ptid
);
1393 switch_to_thread (thr
);
1399 scoped_restore_current_thread::restore ()
1401 /* If an entry of thread_info was previously selected, it won't be
1402 deleted because we've increased its refcount. The thread represented
1403 by this thread_info entry may have already exited (due to normal exit,
1404 detach, etc), so the thread_info.state is THREAD_EXITED. */
1405 if (m_thread
!= NULL
1406 /* If the previously selected thread belonged to a process that has
1407 in the mean time exited (or killed, detached, etc.), then don't revert
1408 back to it, but instead simply drop back to no thread selected. */
1410 switch_to_thread (m_thread
.get ());
1412 switch_to_inferior_no_thread (m_inf
.get ());
1414 /* The running state of the originally selected thread may have
1415 changed, so we have to recheck it here. */
1416 if (inferior_ptid
!= null_ptid
1418 && m_thread
->state
== THREAD_STOPPED
1419 && target_has_registers ()
1420 && target_has_stack ()
1421 && target_has_memory ())
1422 restore_selected_frame (m_selected_frame_id
, m_selected_frame_level
);
1424 set_language (m_lang
);
1427 scoped_restore_current_thread::~scoped_restore_current_thread ()
1429 if (!m_dont_restore
)
1433 scoped_restore_current_thread::scoped_restore_current_thread ()
1435 m_inf
= inferior_ref::new_reference (current_inferior ());
1437 m_lang
= current_language
->la_language
;
1439 if (inferior_ptid
!= null_ptid
)
1441 m_thread
= thread_info_ref::new_reference (inferior_thread ());
1443 m_was_stopped
= m_thread
->state
== THREAD_STOPPED
;
1444 save_selected_frame (&m_selected_frame_id
, &m_selected_frame_level
);
1448 scoped_restore_current_thread::scoped_restore_current_thread
1449 (scoped_restore_current_thread
&&rhs
)
1450 : m_dont_restore (std::move (rhs
.m_dont_restore
)),
1451 m_thread (std::move (rhs
.m_thread
)),
1452 m_inf (std::move (rhs
.m_inf
)),
1453 m_selected_frame_id (std::move (rhs
.m_selected_frame_id
)),
1454 m_selected_frame_level (std::move (rhs
.m_selected_frame_level
)),
1455 m_was_stopped (std::move (rhs
.m_was_stopped
)),
1456 m_lang (std::move (rhs
.m_lang
))
1458 /* Deactivate the rhs. */
1459 rhs
.m_dont_restore
= true;
1462 /* See gdbthread.h. */
1465 show_thread_that_caused_stop (void)
1467 return highest_thread_num
> 1;
1470 /* See gdbthread.h. */
1473 show_inferior_qualified_tids (void)
1475 auto inf
= inferior_list
.begin ();
1479 return inf
!= inferior_list
.end ();
1482 /* See gdbthread.h. */
1485 print_thread_id (struct thread_info
*thr
)
1487 if (show_inferior_qualified_tids ())
1488 return print_full_thread_id (thr
);
1490 char *s
= get_print_cell ();
1492 gdb_assert (thr
!= nullptr);
1493 xsnprintf (s
, PRINT_CELL_SIZE
, "%d", thr
->per_inf_num
);
1497 /* See gdbthread.h. */
1500 print_full_thread_id (struct thread_info
*thr
)
1502 char *s
= get_print_cell ();
1504 gdb_assert (thr
!= nullptr);
1505 xsnprintf (s
, PRINT_CELL_SIZE
, "%d.%d", thr
->inf
->num
, thr
->per_inf_num
);
1509 /* Sort an array of struct thread_info pointers by thread ID (first by
1510 inferior number, and then by per-inferior thread number). Sorts in
1514 tp_array_compar_ascending (const thread_info_ref
&a
, const thread_info_ref
&b
)
1516 if (a
->inf
->num
!= b
->inf
->num
)
1517 return a
->inf
->num
< b
->inf
->num
;
1519 return (a
->per_inf_num
< b
->per_inf_num
);
1522 /* Sort an array of struct thread_info pointers by thread ID (first by
1523 inferior number, and then by per-inferior thread number). Sorts in
1524 descending order. */
1527 tp_array_compar_descending (const thread_info_ref
&a
, const thread_info_ref
&b
)
1529 if (a
->inf
->num
!= b
->inf
->num
)
1530 return a
->inf
->num
> b
->inf
->num
;
1532 return (a
->per_inf_num
> b
->per_inf_num
);
1535 /* See gdbthread.h. */
1538 thread_try_catch_cmd (thread_info
*thr
, gdb::optional
<int> ada_task
,
1539 const char *cmd
, int from_tty
,
1540 const qcs_flags
&flags
)
1542 gdb_assert (is_current_thread (thr
));
1544 /* The thread header is computed before running the command since
1545 the command can change the inferior, which is not permitted
1546 by thread_target_id_str. */
1547 std::string thr_header
;
1548 if (ada_task
.has_value ())
1549 thr_header
= string_printf (_("\nTask ID %d:\n"), *ada_task
);
1551 thr_header
= string_printf (_("\nThread %s (%s):\n"),
1552 print_thread_id (thr
),
1553 thread_target_id_str (thr
).c_str ());
1557 std::string cmd_result
;
1558 execute_command_to_string
1559 (cmd_result
, cmd
, from_tty
, gdb_stdout
->term_out ());
1560 if (!flags
.silent
|| cmd_result
.length () > 0)
1563 gdb_printf ("%s", thr_header
.c_str ());
1564 gdb_printf ("%s", cmd_result
.c_str ());
1567 catch (const gdb_exception_error
&ex
)
1572 gdb_printf ("%s", thr_header
.c_str ());
1574 gdb_printf ("%s\n", ex
.what ());
1581 /* Option definition of "thread apply"'s "-ascending" option. */
1583 static const gdb::option::flag_option_def
<> ascending_option_def
= {
1586 Call COMMAND for all threads in ascending order.\n\
1587 The default is descending order."),
1590 /* The qcs command line flags for the "thread apply" commands. Keep
1591 this in sync with the "frame apply" commands. */
1593 using qcs_flag_option_def
1594 = gdb::option::flag_option_def
<qcs_flags
>;
1596 static const gdb::option::option_def thr_qcs_flags_option_defs
[] = {
1597 qcs_flag_option_def
{
1598 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
1599 N_("Disables printing the thread information."),
1602 qcs_flag_option_def
{
1603 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
1604 N_("Print any error raised by COMMAND and continue."),
1607 qcs_flag_option_def
{
1608 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
1609 N_("Silently ignore any errors or empty output produced by COMMAND."),
1613 /* Create an option_def_group for the "thread apply all" options, with
1614 ASCENDING and FLAGS as context. */
1616 static inline std::array
<gdb::option::option_def_group
, 2>
1617 make_thread_apply_all_options_def_group (bool *ascending
,
1621 { {ascending_option_def
.def ()}, ascending
},
1622 { {thr_qcs_flags_option_defs
}, flags
},
1626 /* Create an option_def_group for the "thread apply" options, with
1627 FLAGS as context. */
1629 static inline gdb::option::option_def_group
1630 make_thread_apply_options_def_group (qcs_flags
*flags
)
1632 return {{thr_qcs_flags_option_defs
}, flags
};
1635 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1636 separated list of numbers, or ranges, or the keyword `all'. Ranges consist
1637 of two numbers separated by a hyphen. Examples:
1639 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1640 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1641 thread apply all x/i $pc Apply x/i $pc cmd to all threads. */
1644 thread_apply_all_command (const char *cmd
, int from_tty
)
1646 bool ascending
= false;
1649 auto group
= make_thread_apply_all_options_def_group (&ascending
,
1651 gdb::option::process_options
1652 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1654 validate_flags_qcs ("thread apply all", &flags
);
1656 if (cmd
== NULL
|| *cmd
== '\000')
1657 error (_("Please specify a command at the end of 'thread apply all'"));
1659 update_thread_list ();
1661 int tc
= live_threads_count ();
1664 /* Save a copy of the thread list and increment each thread's
1665 refcount while executing the command in the context of each
1666 thread, in case the command is one that wipes threads. E.g.,
1667 detach, kill, disconnect, etc., or even normally continuing
1668 over an inferior or thread exit. */
1669 std::vector
<thread_info_ref
> thr_list_cpy
;
1670 thr_list_cpy
.reserve (tc
);
1672 for (thread_info
*tp
: all_non_exited_threads ())
1673 thr_list_cpy
.push_back (thread_info_ref::new_reference (tp
));
1674 gdb_assert (thr_list_cpy
.size () == tc
);
1676 auto *sorter
= (ascending
1677 ? tp_array_compar_ascending
1678 : tp_array_compar_descending
);
1679 std::sort (thr_list_cpy
.begin (), thr_list_cpy
.end (), sorter
);
1681 scoped_restore_current_thread restore_thread
;
1683 for (thread_info_ref
&thr
: thr_list_cpy
)
1684 if (switch_to_thread_if_alive (thr
.get ()))
1685 thread_try_catch_cmd (thr
.get (), {}, cmd
, from_tty
, flags
);
1689 /* Completer for "thread apply [ID list]". */
1692 thread_apply_command_completer (cmd_list_element
*ignore
,
1693 completion_tracker
&tracker
,
1694 const char *text
, const char * /*word*/)
1696 /* Don't leave this to complete_options because there's an early
1698 tracker
.set_use_custom_word_point (true);
1700 tid_range_parser parser
;
1701 parser
.init (text
, current_inferior ()->num
);
1705 while (!parser
.finished ())
1707 int inf_num
, thr_start
, thr_end
;
1709 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1712 if (parser
.in_star_range () || parser
.in_thread_range ())
1713 parser
.skip_range ();
1716 catch (const gdb_exception_error
&ex
)
1718 /* get_tid_range throws if it parses a negative number, for
1719 example. But a seemingly negative number may be the start of
1720 an option instead. */
1723 const char *cmd
= parser
.cur_tok ();
1727 /* No thread ID list yet. */
1731 /* Check if we're past a valid thread ID list already. */
1732 if (parser
.finished ()
1733 && cmd
> text
&& !isspace (cmd
[-1]))
1736 /* We're past the thread ID list, advance word point. */
1737 tracker
.advance_custom_word_point_by (cmd
- text
);
1740 const auto group
= make_thread_apply_options_def_group (nullptr);
1741 if (gdb::option::complete_options
1742 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1745 complete_nested_command_line (tracker
, text
);
1748 /* Completer for "thread apply all". */
1751 thread_apply_all_command_completer (cmd_list_element
*ignore
,
1752 completion_tracker
&tracker
,
1753 const char *text
, const char *word
)
1755 const auto group
= make_thread_apply_all_options_def_group (nullptr,
1757 if (gdb::option::complete_options
1758 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1761 complete_nested_command_line (tracker
, text
);
1764 /* Implementation of the "thread apply" command. */
1767 thread_apply_command (const char *tidlist
, int from_tty
)
1770 const char *cmd
= NULL
;
1771 tid_range_parser parser
;
1773 if (tidlist
== NULL
|| *tidlist
== '\000')
1774 error (_("Please specify a thread ID list"));
1776 parser
.init (tidlist
, current_inferior ()->num
);
1777 while (!parser
.finished ())
1779 int inf_num
, thr_start
, thr_end
;
1781 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1785 cmd
= parser
.cur_tok ();
1787 auto group
= make_thread_apply_options_def_group (&flags
);
1788 gdb::option::process_options
1789 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1791 validate_flags_qcs ("thread apply", &flags
);
1794 error (_("Please specify a command following the thread ID list"));
1796 if (tidlist
== cmd
|| isdigit (cmd
[0]))
1797 invalid_thread_id_error (cmd
);
1799 scoped_restore_current_thread restore_thread
;
1801 parser
.init (tidlist
, current_inferior ()->num
);
1802 while (!parser
.finished ())
1804 struct thread_info
*tp
= NULL
;
1805 struct inferior
*inf
;
1806 int inf_num
, thr_num
;
1808 parser
.get_tid (&inf_num
, &thr_num
);
1809 inf
= find_inferior_id (inf_num
);
1811 tp
= find_thread_id (inf
, thr_num
);
1813 if (parser
.in_star_range ())
1817 warning (_("Unknown inferior %d"), inf_num
);
1818 parser
.skip_range ();
1822 /* No use looking for threads past the highest thread number
1823 the inferior ever had. */
1824 if (thr_num
>= inf
->highest_thread_num
)
1825 parser
.skip_range ();
1827 /* Be quiet about unknown threads numbers. */
1834 if (show_inferior_qualified_tids () || parser
.tid_is_qualified ())
1835 warning (_("Unknown thread %d.%d"), inf_num
, thr_num
);
1837 warning (_("Unknown thread %d"), thr_num
);
1841 if (!switch_to_thread_if_alive (tp
))
1843 warning (_("Thread %s has terminated."), print_thread_id (tp
));
1847 thread_try_catch_cmd (tp
, {}, cmd
, from_tty
, flags
);
1852 /* Implementation of the "taas" command. */
1855 taas_command (const char *cmd
, int from_tty
)
1857 if (cmd
== NULL
|| *cmd
== '\0')
1858 error (_("Please specify a command to apply on all threads"));
1859 std::string expanded
= std::string ("thread apply all -s ") + cmd
;
1860 execute_command (expanded
.c_str (), from_tty
);
1863 /* Implementation of the "tfaas" command. */
1866 tfaas_command (const char *cmd
, int from_tty
)
1868 if (cmd
== NULL
|| *cmd
== '\0')
1869 error (_("Please specify a command to apply on all frames of all threads"));
1870 std::string expanded
1871 = std::string ("thread apply all -s -- frame apply all -s ") + cmd
;
1872 execute_command (expanded
.c_str (), from_tty
);
1875 /* Switch to the specified thread, or print the current thread. */
1878 thread_command (const char *tidstr
, int from_tty
)
1882 if (inferior_ptid
== null_ptid
)
1883 error (_("No thread selected"));
1885 if (target_has_stack ())
1887 struct thread_info
*tp
= inferior_thread ();
1889 if (tp
->state
== THREAD_EXITED
)
1890 gdb_printf (_("[Current thread is %s (%s) (exited)]\n"),
1891 print_thread_id (tp
),
1892 target_pid_to_str (inferior_ptid
).c_str ());
1894 gdb_printf (_("[Current thread is %s (%s)]\n"),
1895 print_thread_id (tp
),
1896 target_pid_to_str (inferior_ptid
).c_str ());
1899 error (_("No stack."));
1903 ptid_t previous_ptid
= inferior_ptid
;
1905 thread_select (tidstr
, parse_thread_id (tidstr
, NULL
));
1907 /* Print if the thread has not changed, otherwise an event will
1909 if (inferior_ptid
== previous_ptid
)
1911 print_selected_thread_frame (current_uiout
,
1912 USER_SELECTED_THREAD
1913 | USER_SELECTED_FRAME
);
1916 notify_user_selected_context_changed
1917 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
1921 /* Implementation of `thread name'. */
1924 thread_name_command (const char *arg
, int from_tty
)
1926 struct thread_info
*info
;
1928 if (inferior_ptid
== null_ptid
)
1929 error (_("No thread selected"));
1931 arg
= skip_spaces (arg
);
1933 info
= inferior_thread ();
1934 info
->set_name (arg
!= nullptr ? make_unique_xstrdup (arg
) : nullptr);
1937 /* Find thread ids with a name, target pid, or extra info matching ARG. */
1940 thread_find_command (const char *arg
, int from_tty
)
1943 unsigned long match
= 0;
1945 if (arg
== NULL
|| *arg
== '\0')
1946 error (_("Command requires an argument."));
1948 tmp
= re_comp (arg
);
1950 error (_("Invalid regexp (%s): %s"), tmp
, arg
);
1952 /* We're going to be switching threads. */
1953 scoped_restore_current_thread restore_thread
;
1955 update_thread_list ();
1957 for (thread_info
*tp
: all_threads ())
1959 switch_to_inferior_no_thread (tp
->inf
);
1961 if (tp
->name () != nullptr && re_exec (tp
->name ()))
1963 gdb_printf (_("Thread %s has name '%s'\n"),
1964 print_thread_id (tp
), tp
->name ());
1968 tmp
= target_thread_name (tp
);
1969 if (tmp
!= NULL
&& re_exec (tmp
))
1971 gdb_printf (_("Thread %s has target name '%s'\n"),
1972 print_thread_id (tp
), tmp
);
1976 std::string name
= target_pid_to_str (tp
->ptid
);
1977 if (!name
.empty () && re_exec (name
.c_str ()))
1979 gdb_printf (_("Thread %s has target id '%s'\n"),
1980 print_thread_id (tp
), name
.c_str ());
1984 tmp
= target_extra_thread_info (tp
);
1985 if (tmp
!= NULL
&& re_exec (tmp
))
1987 gdb_printf (_("Thread %s has extra info '%s'\n"),
1988 print_thread_id (tp
), tmp
);
1993 gdb_printf (_("No threads match '%s'\n"), arg
);
1996 /* Print notices when new threads are attached and detached. */
1997 bool print_thread_events
= true;
1999 show_print_thread_events (struct ui_file
*file
, int from_tty
,
2000 struct cmd_list_element
*c
, const char *value
)
2003 _("Printing of thread events is %s.\n"),
2007 /* See gdbthread.h. */
2010 thread_select (const char *tidstr
, thread_info
*tp
)
2012 if (!switch_to_thread_if_alive (tp
))
2013 error (_("Thread ID %s has terminated."), tidstr
);
2015 annotate_thread_changed ();
2017 /* Since the current thread may have changed, see if there is any
2018 exited thread we can now delete. */
2019 delete_exited_threads ();
2022 /* Print thread and frame switch command response. */
2025 print_selected_thread_frame (struct ui_out
*uiout
,
2026 user_selected_what selection
)
2028 struct thread_info
*tp
= inferior_thread ();
2030 if (selection
& USER_SELECTED_THREAD
)
2032 if (uiout
->is_mi_like_p ())
2034 uiout
->field_signed ("new-thread-id",
2035 inferior_thread ()->global_num
);
2039 uiout
->text ("[Switching to thread ");
2040 uiout
->field_string ("new-thread-id", print_thread_id (tp
));
2042 uiout
->text (target_pid_to_str (inferior_ptid
));
2047 if (tp
->state
== THREAD_RUNNING
)
2049 if (selection
& USER_SELECTED_THREAD
)
2050 uiout
->text ("(running)\n");
2052 else if (selection
& USER_SELECTED_FRAME
)
2054 if (selection
& USER_SELECTED_THREAD
)
2057 if (has_stack_frames ())
2058 print_stack_frame_to_uiout (uiout
, get_selected_frame (NULL
),
2063 /* Update the 'threads_executing' global based on the threads we know
2064 about right now. This is used by infrun to tell whether we should
2065 pull events out of the current target. */
2068 update_threads_executing (void)
2070 process_stratum_target
*targ
= current_inferior ()->process_target ();
2075 targ
->threads_executing
= false;
2077 for (inferior
*inf
: all_non_exited_inferiors (targ
))
2079 if (!inf
->has_execution ())
2082 /* If the process has no threads, then it must be we have a
2083 process-exit event pending. */
2084 if (inf
->thread_list
.empty ())
2086 targ
->threads_executing
= true;
2090 for (thread_info
*tp
: inf
->non_exited_threads ())
2092 if (tp
->executing ())
2094 targ
->threads_executing
= true;
2102 update_thread_list (void)
2104 target_update_thread_list ();
2105 update_threads_executing ();
2108 /* See gdbthread.h. */
2111 thread_name (thread_info
*thread
)
2113 /* Use the manually set name if there is one. */
2114 const char *name
= thread
->name ();
2115 if (name
!= nullptr)
2118 /* Otherwise, ask the target. Ensure we query the right target stack. */
2119 scoped_restore_current_thread restore_thread
;
2120 if (thread
->inf
!= current_inferior ())
2121 switch_to_inferior_no_thread (thread
->inf
);
2123 return target_thread_name (thread
);
2126 /* See gdbthread.h. */
2129 thread_state_string (enum thread_state state
)
2133 case THREAD_STOPPED
:
2136 case THREAD_RUNNING
:
2143 gdb_assert_not_reached ("unknown thread state");
2146 /* Return a new value for the selected thread's id. Return a value of
2147 0 if no thread is selected. If GLOBAL is true, return the thread's
2148 global number. Otherwise return the per-inferior number. */
2150 static struct value
*
2151 thread_num_make_value_helper (struct gdbarch
*gdbarch
, int global
)
2155 if (inferior_ptid
== null_ptid
)
2159 thread_info
*tp
= inferior_thread ();
2161 int_val
= tp
->global_num
;
2163 int_val
= tp
->per_inf_num
;
2166 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, int_val
);
2169 /* Return a new value for the selected thread's per-inferior thread
2170 number. Return a value of 0 if no thread is selected, or no
2173 static struct value
*
2174 thread_id_per_inf_num_make_value (struct gdbarch
*gdbarch
,
2175 struct internalvar
*var
,
2178 return thread_num_make_value_helper (gdbarch
, 0);
2181 /* Return a new value for the selected thread's global id. Return a
2182 value of 0 if no thread is selected, or no threads exist. */
2184 static struct value
*
2185 global_thread_id_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
2188 return thread_num_make_value_helper (gdbarch
, 1);
2191 /* Return a new value for the number of non-exited threads in the current
2192 inferior. If there are no threads in the current inferior return a
2195 static struct value
*
2196 inferior_thread_count_make_value (struct gdbarch
*gdbarch
,
2197 struct internalvar
*var
, void *ignore
)
2201 update_thread_list ();
2203 if (inferior_ptid
!= null_ptid
)
2204 int_val
= current_inferior ()->non_exited_threads ().size ();
2206 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, int_val
);
2209 /* Commands with a prefix of `thread'. */
2210 struct cmd_list_element
*thread_cmd_list
= NULL
;
2212 /* Implementation of `thread' variable. */
2214 static const struct internalvar_funcs thread_funcs
=
2216 thread_id_per_inf_num_make_value
,
2220 /* Implementation of `gthread' variable. */
2222 static const struct internalvar_funcs gthread_funcs
=
2224 global_thread_id_make_value
,
2228 /* Implementation of `_inferior_thread_count` convenience variable. */
2230 static const struct internalvar_funcs inferior_thread_count_funcs
=
2232 inferior_thread_count_make_value
,
2236 void _initialize_thread ();
2238 _initialize_thread ()
2240 static struct cmd_list_element
*thread_apply_list
= NULL
;
2241 cmd_list_element
*c
;
2243 const auto info_threads_opts
= make_info_threads_options_def_group (nullptr);
2245 /* Note: keep this "ID" in sync with what "info threads [TAB]"
2247 static std::string info_threads_help
2248 = gdb::option::build_help (_("\
2249 Display currently known threads.\n\
2250 Usage: info threads [OPTION]... [ID]...\n\
2251 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2252 Otherwise, all threads are displayed.\n\
2258 c
= add_info ("threads", info_threads_command
, info_threads_help
.c_str ());
2259 set_cmd_completer_handle_brkchars (c
, info_threads_command_completer
);
2261 cmd_list_element
*thread_cmd
2262 = add_prefix_cmd ("thread", class_run
, thread_command
, _("\
2263 Use this command to switch between threads.\n\
2264 The new thread ID must be currently known."),
2265 &thread_cmd_list
, 1, &cmdlist
);
2267 add_com_alias ("t", thread_cmd
, class_run
, 1);
2269 #define THREAD_APPLY_OPTION_HELP "\
2270 Prints per-inferior thread number and target system's thread id\n\
2271 followed by COMMAND output.\n\
2273 By default, an error raised during the execution of COMMAND\n\
2274 aborts \"thread apply\".\n\
2279 const auto thread_apply_opts
= make_thread_apply_options_def_group (nullptr);
2281 static std::string thread_apply_help
= gdb::option::build_help (_("\
2282 Apply a command to a list of threads.\n\
2283 Usage: thread apply ID... [OPTION]... COMMAND\n\
2284 ID is a space-separated list of IDs of threads to apply COMMAND on.\n"
2285 THREAD_APPLY_OPTION_HELP
),
2288 c
= add_prefix_cmd ("apply", class_run
, thread_apply_command
,
2289 thread_apply_help
.c_str (),
2290 &thread_apply_list
, 1,
2292 set_cmd_completer_handle_brkchars (c
, thread_apply_command_completer
);
2294 const auto thread_apply_all_opts
2295 = make_thread_apply_all_options_def_group (nullptr, nullptr);
2297 static std::string thread_apply_all_help
= gdb::option::build_help (_("\
2298 Apply a command to all threads.\n\
2300 Usage: thread apply all [OPTION]... COMMAND\n"
2301 THREAD_APPLY_OPTION_HELP
),
2302 thread_apply_all_opts
);
2304 c
= add_cmd ("all", class_run
, thread_apply_all_command
,
2305 thread_apply_all_help
.c_str (),
2306 &thread_apply_list
);
2307 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2309 c
= add_com ("taas", class_run
, taas_command
, _("\
2310 Apply a command to all threads (ignoring errors and empty output).\n\
2311 Usage: taas [OPTION]... COMMAND\n\
2312 shortcut for 'thread apply all -s [OPTION]... COMMAND'\n\
2313 See \"help thread apply all\" for available options."));
2314 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2316 c
= add_com ("tfaas", class_run
, tfaas_command
, _("\
2317 Apply a command to all frames of all threads (ignoring errors and empty output).\n\
2318 Usage: tfaas [OPTION]... COMMAND\n\
2319 shortcut for 'thread apply all -s -- frame apply all -s [OPTION]... COMMAND'\n\
2320 See \"help frame apply all\" for available options."));
2321 set_cmd_completer_handle_brkchars (c
, frame_apply_all_cmd_completer
);
2323 add_cmd ("name", class_run
, thread_name_command
,
2324 _("Set the current thread's name.\n\
2325 Usage: thread name [NAME]\n\
2326 If NAME is not given, then any existing name is removed."), &thread_cmd_list
);
2328 add_cmd ("find", class_run
, thread_find_command
, _("\
2329 Find threads that match a regular expression.\n\
2330 Usage: thread find REGEXP\n\
2331 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2334 add_setshow_boolean_cmd ("thread-events", no_class
,
2335 &print_thread_events
, _("\
2336 Set printing of thread events (such as thread start and exit)."), _("\
2337 Show printing of thread events (such as thread start and exit)."), NULL
,
2339 show_print_thread_events
,
2340 &setprintlist
, &showprintlist
);
2342 add_setshow_boolean_cmd ("threads", class_maintenance
, &debug_threads
, _("\
2343 Set thread debugging."), _("\
2344 Show thread debugging."), _("\
2345 When on messages about thread creation and deletion are printed."),
2348 &setdebuglist
, &showdebuglist
);
2350 create_internalvar_type_lazy ("_thread", &thread_funcs
, NULL
);
2351 create_internalvar_type_lazy ("_gthread", >hread_funcs
, NULL
);
2352 create_internalvar_type_lazy ("_inferior_thread_count",
2353 &inferior_thread_count_funcs
, NULL
);