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_is_in_step_over_chain (struct thread_info
*tp
)
437 return tp
->step_over_list_node
.is_linked ();
440 /* See gdbthread.h. */
443 thread_step_over_chain_length (const thread_step_over_list
&l
)
447 for (const thread_info
&thread ATTRIBUTE_UNUSED
: l
)
453 /* See gdbthread.h. */
456 global_thread_step_over_chain_enqueue (struct thread_info
*tp
)
458 infrun_debug_printf ("enqueueing thread %s in global step over chain",
459 tp
->ptid
.to_string ().c_str ());
461 gdb_assert (!thread_is_in_step_over_chain (tp
));
462 global_thread_step_over_list
.push_back (*tp
);
465 /* See gdbthread.h. */
468 global_thread_step_over_chain_enqueue_chain (thread_step_over_list
&&list
)
470 global_thread_step_over_list
.splice (std::move (list
));
473 /* See gdbthread.h. */
476 global_thread_step_over_chain_remove (struct thread_info
*tp
)
478 infrun_debug_printf ("removing thread %s from global step over chain",
479 tp
->ptid
.to_string ().c_str ());
481 gdb_assert (thread_is_in_step_over_chain (tp
));
482 auto it
= global_thread_step_over_list
.iterator_to (*tp
);
483 global_thread_step_over_list
.erase (it
);
486 /* Helper for the different delete_thread variants. */
489 delete_thread_1 (thread_info
*thr
, gdb::optional
<ULONGEST
> exit_code
,
492 gdb_assert (thr
!= nullptr);
494 threads_debug_printf ("deleting thread %s, exit_code = %s, silent = %d",
495 thr
->ptid
.to_string ().c_str (),
496 (exit_code
.has_value ()
497 ? pulongest (*exit_code
)
501 set_thread_exited (thr
, exit_code
, silent
);
503 if (!thr
->deletable ())
505 /* Will be really deleted some other time. */
509 auto it
= thr
->inf
->thread_list
.iterator_to (*thr
);
510 thr
->inf
->thread_list
.erase (it
);
515 /* See gdbthread.h. */
518 delete_thread_with_exit_code (thread_info
*thread
, ULONGEST exit_code
,
521 delete_thread_1 (thread
, exit_code
, silent
);
524 /* See gdbthread.h. */
527 delete_thread (thread_info
*thread
)
529 delete_thread_1 (thread
, {}, false /* not silent */);
533 delete_thread_silent (thread_info
*thread
)
535 delete_thread_1 (thread
, {}, true /* not silent */);
539 find_thread_global_id (int global_id
)
541 for (thread_info
*tp
: all_threads ())
542 if (tp
->global_num
== global_id
)
548 static struct thread_info
*
549 find_thread_id (struct inferior
*inf
, int thr_num
)
551 for (thread_info
*tp
: inf
->threads ())
552 if (tp
->per_inf_num
== thr_num
)
558 /* See gdbthread.h. */
561 find_thread_by_handle (gdb::array_view
<const gdb_byte
> handle
,
562 struct inferior
*inf
)
564 return target_thread_handle_to_thread_info (handle
.data (),
570 * Thread iterator function.
572 * Calls a callback function once for each thread, so long as
573 * the callback function returns false. If the callback function
574 * returns true, the iteration will end and the current thread
575 * will be returned. This can be useful for implementing a
576 * search for a thread with arbitrary attributes, or for applying
577 * some operation to every thread.
579 * FIXME: some of the existing functionality, such as
580 * "Thread apply all", might be rewritten using this functionality.
584 iterate_over_threads (int (*callback
) (struct thread_info
*, void *),
587 for (thread_info
*tp
: all_threads_safe ())
588 if ((*callback
) (tp
, data
))
594 /* See gdbthread.h. */
599 for (thread_info
*tp ATTRIBUTE_UNUSED
: all_threads ())
605 thread_count (process_stratum_target
*proc_target
)
607 auto rng
= all_threads (proc_target
);
608 return std::distance (rng
.begin (), rng
.end ());
611 /* Return the number of non-exited threads in the thread list. */
614 live_threads_count (void)
616 auto rng
= all_non_exited_threads ();
617 return std::distance (rng
.begin (), rng
.end ());
621 valid_global_thread_id (int global_id
)
623 for (thread_info
*tp
: all_threads ())
624 if (tp
->global_num
== global_id
)
631 in_thread_list (process_stratum_target
*targ
, ptid_t ptid
)
633 return targ
->find_thread (ptid
) != nullptr;
636 /* Finds the first thread of the inferior. */
639 first_thread_of_inferior (inferior
*inf
)
641 if (inf
->thread_list
.empty ())
644 return &inf
->thread_list
.front ();
648 any_thread_of_inferior (inferior
*inf
)
650 gdb_assert (inf
->pid
!= 0);
652 /* Prefer the current thread, if there's one. */
653 if (inf
== current_inferior () && inferior_ptid
!= null_ptid
)
654 return inferior_thread ();
656 for (thread_info
*tp
: inf
->non_exited_threads ())
663 any_live_thread_of_inferior (inferior
*inf
)
665 struct thread_info
*curr_tp
= NULL
;
666 struct thread_info
*tp_executing
= NULL
;
668 gdb_assert (inf
!= NULL
&& inf
->pid
!= 0);
670 /* Prefer the current thread if it's not executing. */
671 if (inferior_ptid
!= null_ptid
&& current_inferior () == inf
)
673 /* If the current thread is dead, forget it. If it's not
674 executing, use it. Otherwise, still choose it (below), but
675 only if no other non-executing thread is found. */
676 curr_tp
= inferior_thread ();
677 if (curr_tp
->state
== THREAD_EXITED
)
679 else if (!curr_tp
->executing ())
683 for (thread_info
*tp
: inf
->non_exited_threads ())
685 if (!tp
->executing ())
691 /* If both the current thread and all live threads are executing,
692 prefer the current thread. */
696 /* Otherwise, just return an executing thread, if any. */
700 /* Return true if TP is an active thread. */
702 thread_alive (thread_info
*tp
)
704 if (tp
->state
== THREAD_EXITED
)
707 /* Ensure we're looking at the right target stack. */
708 gdb_assert (tp
->inf
== current_inferior ());
710 return target_thread_alive (tp
->ptid
);
713 /* See gdbthreads.h. */
716 switch_to_thread_if_alive (thread_info
*thr
)
718 scoped_restore_current_thread restore_thread
;
720 /* Switch inferior first, so that we're looking at the right target
722 switch_to_inferior_no_thread (thr
->inf
);
724 if (thread_alive (thr
))
726 switch_to_thread (thr
);
727 restore_thread
.dont_restore ();
734 /* See gdbthreads.h. */
739 scoped_restore_current_thread restore_thread
;
741 for (thread_info
*tp
: all_threads_safe ())
743 switch_to_inferior_no_thread (tp
->inf
);
745 if (!thread_alive (tp
))
750 /* See gdbthreads.h. */
753 delete_exited_threads (void)
755 for (thread_info
*tp
: all_threads_safe ())
756 if (tp
->state
== THREAD_EXITED
)
760 /* Return true value if stack temporaries are enabled for the thread
764 thread_stack_temporaries_enabled_p (thread_info
*tp
)
769 return tp
->stack_temporaries_enabled
;
772 /* Push V on to the stack temporaries of the thread with id PTID. */
775 push_thread_stack_temporary (thread_info
*tp
, struct value
*v
)
777 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
778 tp
->stack_temporaries
.push_back (v
);
781 /* Return true if VAL is among the stack temporaries of the thread
782 TP. Return false otherwise. */
785 value_in_thread_stack_temporaries (struct value
*val
, thread_info
*tp
)
787 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
788 for (value
*v
: tp
->stack_temporaries
)
795 /* Return the last of the stack temporaries for thread with id PTID.
796 Return NULL if there are no stack temporaries for the thread. */
799 get_last_thread_stack_temporary (thread_info
*tp
)
801 struct value
*lastval
= NULL
;
803 gdb_assert (tp
!= NULL
);
804 if (!tp
->stack_temporaries
.empty ())
805 lastval
= tp
->stack_temporaries
.back ();
811 thread_change_ptid (process_stratum_target
*targ
,
812 ptid_t old_ptid
, ptid_t new_ptid
)
814 struct inferior
*inf
;
815 struct thread_info
*tp
;
817 /* It can happen that what we knew as the target inferior id
818 changes. E.g, target remote may only discover the remote process
819 pid after adding the inferior to GDB's list. */
820 inf
= find_inferior_ptid (targ
, old_ptid
);
821 inf
->pid
= new_ptid
.pid ();
823 tp
= inf
->find_thread (old_ptid
);
824 gdb_assert (tp
!= nullptr);
826 int num_erased
= inf
->ptid_thread_map
.erase (old_ptid
);
827 gdb_assert (num_erased
== 1);
830 inf
->ptid_thread_map
[new_ptid
] = tp
;
832 gdb::observers::thread_ptid_changed
.notify (targ
, old_ptid
, new_ptid
);
835 /* See gdbthread.h. */
838 set_resumed (process_stratum_target
*targ
, ptid_t ptid
, bool resumed
)
840 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
841 tp
->set_resumed (resumed
);
844 /* Helper for set_running, that marks one thread either running or
848 set_running_thread (struct thread_info
*tp
, bool running
)
850 bool started
= false;
852 if (running
&& tp
->state
== THREAD_STOPPED
)
854 tp
->state
= running
? THREAD_RUNNING
: THREAD_STOPPED
;
856 threads_debug_printf ("thread: %s, running? %d%s",
857 tp
->ptid
.to_string ().c_str (), running
,
858 (started
? " (started)" : ""));
862 /* If the thread is now marked stopped, remove it from
863 the step-over queue, so that we don't try to resume
864 it until the user wants it to. */
865 if (thread_is_in_step_over_chain (tp
))
866 global_thread_step_over_chain_remove (tp
);
872 /* Notify interpreters and observers that the target was resumed. */
875 notify_target_resumed (ptid_t ptid
)
877 interps_notify_target_resumed (ptid
);
878 gdb::observers::target_resumed
.notify (ptid
);
881 /* See gdbthread.h. */
884 thread_info::set_running (bool running
)
886 if (set_running_thread (this, running
))
887 notify_target_resumed (this->ptid
);
891 set_running (process_stratum_target
*targ
, ptid_t ptid
, bool running
)
893 /* We try not to notify the observer if no thread has actually
894 changed the running state -- merely to reduce the number of
895 messages to the MI frontend. A frontend is supposed to handle
896 multiple *running notifications just fine. */
897 bool any_started
= false;
899 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
900 if (set_running_thread (tp
, running
))
904 notify_target_resumed (ptid
);
908 set_executing (process_stratum_target
*targ
, ptid_t ptid
, bool executing
)
910 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
911 tp
->set_executing (executing
);
913 /* It only takes one running thread to spawn more threads. */
915 targ
->threads_executing
= true;
916 /* Only clear the flag if the caller is telling us everything is
918 else if (minus_one_ptid
== ptid
)
919 targ
->threads_executing
= false;
922 /* See gdbthread.h. */
925 threads_are_executing (process_stratum_target
*target
)
927 return target
->threads_executing
;
931 set_stop_requested (process_stratum_target
*targ
, ptid_t ptid
, bool stop
)
933 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
934 tp
->stop_requested
= stop
;
936 /* Call the stop requested observer so other components of GDB can
937 react to this request. */
939 gdb::observers::thread_stop_requested
.notify (ptid
);
943 finish_thread_state (process_stratum_target
*targ
, ptid_t ptid
)
945 bool any_started
= false;
947 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
948 if (set_running_thread (tp
, tp
->executing ()))
952 notify_target_resumed (ptid
);
955 /* See gdbthread.h. */
958 validate_registers_access (void)
960 /* No selected thread, no registers. */
961 if (inferior_ptid
== null_ptid
)
962 error (_("No thread selected."));
964 thread_info
*tp
= inferior_thread ();
966 /* Don't try to read from a dead thread. */
967 if (tp
->state
== THREAD_EXITED
)
968 error (_("The current thread has terminated"));
970 /* ... or from a spinning thread. FIXME: This isn't actually fully
971 correct. It'll allow an user-requested access (e.g., "print $pc"
972 at the prompt) when a thread is not executing for some internal
973 reason, but is marked running from the user's perspective. E.g.,
974 the thread is waiting for its turn in the step-over queue. */
975 if (tp
->executing ())
976 error (_("Selected thread is running."));
979 /* See gdbthread.h. */
982 can_access_registers_thread (thread_info
*thread
)
984 /* No thread, no registers. */
988 /* Don't try to read from a dead thread. */
989 if (thread
->state
== THREAD_EXITED
)
992 /* ... or from a spinning thread. FIXME: see validate_registers_access. */
993 if (thread
->executing ())
1000 pc_in_thread_step_range (CORE_ADDR pc
, struct thread_info
*thread
)
1002 return (pc
>= thread
->control
.step_range_start
1003 && pc
< thread
->control
.step_range_end
);
1006 /* Helper for print_thread_info. Returns true if THR should be
1007 printed. If REQUESTED_THREADS, a list of GDB ids/ranges, is not
1008 NULL, only print THR if its ID is included in the list. GLOBAL_IDS
1009 is true if REQUESTED_THREADS is list of global IDs, false if a list
1010 of per-inferior thread ids. If PID is not -1, only print THR if it
1011 is a thread from the process PID. Otherwise, threads from all
1012 attached PIDs are printed. If both REQUESTED_THREADS is not NULL
1013 and PID is not -1, then the thread is printed if it belongs to the
1014 specified process. Otherwise, an error is raised. */
1017 should_print_thread (const char *requested_threads
, int default_inf_num
,
1018 int global_ids
, int pid
, struct thread_info
*thr
)
1020 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1025 in_list
= number_is_in_list (requested_threads
, thr
->global_num
);
1027 in_list
= tid_is_in_list (requested_threads
, default_inf_num
,
1028 thr
->inf
->num
, thr
->per_inf_num
);
1033 if (pid
!= -1 && thr
->ptid
.pid () != pid
)
1035 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1036 error (_("Requested thread not found in requested process"));
1040 if (thr
->state
== THREAD_EXITED
)
1046 /* Return the string to display in "info threads"'s "Target Id"
1050 thread_target_id_str (thread_info
*tp
)
1052 std::string target_id
= target_pid_to_str (tp
->ptid
);
1053 const char *extra_info
= target_extra_thread_info (tp
);
1054 const char *name
= thread_name (tp
);
1056 if (extra_info
!= nullptr && name
!= nullptr)
1057 return string_printf ("%s \"%s\" (%s)", target_id
.c_str (), name
,
1059 else if (extra_info
!= nullptr)
1060 return string_printf ("%s (%s)", target_id
.c_str (), extra_info
);
1061 else if (name
!= nullptr)
1062 return string_printf ("%s \"%s\"", target_id
.c_str (), name
);
1067 /* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1068 whether REQUESTED_THREADS is a list of global or per-inferior
1072 print_thread_info_1 (struct ui_out
*uiout
, const char *requested_threads
,
1073 int global_ids
, int pid
,
1074 int show_global_ids
)
1076 int default_inf_num
= current_inferior ()->num
;
1078 update_thread_list ();
1080 /* Whether we saw any thread. */
1081 bool any_thread
= false;
1082 /* Whether the current thread is exited. */
1083 bool current_exited
= false;
1085 thread_info
*current_thread
= (inferior_ptid
!= null_ptid
1086 ? inferior_thread () : NULL
);
1089 /* For backward compatibility, we make a list for MI. A table is
1090 preferable for the CLI, though, because it shows table
1092 gdb::optional
<ui_out_emit_list
> list_emitter
;
1093 gdb::optional
<ui_out_emit_table
> table_emitter
;
1095 /* We'll be switching threads temporarily below. */
1096 scoped_restore_current_thread restore_thread
;
1098 if (uiout
->is_mi_like_p ())
1099 list_emitter
.emplace (uiout
, "threads");
1103 /* The width of the "Target Id" column. Grown below to
1104 accommodate the largest entry. */
1105 size_t target_id_col_width
= 17;
1107 for (thread_info
*tp
: all_threads ())
1109 if (!should_print_thread (requested_threads
, default_inf_num
,
1110 global_ids
, pid
, tp
))
1113 /* Switch inferiors so we're looking at the right
1115 switch_to_inferior_no_thread (tp
->inf
);
1118 = std::max (target_id_col_width
,
1119 thread_target_id_str (tp
).size ());
1126 if (requested_threads
== NULL
|| *requested_threads
== '\0')
1127 uiout
->message (_("No threads.\n"));
1129 uiout
->message (_("No threads match '%s'.\n"),
1134 table_emitter
.emplace (uiout
, show_global_ids
? 5 : 4,
1135 n_threads
, "threads");
1137 uiout
->table_header (1, ui_left
, "current", "");
1138 uiout
->table_header (4, ui_left
, "id-in-tg", "Id");
1139 if (show_global_ids
)
1140 uiout
->table_header (4, ui_left
, "id", "GId");
1141 uiout
->table_header (target_id_col_width
, ui_left
,
1142 "target-id", "Target Id");
1143 uiout
->table_header (1, ui_left
, "frame", "Frame");
1144 uiout
->table_body ();
1147 for (inferior
*inf
: all_inferiors ())
1148 for (thread_info
*tp
: inf
->threads ())
1153 if (tp
== current_thread
&& tp
->state
== THREAD_EXITED
)
1154 current_exited
= true;
1156 if (!should_print_thread (requested_threads
, default_inf_num
,
1157 global_ids
, pid
, tp
))
1160 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1162 if (!uiout
->is_mi_like_p ())
1164 if (tp
== current_thread
)
1165 uiout
->field_string ("current", "*");
1167 uiout
->field_skip ("current");
1169 uiout
->field_string ("id-in-tg", print_thread_id (tp
));
1172 if (show_global_ids
|| uiout
->is_mi_like_p ())
1173 uiout
->field_signed ("id", tp
->global_num
);
1175 /* Switch to the thread (and inferior / target). */
1176 switch_to_thread (tp
);
1178 /* For the CLI, we stuff everything into the target-id field.
1179 This is a gross hack to make the output come out looking
1180 correct. The underlying problem here is that ui-out has no
1181 way to specify that a field's space allocation should be
1182 shared by several fields. For MI, we do the right thing
1185 if (uiout
->is_mi_like_p ())
1187 uiout
->field_string ("target-id", target_pid_to_str (tp
->ptid
));
1189 const char *extra_info
= target_extra_thread_info (tp
);
1190 if (extra_info
!= nullptr)
1191 uiout
->field_string ("details", extra_info
);
1193 const char *name
= thread_name (tp
);
1195 uiout
->field_string ("name", name
);
1199 uiout
->field_string ("target-id", thread_target_id_str (tp
));
1202 if (tp
->state
== THREAD_RUNNING
)
1203 uiout
->text ("(running)\n");
1206 /* The switch above put us at the top of the stack (leaf
1208 print_stack_frame (get_selected_frame (NULL
),
1209 /* For MI output, print frame level. */
1210 uiout
->is_mi_like_p (),
1214 if (uiout
->is_mi_like_p ())
1216 const char *state
= "stopped";
1218 if (tp
->state
== THREAD_RUNNING
)
1220 uiout
->field_string ("state", state
);
1223 core
= target_core_of_thread (tp
->ptid
);
1224 if (uiout
->is_mi_like_p () && core
!= -1)
1225 uiout
->field_signed ("core", core
);
1228 /* This end scope restores the current thread and the frame
1229 selected before the "info threads" command, and it finishes the
1230 ui-out list or table. */
1233 if (pid
== -1 && requested_threads
== NULL
)
1235 if (uiout
->is_mi_like_p () && inferior_ptid
!= null_ptid
)
1236 uiout
->field_signed ("current-thread-id", current_thread
->global_num
);
1238 if (inferior_ptid
!= null_ptid
&& current_exited
)
1239 uiout
->message ("\n\
1240 The current thread <Thread ID %s> has terminated. See `help thread'.\n",
1241 print_thread_id (inferior_thread ()));
1242 else if (any_thread
&& inferior_ptid
== null_ptid
)
1243 uiout
->message ("\n\
1244 No selected thread. See `help thread'.\n");
1248 /* See gdbthread.h. */
1251 print_thread_info (struct ui_out
*uiout
, const char *requested_threads
,
1254 print_thread_info_1 (uiout
, requested_threads
, 1, pid
, 0);
1257 /* The options for the "info threads" command. */
1259 struct info_threads_opts
1262 bool show_global_ids
= false;
1265 static const gdb::option::option_def info_threads_option_defs
[] = {
1267 gdb::option::flag_option_def
<info_threads_opts
> {
1269 [] (info_threads_opts
*opts
) { return &opts
->show_global_ids
; },
1270 N_("Show global thread IDs."),
1275 /* Create an option_def_group for the "info threads" options, with
1276 IT_OPTS as context. */
1278 static inline gdb::option::option_def_group
1279 make_info_threads_options_def_group (info_threads_opts
*it_opts
)
1281 return {{info_threads_option_defs
}, it_opts
};
1284 /* Implementation of the "info threads" command.
1286 Note: this has the drawback that it _really_ switches
1287 threads, which frees the frame cache. A no-side
1288 effects info-threads command would be nicer. */
1291 info_threads_command (const char *arg
, int from_tty
)
1293 info_threads_opts it_opts
;
1295 auto grp
= make_info_threads_options_def_group (&it_opts
);
1296 gdb::option::process_options
1297 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
);
1299 print_thread_info_1 (current_uiout
, arg
, 0, -1, it_opts
.show_global_ids
);
1302 /* Completer for the "info threads" command. */
1305 info_threads_command_completer (struct cmd_list_element
*ignore
,
1306 completion_tracker
&tracker
,
1307 const char *text
, const char *word_ignored
)
1309 const auto grp
= make_info_threads_options_def_group (nullptr);
1311 if (gdb::option::complete_options
1312 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
))
1315 /* Convenience to let the user know what the option can accept. */
1318 gdb::option::complete_on_all_options (tracker
, grp
);
1319 /* Keep this "ID" in sync with what "help info threads"
1321 tracker
.add_completion (make_unique_xstrdup ("ID"));
1325 /* See gdbthread.h. */
1328 switch_to_thread_no_regs (struct thread_info
*thread
)
1330 gdb_assert (thread
!= nullptr);
1331 threads_debug_printf ("thread = %s", thread
->ptid
.to_string ().c_str ());
1333 struct inferior
*inf
= thread
->inf
;
1335 set_current_program_space (inf
->pspace
);
1336 set_current_inferior (inf
);
1338 current_thread_
= thread
;
1339 inferior_ptid
= current_thread_
->ptid
;
1342 /* See gdbthread.h. */
1345 switch_to_no_thread ()
1347 if (current_thread_
== nullptr)
1350 threads_debug_printf ("thread = NONE");
1352 current_thread_
= nullptr;
1353 inferior_ptid
= null_ptid
;
1354 reinit_frame_cache ();
1357 /* See gdbthread.h. */
1360 switch_to_thread (thread_info
*thr
)
1362 gdb_assert (thr
!= NULL
);
1364 if (is_current_thread (thr
))
1367 switch_to_thread_no_regs (thr
);
1369 reinit_frame_cache ();
1372 /* See gdbsupport/common-gdbthread.h. */
1375 switch_to_thread (process_stratum_target
*proc_target
, ptid_t ptid
)
1377 thread_info
*thr
= proc_target
->find_thread (ptid
);
1378 switch_to_thread (thr
);
1384 scoped_restore_current_thread::restore ()
1386 /* If an entry of thread_info was previously selected, it won't be
1387 deleted because we've increased its refcount. The thread represented
1388 by this thread_info entry may have already exited (due to normal exit,
1389 detach, etc), so the thread_info.state is THREAD_EXITED. */
1390 if (m_thread
!= NULL
1391 /* If the previously selected thread belonged to a process that has
1392 in the mean time exited (or killed, detached, etc.), then don't revert
1393 back to it, but instead simply drop back to no thread selected. */
1395 switch_to_thread (m_thread
.get ());
1397 switch_to_inferior_no_thread (m_inf
.get ());
1399 /* The running state of the originally selected thread may have
1400 changed, so we have to recheck it here. */
1401 if (inferior_ptid
!= null_ptid
1403 && m_thread
->state
== THREAD_STOPPED
1404 && target_has_registers ()
1405 && target_has_stack ()
1406 && target_has_memory ())
1407 restore_selected_frame (m_selected_frame_id
, m_selected_frame_level
);
1409 set_language (m_lang
);
1412 scoped_restore_current_thread::~scoped_restore_current_thread ()
1414 if (!m_dont_restore
)
1418 scoped_restore_current_thread::scoped_restore_current_thread ()
1420 m_inf
= inferior_ref::new_reference (current_inferior ());
1422 m_lang
= current_language
->la_language
;
1424 if (inferior_ptid
!= null_ptid
)
1426 m_thread
= thread_info_ref::new_reference (inferior_thread ());
1428 m_was_stopped
= m_thread
->state
== THREAD_STOPPED
;
1429 save_selected_frame (&m_selected_frame_id
, &m_selected_frame_level
);
1433 scoped_restore_current_thread::scoped_restore_current_thread
1434 (scoped_restore_current_thread
&&rhs
)
1435 : m_dont_restore (std::move (rhs
.m_dont_restore
)),
1436 m_thread (std::move (rhs
.m_thread
)),
1437 m_inf (std::move (rhs
.m_inf
)),
1438 m_selected_frame_id (std::move (rhs
.m_selected_frame_id
)),
1439 m_selected_frame_level (std::move (rhs
.m_selected_frame_level
)),
1440 m_was_stopped (std::move (rhs
.m_was_stopped
)),
1441 m_lang (std::move (rhs
.m_lang
))
1443 /* Deactivate the rhs. */
1444 rhs
.m_dont_restore
= true;
1447 /* See gdbthread.h. */
1450 show_thread_that_caused_stop (void)
1452 return highest_thread_num
> 1;
1455 /* See gdbthread.h. */
1458 show_inferior_qualified_tids (void)
1460 auto inf
= inferior_list
.begin ();
1464 return inf
!= inferior_list
.end ();
1467 /* See gdbthread.h. */
1470 print_thread_id (struct thread_info
*thr
)
1472 if (show_inferior_qualified_tids ())
1473 return print_full_thread_id (thr
);
1475 char *s
= get_print_cell ();
1477 gdb_assert (thr
!= nullptr);
1478 xsnprintf (s
, PRINT_CELL_SIZE
, "%d", thr
->per_inf_num
);
1482 /* See gdbthread.h. */
1485 print_full_thread_id (struct thread_info
*thr
)
1487 char *s
= get_print_cell ();
1489 gdb_assert (thr
!= nullptr);
1490 xsnprintf (s
, PRINT_CELL_SIZE
, "%d.%d", thr
->inf
->num
, thr
->per_inf_num
);
1494 /* Sort an array of struct thread_info pointers by thread ID (first by
1495 inferior number, and then by per-inferior thread number). Sorts in
1499 tp_array_compar_ascending (const thread_info_ref
&a
, const thread_info_ref
&b
)
1501 if (a
->inf
->num
!= b
->inf
->num
)
1502 return a
->inf
->num
< b
->inf
->num
;
1504 return (a
->per_inf_num
< b
->per_inf_num
);
1507 /* Sort an array of struct thread_info pointers by thread ID (first by
1508 inferior number, and then by per-inferior thread number). Sorts in
1509 descending order. */
1512 tp_array_compar_descending (const thread_info_ref
&a
, const thread_info_ref
&b
)
1514 if (a
->inf
->num
!= b
->inf
->num
)
1515 return a
->inf
->num
> b
->inf
->num
;
1517 return (a
->per_inf_num
> b
->per_inf_num
);
1520 /* See gdbthread.h. */
1523 thread_try_catch_cmd (thread_info
*thr
, gdb::optional
<int> ada_task
,
1524 const char *cmd
, int from_tty
,
1525 const qcs_flags
&flags
)
1527 gdb_assert (is_current_thread (thr
));
1529 /* The thread header is computed before running the command since
1530 the command can change the inferior, which is not permitted
1531 by thread_target_id_str. */
1532 std::string thr_header
;
1533 if (ada_task
.has_value ())
1534 thr_header
= string_printf (_("\nTask ID %d:\n"), *ada_task
);
1536 thr_header
= string_printf (_("\nThread %s (%s):\n"),
1537 print_thread_id (thr
),
1538 thread_target_id_str (thr
).c_str ());
1542 std::string cmd_result
;
1543 execute_command_to_string
1544 (cmd_result
, cmd
, from_tty
, gdb_stdout
->term_out ());
1545 if (!flags
.silent
|| cmd_result
.length () > 0)
1548 gdb_printf ("%s", thr_header
.c_str ());
1549 gdb_printf ("%s", cmd_result
.c_str ());
1552 catch (const gdb_exception_error
&ex
)
1557 gdb_printf ("%s", thr_header
.c_str ());
1559 gdb_printf ("%s\n", ex
.what ());
1566 /* Option definition of "thread apply"'s "-ascending" option. */
1568 static const gdb::option::flag_option_def
<> ascending_option_def
= {
1571 Call COMMAND for all threads in ascending order.\n\
1572 The default is descending order."),
1575 /* The qcs command line flags for the "thread apply" commands. Keep
1576 this in sync with the "frame apply" commands. */
1578 using qcs_flag_option_def
1579 = gdb::option::flag_option_def
<qcs_flags
>;
1581 static const gdb::option::option_def thr_qcs_flags_option_defs
[] = {
1582 qcs_flag_option_def
{
1583 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
1584 N_("Disables printing the thread information."),
1587 qcs_flag_option_def
{
1588 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
1589 N_("Print any error raised by COMMAND and continue."),
1592 qcs_flag_option_def
{
1593 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
1594 N_("Silently ignore any errors or empty output produced by COMMAND."),
1598 /* Create an option_def_group for the "thread apply all" options, with
1599 ASCENDING and FLAGS as context. */
1601 static inline std::array
<gdb::option::option_def_group
, 2>
1602 make_thread_apply_all_options_def_group (bool *ascending
,
1606 { {ascending_option_def
.def ()}, ascending
},
1607 { {thr_qcs_flags_option_defs
}, flags
},
1611 /* Create an option_def_group for the "thread apply" options, with
1612 FLAGS as context. */
1614 static inline gdb::option::option_def_group
1615 make_thread_apply_options_def_group (qcs_flags
*flags
)
1617 return {{thr_qcs_flags_option_defs
}, flags
};
1620 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1621 separated list of numbers, or ranges, or the keyword `all'. Ranges consist
1622 of two numbers separated by a hyphen. Examples:
1624 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1625 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1626 thread apply all x/i $pc Apply x/i $pc cmd to all threads. */
1629 thread_apply_all_command (const char *cmd
, int from_tty
)
1631 bool ascending
= false;
1634 auto group
= make_thread_apply_all_options_def_group (&ascending
,
1636 gdb::option::process_options
1637 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1639 validate_flags_qcs ("thread apply all", &flags
);
1641 if (cmd
== NULL
|| *cmd
== '\000')
1642 error (_("Please specify a command at the end of 'thread apply all'"));
1644 update_thread_list ();
1646 int tc
= live_threads_count ();
1649 /* Save a copy of the thread list and increment each thread's
1650 refcount while executing the command in the context of each
1651 thread, in case the command is one that wipes threads. E.g.,
1652 detach, kill, disconnect, etc., or even normally continuing
1653 over an inferior or thread exit. */
1654 std::vector
<thread_info_ref
> thr_list_cpy
;
1655 thr_list_cpy
.reserve (tc
);
1657 for (thread_info
*tp
: all_non_exited_threads ())
1658 thr_list_cpy
.push_back (thread_info_ref::new_reference (tp
));
1659 gdb_assert (thr_list_cpy
.size () == tc
);
1661 auto *sorter
= (ascending
1662 ? tp_array_compar_ascending
1663 : tp_array_compar_descending
);
1664 std::sort (thr_list_cpy
.begin (), thr_list_cpy
.end (), sorter
);
1666 scoped_restore_current_thread restore_thread
;
1668 for (thread_info_ref
&thr
: thr_list_cpy
)
1669 if (switch_to_thread_if_alive (thr
.get ()))
1670 thread_try_catch_cmd (thr
.get (), {}, cmd
, from_tty
, flags
);
1674 /* Completer for "thread apply [ID list]". */
1677 thread_apply_command_completer (cmd_list_element
*ignore
,
1678 completion_tracker
&tracker
,
1679 const char *text
, const char * /*word*/)
1681 /* Don't leave this to complete_options because there's an early
1683 tracker
.set_use_custom_word_point (true);
1685 tid_range_parser parser
;
1686 parser
.init (text
, current_inferior ()->num
);
1690 while (!parser
.finished ())
1692 int inf_num
, thr_start
, thr_end
;
1694 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1697 if (parser
.in_star_range () || parser
.in_thread_range ())
1698 parser
.skip_range ();
1701 catch (const gdb_exception_error
&ex
)
1703 /* get_tid_range throws if it parses a negative number, for
1704 example. But a seemingly negative number may be the start of
1705 an option instead. */
1708 const char *cmd
= parser
.cur_tok ();
1712 /* No thread ID list yet. */
1716 /* Check if we're past a valid thread ID list already. */
1717 if (parser
.finished ()
1718 && cmd
> text
&& !isspace (cmd
[-1]))
1721 /* We're past the thread ID list, advance word point. */
1722 tracker
.advance_custom_word_point_by (cmd
- text
);
1725 const auto group
= make_thread_apply_options_def_group (nullptr);
1726 if (gdb::option::complete_options
1727 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1730 complete_nested_command_line (tracker
, text
);
1733 /* Completer for "thread apply all". */
1736 thread_apply_all_command_completer (cmd_list_element
*ignore
,
1737 completion_tracker
&tracker
,
1738 const char *text
, const char *word
)
1740 const auto group
= make_thread_apply_all_options_def_group (nullptr,
1742 if (gdb::option::complete_options
1743 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1746 complete_nested_command_line (tracker
, text
);
1749 /* Implementation of the "thread apply" command. */
1752 thread_apply_command (const char *tidlist
, int from_tty
)
1755 const char *cmd
= NULL
;
1756 tid_range_parser parser
;
1758 if (tidlist
== NULL
|| *tidlist
== '\000')
1759 error (_("Please specify a thread ID list"));
1761 parser
.init (tidlist
, current_inferior ()->num
);
1762 while (!parser
.finished ())
1764 int inf_num
, thr_start
, thr_end
;
1766 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1770 cmd
= parser
.cur_tok ();
1772 auto group
= make_thread_apply_options_def_group (&flags
);
1773 gdb::option::process_options
1774 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1776 validate_flags_qcs ("thread apply", &flags
);
1779 error (_("Please specify a command following the thread ID list"));
1781 if (tidlist
== cmd
|| isdigit (cmd
[0]))
1782 invalid_thread_id_error (cmd
);
1784 scoped_restore_current_thread restore_thread
;
1786 parser
.init (tidlist
, current_inferior ()->num
);
1787 while (!parser
.finished ())
1789 struct thread_info
*tp
= NULL
;
1790 struct inferior
*inf
;
1791 int inf_num
, thr_num
;
1793 parser
.get_tid (&inf_num
, &thr_num
);
1794 inf
= find_inferior_id (inf_num
);
1796 tp
= find_thread_id (inf
, thr_num
);
1798 if (parser
.in_star_range ())
1802 warning (_("Unknown inferior %d"), inf_num
);
1803 parser
.skip_range ();
1807 /* No use looking for threads past the highest thread number
1808 the inferior ever had. */
1809 if (thr_num
>= inf
->highest_thread_num
)
1810 parser
.skip_range ();
1812 /* Be quiet about unknown threads numbers. */
1819 if (show_inferior_qualified_tids () || parser
.tid_is_qualified ())
1820 warning (_("Unknown thread %d.%d"), inf_num
, thr_num
);
1822 warning (_("Unknown thread %d"), thr_num
);
1826 if (!switch_to_thread_if_alive (tp
))
1828 warning (_("Thread %s has terminated."), print_thread_id (tp
));
1832 thread_try_catch_cmd (tp
, {}, cmd
, from_tty
, flags
);
1837 /* Implementation of the "taas" command. */
1840 taas_command (const char *cmd
, int from_tty
)
1842 if (cmd
== NULL
|| *cmd
== '\0')
1843 error (_("Please specify a command to apply on all threads"));
1844 std::string expanded
= std::string ("thread apply all -s ") + cmd
;
1845 execute_command (expanded
.c_str (), from_tty
);
1848 /* Implementation of the "tfaas" command. */
1851 tfaas_command (const char *cmd
, int from_tty
)
1853 if (cmd
== NULL
|| *cmd
== '\0')
1854 error (_("Please specify a command to apply on all frames of all threads"));
1855 std::string expanded
1856 = std::string ("thread apply all -s -- frame apply all -s ") + cmd
;
1857 execute_command (expanded
.c_str (), from_tty
);
1860 /* Switch to the specified thread, or print the current thread. */
1863 thread_command (const char *tidstr
, int from_tty
)
1867 if (inferior_ptid
== null_ptid
)
1868 error (_("No thread selected"));
1870 if (target_has_stack ())
1872 struct thread_info
*tp
= inferior_thread ();
1874 if (tp
->state
== THREAD_EXITED
)
1875 gdb_printf (_("[Current thread is %s (%s) (exited)]\n"),
1876 print_thread_id (tp
),
1877 target_pid_to_str (inferior_ptid
).c_str ());
1879 gdb_printf (_("[Current thread is %s (%s)]\n"),
1880 print_thread_id (tp
),
1881 target_pid_to_str (inferior_ptid
).c_str ());
1884 error (_("No stack."));
1888 ptid_t previous_ptid
= inferior_ptid
;
1890 thread_select (tidstr
, parse_thread_id (tidstr
, NULL
));
1892 /* Print if the thread has not changed, otherwise an event will
1894 if (inferior_ptid
== previous_ptid
)
1896 print_selected_thread_frame (current_uiout
,
1897 USER_SELECTED_THREAD
1898 | USER_SELECTED_FRAME
);
1901 notify_user_selected_context_changed
1902 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
1906 /* Implementation of `thread name'. */
1909 thread_name_command (const char *arg
, int from_tty
)
1911 struct thread_info
*info
;
1913 if (inferior_ptid
== null_ptid
)
1914 error (_("No thread selected"));
1916 arg
= skip_spaces (arg
);
1918 info
= inferior_thread ();
1919 info
->set_name (arg
!= nullptr ? make_unique_xstrdup (arg
) : nullptr);
1922 /* Find thread ids with a name, target pid, or extra info matching ARG. */
1925 thread_find_command (const char *arg
, int from_tty
)
1928 unsigned long match
= 0;
1930 if (arg
== NULL
|| *arg
== '\0')
1931 error (_("Command requires an argument."));
1933 tmp
= re_comp (arg
);
1935 error (_("Invalid regexp (%s): %s"), tmp
, arg
);
1937 /* We're going to be switching threads. */
1938 scoped_restore_current_thread restore_thread
;
1940 update_thread_list ();
1942 for (thread_info
*tp
: all_threads ())
1944 switch_to_inferior_no_thread (tp
->inf
);
1946 if (tp
->name () != nullptr && re_exec (tp
->name ()))
1948 gdb_printf (_("Thread %s has name '%s'\n"),
1949 print_thread_id (tp
), tp
->name ());
1953 tmp
= target_thread_name (tp
);
1954 if (tmp
!= NULL
&& re_exec (tmp
))
1956 gdb_printf (_("Thread %s has target name '%s'\n"),
1957 print_thread_id (tp
), tmp
);
1961 std::string name
= target_pid_to_str (tp
->ptid
);
1962 if (!name
.empty () && re_exec (name
.c_str ()))
1964 gdb_printf (_("Thread %s has target id '%s'\n"),
1965 print_thread_id (tp
), name
.c_str ());
1969 tmp
= target_extra_thread_info (tp
);
1970 if (tmp
!= NULL
&& re_exec (tmp
))
1972 gdb_printf (_("Thread %s has extra info '%s'\n"),
1973 print_thread_id (tp
), tmp
);
1978 gdb_printf (_("No threads match '%s'\n"), arg
);
1981 /* Print notices when new threads are attached and detached. */
1982 bool print_thread_events
= true;
1984 show_print_thread_events (struct ui_file
*file
, int from_tty
,
1985 struct cmd_list_element
*c
, const char *value
)
1988 _("Printing of thread events is %s.\n"),
1992 /* See gdbthread.h. */
1995 thread_select (const char *tidstr
, thread_info
*tp
)
1997 if (!switch_to_thread_if_alive (tp
))
1998 error (_("Thread ID %s has terminated."), tidstr
);
2000 annotate_thread_changed ();
2002 /* Since the current thread may have changed, see if there is any
2003 exited thread we can now delete. */
2004 delete_exited_threads ();
2007 /* Print thread and frame switch command response. */
2010 print_selected_thread_frame (struct ui_out
*uiout
,
2011 user_selected_what selection
)
2013 struct thread_info
*tp
= inferior_thread ();
2015 if (selection
& USER_SELECTED_THREAD
)
2017 if (uiout
->is_mi_like_p ())
2019 uiout
->field_signed ("new-thread-id",
2020 inferior_thread ()->global_num
);
2024 uiout
->text ("[Switching to thread ");
2025 uiout
->field_string ("new-thread-id", print_thread_id (tp
));
2027 uiout
->text (target_pid_to_str (inferior_ptid
));
2032 if (tp
->state
== THREAD_RUNNING
)
2034 if (selection
& USER_SELECTED_THREAD
)
2035 uiout
->text ("(running)\n");
2037 else if (selection
& USER_SELECTED_FRAME
)
2039 if (selection
& USER_SELECTED_THREAD
)
2042 if (has_stack_frames ())
2043 print_stack_frame_to_uiout (uiout
, get_selected_frame (NULL
),
2048 /* Update the 'threads_executing' global based on the threads we know
2049 about right now. This is used by infrun to tell whether we should
2050 pull events out of the current target. */
2053 update_threads_executing (void)
2055 process_stratum_target
*targ
= current_inferior ()->process_target ();
2060 targ
->threads_executing
= false;
2062 for (inferior
*inf
: all_non_exited_inferiors (targ
))
2064 if (!inf
->has_execution ())
2067 /* If the process has no threads, then it must be we have a
2068 process-exit event pending. */
2069 if (inf
->thread_list
.empty ())
2071 targ
->threads_executing
= true;
2075 for (thread_info
*tp
: inf
->non_exited_threads ())
2077 if (tp
->executing ())
2079 targ
->threads_executing
= true;
2087 update_thread_list (void)
2089 target_update_thread_list ();
2090 update_threads_executing ();
2093 /* See gdbthread.h. */
2096 thread_name (thread_info
*thread
)
2098 /* Use the manually set name if there is one. */
2099 const char *name
= thread
->name ();
2100 if (name
!= nullptr)
2103 /* Otherwise, ask the target. Ensure we query the right target stack. */
2104 scoped_restore_current_thread restore_thread
;
2105 if (thread
->inf
!= current_inferior ())
2106 switch_to_inferior_no_thread (thread
->inf
);
2108 return target_thread_name (thread
);
2111 /* See gdbthread.h. */
2114 thread_state_string (enum thread_state state
)
2118 case THREAD_STOPPED
:
2121 case THREAD_RUNNING
:
2128 gdb_assert_not_reached ("unknown thread state");
2131 /* Return a new value for the selected thread's id. Return a value of
2132 0 if no thread is selected. If GLOBAL is true, return the thread's
2133 global number. Otherwise return the per-inferior number. */
2135 static struct value
*
2136 thread_num_make_value_helper (struct gdbarch
*gdbarch
, int global
)
2140 if (inferior_ptid
== null_ptid
)
2144 thread_info
*tp
= inferior_thread ();
2146 int_val
= tp
->global_num
;
2148 int_val
= tp
->per_inf_num
;
2151 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, int_val
);
2154 /* Return a new value for the selected thread's per-inferior thread
2155 number. Return a value of 0 if no thread is selected, or no
2158 static struct value
*
2159 thread_id_per_inf_num_make_value (struct gdbarch
*gdbarch
,
2160 struct internalvar
*var
,
2163 return thread_num_make_value_helper (gdbarch
, 0);
2166 /* Return a new value for the selected thread's global id. Return a
2167 value of 0 if no thread is selected, or no threads exist. */
2169 static struct value
*
2170 global_thread_id_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
2173 return thread_num_make_value_helper (gdbarch
, 1);
2176 /* Return a new value for the number of non-exited threads in the current
2177 inferior. If there are no threads in the current inferior return a
2180 static struct value
*
2181 inferior_thread_count_make_value (struct gdbarch
*gdbarch
,
2182 struct internalvar
*var
, void *ignore
)
2186 update_thread_list ();
2188 if (inferior_ptid
!= null_ptid
)
2189 int_val
= current_inferior ()->non_exited_threads ().size ();
2191 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, int_val
);
2194 /* Commands with a prefix of `thread'. */
2195 struct cmd_list_element
*thread_cmd_list
= NULL
;
2197 /* Implementation of `thread' variable. */
2199 static const struct internalvar_funcs thread_funcs
=
2201 thread_id_per_inf_num_make_value
,
2205 /* Implementation of `gthread' variable. */
2207 static const struct internalvar_funcs gthread_funcs
=
2209 global_thread_id_make_value
,
2213 /* Implementation of `_inferior_thread_count` convenience variable. */
2215 static const struct internalvar_funcs inferior_thread_count_funcs
=
2217 inferior_thread_count_make_value
,
2221 void _initialize_thread ();
2223 _initialize_thread ()
2225 static struct cmd_list_element
*thread_apply_list
= NULL
;
2226 cmd_list_element
*c
;
2228 const auto info_threads_opts
= make_info_threads_options_def_group (nullptr);
2230 /* Note: keep this "ID" in sync with what "info threads [TAB]"
2232 static std::string info_threads_help
2233 = gdb::option::build_help (_("\
2234 Display currently known threads.\n\
2235 Usage: info threads [OPTION]... [ID]...\n\
2236 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2237 Otherwise, all threads are displayed.\n\
2243 c
= add_info ("threads", info_threads_command
, info_threads_help
.c_str ());
2244 set_cmd_completer_handle_brkchars (c
, info_threads_command_completer
);
2246 cmd_list_element
*thread_cmd
2247 = add_prefix_cmd ("thread", class_run
, thread_command
, _("\
2248 Use this command to switch between threads.\n\
2249 The new thread ID must be currently known."),
2250 &thread_cmd_list
, 1, &cmdlist
);
2252 add_com_alias ("t", thread_cmd
, class_run
, 1);
2254 #define THREAD_APPLY_OPTION_HELP "\
2255 Prints per-inferior thread number and target system's thread id\n\
2256 followed by COMMAND output.\n\
2258 By default, an error raised during the execution of COMMAND\n\
2259 aborts \"thread apply\".\n\
2264 const auto thread_apply_opts
= make_thread_apply_options_def_group (nullptr);
2266 static std::string thread_apply_help
= gdb::option::build_help (_("\
2267 Apply a command to a list of threads.\n\
2268 Usage: thread apply ID... [OPTION]... COMMAND\n\
2269 ID is a space-separated list of IDs of threads to apply COMMAND on.\n"
2270 THREAD_APPLY_OPTION_HELP
),
2273 c
= add_prefix_cmd ("apply", class_run
, thread_apply_command
,
2274 thread_apply_help
.c_str (),
2275 &thread_apply_list
, 1,
2277 set_cmd_completer_handle_brkchars (c
, thread_apply_command_completer
);
2279 const auto thread_apply_all_opts
2280 = make_thread_apply_all_options_def_group (nullptr, nullptr);
2282 static std::string thread_apply_all_help
= gdb::option::build_help (_("\
2283 Apply a command to all threads.\n\
2285 Usage: thread apply all [OPTION]... COMMAND\n"
2286 THREAD_APPLY_OPTION_HELP
),
2287 thread_apply_all_opts
);
2289 c
= add_cmd ("all", class_run
, thread_apply_all_command
,
2290 thread_apply_all_help
.c_str (),
2291 &thread_apply_list
);
2292 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2294 c
= add_com ("taas", class_run
, taas_command
, _("\
2295 Apply a command to all threads (ignoring errors and empty output).\n\
2296 Usage: taas [OPTION]... COMMAND\n\
2297 shortcut for 'thread apply all -s [OPTION]... COMMAND'\n\
2298 See \"help thread apply all\" for available options."));
2299 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2301 c
= add_com ("tfaas", class_run
, tfaas_command
, _("\
2302 Apply a command to all frames of all threads (ignoring errors and empty output).\n\
2303 Usage: tfaas [OPTION]... COMMAND\n\
2304 shortcut for 'thread apply all -s -- frame apply all -s [OPTION]... COMMAND'\n\
2305 See \"help frame apply all\" for available options."));
2306 set_cmd_completer_handle_brkchars (c
, frame_apply_all_cmd_completer
);
2308 add_cmd ("name", class_run
, thread_name_command
,
2309 _("Set the current thread's name.\n\
2310 Usage: thread name [NAME]\n\
2311 If NAME is not given, then any existing name is removed."), &thread_cmd_list
);
2313 add_cmd ("find", class_run
, thread_find_command
, _("\
2314 Find threads that match a regular expression.\n\
2315 Usage: thread find REGEXP\n\
2316 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2319 add_setshow_boolean_cmd ("thread-events", no_class
,
2320 &print_thread_events
, _("\
2321 Set printing of thread events (such as thread start and exit)."), _("\
2322 Show printing of thread events (such as thread start and exit)."), NULL
,
2324 show_print_thread_events
,
2325 &setprintlist
, &showprintlist
);
2327 add_setshow_boolean_cmd ("threads", class_maintenance
, &debug_threads
, _("\
2328 Set thread debugging."), _("\
2329 Show thread debugging."), _("\
2330 When on messages about thread creation and deletion are printed."),
2333 &setdebuglist
, &showdebuglist
);
2335 create_internalvar_type_lazy ("_thread", &thread_funcs
, NULL
);
2336 create_internalvar_type_lazy ("_gthread", >hread_funcs
, NULL
);
2337 create_internalvar_type_lazy ("_inferior_thread_count",
2338 &inferior_thread_count_funcs
, NULL
);