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 /* Assuming that THR is the current thread, execute CMD.
1470 FLAGS.QUIET controls the printing of the thread information.
1471 FLAGS.CONT and FLAGS.SILENT control how to handle errors. Can throw an
1472 exception if !FLAGS.SILENT and !FLAGS.CONT and CMD fails. */
1475 thr_try_catch_cmd (thread_info
*thr
, const char *cmd
, int from_tty
,
1476 const qcs_flags
&flags
)
1478 gdb_assert (is_current_thread (thr
));
1480 /* The thread header is computed before running the command since
1481 the command can change the inferior, which is not permitted
1482 by thread_target_id_str. */
1483 std::string thr_header
=
1484 string_printf (_("\nThread %s (%s):\n"), print_thread_id (thr
),
1485 thread_target_id_str (thr
).c_str ());
1489 std::string cmd_result
= execute_command_to_string
1490 (cmd
, from_tty
, gdb_stdout
->term_out ());
1491 if (!flags
.silent
|| cmd_result
.length () > 0)
1494 printf_filtered ("%s", thr_header
.c_str ());
1495 printf_filtered ("%s", cmd_result
.c_str ());
1498 catch (const gdb_exception_error
&ex
)
1503 printf_filtered ("%s", thr_header
.c_str ());
1505 printf_filtered ("%s\n", ex
.what ());
1512 /* Option definition of "thread apply"'s "-ascending" option. */
1514 static const gdb::option::flag_option_def
<> ascending_option_def
= {
1517 Call COMMAND for all threads in ascending order.\n\
1518 The default is descending order."),
1521 /* The qcs command line flags for the "thread apply" commands. Keep
1522 this in sync with the "frame apply" commands. */
1524 using qcs_flag_option_def
1525 = gdb::option::flag_option_def
<qcs_flags
>;
1527 static const gdb::option::option_def thr_qcs_flags_option_defs
[] = {
1528 qcs_flag_option_def
{
1529 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
1530 N_("Disables printing the thread information."),
1533 qcs_flag_option_def
{
1534 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
1535 N_("Print any error raised by COMMAND and continue."),
1538 qcs_flag_option_def
{
1539 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
1540 N_("Silently ignore any errors or empty output produced by COMMAND."),
1544 /* Create an option_def_group for the "thread apply all" options, with
1545 ASCENDING and FLAGS as context. */
1547 static inline std::array
<gdb::option::option_def_group
, 2>
1548 make_thread_apply_all_options_def_group (bool *ascending
,
1552 { {ascending_option_def
.def ()}, ascending
},
1553 { {thr_qcs_flags_option_defs
}, flags
},
1557 /* Create an option_def_group for the "thread apply" options, with
1558 FLAGS as context. */
1560 static inline gdb::option::option_def_group
1561 make_thread_apply_options_def_group (qcs_flags
*flags
)
1563 return {{thr_qcs_flags_option_defs
}, flags
};
1566 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1567 separated list of numbers, or ranges, or the keyword `all'. Ranges consist
1568 of two numbers separated by a hyphen. Examples:
1570 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1571 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1572 thread apply all x/i $pc Apply x/i $pc cmd to all threads. */
1575 thread_apply_all_command (const char *cmd
, int from_tty
)
1577 bool ascending
= false;
1580 auto group
= make_thread_apply_all_options_def_group (&ascending
,
1582 gdb::option::process_options
1583 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1585 validate_flags_qcs ("thread apply all", &flags
);
1587 if (cmd
== NULL
|| *cmd
== '\000')
1588 error (_("Please specify a command at the end of 'thread apply all'"));
1590 update_thread_list ();
1592 int tc
= live_threads_count ();
1595 /* Save a copy of the thread list and increment each thread's
1596 refcount while executing the command in the context of each
1597 thread, in case the command is one that wipes threads. E.g.,
1598 detach, kill, disconnect, etc., or even normally continuing
1599 over an inferior or thread exit. */
1600 std::vector
<thread_info_ref
> thr_list_cpy
;
1601 thr_list_cpy
.reserve (tc
);
1603 for (thread_info
*tp
: all_non_exited_threads ())
1604 thr_list_cpy
.push_back (thread_info_ref::new_reference (tp
));
1605 gdb_assert (thr_list_cpy
.size () == tc
);
1607 auto *sorter
= (ascending
1608 ? tp_array_compar_ascending
1609 : tp_array_compar_descending
);
1610 std::sort (thr_list_cpy
.begin (), thr_list_cpy
.end (), sorter
);
1612 scoped_restore_current_thread restore_thread
;
1614 for (thread_info_ref
&thr
: thr_list_cpy
)
1615 if (switch_to_thread_if_alive (thr
.get ()))
1616 thr_try_catch_cmd (thr
.get (), cmd
, from_tty
, flags
);
1620 /* Completer for "thread apply [ID list]". */
1623 thread_apply_command_completer (cmd_list_element
*ignore
,
1624 completion_tracker
&tracker
,
1625 const char *text
, const char * /*word*/)
1627 /* Don't leave this to complete_options because there's an early
1629 tracker
.set_use_custom_word_point (true);
1631 tid_range_parser parser
;
1632 parser
.init (text
, current_inferior ()->num
);
1636 while (!parser
.finished ())
1638 int inf_num
, thr_start
, thr_end
;
1640 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1643 if (parser
.in_star_range () || parser
.in_thread_range ())
1644 parser
.skip_range ();
1647 catch (const gdb_exception_error
&ex
)
1649 /* get_tid_range throws if it parses a negative number, for
1650 example. But a seemingly negative number may be the start of
1651 an option instead. */
1654 const char *cmd
= parser
.cur_tok ();
1658 /* No thread ID list yet. */
1662 /* Check if we're past a valid thread ID list already. */
1663 if (parser
.finished ()
1664 && cmd
> text
&& !isspace (cmd
[-1]))
1667 /* We're past the thread ID list, advance word point. */
1668 tracker
.advance_custom_word_point_by (cmd
- text
);
1671 const auto group
= make_thread_apply_options_def_group (nullptr);
1672 if (gdb::option::complete_options
1673 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1676 complete_nested_command_line (tracker
, text
);
1679 /* Completer for "thread apply all". */
1682 thread_apply_all_command_completer (cmd_list_element
*ignore
,
1683 completion_tracker
&tracker
,
1684 const char *text
, const char *word
)
1686 const auto group
= make_thread_apply_all_options_def_group (nullptr,
1688 if (gdb::option::complete_options
1689 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1692 complete_nested_command_line (tracker
, text
);
1695 /* Implementation of the "thread apply" command. */
1698 thread_apply_command (const char *tidlist
, int from_tty
)
1701 const char *cmd
= NULL
;
1702 tid_range_parser parser
;
1704 if (tidlist
== NULL
|| *tidlist
== '\000')
1705 error (_("Please specify a thread ID list"));
1707 parser
.init (tidlist
, current_inferior ()->num
);
1708 while (!parser
.finished ())
1710 int inf_num
, thr_start
, thr_end
;
1712 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1716 cmd
= parser
.cur_tok ();
1718 auto group
= make_thread_apply_options_def_group (&flags
);
1719 gdb::option::process_options
1720 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1722 validate_flags_qcs ("thread apply", &flags
);
1725 error (_("Please specify a command following the thread ID list"));
1727 if (tidlist
== cmd
|| isdigit (cmd
[0]))
1728 invalid_thread_id_error (cmd
);
1730 scoped_restore_current_thread restore_thread
;
1732 parser
.init (tidlist
, current_inferior ()->num
);
1733 while (!parser
.finished ())
1735 struct thread_info
*tp
= NULL
;
1736 struct inferior
*inf
;
1737 int inf_num
, thr_num
;
1739 parser
.get_tid (&inf_num
, &thr_num
);
1740 inf
= find_inferior_id (inf_num
);
1742 tp
= find_thread_id (inf
, thr_num
);
1744 if (parser
.in_star_range ())
1748 warning (_("Unknown inferior %d"), inf_num
);
1749 parser
.skip_range ();
1753 /* No use looking for threads past the highest thread number
1754 the inferior ever had. */
1755 if (thr_num
>= inf
->highest_thread_num
)
1756 parser
.skip_range ();
1758 /* Be quiet about unknown threads numbers. */
1765 if (show_inferior_qualified_tids () || parser
.tid_is_qualified ())
1766 warning (_("Unknown thread %d.%d"), inf_num
, thr_num
);
1768 warning (_("Unknown thread %d"), thr_num
);
1772 if (!switch_to_thread_if_alive (tp
))
1774 warning (_("Thread %s has terminated."), print_thread_id (tp
));
1778 thr_try_catch_cmd (tp
, cmd
, from_tty
, flags
);
1783 /* Implementation of the "taas" command. */
1786 taas_command (const char *cmd
, int from_tty
)
1788 if (cmd
== NULL
|| *cmd
== '\0')
1789 error (_("Please specify a command to apply on all threads"));
1790 std::string expanded
= std::string ("thread apply all -s ") + cmd
;
1791 execute_command (expanded
.c_str (), from_tty
);
1794 /* Implementation of the "tfaas" command. */
1797 tfaas_command (const char *cmd
, int from_tty
)
1799 if (cmd
== NULL
|| *cmd
== '\0')
1800 error (_("Please specify a command to apply on all frames of all threads"));
1801 std::string expanded
1802 = std::string ("thread apply all -s -- frame apply all -s ") + cmd
;
1803 execute_command (expanded
.c_str (), from_tty
);
1806 /* Switch to the specified thread, or print the current thread. */
1809 thread_command (const char *tidstr
, int from_tty
)
1813 if (inferior_ptid
== null_ptid
)
1814 error (_("No thread selected"));
1816 if (target_has_stack ())
1818 struct thread_info
*tp
= inferior_thread ();
1820 if (tp
->state
== THREAD_EXITED
)
1821 printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
1822 print_thread_id (tp
),
1823 target_pid_to_str (inferior_ptid
).c_str ());
1825 printf_filtered (_("[Current thread is %s (%s)]\n"),
1826 print_thread_id (tp
),
1827 target_pid_to_str (inferior_ptid
).c_str ());
1830 error (_("No stack."));
1834 ptid_t previous_ptid
= inferior_ptid
;
1836 thread_select (tidstr
, parse_thread_id (tidstr
, NULL
));
1838 /* Print if the thread has not changed, otherwise an event will
1840 if (inferior_ptid
== previous_ptid
)
1842 print_selected_thread_frame (current_uiout
,
1843 USER_SELECTED_THREAD
1844 | USER_SELECTED_FRAME
);
1848 gdb::observers::user_selected_context_changed
.notify
1849 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
1854 /* Implementation of `thread name'. */
1857 thread_name_command (const char *arg
, int from_tty
)
1859 struct thread_info
*info
;
1861 if (inferior_ptid
== null_ptid
)
1862 error (_("No thread selected"));
1864 arg
= skip_spaces (arg
);
1866 info
= inferior_thread ();
1868 info
->name
= arg
? xstrdup (arg
) : NULL
;
1871 /* Find thread ids with a name, target pid, or extra info matching ARG. */
1874 thread_find_command (const char *arg
, int from_tty
)
1877 unsigned long match
= 0;
1879 if (arg
== NULL
|| *arg
== '\0')
1880 error (_("Command requires an argument."));
1882 tmp
= re_comp (arg
);
1884 error (_("Invalid regexp (%s): %s"), tmp
, arg
);
1886 /* We're going to be switching threads. */
1887 scoped_restore_current_thread restore_thread
;
1889 update_thread_list ();
1891 for (thread_info
*tp
: all_threads ())
1893 switch_to_inferior_no_thread (tp
->inf
);
1895 if (tp
->name
!= NULL
&& re_exec (tp
->name
))
1897 printf_filtered (_("Thread %s has name '%s'\n"),
1898 print_thread_id (tp
), tp
->name
);
1902 tmp
= target_thread_name (tp
);
1903 if (tmp
!= NULL
&& re_exec (tmp
))
1905 printf_filtered (_("Thread %s has target name '%s'\n"),
1906 print_thread_id (tp
), tmp
);
1910 std::string name
= target_pid_to_str (tp
->ptid
);
1911 if (!name
.empty () && re_exec (name
.c_str ()))
1913 printf_filtered (_("Thread %s has target id '%s'\n"),
1914 print_thread_id (tp
), name
.c_str ());
1918 tmp
= target_extra_thread_info (tp
);
1919 if (tmp
!= NULL
&& re_exec (tmp
))
1921 printf_filtered (_("Thread %s has extra info '%s'\n"),
1922 print_thread_id (tp
), tmp
);
1927 printf_filtered (_("No threads match '%s'\n"), arg
);
1930 /* Print notices when new threads are attached and detached. */
1931 bool print_thread_events
= true;
1933 show_print_thread_events (struct ui_file
*file
, int from_tty
,
1934 struct cmd_list_element
*c
, const char *value
)
1936 fprintf_filtered (file
,
1937 _("Printing of thread events is %s.\n"),
1941 /* See gdbthread.h. */
1944 thread_select (const char *tidstr
, thread_info
*tp
)
1946 if (!switch_to_thread_if_alive (tp
))
1947 error (_("Thread ID %s has terminated."), tidstr
);
1949 annotate_thread_changed ();
1951 /* Since the current thread may have changed, see if there is any
1952 exited thread we can now delete. */
1953 delete_exited_threads ();
1956 /* Print thread and frame switch command response. */
1959 print_selected_thread_frame (struct ui_out
*uiout
,
1960 user_selected_what selection
)
1962 struct thread_info
*tp
= inferior_thread ();
1964 if (selection
& USER_SELECTED_THREAD
)
1966 if (uiout
->is_mi_like_p ())
1968 uiout
->field_signed ("new-thread-id",
1969 inferior_thread ()->global_num
);
1973 uiout
->text ("[Switching to thread ");
1974 uiout
->field_string ("new-thread-id", print_thread_id (tp
));
1976 uiout
->text (target_pid_to_str (inferior_ptid
).c_str ());
1981 if (tp
->state
== THREAD_RUNNING
)
1983 if (selection
& USER_SELECTED_THREAD
)
1984 uiout
->text ("(running)\n");
1986 else if (selection
& USER_SELECTED_FRAME
)
1988 if (selection
& USER_SELECTED_THREAD
)
1991 if (has_stack_frames ())
1992 print_stack_frame_to_uiout (uiout
, get_selected_frame (NULL
),
1997 /* Update the 'threads_executing' global based on the threads we know
1998 about right now. This is used by infrun to tell whether we should
1999 pull events out of the current target. */
2002 update_threads_executing (void)
2004 process_stratum_target
*targ
= current_inferior ()->process_target ();
2009 targ
->threads_executing
= false;
2011 for (inferior
*inf
: all_non_exited_inferiors (targ
))
2013 if (!inf
->has_execution ())
2016 /* If the process has no threads, then it must be we have a
2017 process-exit event pending. */
2018 if (inf
->thread_list
== NULL
)
2020 targ
->threads_executing
= true;
2024 for (thread_info
*tp
: inf
->non_exited_threads ())
2028 targ
->threads_executing
= true;
2036 update_thread_list (void)
2038 target_update_thread_list ();
2039 update_threads_executing ();
2042 /* Return a new value for the selected thread's id. Return a value of
2043 0 if no thread is selected. If GLOBAL is true, return the thread's
2044 global number. Otherwise return the per-inferior number. */
2046 static struct value
*
2047 thread_num_make_value_helper (struct gdbarch
*gdbarch
, int global
)
2051 if (inferior_ptid
== null_ptid
)
2055 thread_info
*tp
= inferior_thread ();
2057 int_val
= tp
->global_num
;
2059 int_val
= tp
->per_inf_num
;
2062 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, int_val
);
2065 /* Return a new value for the selected thread's per-inferior thread
2066 number. Return a value of 0 if no thread is selected, or no
2069 static struct value
*
2070 thread_id_per_inf_num_make_value (struct gdbarch
*gdbarch
,
2071 struct internalvar
*var
,
2074 return thread_num_make_value_helper (gdbarch
, 0);
2077 /* Return a new value for the selected thread's global id. Return a
2078 value of 0 if no thread is selected, or no threads exist. */
2080 static struct value
*
2081 global_thread_id_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
2084 return thread_num_make_value_helper (gdbarch
, 1);
2087 /* Commands with a prefix of `thread'. */
2088 struct cmd_list_element
*thread_cmd_list
= NULL
;
2090 /* Implementation of `thread' variable. */
2092 static const struct internalvar_funcs thread_funcs
=
2094 thread_id_per_inf_num_make_value
,
2099 /* Implementation of `gthread' variable. */
2101 static const struct internalvar_funcs gthread_funcs
=
2103 global_thread_id_make_value
,
2108 void _initialize_thread ();
2110 _initialize_thread ()
2112 static struct cmd_list_element
*thread_apply_list
= NULL
;
2113 cmd_list_element
*c
;
2115 const auto info_threads_opts
= make_info_threads_options_def_group (nullptr);
2117 /* Note: keep this "ID" in sync with what "info threads [TAB]"
2119 static std::string info_threads_help
2120 = gdb::option::build_help (_("\
2121 Display currently known threads.\n\
2122 Usage: info threads [OPTION]... [ID]...\n\
2123 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2124 Otherwise, all threads are displayed.\n\
2130 c
= add_info ("threads", info_threads_command
, info_threads_help
.c_str ());
2131 set_cmd_completer_handle_brkchars (c
, info_threads_command_completer
);
2133 add_prefix_cmd ("thread", class_run
, thread_command
, _("\
2134 Use this command to switch between threads.\n\
2135 The new thread ID must be currently known."),
2136 &thread_cmd_list
, "thread ", 1, &cmdlist
);
2138 #define THREAD_APPLY_OPTION_HELP "\
2139 Prints per-inferior thread number and target system's thread id\n\
2140 followed by COMMAND output.\n\
2142 By default, an error raised during the execution of COMMAND\n\
2143 aborts \"thread apply\".\n\
2148 const auto thread_apply_opts
= make_thread_apply_options_def_group (nullptr);
2150 static std::string thread_apply_help
= gdb::option::build_help (_("\
2151 Apply a command to a list of threads.\n\
2152 Usage: thread apply ID... [OPTION]... COMMAND\n\
2153 ID is a space-separated list of IDs of threads to apply COMMAND on.\n"
2154 THREAD_APPLY_OPTION_HELP
),
2157 c
= add_prefix_cmd ("apply", class_run
, thread_apply_command
,
2158 thread_apply_help
.c_str (),
2159 &thread_apply_list
, "thread apply ", 1,
2161 set_cmd_completer_handle_brkchars (c
, thread_apply_command_completer
);
2163 const auto thread_apply_all_opts
2164 = make_thread_apply_all_options_def_group (nullptr, nullptr);
2166 static std::string thread_apply_all_help
= gdb::option::build_help (_("\
2167 Apply a command to all threads.\n\
2169 Usage: thread apply all [OPTION]... COMMAND\n"
2170 THREAD_APPLY_OPTION_HELP
),
2171 thread_apply_all_opts
);
2173 c
= add_cmd ("all", class_run
, thread_apply_all_command
,
2174 thread_apply_all_help
.c_str (),
2175 &thread_apply_list
);
2176 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2178 c
= add_com ("taas", class_run
, taas_command
, _("\
2179 Apply a command to all threads (ignoring errors and empty output).\n\
2180 Usage: taas [OPTION]... COMMAND\n\
2181 shortcut for 'thread apply all -s [OPTION]... COMMAND'\n\
2182 See \"help thread apply all\" for available options."));
2183 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2185 c
= add_com ("tfaas", class_run
, tfaas_command
, _("\
2186 Apply a command to all frames of all threads (ignoring errors and empty output).\n\
2187 Usage: tfaas [OPTION]... COMMAND\n\
2188 shortcut for 'thread apply all -s -- frame apply all -s [OPTION]... COMMAND'\n\
2189 See \"help frame apply all\" for available options."));
2190 set_cmd_completer_handle_brkchars (c
, frame_apply_all_cmd_completer
);
2192 add_cmd ("name", class_run
, thread_name_command
,
2193 _("Set the current thread's name.\n\
2194 Usage: thread name [NAME]\n\
2195 If NAME is not given, then any existing name is removed."), &thread_cmd_list
);
2197 add_cmd ("find", class_run
, thread_find_command
, _("\
2198 Find threads that match a regular expression.\n\
2199 Usage: thread find REGEXP\n\
2200 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2203 add_com_alias ("t", "thread", class_run
, 1);
2205 add_setshow_boolean_cmd ("thread-events", no_class
,
2206 &print_thread_events
, _("\
2207 Set printing of thread events (such as thread start and exit)."), _("\
2208 Show printing of thread events (such as thread start and exit)."), NULL
,
2210 show_print_thread_events
,
2211 &setprintlist
, &showprintlist
);
2213 create_internalvar_type_lazy ("_thread", &thread_funcs
, NULL
);
2214 create_internalvar_type_lazy ("_gthread", >hread_funcs
, NULL
);