1 /* Multi-process/thread control for GDB, the GNU debugger.
3 Copyright (C) 1986-2021 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/>. */
26 #include "gdbsupport/environ.h"
29 #include "gdbthread.h"
36 #include <sys/types.h>
39 #include "observable.h"
41 #include "cli/cli-decode.h"
42 #include "cli/cli-option.h"
43 #include "gdb_regex.h"
44 #include "cli/cli-utils.h"
45 #include "thread-fsm.h"
46 #include "tid-parse.h"
48 #include "gdbsupport/gdb_optional.h"
49 #include "inline-frame.h"
52 /* Definition of struct thread_info exported to gdbthread.h. */
54 /* Prototypes for local functions. */
56 static int highest_thread_num
;
58 /* The current/selected thread. */
59 static thread_info
*current_thread_
;
61 /* Returns true if THR is the current thread. */
64 is_current_thread (const thread_info
*thr
)
66 return thr
== current_thread_
;
70 inferior_thread (void)
72 gdb_assert (current_thread_
!= nullptr);
73 return current_thread_
;
76 /* Delete the breakpoint pointed at by BP_P, if there's one. */
79 delete_thread_breakpoint (struct breakpoint
**bp_p
)
83 delete_breakpoint (*bp_p
);
89 delete_step_resume_breakpoint (struct thread_info
*tp
)
92 delete_thread_breakpoint (&tp
->control
.step_resume_breakpoint
);
96 delete_exception_resume_breakpoint (struct thread_info
*tp
)
99 delete_thread_breakpoint (&tp
->control
.exception_resume_breakpoint
);
102 /* See gdbthread.h. */
105 delete_single_step_breakpoints (struct thread_info
*tp
)
108 delete_thread_breakpoint (&tp
->control
.single_step_breakpoints
);
111 /* Delete the breakpoint pointed at by BP_P at the next stop, if
115 delete_at_next_stop (struct breakpoint
**bp
)
119 (*bp
)->disposition
= disp_del_at_next_stop
;
124 /* See gdbthread.h. */
127 thread_has_single_step_breakpoints_set (struct thread_info
*tp
)
129 return tp
->control
.single_step_breakpoints
!= NULL
;
132 /* See gdbthread.h. */
135 thread_has_single_step_breakpoint_here (struct thread_info
*tp
,
136 const address_space
*aspace
,
139 struct breakpoint
*ss_bps
= tp
->control
.single_step_breakpoints
;
141 return (ss_bps
!= NULL
142 && breakpoint_has_location_inserted_here (ss_bps
, aspace
, addr
));
145 /* See gdbthread.h. */
148 thread_cancel_execution_command (struct thread_info
*thr
)
150 if (thr
->thread_fsm
!= NULL
)
152 thr
->thread_fsm
->clean_up (thr
);
153 delete thr
->thread_fsm
;
154 thr
->thread_fsm
= NULL
;
159 clear_thread_inferior_resources (struct thread_info
*tp
)
161 /* NOTE: this will take care of any left-over step_resume breakpoints,
162 but not any user-specified thread-specific breakpoints. We can not
163 delete the breakpoint straight-off, because the inferior might not
164 be stopped at the moment. */
165 delete_at_next_stop (&tp
->control
.step_resume_breakpoint
);
166 delete_at_next_stop (&tp
->control
.exception_resume_breakpoint
);
167 delete_at_next_stop (&tp
->control
.single_step_breakpoints
);
169 delete_longjmp_breakpoint_at_next_stop (tp
->global_num
);
171 bpstat_clear (&tp
->control
.stop_bpstat
);
173 btrace_teardown (tp
);
175 thread_cancel_execution_command (tp
);
177 clear_inline_frame_state (tp
);
180 /* Set the TP's state as exited. */
183 set_thread_exited (thread_info
*tp
, bool silent
)
185 /* Dead threads don't need to step-over. Remove from chain. */
186 if (tp
->step_over_next
!= NULL
)
187 global_thread_step_over_chain_remove (tp
);
189 if (tp
->state
!= THREAD_EXITED
)
191 gdb::observers::thread_exit
.notify (tp
, silent
);
193 /* Tag it as exited. */
194 tp
->state
= THREAD_EXITED
;
196 /* Clear breakpoints, etc. associated with this thread. */
197 clear_thread_inferior_resources (tp
);
202 init_thread_list (void)
204 highest_thread_num
= 0;
206 for (thread_info
*tp
: all_threads_safe ())
208 inferior
*inf
= tp
->inf
;
210 if (tp
->deletable ())
213 set_thread_exited (tp
, 1);
215 inf
->thread_list
= NULL
;
219 /* Allocate a new thread of inferior INF with target id PTID and add
220 it to the thread list. */
222 static struct thread_info
*
223 new_thread (struct inferior
*inf
, ptid_t ptid
)
225 thread_info
*tp
= new thread_info (inf
, ptid
);
227 if (inf
->thread_list
== NULL
)
228 inf
->thread_list
= tp
;
231 struct thread_info
*last
;
233 for (last
= inf
->thread_list
; last
->next
!= NULL
; last
= last
->next
)
234 gdb_assert (ptid
!= last
->ptid
235 || last
->state
== THREAD_EXITED
);
237 gdb_assert (ptid
!= last
->ptid
238 || last
->state
== THREAD_EXITED
);
247 add_thread_silent (process_stratum_target
*targ
, ptid_t ptid
)
249 inferior
*inf
= find_inferior_ptid (targ
, ptid
);
251 /* We may have an old thread with the same id in the thread list.
252 If we do, it must be dead, otherwise we wouldn't be adding a new
253 thread with the same id. The OS is reusing this id --- delete
254 the old thread, and create a new one. */
255 thread_info
*tp
= find_thread_ptid (inf
, ptid
);
259 tp
= new_thread (inf
, ptid
);
260 gdb::observers::new_thread
.notify (tp
);
266 add_thread_with_info (process_stratum_target
*targ
, ptid_t ptid
,
267 private_thread_info
*priv
)
269 thread_info
*result
= add_thread_silent (targ
, ptid
);
271 result
->priv
.reset (priv
);
273 if (print_thread_events
)
274 printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid
).c_str ());
276 annotate_new_thread ();
281 add_thread (process_stratum_target
*targ
, ptid_t ptid
)
283 return add_thread_with_info (targ
, ptid
, NULL
);
286 private_thread_info::~private_thread_info () = default;
288 thread_info::thread_info (struct inferior
*inf_
, ptid_t ptid_
)
289 : ptid (ptid_
), inf (inf_
)
291 gdb_assert (inf_
!= NULL
);
293 this->global_num
= ++highest_thread_num
;
294 this->per_inf_num
= ++inf_
->highest_thread_num
;
296 /* Nothing to follow yet. */
297 memset (&this->pending_follow
, 0, sizeof (this->pending_follow
));
298 this->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
299 this->suspend
.waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
302 thread_info::~thread_info ()
307 /* See gdbthread.h. */
310 thread_info::deletable () const
312 /* If this is the current thread, or there's code out there that
313 relies on it existing (refcount > 0) we can't delete yet. */
314 return refcount () == 0 && !is_current_thread (this);
317 /* Add TP to the end of the step-over chain LIST_P. */
320 step_over_chain_enqueue (struct thread_info
**list_p
, struct thread_info
*tp
)
322 gdb_assert (tp
->step_over_next
== NULL
);
323 gdb_assert (tp
->step_over_prev
== NULL
);
328 tp
->step_over_prev
= tp
->step_over_next
= tp
;
332 struct thread_info
*head
= *list_p
;
333 struct thread_info
*tail
= head
->step_over_prev
;
335 tp
->step_over_prev
= tail
;
336 tp
->step_over_next
= head
;
337 head
->step_over_prev
= tp
;
338 tail
->step_over_next
= tp
;
342 /* See gdbthread.h. */
345 thread_step_over_chain_remove (thread_info
**list_p
, thread_info
*tp
)
347 gdb_assert (tp
->step_over_next
!= NULL
);
348 gdb_assert (tp
->step_over_prev
!= NULL
);
352 if (tp
== tp
->step_over_next
)
355 *list_p
= tp
->step_over_next
;
358 tp
->step_over_prev
->step_over_next
= tp
->step_over_next
;
359 tp
->step_over_next
->step_over_prev
= tp
->step_over_prev
;
360 tp
->step_over_prev
= tp
->step_over_next
= NULL
;
363 /* See gdbthread.h. */
366 thread_step_over_chain_next (thread_info
*chain_head
, thread_info
*tp
)
368 thread_info
*next
= tp
->step_over_next
;
370 return next
== chain_head
? NULL
: next
;
373 /* See gdbthread.h. */
376 global_thread_step_over_chain_next (struct thread_info
*tp
)
378 return thread_step_over_chain_next (global_thread_step_over_chain_head
, tp
);
381 /* See gdbthread.h. */
384 thread_is_in_step_over_chain (struct thread_info
*tp
)
386 return (tp
->step_over_next
!= NULL
);
389 /* See gdbthread.h. */
392 thread_step_over_chain_length (thread_info
*tp
)
397 gdb_assert (thread_is_in_step_over_chain (tp
));
401 for (thread_info
*iter
= tp
->step_over_next
;
403 iter
= iter
->step_over_next
)
409 /* See gdbthread.h. */
412 global_thread_step_over_chain_enqueue (struct thread_info
*tp
)
414 infrun_debug_printf ("enqueueing thread %s in global step over chain",
415 target_pid_to_str (tp
->ptid
).c_str ());
417 step_over_chain_enqueue (&global_thread_step_over_chain_head
, tp
);
420 /* See gdbthread.h. */
423 global_thread_step_over_chain_enqueue_chain (thread_info
*chain_head
)
425 gdb_assert (chain_head
->step_over_next
!= nullptr);
426 gdb_assert (chain_head
->step_over_prev
!= nullptr);
428 if (global_thread_step_over_chain_head
== nullptr)
429 global_thread_step_over_chain_head
= chain_head
;
432 thread_info
*global_last
= global_thread_step_over_chain_head
->step_over_prev
;
433 thread_info
*chain_last
= chain_head
->step_over_prev
;
435 chain_last
->step_over_next
= global_thread_step_over_chain_head
;
436 global_last
->step_over_next
= chain_head
;
437 global_thread_step_over_chain_head
->step_over_prev
= chain_last
;
438 chain_head
->step_over_prev
= global_last
;
442 /* See gdbthread.h. */
445 global_thread_step_over_chain_remove (struct thread_info
*tp
)
447 infrun_debug_printf ("removing thread %s from global step over chain",
448 target_pid_to_str (tp
->ptid
).c_str ());
450 thread_step_over_chain_remove (&global_thread_step_over_chain_head
, tp
);
453 /* Delete the thread referenced by THR. If SILENT, don't notify
454 the observer of this exit.
456 THR must not be NULL or a failed assertion will be raised. */
459 delete_thread_1 (thread_info
*thr
, bool silent
)
461 gdb_assert (thr
!= nullptr);
463 struct thread_info
*tp
, *tpprev
= NULL
;
465 for (tp
= thr
->inf
->thread_list
; tp
; tpprev
= tp
, tp
= tp
->next
)
472 set_thread_exited (tp
, silent
);
474 if (!tp
->deletable ())
476 /* Will be really deleted some other time. */
481 tpprev
->next
= tp
->next
;
483 tp
->inf
->thread_list
= tp
->next
;
488 /* See gdbthread.h. */
491 delete_thread (thread_info
*thread
)
493 delete_thread_1 (thread
, false /* not silent */);
497 delete_thread_silent (thread_info
*thread
)
499 delete_thread_1 (thread
, true /* silent */);
503 find_thread_global_id (int global_id
)
505 for (thread_info
*tp
: all_threads ())
506 if (tp
->global_num
== global_id
)
512 static struct thread_info
*
513 find_thread_id (struct inferior
*inf
, int thr_num
)
515 for (thread_info
*tp
: inf
->threads ())
516 if (tp
->per_inf_num
== thr_num
)
522 /* See gdbthread.h. */
525 find_thread_ptid (process_stratum_target
*targ
, ptid_t ptid
)
527 inferior
*inf
= find_inferior_ptid (targ
, ptid
);
530 return find_thread_ptid (inf
, ptid
);
533 /* See gdbthread.h. */
536 find_thread_ptid (inferior
*inf
, ptid_t ptid
)
538 for (thread_info
*tp
: inf
->non_exited_threads ())
539 if (tp
->ptid
== ptid
)
545 /* See gdbthread.h. */
548 find_thread_by_handle (gdb::array_view
<const gdb_byte
> handle
,
549 struct inferior
*inf
)
551 return target_thread_handle_to_thread_info (handle
.data (),
557 * Thread iterator function.
559 * Calls a callback function once for each thread, so long as
560 * the callback function returns false. If the callback function
561 * returns true, the iteration will end and the current thread
562 * will be returned. This can be useful for implementing a
563 * search for a thread with arbitrary attributes, or for applying
564 * some operation to every thread.
566 * FIXME: some of the existing functionality, such as
567 * "Thread apply all", might be rewritten using this functionality.
571 iterate_over_threads (int (*callback
) (struct thread_info
*, void *),
574 for (thread_info
*tp
: all_threads_safe ())
575 if ((*callback
) (tp
, data
))
581 /* See gdbthread.h. */
586 for (thread_info
*tp ATTRIBUTE_UNUSED
: all_threads ())
592 thread_count (process_stratum_target
*proc_target
)
594 auto rng
= all_threads (proc_target
);
595 return std::distance (rng
.begin (), rng
.end ());
598 /* Return the number of non-exited threads in the thread list. */
601 live_threads_count (void)
603 auto rng
= all_non_exited_threads ();
604 return std::distance (rng
.begin (), rng
.end ());
608 valid_global_thread_id (int global_id
)
610 for (thread_info
*tp
: all_threads ())
611 if (tp
->global_num
== global_id
)
618 in_thread_list (process_stratum_target
*targ
, ptid_t ptid
)
620 return find_thread_ptid (targ
, ptid
) != nullptr;
623 /* Finds the first thread of the inferior. */
626 first_thread_of_inferior (inferior
*inf
)
628 return inf
->thread_list
;
632 any_thread_of_inferior (inferior
*inf
)
634 gdb_assert (inf
->pid
!= 0);
636 /* Prefer the current thread. */
637 if (inf
== current_inferior ())
638 return inferior_thread ();
640 for (thread_info
*tp
: inf
->non_exited_threads ())
647 any_live_thread_of_inferior (inferior
*inf
)
649 struct thread_info
*curr_tp
= NULL
;
650 struct thread_info
*tp_executing
= NULL
;
652 gdb_assert (inf
!= NULL
&& inf
->pid
!= 0);
654 /* Prefer the current thread if it's not executing. */
655 if (inferior_ptid
!= null_ptid
&& current_inferior () == inf
)
657 /* If the current thread is dead, forget it. If it's not
658 executing, use it. Otherwise, still choose it (below), but
659 only if no other non-executing thread is found. */
660 curr_tp
= inferior_thread ();
661 if (curr_tp
->state
== THREAD_EXITED
)
663 else if (!curr_tp
->executing
)
667 for (thread_info
*tp
: inf
->non_exited_threads ())
675 /* If both the current thread and all live threads are executing,
676 prefer the current thread. */
680 /* Otherwise, just return an executing thread, if any. */
684 /* Return true if TP is an active thread. */
686 thread_alive (thread_info
*tp
)
688 if (tp
->state
== THREAD_EXITED
)
691 /* Ensure we're looking at the right target stack. */
692 gdb_assert (tp
->inf
== current_inferior ());
694 return target_thread_alive (tp
->ptid
);
697 /* Switch to thread TP if it is alive. Returns true if successfully
698 switched, false otherwise. */
701 switch_to_thread_if_alive (thread_info
*thr
)
703 scoped_restore_current_thread restore_thread
;
705 /* Switch inferior first, so that we're looking at the right target
707 switch_to_inferior_no_thread (thr
->inf
);
709 if (thread_alive (thr
))
711 switch_to_thread (thr
);
712 restore_thread
.dont_restore ();
719 /* See gdbthreads.h. */
724 scoped_restore_current_thread restore_thread
;
726 for (thread_info
*tp
: all_threads_safe ())
728 switch_to_inferior_no_thread (tp
->inf
);
730 if (!thread_alive (tp
))
735 /* See gdbthreads.h. */
738 delete_exited_threads (void)
740 for (thread_info
*tp
: all_threads_safe ())
741 if (tp
->state
== THREAD_EXITED
)
745 /* Return true value if stack temporaries are enabled for the thread
749 thread_stack_temporaries_enabled_p (thread_info
*tp
)
754 return tp
->stack_temporaries_enabled
;
757 /* Push V on to the stack temporaries of the thread with id PTID. */
760 push_thread_stack_temporary (thread_info
*tp
, struct value
*v
)
762 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
763 tp
->stack_temporaries
.push_back (v
);
766 /* Return true if VAL is among the stack temporaries of the thread
767 TP. Return false otherwise. */
770 value_in_thread_stack_temporaries (struct value
*val
, thread_info
*tp
)
772 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
773 for (value
*v
: tp
->stack_temporaries
)
780 /* Return the last of the stack temporaries for thread with id PTID.
781 Return NULL if there are no stack temporaries for the thread. */
784 get_last_thread_stack_temporary (thread_info
*tp
)
786 struct value
*lastval
= NULL
;
788 gdb_assert (tp
!= NULL
);
789 if (!tp
->stack_temporaries
.empty ())
790 lastval
= tp
->stack_temporaries
.back ();
796 thread_change_ptid (process_stratum_target
*targ
,
797 ptid_t old_ptid
, ptid_t new_ptid
)
799 struct inferior
*inf
;
800 struct thread_info
*tp
;
802 /* It can happen that what we knew as the target inferior id
803 changes. E.g, target remote may only discover the remote process
804 pid after adding the inferior to GDB's list. */
805 inf
= find_inferior_ptid (targ
, old_ptid
);
806 inf
->pid
= new_ptid
.pid ();
808 tp
= find_thread_ptid (inf
, old_ptid
);
811 gdb::observers::thread_ptid_changed
.notify (targ
, old_ptid
, new_ptid
);
814 /* See gdbthread.h. */
817 set_resumed (process_stratum_target
*targ
, ptid_t ptid
, bool resumed
)
819 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
820 tp
->resumed
= resumed
;
823 /* Helper for set_running, that marks one thread either running or
827 set_running_thread (struct thread_info
*tp
, bool running
)
829 bool started
= false;
831 if (running
&& tp
->state
== THREAD_STOPPED
)
833 tp
->state
= running
? THREAD_RUNNING
: THREAD_STOPPED
;
837 /* If the thread is now marked stopped, remove it from
838 the step-over queue, so that we don't try to resume
839 it until the user wants it to. */
840 if (tp
->step_over_next
!= NULL
)
841 global_thread_step_over_chain_remove (tp
);
847 /* See gdbthread.h. */
850 thread_info::set_running (bool running
)
852 if (set_running_thread (this, running
))
853 gdb::observers::target_resumed
.notify (this->ptid
);
857 set_running (process_stratum_target
*targ
, ptid_t ptid
, bool running
)
859 /* We try not to notify the observer if no thread has actually
860 changed the running state -- merely to reduce the number of
861 messages to the MI frontend. A frontend is supposed to handle
862 multiple *running notifications just fine. */
863 bool any_started
= false;
865 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
866 if (set_running_thread (tp
, running
))
870 gdb::observers::target_resumed
.notify (ptid
);
874 /* Helper for set_executing. Set's the thread's 'executing' field
875 from EXECUTING, and if EXECUTING is true also clears the thread's
879 set_executing_thread (thread_info
*thr
, bool executing
)
881 thr
->executing
= executing
;
883 thr
->suspend
.stop_pc
= ~(CORE_ADDR
) 0;
887 set_executing (process_stratum_target
*targ
, ptid_t ptid
, bool executing
)
889 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
890 set_executing_thread (tp
, executing
);
892 /* It only takes one running thread to spawn more threads. */
894 targ
->threads_executing
= true;
895 /* Only clear the flag if the caller is telling us everything is
897 else if (minus_one_ptid
== ptid
)
898 targ
->threads_executing
= false;
901 /* See gdbthread.h. */
904 threads_are_executing (process_stratum_target
*target
)
906 return target
->threads_executing
;
910 set_stop_requested (process_stratum_target
*targ
, ptid_t ptid
, bool stop
)
912 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
913 tp
->stop_requested
= stop
;
915 /* Call the stop requested observer so other components of GDB can
916 react to this request. */
918 gdb::observers::thread_stop_requested
.notify (ptid
);
922 finish_thread_state (process_stratum_target
*targ
, ptid_t ptid
)
924 bool any_started
= false;
926 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
927 if (set_running_thread (tp
, tp
->executing
))
931 gdb::observers::target_resumed
.notify (ptid
);
934 /* See gdbthread.h. */
937 validate_registers_access (void)
939 /* No selected thread, no registers. */
940 if (inferior_ptid
== null_ptid
)
941 error (_("No thread selected."));
943 thread_info
*tp
= inferior_thread ();
945 /* Don't try to read from a dead thread. */
946 if (tp
->state
== THREAD_EXITED
)
947 error (_("The current thread has terminated"));
949 /* ... or from a spinning thread. FIXME: This isn't actually fully
950 correct. It'll allow an user-requested access (e.g., "print $pc"
951 at the prompt) when a thread is not executing for some internal
952 reason, but is marked running from the user's perspective. E.g.,
953 the thread is waiting for its turn in the step-over queue. */
955 error (_("Selected thread is running."));
958 /* See gdbthread.h. */
961 can_access_registers_thread (thread_info
*thread
)
963 /* No thread, no registers. */
967 /* Don't try to read from a dead thread. */
968 if (thread
->state
== THREAD_EXITED
)
971 /* ... or from a spinning thread. FIXME: see validate_registers_access. */
972 if (thread
->executing
)
979 pc_in_thread_step_range (CORE_ADDR pc
, struct thread_info
*thread
)
981 return (pc
>= thread
->control
.step_range_start
982 && pc
< thread
->control
.step_range_end
);
985 /* Helper for print_thread_info. Returns true if THR should be
986 printed. If REQUESTED_THREADS, a list of GDB ids/ranges, is not
987 NULL, only print THR if its ID is included in the list. GLOBAL_IDS
988 is true if REQUESTED_THREADS is list of global IDs, false if a list
989 of per-inferior thread ids. If PID is not -1, only print THR if it
990 is a thread from the process PID. Otherwise, threads from all
991 attached PIDs are printed. If both REQUESTED_THREADS is not NULL
992 and PID is not -1, then the thread is printed if it belongs to the
993 specified process. Otherwise, an error is raised. */
996 should_print_thread (const char *requested_threads
, int default_inf_num
,
997 int global_ids
, int pid
, struct thread_info
*thr
)
999 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1004 in_list
= number_is_in_list (requested_threads
, thr
->global_num
);
1006 in_list
= tid_is_in_list (requested_threads
, default_inf_num
,
1007 thr
->inf
->num
, thr
->per_inf_num
);
1012 if (pid
!= -1 && thr
->ptid
.pid () != pid
)
1014 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1015 error (_("Requested thread not found in requested process"));
1019 if (thr
->state
== THREAD_EXITED
)
1025 /* Return the string to display in "info threads"'s "Target Id"
1029 thread_target_id_str (thread_info
*tp
)
1031 std::string target_id
= target_pid_to_str (tp
->ptid
);
1032 const char *extra_info
= target_extra_thread_info (tp
);
1033 const char *name
= tp
->name
!= nullptr ? tp
->name
: target_thread_name (tp
);
1035 if (extra_info
!= nullptr && name
!= nullptr)
1036 return string_printf ("%s \"%s\" (%s)", target_id
.c_str (), name
,
1038 else if (extra_info
!= nullptr)
1039 return string_printf ("%s (%s)", target_id
.c_str (), extra_info
);
1040 else if (name
!= nullptr)
1041 return string_printf ("%s \"%s\"", target_id
.c_str (), name
);
1046 /* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1047 whether REQUESTED_THREADS is a list of global or per-inferior
1051 print_thread_info_1 (struct ui_out
*uiout
, const char *requested_threads
,
1052 int global_ids
, int pid
,
1053 int show_global_ids
)
1055 int default_inf_num
= current_inferior ()->num
;
1057 update_thread_list ();
1059 /* Whether we saw any thread. */
1060 bool any_thread
= false;
1061 /* Whether the current thread is exited. */
1062 bool current_exited
= false;
1064 thread_info
*current_thread
= (inferior_ptid
!= null_ptid
1065 ? inferior_thread () : NULL
);
1068 /* For backward compatibility, we make a list for MI. A table is
1069 preferable for the CLI, though, because it shows table
1071 gdb::optional
<ui_out_emit_list
> list_emitter
;
1072 gdb::optional
<ui_out_emit_table
> table_emitter
;
1074 /* We'll be switching threads temporarily below. */
1075 scoped_restore_current_thread restore_thread
;
1077 if (uiout
->is_mi_like_p ())
1078 list_emitter
.emplace (uiout
, "threads");
1082 /* The width of the "Target Id" column. Grown below to
1083 accommodate the largest entry. */
1084 size_t target_id_col_width
= 17;
1086 for (thread_info
*tp
: all_threads ())
1088 if (!should_print_thread (requested_threads
, default_inf_num
,
1089 global_ids
, pid
, tp
))
1092 if (!uiout
->is_mi_like_p ())
1094 /* Switch inferiors so we're looking at the right
1096 switch_to_inferior_no_thread (tp
->inf
);
1099 = std::max (target_id_col_width
,
1100 thread_target_id_str (tp
).size ());
1108 if (requested_threads
== NULL
|| *requested_threads
== '\0')
1109 uiout
->message (_("No threads.\n"));
1111 uiout
->message (_("No threads match '%s'.\n"),
1116 table_emitter
.emplace (uiout
, show_global_ids
? 5 : 4,
1117 n_threads
, "threads");
1119 uiout
->table_header (1, ui_left
, "current", "");
1120 uiout
->table_header (4, ui_left
, "id-in-tg", "Id");
1121 if (show_global_ids
)
1122 uiout
->table_header (4, ui_left
, "id", "GId");
1123 uiout
->table_header (target_id_col_width
, ui_left
,
1124 "target-id", "Target Id");
1125 uiout
->table_header (1, ui_left
, "frame", "Frame");
1126 uiout
->table_body ();
1129 for (inferior
*inf
: all_inferiors ())
1130 for (thread_info
*tp
: inf
->threads ())
1135 if (tp
== current_thread
&& tp
->state
== THREAD_EXITED
)
1136 current_exited
= true;
1138 if (!should_print_thread (requested_threads
, default_inf_num
,
1139 global_ids
, pid
, tp
))
1142 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1144 if (!uiout
->is_mi_like_p ())
1146 if (tp
== current_thread
)
1147 uiout
->field_string ("current", "*");
1149 uiout
->field_skip ("current");
1151 uiout
->field_string ("id-in-tg", print_thread_id (tp
));
1154 if (show_global_ids
|| uiout
->is_mi_like_p ())
1155 uiout
->field_signed ("id", tp
->global_num
);
1157 /* Switch to the thread (and inferior / target). */
1158 switch_to_thread (tp
);
1160 /* For the CLI, we stuff everything into the target-id field.
1161 This is a gross hack to make the output come out looking
1162 correct. The underlying problem here is that ui-out has no
1163 way to specify that a field's space allocation should be
1164 shared by several fields. For MI, we do the right thing
1167 if (uiout
->is_mi_like_p ())
1169 uiout
->field_string ("target-id", target_pid_to_str (tp
->ptid
));
1171 const char *extra_info
= target_extra_thread_info (tp
);
1172 if (extra_info
!= nullptr)
1173 uiout
->field_string ("details", extra_info
);
1175 const char *name
= (tp
->name
!= nullptr
1177 : target_thread_name (tp
));
1179 uiout
->field_string ("name", name
);
1183 uiout
->field_string ("target-id",
1184 thread_target_id_str (tp
).c_str ());
1187 if (tp
->state
== THREAD_RUNNING
)
1188 uiout
->text ("(running)\n");
1191 /* The switch above put us at the top of the stack (leaf
1193 print_stack_frame (get_selected_frame (NULL
),
1194 /* For MI output, print frame level. */
1195 uiout
->is_mi_like_p (),
1199 if (uiout
->is_mi_like_p ())
1201 const char *state
= "stopped";
1203 if (tp
->state
== THREAD_RUNNING
)
1205 uiout
->field_string ("state", state
);
1208 core
= target_core_of_thread (tp
->ptid
);
1209 if (uiout
->is_mi_like_p () && core
!= -1)
1210 uiout
->field_signed ("core", core
);
1213 /* This end scope restores the current thread and the frame
1214 selected before the "info threads" command, and it finishes the
1215 ui-out list or table. */
1218 if (pid
== -1 && requested_threads
== NULL
)
1220 if (uiout
->is_mi_like_p () && inferior_ptid
!= null_ptid
)
1221 uiout
->field_signed ("current-thread-id", current_thread
->global_num
);
1223 if (inferior_ptid
!= null_ptid
&& current_exited
)
1224 uiout
->message ("\n\
1225 The current thread <Thread ID %s> has terminated. See `help thread'.\n",
1226 print_thread_id (inferior_thread ()));
1227 else if (any_thread
&& inferior_ptid
== null_ptid
)
1228 uiout
->message ("\n\
1229 No selected thread. See `help thread'.\n");
1233 /* See gdbthread.h. */
1236 print_thread_info (struct ui_out
*uiout
, const char *requested_threads
,
1239 print_thread_info_1 (uiout
, requested_threads
, 1, pid
, 0);
1242 /* The options for the "info threads" command. */
1244 struct info_threads_opts
1247 bool show_global_ids
= false;
1250 static const gdb::option::option_def info_threads_option_defs
[] = {
1252 gdb::option::flag_option_def
<info_threads_opts
> {
1254 [] (info_threads_opts
*opts
) { return &opts
->show_global_ids
; },
1255 N_("Show global thread IDs."),
1260 /* Create an option_def_group for the "info threads" options, with
1261 IT_OPTS as context. */
1263 static inline gdb::option::option_def_group
1264 make_info_threads_options_def_group (info_threads_opts
*it_opts
)
1266 return {{info_threads_option_defs
}, it_opts
};
1269 /* Implementation of the "info threads" command.
1271 Note: this has the drawback that it _really_ switches
1272 threads, which frees the frame cache. A no-side
1273 effects info-threads command would be nicer. */
1276 info_threads_command (const char *arg
, int from_tty
)
1278 info_threads_opts it_opts
;
1280 auto grp
= make_info_threads_options_def_group (&it_opts
);
1281 gdb::option::process_options
1282 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
);
1284 print_thread_info_1 (current_uiout
, arg
, 0, -1, it_opts
.show_global_ids
);
1287 /* Completer for the "info threads" command. */
1290 info_threads_command_completer (struct cmd_list_element
*ignore
,
1291 completion_tracker
&tracker
,
1292 const char *text
, const char *word_ignored
)
1294 const auto grp
= make_info_threads_options_def_group (nullptr);
1296 if (gdb::option::complete_options
1297 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
))
1300 /* Convenience to let the user know what the option can accept. */
1303 gdb::option::complete_on_all_options (tracker
, grp
);
1304 /* Keep this "ID" in sync with what "help info threads"
1306 tracker
.add_completion (make_unique_xstrdup ("ID"));
1310 /* See gdbthread.h. */
1313 switch_to_thread_no_regs (struct thread_info
*thread
)
1315 struct inferior
*inf
= thread
->inf
;
1317 set_current_program_space (inf
->pspace
);
1318 set_current_inferior (inf
);
1320 current_thread_
= thread
;
1321 inferior_ptid
= current_thread_
->ptid
;
1324 /* See gdbthread.h. */
1327 switch_to_no_thread ()
1329 if (current_thread_
== nullptr)
1332 current_thread_
= nullptr;
1333 inferior_ptid
= null_ptid
;
1334 reinit_frame_cache ();
1337 /* See gdbthread.h. */
1340 switch_to_thread (thread_info
*thr
)
1342 gdb_assert (thr
!= NULL
);
1344 if (is_current_thread (thr
))
1347 switch_to_thread_no_regs (thr
);
1349 reinit_frame_cache ();
1352 /* See gdbsupport/common-gdbthread.h. */
1355 switch_to_thread (process_stratum_target
*proc_target
, ptid_t ptid
)
1357 thread_info
*thr
= find_thread_ptid (proc_target
, ptid
);
1358 switch_to_thread (thr
);
1364 scoped_restore_current_thread::restore ()
1366 /* If an entry of thread_info was previously selected, it won't be
1367 deleted because we've increased its refcount. The thread represented
1368 by this thread_info entry may have already exited (due to normal exit,
1369 detach, etc), so the thread_info.state is THREAD_EXITED. */
1370 if (m_thread
!= NULL
1371 /* If the previously selected thread belonged to a process that has
1372 in the mean time exited (or killed, detached, etc.), then don't revert
1373 back to it, but instead simply drop back to no thread selected. */
1375 switch_to_thread (m_thread
.get ());
1377 switch_to_inferior_no_thread (m_inf
.get ());
1379 /* The running state of the originally selected thread may have
1380 changed, so we have to recheck it here. */
1381 if (inferior_ptid
!= null_ptid
1383 && m_thread
->state
== THREAD_STOPPED
1384 && target_has_registers ()
1385 && target_has_stack ()
1386 && target_has_memory ())
1387 restore_selected_frame (m_selected_frame_id
, m_selected_frame_level
);
1389 set_language (m_lang
);
1392 scoped_restore_current_thread::~scoped_restore_current_thread ()
1394 if (!m_dont_restore
)
1398 scoped_restore_current_thread::scoped_restore_current_thread ()
1400 m_inf
= inferior_ref::new_reference (current_inferior ());
1402 m_lang
= current_language
->la_language
;
1404 if (inferior_ptid
!= null_ptid
)
1406 m_thread
= thread_info_ref::new_reference (inferior_thread ());
1408 m_was_stopped
= m_thread
->state
== THREAD_STOPPED
;
1409 save_selected_frame (&m_selected_frame_id
, &m_selected_frame_level
);
1413 /* See gdbthread.h. */
1416 show_thread_that_caused_stop (void)
1418 return highest_thread_num
> 1;
1421 /* See gdbthread.h. */
1424 show_inferior_qualified_tids (void)
1426 return (inferior_list
->next
!= NULL
|| inferior_list
->num
!= 1);
1429 /* See gdbthread.h. */
1432 print_thread_id (struct thread_info
*thr
)
1434 char *s
= get_print_cell ();
1436 if (show_inferior_qualified_tids ())
1437 xsnprintf (s
, PRINT_CELL_SIZE
, "%d.%d", thr
->inf
->num
, thr
->per_inf_num
);
1439 xsnprintf (s
, PRINT_CELL_SIZE
, "%d", thr
->per_inf_num
);
1443 /* Sort an array of struct thread_info pointers by thread ID (first by
1444 inferior number, and then by per-inferior thread number). Sorts in
1448 tp_array_compar_ascending (const thread_info_ref
&a
, const thread_info_ref
&b
)
1450 if (a
->inf
->num
!= b
->inf
->num
)
1451 return a
->inf
->num
< b
->inf
->num
;
1453 return (a
->per_inf_num
< b
->per_inf_num
);
1456 /* Sort an array of struct thread_info pointers by thread ID (first by
1457 inferior number, and then by per-inferior thread number). Sorts in
1458 descending order. */
1461 tp_array_compar_descending (const thread_info_ref
&a
, const thread_info_ref
&b
)
1463 if (a
->inf
->num
!= b
->inf
->num
)
1464 return a
->inf
->num
> b
->inf
->num
;
1466 return (a
->per_inf_num
> b
->per_inf_num
);
1469 /* Switch to thread THR and execute CMD.
1470 FLAGS.QUIET controls the printing of the thread information.
1471 FLAGS.CONT and FLAGS.SILENT control how to handle errors. */
1474 thr_try_catch_cmd (thread_info
*thr
, const char *cmd
, int from_tty
,
1475 const qcs_flags
&flags
)
1477 switch_to_thread (thr
);
1479 /* The thread header is computed before running the command since
1480 the command can change the inferior, which is not permitted
1481 by thread_target_id_str. */
1482 std::string thr_header
=
1483 string_printf (_("\nThread %s (%s):\n"), print_thread_id (thr
),
1484 thread_target_id_str (thr
).c_str ());
1488 std::string cmd_result
= execute_command_to_string
1489 (cmd
, from_tty
, gdb_stdout
->term_out ());
1490 if (!flags
.silent
|| cmd_result
.length () > 0)
1493 printf_filtered ("%s", thr_header
.c_str ());
1494 printf_filtered ("%s", cmd_result
.c_str ());
1497 catch (const gdb_exception_error
&ex
)
1502 printf_filtered ("%s", thr_header
.c_str ());
1504 printf_filtered ("%s\n", ex
.what ());
1511 /* Option definition of "thread apply"'s "-ascending" option. */
1513 static const gdb::option::flag_option_def
<> ascending_option_def
= {
1516 Call COMMAND for all threads in ascending order.\n\
1517 The default is descending order."),
1520 /* The qcs command line flags for the "thread apply" commands. Keep
1521 this in sync with the "frame apply" commands. */
1523 using qcs_flag_option_def
1524 = gdb::option::flag_option_def
<qcs_flags
>;
1526 static const gdb::option::option_def thr_qcs_flags_option_defs
[] = {
1527 qcs_flag_option_def
{
1528 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
1529 N_("Disables printing the thread information."),
1532 qcs_flag_option_def
{
1533 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
1534 N_("Print any error raised by COMMAND and continue."),
1537 qcs_flag_option_def
{
1538 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
1539 N_("Silently ignore any errors or empty output produced by COMMAND."),
1543 /* Create an option_def_group for the "thread apply all" options, with
1544 ASCENDING and FLAGS as context. */
1546 static inline std::array
<gdb::option::option_def_group
, 2>
1547 make_thread_apply_all_options_def_group (bool *ascending
,
1551 { {ascending_option_def
.def ()}, ascending
},
1552 { {thr_qcs_flags_option_defs
}, flags
},
1556 /* Create an option_def_group for the "thread apply" options, with
1557 FLAGS as context. */
1559 static inline gdb::option::option_def_group
1560 make_thread_apply_options_def_group (qcs_flags
*flags
)
1562 return {{thr_qcs_flags_option_defs
}, flags
};
1565 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1566 separated list of numbers, or ranges, or the keyword `all'. Ranges consist
1567 of two numbers separated by a hyphen. Examples:
1569 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1570 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1571 thread apply all x/i $pc Apply x/i $pc cmd to all threads. */
1574 thread_apply_all_command (const char *cmd
, int from_tty
)
1576 bool ascending
= false;
1579 auto group
= make_thread_apply_all_options_def_group (&ascending
,
1581 gdb::option::process_options
1582 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1584 validate_flags_qcs ("thread apply all", &flags
);
1586 if (cmd
== NULL
|| *cmd
== '\000')
1587 error (_("Please specify a command at the end of 'thread apply all'"));
1589 update_thread_list ();
1591 int tc
= live_threads_count ();
1594 /* Save a copy of the thread list and increment each thread's
1595 refcount while executing the command in the context of each
1596 thread, in case the command is one that wipes threads. E.g.,
1597 detach, kill, disconnect, etc., or even normally continuing
1598 over an inferior or thread exit. */
1599 std::vector
<thread_info_ref
> thr_list_cpy
;
1600 thr_list_cpy
.reserve (tc
);
1602 for (thread_info
*tp
: all_non_exited_threads ())
1603 thr_list_cpy
.push_back (thread_info_ref::new_reference (tp
));
1604 gdb_assert (thr_list_cpy
.size () == tc
);
1606 auto *sorter
= (ascending
1607 ? tp_array_compar_ascending
1608 : tp_array_compar_descending
);
1609 std::sort (thr_list_cpy
.begin (), thr_list_cpy
.end (), sorter
);
1611 scoped_restore_current_thread restore_thread
;
1613 for (thread_info_ref
&thr
: thr_list_cpy
)
1614 if (switch_to_thread_if_alive (thr
.get ()))
1615 thr_try_catch_cmd (thr
.get (), cmd
, from_tty
, flags
);
1619 /* Completer for "thread apply [ID list]". */
1622 thread_apply_command_completer (cmd_list_element
*ignore
,
1623 completion_tracker
&tracker
,
1624 const char *text
, const char * /*word*/)
1626 /* Don't leave this to complete_options because there's an early
1628 tracker
.set_use_custom_word_point (true);
1630 tid_range_parser parser
;
1631 parser
.init (text
, current_inferior ()->num
);
1635 while (!parser
.finished ())
1637 int inf_num
, thr_start
, thr_end
;
1639 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1642 if (parser
.in_star_range () || parser
.in_thread_range ())
1643 parser
.skip_range ();
1646 catch (const gdb_exception_error
&ex
)
1648 /* get_tid_range throws if it parses a negative number, for
1649 example. But a seemingly negative number may be the start of
1650 an option instead. */
1653 const char *cmd
= parser
.cur_tok ();
1657 /* No thread ID list yet. */
1661 /* Check if we're past a valid thread ID list already. */
1662 if (parser
.finished ()
1663 && cmd
> text
&& !isspace (cmd
[-1]))
1666 /* We're past the thread ID list, advance word point. */
1667 tracker
.advance_custom_word_point_by (cmd
- text
);
1670 const auto group
= make_thread_apply_options_def_group (nullptr);
1671 if (gdb::option::complete_options
1672 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1675 complete_nested_command_line (tracker
, text
);
1678 /* Completer for "thread apply all". */
1681 thread_apply_all_command_completer (cmd_list_element
*ignore
,
1682 completion_tracker
&tracker
,
1683 const char *text
, const char *word
)
1685 const auto group
= make_thread_apply_all_options_def_group (nullptr,
1687 if (gdb::option::complete_options
1688 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1691 complete_nested_command_line (tracker
, text
);
1694 /* Implementation of the "thread apply" command. */
1697 thread_apply_command (const char *tidlist
, int from_tty
)
1700 const char *cmd
= NULL
;
1701 tid_range_parser parser
;
1703 if (tidlist
== NULL
|| *tidlist
== '\000')
1704 error (_("Please specify a thread ID list"));
1706 parser
.init (tidlist
, current_inferior ()->num
);
1707 while (!parser
.finished ())
1709 int inf_num
, thr_start
, thr_end
;
1711 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1715 cmd
= parser
.cur_tok ();
1717 auto group
= make_thread_apply_options_def_group (&flags
);
1718 gdb::option::process_options
1719 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1721 validate_flags_qcs ("thread apply", &flags
);
1724 error (_("Please specify a command following the thread ID list"));
1726 if (tidlist
== cmd
|| isdigit (cmd
[0]))
1727 invalid_thread_id_error (cmd
);
1729 scoped_restore_current_thread restore_thread
;
1731 parser
.init (tidlist
, current_inferior ()->num
);
1732 while (!parser
.finished ())
1734 struct thread_info
*tp
= NULL
;
1735 struct inferior
*inf
;
1736 int inf_num
, thr_num
;
1738 parser
.get_tid (&inf_num
, &thr_num
);
1739 inf
= find_inferior_id (inf_num
);
1741 tp
= find_thread_id (inf
, thr_num
);
1743 if (parser
.in_star_range ())
1747 warning (_("Unknown inferior %d"), inf_num
);
1748 parser
.skip_range ();
1752 /* No use looking for threads past the highest thread number
1753 the inferior ever had. */
1754 if (thr_num
>= inf
->highest_thread_num
)
1755 parser
.skip_range ();
1757 /* Be quiet about unknown threads numbers. */
1764 if (show_inferior_qualified_tids () || parser
.tid_is_qualified ())
1765 warning (_("Unknown thread %d.%d"), inf_num
, thr_num
);
1767 warning (_("Unknown thread %d"), thr_num
);
1771 if (!switch_to_thread_if_alive (tp
))
1773 warning (_("Thread %s has terminated."), print_thread_id (tp
));
1777 thr_try_catch_cmd (tp
, cmd
, from_tty
, flags
);
1782 /* Implementation of the "taas" command. */
1785 taas_command (const char *cmd
, int from_tty
)
1787 if (cmd
== NULL
|| *cmd
== '\0')
1788 error (_("Please specify a command to apply on all threads"));
1789 std::string expanded
= std::string ("thread apply all -s ") + cmd
;
1790 execute_command (expanded
.c_str (), from_tty
);
1793 /* Implementation of the "tfaas" command. */
1796 tfaas_command (const char *cmd
, int from_tty
)
1798 if (cmd
== NULL
|| *cmd
== '\0')
1799 error (_("Please specify a command to apply on all frames of all threads"));
1800 std::string expanded
1801 = std::string ("thread apply all -s -- frame apply all -s ") + cmd
;
1802 execute_command (expanded
.c_str (), from_tty
);
1805 /* Switch to the specified thread, or print the current thread. */
1808 thread_command (const char *tidstr
, int from_tty
)
1812 if (inferior_ptid
== null_ptid
)
1813 error (_("No thread selected"));
1815 if (target_has_stack ())
1817 struct thread_info
*tp
= inferior_thread ();
1819 if (tp
->state
== THREAD_EXITED
)
1820 printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
1821 print_thread_id (tp
),
1822 target_pid_to_str (inferior_ptid
).c_str ());
1824 printf_filtered (_("[Current thread is %s (%s)]\n"),
1825 print_thread_id (tp
),
1826 target_pid_to_str (inferior_ptid
).c_str ());
1829 error (_("No stack."));
1833 ptid_t previous_ptid
= inferior_ptid
;
1835 thread_select (tidstr
, parse_thread_id (tidstr
, NULL
));
1837 /* Print if the thread has not changed, otherwise an event will
1839 if (inferior_ptid
== previous_ptid
)
1841 print_selected_thread_frame (current_uiout
,
1842 USER_SELECTED_THREAD
1843 | USER_SELECTED_FRAME
);
1847 gdb::observers::user_selected_context_changed
.notify
1848 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
1853 /* Implementation of `thread name'. */
1856 thread_name_command (const char *arg
, int from_tty
)
1858 struct thread_info
*info
;
1860 if (inferior_ptid
== null_ptid
)
1861 error (_("No thread selected"));
1863 arg
= skip_spaces (arg
);
1865 info
= inferior_thread ();
1867 info
->name
= arg
? xstrdup (arg
) : NULL
;
1870 /* Find thread ids with a name, target pid, or extra info matching ARG. */
1873 thread_find_command (const char *arg
, int from_tty
)
1876 unsigned long match
= 0;
1878 if (arg
== NULL
|| *arg
== '\0')
1879 error (_("Command requires an argument."));
1881 tmp
= re_comp (arg
);
1883 error (_("Invalid regexp (%s): %s"), tmp
, arg
);
1885 /* We're going to be switching threads. */
1886 scoped_restore_current_thread restore_thread
;
1888 update_thread_list ();
1890 for (thread_info
*tp
: all_threads ())
1892 switch_to_inferior_no_thread (tp
->inf
);
1894 if (tp
->name
!= NULL
&& re_exec (tp
->name
))
1896 printf_filtered (_("Thread %s has name '%s'\n"),
1897 print_thread_id (tp
), tp
->name
);
1901 tmp
= target_thread_name (tp
);
1902 if (tmp
!= NULL
&& re_exec (tmp
))
1904 printf_filtered (_("Thread %s has target name '%s'\n"),
1905 print_thread_id (tp
), tmp
);
1909 std::string name
= target_pid_to_str (tp
->ptid
);
1910 if (!name
.empty () && re_exec (name
.c_str ()))
1912 printf_filtered (_("Thread %s has target id '%s'\n"),
1913 print_thread_id (tp
), name
.c_str ());
1917 tmp
= target_extra_thread_info (tp
);
1918 if (tmp
!= NULL
&& re_exec (tmp
))
1920 printf_filtered (_("Thread %s has extra info '%s'\n"),
1921 print_thread_id (tp
), tmp
);
1926 printf_filtered (_("No threads match '%s'\n"), arg
);
1929 /* Print notices when new threads are attached and detached. */
1930 bool print_thread_events
= true;
1932 show_print_thread_events (struct ui_file
*file
, int from_tty
,
1933 struct cmd_list_element
*c
, const char *value
)
1935 fprintf_filtered (file
,
1936 _("Printing of thread events is %s.\n"),
1940 /* See gdbthread.h. */
1943 thread_select (const char *tidstr
, thread_info
*tp
)
1945 if (!switch_to_thread_if_alive (tp
))
1946 error (_("Thread ID %s has terminated."), tidstr
);
1948 annotate_thread_changed ();
1950 /* Since the current thread may have changed, see if there is any
1951 exited thread we can now delete. */
1952 delete_exited_threads ();
1955 /* Print thread and frame switch command response. */
1958 print_selected_thread_frame (struct ui_out
*uiout
,
1959 user_selected_what selection
)
1961 struct thread_info
*tp
= inferior_thread ();
1963 if (selection
& USER_SELECTED_THREAD
)
1965 if (uiout
->is_mi_like_p ())
1967 uiout
->field_signed ("new-thread-id",
1968 inferior_thread ()->global_num
);
1972 uiout
->text ("[Switching to thread ");
1973 uiout
->field_string ("new-thread-id", print_thread_id (tp
));
1975 uiout
->text (target_pid_to_str (inferior_ptid
).c_str ());
1980 if (tp
->state
== THREAD_RUNNING
)
1982 if (selection
& USER_SELECTED_THREAD
)
1983 uiout
->text ("(running)\n");
1985 else if (selection
& USER_SELECTED_FRAME
)
1987 if (selection
& USER_SELECTED_THREAD
)
1990 if (has_stack_frames ())
1991 print_stack_frame_to_uiout (uiout
, get_selected_frame (NULL
),
1996 /* Update the 'threads_executing' global based on the threads we know
1997 about right now. This is used by infrun to tell whether we should
1998 pull events out of the current target. */
2001 update_threads_executing (void)
2003 process_stratum_target
*targ
= current_inferior ()->process_target ();
2008 targ
->threads_executing
= false;
2010 for (inferior
*inf
: all_non_exited_inferiors (targ
))
2012 if (!inf
->has_execution ())
2015 /* If the process has no threads, then it must be we have a
2016 process-exit event pending. */
2017 if (inf
->thread_list
== NULL
)
2019 targ
->threads_executing
= true;
2023 for (thread_info
*tp
: inf
->non_exited_threads ())
2027 targ
->threads_executing
= true;
2035 update_thread_list (void)
2037 target_update_thread_list ();
2038 update_threads_executing ();
2041 /* Return a new value for the selected thread's id. Return a value of
2042 0 if no thread is selected. If GLOBAL is true, return the thread's
2043 global number. Otherwise return the per-inferior number. */
2045 static struct value
*
2046 thread_num_make_value_helper (struct gdbarch
*gdbarch
, int global
)
2050 if (inferior_ptid
== null_ptid
)
2054 thread_info
*tp
= inferior_thread ();
2056 int_val
= tp
->global_num
;
2058 int_val
= tp
->per_inf_num
;
2061 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, int_val
);
2064 /* Return a new value for the selected thread's per-inferior thread
2065 number. Return a value of 0 if no thread is selected, or no
2068 static struct value
*
2069 thread_id_per_inf_num_make_value (struct gdbarch
*gdbarch
,
2070 struct internalvar
*var
,
2073 return thread_num_make_value_helper (gdbarch
, 0);
2076 /* Return a new value for the selected thread's global id. Return a
2077 value of 0 if no thread is selected, or no threads exist. */
2079 static struct value
*
2080 global_thread_id_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
2083 return thread_num_make_value_helper (gdbarch
, 1);
2086 /* Commands with a prefix of `thread'. */
2087 struct cmd_list_element
*thread_cmd_list
= NULL
;
2089 /* Implementation of `thread' variable. */
2091 static const struct internalvar_funcs thread_funcs
=
2093 thread_id_per_inf_num_make_value
,
2098 /* Implementation of `gthread' variable. */
2100 static const struct internalvar_funcs gthread_funcs
=
2102 global_thread_id_make_value
,
2107 void _initialize_thread ();
2109 _initialize_thread ()
2111 static struct cmd_list_element
*thread_apply_list
= NULL
;
2112 cmd_list_element
*c
;
2114 const auto info_threads_opts
= make_info_threads_options_def_group (nullptr);
2116 /* Note: keep this "ID" in sync with what "info threads [TAB]"
2118 static std::string info_threads_help
2119 = gdb::option::build_help (_("\
2120 Display currently known threads.\n\
2121 Usage: info threads [OPTION]... [ID]...\n\
2122 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2123 Otherwise, all threads are displayed.\n\
2129 c
= add_info ("threads", info_threads_command
, info_threads_help
.c_str ());
2130 set_cmd_completer_handle_brkchars (c
, info_threads_command_completer
);
2132 add_prefix_cmd ("thread", class_run
, thread_command
, _("\
2133 Use this command to switch between threads.\n\
2134 The new thread ID must be currently known."),
2135 &thread_cmd_list
, "thread ", 1, &cmdlist
);
2137 #define THREAD_APPLY_OPTION_HELP "\
2138 Prints per-inferior thread number and target system's thread id\n\
2139 followed by COMMAND output.\n\
2141 By default, an error raised during the execution of COMMAND\n\
2142 aborts \"thread apply\".\n\
2147 const auto thread_apply_opts
= make_thread_apply_options_def_group (nullptr);
2149 static std::string thread_apply_help
= gdb::option::build_help (_("\
2150 Apply a command to a list of threads.\n\
2151 Usage: thread apply ID... [OPTION]... COMMAND\n\
2152 ID is a space-separated list of IDs of threads to apply COMMAND on.\n"
2153 THREAD_APPLY_OPTION_HELP
),
2156 c
= add_prefix_cmd ("apply", class_run
, thread_apply_command
,
2157 thread_apply_help
.c_str (),
2158 &thread_apply_list
, "thread apply ", 1,
2160 set_cmd_completer_handle_brkchars (c
, thread_apply_command_completer
);
2162 const auto thread_apply_all_opts
2163 = make_thread_apply_all_options_def_group (nullptr, nullptr);
2165 static std::string thread_apply_all_help
= gdb::option::build_help (_("\
2166 Apply a command to all threads.\n\
2168 Usage: thread apply all [OPTION]... COMMAND\n"
2169 THREAD_APPLY_OPTION_HELP
),
2170 thread_apply_all_opts
);
2172 c
= add_cmd ("all", class_run
, thread_apply_all_command
,
2173 thread_apply_all_help
.c_str (),
2174 &thread_apply_list
);
2175 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2177 c
= add_com ("taas", class_run
, taas_command
, _("\
2178 Apply a command to all threads (ignoring errors and empty output).\n\
2179 Usage: taas [OPTION]... COMMAND\n\
2180 shortcut for 'thread apply all -s [OPTION]... COMMAND'\n\
2181 See \"help thread apply all\" for available options."));
2182 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2184 c
= add_com ("tfaas", class_run
, tfaas_command
, _("\
2185 Apply a command to all frames of all threads (ignoring errors and empty output).\n\
2186 Usage: tfaas [OPTION]... COMMAND\n\
2187 shortcut for 'thread apply all -s -- frame apply all -s [OPTION]... COMMAND'\n\
2188 See \"help frame apply all\" for available options."));
2189 set_cmd_completer_handle_brkchars (c
, frame_apply_all_cmd_completer
);
2191 add_cmd ("name", class_run
, thread_name_command
,
2192 _("Set the current thread's name.\n\
2193 Usage: thread name [NAME]\n\
2194 If NAME is not given, then any existing name is removed."), &thread_cmd_list
);
2196 add_cmd ("find", class_run
, thread_find_command
, _("\
2197 Find threads that match a regular expression.\n\
2198 Usage: thread find REGEXP\n\
2199 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2202 add_com_alias ("t", "thread", class_run
, 1);
2204 add_setshow_boolean_cmd ("thread-events", no_class
,
2205 &print_thread_events
, _("\
2206 Set printing of thread events (such as thread start and exit)."), _("\
2207 Show printing of thread events (such as thread start and exit)."), NULL
,
2209 show_print_thread_events
,
2210 &setprintlist
, &showprintlist
);
2212 create_internalvar_type_lazy ("_thread", &thread_funcs
, NULL
);
2213 create_internalvar_type_lazy ("_gthread", >hread_funcs
, NULL
);