1 /* Multi-process/thread control for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 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 /* RAII type used to increase / decrease the refcount of each thread
59 in a given list of threads. */
61 class scoped_inc_dec_ref
64 explicit scoped_inc_dec_ref (const std::vector
<thread_info
*> &thrds
)
67 for (thread_info
*thr
: m_thrds
)
71 ~scoped_inc_dec_ref ()
73 for (thread_info
*thr
: m_thrds
)
78 const std::vector
<thread_info
*> &m_thrds
;
83 inferior_thread (void)
85 struct thread_info
*tp
= find_thread_ptid (current_inferior (), inferior_ptid
);
90 /* Delete the breakpoint pointed at by BP_P, if there's one. */
93 delete_thread_breakpoint (struct breakpoint
**bp_p
)
97 delete_breakpoint (*bp_p
);
103 delete_step_resume_breakpoint (struct thread_info
*tp
)
106 delete_thread_breakpoint (&tp
->control
.step_resume_breakpoint
);
110 delete_exception_resume_breakpoint (struct thread_info
*tp
)
113 delete_thread_breakpoint (&tp
->control
.exception_resume_breakpoint
);
116 /* See gdbthread.h. */
119 delete_single_step_breakpoints (struct thread_info
*tp
)
122 delete_thread_breakpoint (&tp
->control
.single_step_breakpoints
);
125 /* Delete the breakpoint pointed at by BP_P at the next stop, if
129 delete_at_next_stop (struct breakpoint
**bp
)
133 (*bp
)->disposition
= disp_del_at_next_stop
;
138 /* See gdbthread.h. */
141 thread_has_single_step_breakpoints_set (struct thread_info
*tp
)
143 return tp
->control
.single_step_breakpoints
!= NULL
;
146 /* See gdbthread.h. */
149 thread_has_single_step_breakpoint_here (struct thread_info
*tp
,
150 const address_space
*aspace
,
153 struct breakpoint
*ss_bps
= tp
->control
.single_step_breakpoints
;
155 return (ss_bps
!= NULL
156 && breakpoint_has_location_inserted_here (ss_bps
, aspace
, addr
));
159 /* See gdbthread.h. */
162 thread_cancel_execution_command (struct thread_info
*thr
)
164 if (thr
->thread_fsm
!= NULL
)
166 thr
->thread_fsm
->clean_up (thr
);
167 delete thr
->thread_fsm
;
168 thr
->thread_fsm
= NULL
;
173 clear_thread_inferior_resources (struct thread_info
*tp
)
175 /* NOTE: this will take care of any left-over step_resume breakpoints,
176 but not any user-specified thread-specific breakpoints. We can not
177 delete the breakpoint straight-off, because the inferior might not
178 be stopped at the moment. */
179 delete_at_next_stop (&tp
->control
.step_resume_breakpoint
);
180 delete_at_next_stop (&tp
->control
.exception_resume_breakpoint
);
181 delete_at_next_stop (&tp
->control
.single_step_breakpoints
);
183 delete_longjmp_breakpoint_at_next_stop (tp
->global_num
);
185 bpstat_clear (&tp
->control
.stop_bpstat
);
187 btrace_teardown (tp
);
189 thread_cancel_execution_command (tp
);
191 clear_inline_frame_state (tp
);
194 /* Set the TP's state as exited. */
197 set_thread_exited (thread_info
*tp
, int silent
)
199 /* Dead threads don't need to step-over. Remove from queue. */
200 if (tp
->step_over_next
!= NULL
)
201 global_thread_step_over_chain_remove (tp
);
203 if (tp
->state
!= THREAD_EXITED
)
205 gdb::observers::thread_exit
.notify (tp
, silent
);
207 /* Tag it as exited. */
208 tp
->state
= THREAD_EXITED
;
210 /* Clear breakpoints, etc. associated with this thread. */
211 clear_thread_inferior_resources (tp
);
216 init_thread_list (void)
218 highest_thread_num
= 0;
220 for (thread_info
*tp
: all_threads_safe ())
222 inferior
*inf
= tp
->inf
;
224 if (tp
->deletable ())
227 set_thread_exited (tp
, 1);
229 inf
->thread_list
= NULL
;
233 /* Allocate a new thread of inferior INF with target id PTID and add
234 it to the thread list. */
236 static struct thread_info
*
237 new_thread (struct inferior
*inf
, ptid_t ptid
)
239 thread_info
*tp
= new thread_info (inf
, ptid
);
241 if (inf
->thread_list
== NULL
)
242 inf
->thread_list
= tp
;
245 struct thread_info
*last
;
247 for (last
= inf
->thread_list
; last
->next
!= NULL
; last
= last
->next
)
256 add_thread_silent (process_stratum_target
*targ
, ptid_t ptid
)
260 thread_info
*tp
= find_thread_ptid (targ
, ptid
);
262 /* Found an old thread with the same id. It has to be dead,
263 otherwise we wouldn't be adding a new thread with the same id.
264 The OS is reusing this id --- delete it, and recreate a new
267 /* In addition to deleting the thread, if this is the current
268 thread, then we need to take care that delete_thread doesn't
269 really delete the thread if it is inferior_ptid. Create a
270 new template thread in the list with an invalid ptid, switch
271 to it, delete the original thread, reset the new thread's
272 ptid, and switch to it. */
274 if (inferior_ptid
== ptid
)
276 thread_info
*new_thr
= new_thread (tp
->inf
, null_ptid
);
278 /* Make switch_to_thread not read from the thread. */
279 new_thr
->state
= THREAD_EXITED
;
280 switch_to_no_thread ();
282 /* Now we can delete it. */
285 /* Now reset its ptid, and reswitch inferior_ptid to it. */
286 new_thr
->ptid
= ptid
;
287 new_thr
->state
= THREAD_STOPPED
;
288 switch_to_thread (new_thr
);
290 gdb::observers::new_thread
.notify (new_thr
);
298 /* Just go ahead and delete it. */
302 inf
= find_inferior_ptid (targ
, ptid
);
304 tp
= new_thread (inf
, ptid
);
305 gdb::observers::new_thread
.notify (tp
);
311 add_thread_with_info (process_stratum_target
*targ
, ptid_t ptid
,
312 private_thread_info
*priv
)
314 thread_info
*result
= add_thread_silent (targ
, ptid
);
316 result
->priv
.reset (priv
);
318 if (print_thread_events
)
319 printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid
).c_str ());
321 annotate_new_thread ();
326 add_thread (process_stratum_target
*targ
, ptid_t ptid
)
328 return add_thread_with_info (targ
, ptid
, NULL
);
331 private_thread_info::~private_thread_info () = default;
333 thread_info::thread_info (struct inferior
*inf_
, ptid_t ptid_
)
334 : ptid (ptid_
), inf (inf_
)
336 gdb_assert (inf_
!= NULL
);
338 this->global_num
= ++highest_thread_num
;
339 this->per_inf_num
= ++inf_
->highest_thread_num
;
341 /* Nothing to follow yet. */
342 memset (&this->pending_follow
, 0, sizeof (this->pending_follow
));
343 this->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
344 this->suspend
.waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
347 thread_info::~thread_info ()
352 /* Returns true if THR is the current thread. */
355 is_current_thread (const thread_info
*thr
)
357 return thr
->inf
== current_inferior () && thr
->ptid
== inferior_ptid
;
360 /* See gdbthread.h. */
363 thread_info::deletable () const
365 /* If this is the current thread, or there's code out there that
366 relies on it existing (refcount > 0) we can't delete yet. */
367 return refcount () == 0 && !is_current_thread (this);
370 /* See gdbthread.h. */
372 thread_info::regcache ()
374 return get_thread_regcache (this);
377 /* See gdbthread.h. */
381 return this->regcache ()-> arch ();
384 /* Add TP to the end of the step-over chain LIST_P. */
387 step_over_chain_enqueue (struct thread_info
**list_p
, struct thread_info
*tp
)
389 gdb_assert (tp
->step_over_next
== NULL
);
390 gdb_assert (tp
->step_over_prev
== NULL
);
395 tp
->step_over_prev
= tp
->step_over_next
= tp
;
399 struct thread_info
*head
= *list_p
;
400 struct thread_info
*tail
= head
->step_over_prev
;
402 tp
->step_over_prev
= tail
;
403 tp
->step_over_next
= head
;
404 head
->step_over_prev
= tp
;
405 tail
->step_over_next
= tp
;
409 /* See gdbthread.h. */
412 thread_step_over_chain_remove (thread_info
**list_p
, thread_info
*tp
)
414 gdb_assert (tp
->step_over_next
!= NULL
);
415 gdb_assert (tp
->step_over_prev
!= NULL
);
419 if (tp
== tp
->step_over_next
)
422 *list_p
= tp
->step_over_next
;
425 tp
->step_over_prev
->step_over_next
= tp
->step_over_next
;
426 tp
->step_over_next
->step_over_prev
= tp
->step_over_prev
;
427 tp
->step_over_prev
= tp
->step_over_next
= NULL
;
430 /* See gdbthread.h. */
433 global_thread_step_over_chain_remove (thread_info
*tp
)
435 thread_step_over_chain_remove (&global_thread_step_over_chain_head
, tp
);
438 /* See gdbthread.h. */
441 thread_step_over_chain_next (thread_info
*chain_head
, thread_info
*tp
)
443 thread_info
*next
= tp
->step_over_next
;
445 return next
== chain_head
? NULL
: next
;
448 /* See gdbthread.h. */
451 global_thread_step_over_chain_next (thread_info
*tp
)
453 return thread_step_over_chain_next (global_thread_step_over_chain_head
, tp
);
456 /* See gdbthread.h. */
459 thread_is_in_step_over_chain (struct thread_info
*tp
)
461 return (tp
->step_over_next
!= NULL
);
464 /* See gdbthread.h. */
466 int thread_step_over_chain_length (thread_info
*tp
)
472 thread_info
*iter
= tp
->step_over_next
;
477 iter
= iter
->step_over_next
;
485 /* See gdbthread.h. */
488 global_thread_step_over_chain_enqueue (struct thread_info
*tp
)
491 fprintf_unfiltered (gdb_stdlog
, "enqueueing thread %ld in global step over chain\n", tp
->ptid
.lwp());
492 step_over_chain_enqueue (&global_thread_step_over_chain_head
, tp
);
495 /* Delete the thread referenced by THR. If SILENT, don't notify
496 the observer of this exit.
498 THR must not be NULL or a failed assertion will be raised. */
501 delete_thread_1 (thread_info
*thr
, bool silent
)
503 gdb_assert (thr
!= nullptr);
505 struct thread_info
*tp
, *tpprev
= NULL
;
507 for (tp
= thr
->inf
->thread_list
; tp
; tpprev
= tp
, tp
= tp
->next
)
514 set_thread_exited (tp
, silent
);
516 if (!tp
->deletable ())
518 /* Will be really deleted some other time. */
523 tpprev
->next
= tp
->next
;
525 tp
->inf
->thread_list
= tp
->next
;
530 /* Delete thread THREAD and notify of thread exit. If this is the
531 current thread, don't actually delete it, but tag it as exited and
532 do the notification. If this is the user selected thread, clear
536 delete_thread (thread_info
*thread
)
538 delete_thread_1 (thread
, false /* not silent */);
542 delete_thread_silent (thread_info
*thread
)
544 delete_thread_1 (thread
, true /* silent */);
548 find_thread_global_id (int global_id
)
550 for (thread_info
*tp
: all_threads ())
551 if (tp
->global_num
== global_id
)
557 static struct thread_info
*
558 find_thread_id (struct inferior
*inf
, int thr_num
)
560 for (thread_info
*tp
: inf
->threads ())
561 if (tp
->per_inf_num
== thr_num
)
567 /* See gdbthread.h. */
570 find_thread_ptid (process_stratum_target
*targ
, ptid_t ptid
)
572 inferior
*inf
= find_inferior_ptid (targ
, ptid
);
575 return find_thread_ptid (inf
, ptid
);
578 /* See gdbthread.h. */
581 find_thread_ptid (inferior
*inf
, ptid_t ptid
)
583 for (thread_info
*tp
: inf
->threads ())
584 if (tp
->ptid
== ptid
)
590 /* See gdbthread.h. */
593 find_thread_by_handle (gdb::array_view
<const gdb_byte
> handle
,
594 struct inferior
*inf
)
596 return target_thread_handle_to_thread_info (handle
.data (),
602 * Thread iterator function.
604 * Calls a callback function once for each thread, so long as
605 * the callback function returns false. If the callback function
606 * returns true, the iteration will end and the current thread
607 * will be returned. This can be useful for implementing a
608 * search for a thread with arbitrary attributes, or for applying
609 * some operation to every thread.
611 * FIXME: some of the existing functionality, such as
612 * "Thread apply all", might be rewritten using this functionality.
616 iterate_over_threads (int (*callback
) (struct thread_info
*, void *),
619 for (thread_info
*tp
: all_threads_safe ())
620 if ((*callback
) (tp
, data
))
626 /* See gdbthread.h. */
631 for (thread_info
*tp ATTRIBUTE_UNUSED
: all_threads ())
637 thread_count (process_stratum_target
*proc_target
)
639 auto rng
= all_threads (proc_target
);
640 return std::distance (rng
.begin (), rng
.end ());
643 /* Return the number of non-exited threads in the thread list. */
646 live_threads_count (void)
648 auto rng
= all_non_exited_threads ();
649 return std::distance (rng
.begin (), rng
.end ());
653 valid_global_thread_id (int global_id
)
655 for (thread_info
*tp
: all_threads ())
656 if (tp
->global_num
== global_id
)
663 in_thread_list (process_stratum_target
*targ
, ptid_t ptid
)
665 return find_thread_ptid (targ
, ptid
) != nullptr;
668 /* Finds the first thread of the inferior. */
671 first_thread_of_inferior (inferior
*inf
)
673 return inf
->thread_list
;
677 any_thread_of_inferior (inferior
*inf
)
679 gdb_assert (inf
->pid
!= 0);
681 /* Prefer the current thread. */
682 if (inf
== current_inferior ())
683 return inferior_thread ();
685 for (thread_info
*tp
: inf
->non_exited_threads ())
692 any_live_thread_of_inferior (inferior
*inf
)
694 struct thread_info
*curr_tp
= NULL
;
695 struct thread_info
*tp_executing
= NULL
;
697 gdb_assert (inf
!= NULL
&& inf
->pid
!= 0);
699 /* Prefer the current thread if it's not executing. */
700 if (inferior_ptid
!= null_ptid
&& current_inferior () == inf
)
702 /* If the current thread is dead, forget it. If it's not
703 executing, use it. Otherwise, still choose it (below), but
704 only if no other non-executing thread is found. */
705 curr_tp
= inferior_thread ();
706 if (curr_tp
->state
== THREAD_EXITED
)
708 else if (!curr_tp
->executing
)
712 for (thread_info
*tp
: inf
->non_exited_threads ())
720 /* If both the current thread and all live threads are executing,
721 prefer the current thread. */
725 /* Otherwise, just return an executing thread, if any. */
729 /* Return true if TP is an active thread. */
731 thread_alive (thread_info
*tp
)
733 if (tp
->state
== THREAD_EXITED
)
736 /* Ensure we're looking at the right target stack. */
737 gdb_assert (tp
->inf
== current_inferior ());
739 return target_thread_alive (tp
->ptid
);
742 /* Switch to thread TP if it is alive. Returns true if successfully
743 switched, false otherwise. */
746 switch_to_thread_if_alive (thread_info
*thr
)
748 scoped_restore_current_thread restore_thread
;
750 /* Switch inferior first, so that we're looking at the right target
752 switch_to_inferior_no_thread (thr
->inf
);
754 if (thread_alive (thr
))
756 switch_to_thread (thr
);
757 restore_thread
.dont_restore ();
764 /* See gdbthreads.h. */
769 scoped_restore_current_thread restore_thread
;
771 for (thread_info
*tp
: all_threads_safe ())
773 switch_to_inferior_no_thread (tp
->inf
);
775 if (!thread_alive (tp
))
780 /* See gdbthreads.h. */
783 delete_exited_threads (void)
785 for (thread_info
*tp
: all_threads_safe ())
786 if (tp
->state
== THREAD_EXITED
)
790 /* Return true value if stack temporaries are enabled for the thread
794 thread_stack_temporaries_enabled_p (thread_info
*tp
)
799 return tp
->stack_temporaries_enabled
;
802 /* Push V on to the stack temporaries of the thread with id PTID. */
805 push_thread_stack_temporary (thread_info
*tp
, struct value
*v
)
807 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
808 tp
->stack_temporaries
.push_back (v
);
811 /* Return true if VAL is among the stack temporaries of the thread
812 TP. Return false otherwise. */
815 value_in_thread_stack_temporaries (struct value
*val
, thread_info
*tp
)
817 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
818 for (value
*v
: tp
->stack_temporaries
)
825 /* Return the last of the stack temporaries for thread with id PTID.
826 Return NULL if there are no stack temporaries for the thread. */
829 get_last_thread_stack_temporary (thread_info
*tp
)
831 struct value
*lastval
= NULL
;
833 gdb_assert (tp
!= NULL
);
834 if (!tp
->stack_temporaries
.empty ())
835 lastval
= tp
->stack_temporaries
.back ();
841 thread_change_ptid (process_stratum_target
*targ
,
842 ptid_t old_ptid
, ptid_t new_ptid
)
844 struct inferior
*inf
;
845 struct thread_info
*tp
;
847 /* It can happen that what we knew as the target inferior id
848 changes. E.g, target remote may only discover the remote process
849 pid after adding the inferior to GDB's list. */
850 inf
= find_inferior_ptid (targ
, old_ptid
);
851 inf
->pid
= new_ptid
.pid ();
853 tp
= find_thread_ptid (inf
, old_ptid
);
856 gdb::observers::thread_ptid_changed
.notify (old_ptid
, new_ptid
);
859 /* See gdbthread.h. */
862 set_resumed (process_stratum_target
*targ
, ptid_t ptid
, bool resumed
)
864 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
865 tp
->resumed
= resumed
;
868 /* Helper for set_running, that marks one thread either running or
872 set_running_thread (struct thread_info
*tp
, bool running
)
874 bool started
= false;
876 if (running
&& tp
->state
== THREAD_STOPPED
)
878 tp
->state
= running
? THREAD_RUNNING
: THREAD_STOPPED
;
882 /* If the thread is now marked stopped, remove it from
883 the step-over queue, so that we don't try to resume
884 it until the user wants it to. */
885 if (tp
->step_over_next
!= NULL
)
886 global_thread_step_over_chain_remove (tp
);
892 /* See gdbthread.h. */
895 thread_info::set_running (bool running
)
897 if (set_running_thread (this, running
))
898 gdb::observers::target_resumed
.notify (this->ptid
);
902 set_running (process_stratum_target
*targ
, ptid_t ptid
, bool running
)
904 /* We try not to notify the observer if no thread has actually
905 changed the running state -- merely to reduce the number of
906 messages to the MI frontend. A frontend is supposed to handle
907 multiple *running notifications just fine. */
908 bool any_started
= false;
910 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
911 if (set_running_thread (tp
, running
))
915 gdb::observers::target_resumed
.notify (ptid
);
919 /* Helper for set_executing. Set's the thread's 'executing' field
920 from EXECUTING, and if EXECUTING is true also clears the thread's
924 set_executing_thread (thread_info
*thr
, bool executing
)
926 thr
->executing
= executing
;
928 thr
->suspend
.stop_pc
= ~(CORE_ADDR
) 0;
932 set_executing (process_stratum_target
*targ
, ptid_t ptid
, bool executing
)
934 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
935 set_executing_thread (tp
, executing
);
937 /* It only takes one running thread to spawn more threads. */
939 targ
->threads_executing
= true;
940 /* Only clear the flag if the caller is telling us everything is
942 else if (minus_one_ptid
== ptid
)
943 targ
->threads_executing
= false;
946 /* See gdbthread.h. */
949 threads_are_executing (process_stratum_target
*target
)
951 return target
->threads_executing
;
955 set_stop_requested (process_stratum_target
*targ
, ptid_t ptid
, bool stop
)
957 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
958 tp
->stop_requested
= stop
;
960 /* Call the stop requested observer so other components of GDB can
961 react to this request. */
963 gdb::observers::thread_stop_requested
.notify (ptid
);
967 finish_thread_state (process_stratum_target
*targ
, ptid_t ptid
)
969 bool any_started
= false;
971 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
972 if (set_running_thread (tp
, tp
->executing
))
976 gdb::observers::target_resumed
.notify (ptid
);
979 /* See gdbthread.h. */
982 validate_registers_access (void)
984 /* No selected thread, no registers. */
985 if (inferior_ptid
== null_ptid
)
986 error (_("No thread selected."));
988 thread_info
*tp
= inferior_thread ();
990 /* Don't try to read from a dead thread. */
991 if (tp
->state
== THREAD_EXITED
)
992 error (_("The current thread has terminated"));
994 /* ... or from a spinning thread. FIXME: This isn't actually fully
995 correct. It'll allow an user-requested access (e.g., "print $pc"
996 at the prompt) when a thread is not executing for some internal
997 reason, but is marked running from the user's perspective. E.g.,
998 the thread is waiting for its turn in the step-over queue. */
1000 error (_("Selected thread is running."));
1003 /* See gdbthread.h. */
1006 can_access_registers_thread (thread_info
*thread
)
1008 /* No thread, no registers. */
1012 /* Don't try to read from a dead thread. */
1013 if (thread
->state
== THREAD_EXITED
)
1016 /* ... or from a spinning thread. FIXME: see validate_registers_access. */
1017 if (thread
->executing
)
1024 pc_in_thread_step_range (CORE_ADDR pc
, struct thread_info
*thread
)
1026 return (pc
>= thread
->control
.step_range_start
1027 && pc
< thread
->control
.step_range_end
);
1030 /* Helper for print_thread_info. Returns true if THR should be
1031 printed. If REQUESTED_THREADS, a list of GDB ids/ranges, is not
1032 NULL, only print THR if its ID is included in the list. GLOBAL_IDS
1033 is true if REQUESTED_THREADS is list of global IDs, false if a list
1034 of per-inferior thread ids. If PID is not -1, only print THR if it
1035 is a thread from the process PID. Otherwise, threads from all
1036 attached PIDs are printed. If both REQUESTED_THREADS is not NULL
1037 and PID is not -1, then the thread is printed if it belongs to the
1038 specified process. Otherwise, an error is raised. */
1041 should_print_thread (const char *requested_threads
, int default_inf_num
,
1042 int global_ids
, int pid
, struct thread_info
*thr
)
1044 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1049 in_list
= number_is_in_list (requested_threads
, thr
->global_num
);
1051 in_list
= tid_is_in_list (requested_threads
, default_inf_num
,
1052 thr
->inf
->num
, thr
->per_inf_num
);
1057 if (pid
!= -1 && thr
->ptid
.pid () != pid
)
1059 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1060 error (_("Requested thread not found in requested process"));
1064 if (thr
->state
== THREAD_EXITED
)
1070 /* Return the string to display in "info threads"'s "Target Id"
1074 thread_target_id_str (thread_info
*tp
)
1076 std::string target_id
= target_pid_to_str (tp
->ptid
);
1077 const char *extra_info
= target_extra_thread_info (tp
);
1078 const char *name
= tp
->name
!= nullptr ? tp
->name
: target_thread_name (tp
);
1080 if (extra_info
!= nullptr && name
!= nullptr)
1081 return string_printf ("%s \"%s\" (%s)", target_id
.c_str (), name
,
1083 else if (extra_info
!= nullptr)
1084 return string_printf ("%s (%s)", target_id
.c_str (), extra_info
);
1085 else if (name
!= nullptr)
1086 return string_printf ("%s \"%s\"", target_id
.c_str (), name
);
1091 /* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1092 whether REQUESTED_THREADS is a list of global or per-inferior
1096 print_thread_info_1 (struct ui_out
*uiout
, const char *requested_threads
,
1097 int global_ids
, int pid
,
1098 int show_global_ids
)
1100 int default_inf_num
= current_inferior ()->num
;
1102 update_thread_list ();
1104 /* Whether we saw any thread. */
1105 bool any_thread
= false;
1106 /* Whether the current thread is exited. */
1107 bool current_exited
= false;
1109 thread_info
*current_thread
= (inferior_ptid
!= null_ptid
1110 ? inferior_thread () : NULL
);
1113 /* For backward compatibility, we make a list for MI. A table is
1114 preferable for the CLI, though, because it shows table
1116 gdb::optional
<ui_out_emit_list
> list_emitter
;
1117 gdb::optional
<ui_out_emit_table
> table_emitter
;
1119 /* We'll be switching threads temporarily below. */
1120 scoped_restore_current_thread restore_thread
;
1122 if (uiout
->is_mi_like_p ())
1123 list_emitter
.emplace (uiout
, "threads");
1127 /* The width of the "Target Id" column. Grown below to
1128 accommodate the largest entry. */
1129 size_t target_id_col_width
= 17;
1131 for (thread_info
*tp
: all_threads ())
1133 if (!should_print_thread (requested_threads
, default_inf_num
,
1134 global_ids
, pid
, tp
))
1137 if (!uiout
->is_mi_like_p ())
1139 /* Switch inferiors so we're looking at the right
1141 switch_to_inferior_no_thread (tp
->inf
);
1144 = std::max (target_id_col_width
,
1145 thread_target_id_str (tp
).size ());
1153 if (requested_threads
== NULL
|| *requested_threads
== '\0')
1154 uiout
->message (_("No threads.\n"));
1156 uiout
->message (_("No threads match '%s'.\n"),
1161 table_emitter
.emplace (uiout
, show_global_ids
? 5 : 4,
1162 n_threads
, "threads");
1164 uiout
->table_header (1, ui_left
, "current", "");
1165 uiout
->table_header (4, ui_left
, "id-in-tg", "Id");
1166 if (show_global_ids
)
1167 uiout
->table_header (4, ui_left
, "id", "GId");
1168 uiout
->table_header (target_id_col_width
, ui_left
,
1169 "target-id", "Target Id");
1170 uiout
->table_header (1, ui_left
, "frame", "Frame");
1171 uiout
->table_body ();
1174 for (inferior
*inf
: all_inferiors ())
1175 for (thread_info
*tp
: inf
->threads ())
1180 if (tp
== current_thread
&& tp
->state
== THREAD_EXITED
)
1181 current_exited
= true;
1183 if (!should_print_thread (requested_threads
, default_inf_num
,
1184 global_ids
, pid
, tp
))
1187 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1189 if (!uiout
->is_mi_like_p ())
1191 if (tp
== current_thread
)
1192 uiout
->field_string ("current", "*");
1194 uiout
->field_skip ("current");
1196 uiout
->field_string ("id-in-tg", print_thread_id (tp
));
1199 if (show_global_ids
|| uiout
->is_mi_like_p ())
1200 uiout
->field_signed ("id", tp
->global_num
);
1202 /* Switch to the thread (and inferior / target). */
1203 switch_to_thread (tp
);
1205 /* For the CLI, we stuff everything into the target-id field.
1206 This is a gross hack to make the output come out looking
1207 correct. The underlying problem here is that ui-out has no
1208 way to specify that a field's space allocation should be
1209 shared by several fields. For MI, we do the right thing
1212 if (uiout
->is_mi_like_p ())
1214 uiout
->field_string ("target-id", target_pid_to_str (tp
->ptid
));
1216 const char *extra_info
= target_extra_thread_info (tp
);
1217 if (extra_info
!= nullptr)
1218 uiout
->field_string ("details", extra_info
);
1220 const char *name
= (tp
->name
!= nullptr
1222 : target_thread_name (tp
));
1224 uiout
->field_string ("name", name
);
1228 uiout
->field_string ("target-id",
1229 thread_target_id_str (tp
).c_str ());
1232 if (tp
->state
== THREAD_RUNNING
)
1233 uiout
->text ("(running)\n");
1236 /* The switch above put us at the top of the stack (leaf
1238 print_stack_frame (get_selected_frame (NULL
),
1239 /* For MI output, print frame level. */
1240 uiout
->is_mi_like_p (),
1244 if (uiout
->is_mi_like_p ())
1246 const char *state
= "stopped";
1248 if (tp
->state
== THREAD_RUNNING
)
1250 uiout
->field_string ("state", state
);
1253 core
= target_core_of_thread (tp
->ptid
);
1254 if (uiout
->is_mi_like_p () && core
!= -1)
1255 uiout
->field_signed ("core", core
);
1258 /* This end scope restores the current thread and the frame
1259 selected before the "info threads" command, and it finishes the
1260 ui-out list or table. */
1263 if (pid
== -1 && requested_threads
== NULL
)
1265 if (uiout
->is_mi_like_p () && inferior_ptid
!= null_ptid
)
1266 uiout
->field_signed ("current-thread-id", current_thread
->global_num
);
1268 if (inferior_ptid
!= null_ptid
&& current_exited
)
1269 uiout
->message ("\n\
1270 The current thread <Thread ID %s> has terminated. See `help thread'.\n",
1271 print_thread_id (inferior_thread ()));
1272 else if (any_thread
&& inferior_ptid
== null_ptid
)
1273 uiout
->message ("\n\
1274 No selected thread. See `help thread'.\n");
1278 /* See gdbthread.h. */
1281 print_thread_info (struct ui_out
*uiout
, const char *requested_threads
,
1284 print_thread_info_1 (uiout
, requested_threads
, 1, pid
, 0);
1287 /* The options for the "info threads" command. */
1289 struct info_threads_opts
1292 bool show_global_ids
= false;
1295 static const gdb::option::option_def info_threads_option_defs
[] = {
1297 gdb::option::flag_option_def
<info_threads_opts
> {
1299 [] (info_threads_opts
*opts
) { return &opts
->show_global_ids
; },
1300 N_("Show global thread IDs."),
1305 /* Create an option_def_group for the "info threads" options, with
1306 IT_OPTS as context. */
1308 static inline gdb::option::option_def_group
1309 make_info_threads_options_def_group (info_threads_opts
*it_opts
)
1311 return {{info_threads_option_defs
}, it_opts
};
1314 /* Implementation of the "info threads" command.
1316 Note: this has the drawback that it _really_ switches
1317 threads, which frees the frame cache. A no-side
1318 effects info-threads command would be nicer. */
1321 info_threads_command (const char *arg
, int from_tty
)
1323 info_threads_opts it_opts
;
1325 auto grp
= make_info_threads_options_def_group (&it_opts
);
1326 gdb::option::process_options
1327 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
);
1329 print_thread_info_1 (current_uiout
, arg
, 0, -1, it_opts
.show_global_ids
);
1332 /* Completer for the "info threads" command. */
1335 info_threads_command_completer (struct cmd_list_element
*ignore
,
1336 completion_tracker
&tracker
,
1337 const char *text
, const char *word_ignored
)
1339 const auto grp
= make_info_threads_options_def_group (nullptr);
1341 if (gdb::option::complete_options
1342 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, grp
))
1345 /* Convenience to let the user know what the option can accept. */
1348 gdb::option::complete_on_all_options (tracker
, grp
);
1349 /* Keep this "ID" in sync with what "help info threads"
1351 tracker
.add_completion (make_unique_xstrdup ("ID"));
1355 /* See gdbthread.h. */
1358 switch_to_thread_no_regs (struct thread_info
*thread
)
1360 struct inferior
*inf
= thread
->inf
;
1362 set_current_program_space (inf
->pspace
);
1363 set_current_inferior (inf
);
1365 inferior_ptid
= thread
->ptid
;
1368 /* See gdbthread.h. */
1371 switch_to_no_thread ()
1373 if (inferior_ptid
== null_ptid
)
1376 inferior_ptid
= null_ptid
;
1377 reinit_frame_cache ();
1380 /* See gdbthread.h. */
1383 switch_to_thread (thread_info
*thr
)
1385 gdb_assert (thr
!= NULL
);
1387 if (is_current_thread (thr
))
1390 switch_to_thread_no_regs (thr
);
1392 reinit_frame_cache ();
1395 /* See gdbsupport/common-gdbthread.h. */
1398 switch_to_thread (process_stratum_target
*proc_target
, ptid_t ptid
)
1400 thread_info
*thr
= find_thread_ptid (proc_target
, ptid
);
1401 switch_to_thread (thr
);
1405 restore_selected_frame (struct frame_id a_frame_id
, int frame_level
)
1407 struct frame_info
*frame
= NULL
;
1410 /* This means there was no selected frame. */
1411 if (frame_level
== -1)
1413 select_frame (NULL
);
1417 gdb_assert (frame_level
>= 0);
1419 /* Restore by level first, check if the frame id is the same as
1420 expected. If that fails, try restoring by frame id. If that
1421 fails, nothing to do, just warn the user. */
1423 count
= frame_level
;
1424 frame
= find_relative_frame (get_current_frame (), &count
);
1427 /* The frame ids must match - either both valid or both outer_frame_id.
1428 The latter case is not failsafe, but since it's highly unlikely
1429 the search by level finds the wrong frame, it's 99.9(9)% of
1430 the time (for all practical purposes) safe. */
1431 && frame_id_eq (get_frame_id (frame
), a_frame_id
))
1433 /* Cool, all is fine. */
1434 select_frame (frame
);
1438 frame
= frame_find_by_id (a_frame_id
);
1441 /* Cool, refound it. */
1442 select_frame (frame
);
1446 /* Nothing else to do, the frame layout really changed. Select the
1447 innermost stack frame. */
1448 select_frame (get_current_frame ());
1450 /* Warn the user. */
1451 if (frame_level
> 0 && !current_uiout
->is_mi_like_p ())
1453 warning (_("Couldn't restore frame #%d in "
1454 "current thread. Bottom (innermost) frame selected:"),
1456 /* For MI, we should probably have a notification about
1457 current frame change. But this error is not very
1458 likely, so don't bother for now. */
1459 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1464 scoped_restore_current_thread::restore ()
1466 /* If an entry of thread_info was previously selected, it won't be
1467 deleted because we've increased its refcount. The thread represented
1468 by this thread_info entry may have already exited (due to normal exit,
1469 detach, etc), so the thread_info.state is THREAD_EXITED. */
1470 if (m_thread
!= NULL
1471 /* If the previously selected thread belonged to a process that has
1472 in the mean time exited (or killed, detached, etc.), then don't revert
1473 back to it, but instead simply drop back to no thread selected. */
1475 switch_to_thread (m_thread
);
1477 switch_to_inferior_no_thread (m_inf
);
1479 /* The running state of the originally selected thread may have
1480 changed, so we have to recheck it here. */
1481 if (inferior_ptid
!= null_ptid
1483 && m_thread
->state
== THREAD_STOPPED
1484 && target_has_registers
1486 && target_has_memory
)
1487 restore_selected_frame (m_selected_frame_id
, m_selected_frame_level
);
1490 scoped_restore_current_thread::~scoped_restore_current_thread ()
1492 if (!m_dont_restore
)
1498 catch (const gdb_exception
&ex
)
1500 /* We're in a dtor, there's really nothing else we can do
1501 but swallow the exception. */
1505 if (m_thread
!= NULL
)
1506 m_thread
->decref ();
1510 scoped_restore_current_thread::scoped_restore_current_thread ()
1513 m_inf
= current_inferior ();
1515 if (inferior_ptid
!= null_ptid
)
1517 thread_info
*tp
= inferior_thread ();
1518 struct frame_info
*frame
;
1520 m_was_stopped
= tp
->state
== THREAD_STOPPED
;
1522 && target_has_registers
1524 && target_has_memory
)
1526 /* When processing internal events, there might not be a
1527 selected frame. If we naively call get_selected_frame
1528 here, then we can end up reading debuginfo for the
1529 current frame, but we don't generally need the debuginfo
1531 frame
= get_selected_frame_if_set ();
1538 m_selected_frame_id
= get_frame_id (frame
);
1539 m_selected_frame_level
= frame_relative_level (frame
);
1541 catch (const gdb_exception_error
&ex
)
1543 m_selected_frame_id
= null_frame_id
;
1544 m_selected_frame_level
= -1;
1554 /* See gdbthread.h. */
1557 show_thread_that_caused_stop (void)
1559 return highest_thread_num
> 1;
1562 /* See gdbthread.h. */
1565 show_inferior_qualified_tids (void)
1567 return (inferior_list
->next
!= NULL
|| inferior_list
->num
!= 1);
1570 /* See gdbthread.h. */
1573 print_thread_id (struct thread_info
*thr
)
1575 char *s
= get_print_cell ();
1577 if (show_inferior_qualified_tids ())
1578 xsnprintf (s
, PRINT_CELL_SIZE
, "%d.%d", thr
->inf
->num
, thr
->per_inf_num
);
1580 xsnprintf (s
, PRINT_CELL_SIZE
, "%d", thr
->per_inf_num
);
1584 /* Sort an array of struct thread_info pointers by thread ID (first by
1585 inferior number, and then by per-inferior thread number). Sorts in
1589 tp_array_compar_ascending (const thread_info
*a
, const thread_info
*b
)
1591 if (a
->inf
->num
!= b
->inf
->num
)
1592 return a
->inf
->num
< b
->inf
->num
;
1594 return (a
->per_inf_num
< b
->per_inf_num
);
1597 /* Sort an array of struct thread_info pointers by thread ID (first by
1598 inferior number, and then by per-inferior thread number). Sorts in
1599 descending order. */
1602 tp_array_compar_descending (const thread_info
*a
, const thread_info
*b
)
1604 if (a
->inf
->num
!= b
->inf
->num
)
1605 return a
->inf
->num
> b
->inf
->num
;
1607 return (a
->per_inf_num
> b
->per_inf_num
);
1610 /* Switch to thread THR and execute CMD.
1611 FLAGS.QUIET controls the printing of the thread information.
1612 FLAGS.CONT and FLAGS.SILENT control how to handle errors. */
1615 thr_try_catch_cmd (thread_info
*thr
, const char *cmd
, int from_tty
,
1616 const qcs_flags
&flags
)
1618 switch_to_thread (thr
);
1620 /* The thread header is computed before running the command since
1621 the command can change the inferior, which is not permitted
1622 by thread_target_id_str. */
1623 std::string thr_header
=
1624 string_printf (_("\nThread %s (%s):\n"), print_thread_id (thr
),
1625 thread_target_id_str (thr
).c_str ());
1629 std::string cmd_result
= execute_command_to_string
1630 (cmd
, from_tty
, gdb_stdout
->term_out ());
1631 if (!flags
.silent
|| cmd_result
.length () > 0)
1634 printf_filtered ("%s", thr_header
.c_str ());
1635 printf_filtered ("%s", cmd_result
.c_str ());
1638 catch (const gdb_exception_error
&ex
)
1643 printf_filtered ("%s", thr_header
.c_str ());
1645 printf_filtered ("%s\n", ex
.what ());
1652 /* Option definition of "thread apply"'s "-ascending" option. */
1654 static const gdb::option::flag_option_def
<> ascending_option_def
= {
1657 Call COMMAND for all threads in ascending order.\n\
1658 The default is descending order."),
1661 /* The qcs command line flags for the "thread apply" commands. Keep
1662 this in sync with the "frame apply" commands. */
1664 using qcs_flag_option_def
1665 = gdb::option::flag_option_def
<qcs_flags
>;
1667 static const gdb::option::option_def thr_qcs_flags_option_defs
[] = {
1668 qcs_flag_option_def
{
1669 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
1670 N_("Disables printing the thread information."),
1673 qcs_flag_option_def
{
1674 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
1675 N_("Print any error raised by COMMAND and continue."),
1678 qcs_flag_option_def
{
1679 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
1680 N_("Silently ignore any errors or empty output produced by COMMAND."),
1684 /* Create an option_def_group for the "thread apply all" options, with
1685 ASCENDING and FLAGS as context. */
1687 static inline std::array
<gdb::option::option_def_group
, 2>
1688 make_thread_apply_all_options_def_group (bool *ascending
,
1692 { {ascending_option_def
.def ()}, ascending
},
1693 { {thr_qcs_flags_option_defs
}, flags
},
1697 /* Create an option_def_group for the "thread apply" options, with
1698 FLAGS as context. */
1700 static inline gdb::option::option_def_group
1701 make_thread_apply_options_def_group (qcs_flags
*flags
)
1703 return {{thr_qcs_flags_option_defs
}, flags
};
1706 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1707 separated list of numbers, or ranges, or the keyword `all'. Ranges consist
1708 of two numbers separated by a hyphen. Examples:
1710 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1711 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1712 thread apply all x/i $pc Apply x/i $pc cmd to all threads. */
1715 thread_apply_all_command (const char *cmd
, int from_tty
)
1717 bool ascending
= false;
1720 auto group
= make_thread_apply_all_options_def_group (&ascending
,
1722 gdb::option::process_options
1723 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1725 validate_flags_qcs ("thread apply all", &flags
);
1727 if (cmd
== NULL
|| *cmd
== '\000')
1728 error (_("Please specify a command at the end of 'thread apply all'"));
1730 update_thread_list ();
1732 int tc
= live_threads_count ();
1735 /* Save a copy of the thread list and increment each thread's
1736 refcount while executing the command in the context of each
1737 thread, in case the command is one that wipes threads. E.g.,
1738 detach, kill, disconnect, etc., or even normally continuing
1739 over an inferior or thread exit. */
1740 std::vector
<thread_info
*> thr_list_cpy
;
1741 thr_list_cpy
.reserve (tc
);
1743 for (thread_info
*tp
: all_non_exited_threads ())
1744 thr_list_cpy
.push_back (tp
);
1745 gdb_assert (thr_list_cpy
.size () == tc
);
1747 /* Increment the refcounts, and restore them back on scope
1749 scoped_inc_dec_ref
inc_dec_ref (thr_list_cpy
);
1751 auto *sorter
= (ascending
1752 ? tp_array_compar_ascending
1753 : tp_array_compar_descending
);
1754 std::sort (thr_list_cpy
.begin (), thr_list_cpy
.end (), sorter
);
1756 scoped_restore_current_thread restore_thread
;
1758 for (thread_info
*thr
: thr_list_cpy
)
1759 if (switch_to_thread_if_alive (thr
))
1760 thr_try_catch_cmd (thr
, cmd
, from_tty
, flags
);
1764 /* Completer for "thread apply [ID list]". */
1767 thread_apply_command_completer (cmd_list_element
*ignore
,
1768 completion_tracker
&tracker
,
1769 const char *text
, const char * /*word*/)
1771 /* Don't leave this to complete_options because there's an early
1773 tracker
.set_use_custom_word_point (true);
1775 tid_range_parser parser
;
1776 parser
.init (text
, current_inferior ()->num
);
1780 while (!parser
.finished ())
1782 int inf_num
, thr_start
, thr_end
;
1784 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1787 if (parser
.in_star_range () || parser
.in_thread_range ())
1788 parser
.skip_range ();
1791 catch (const gdb_exception_error
&ex
)
1793 /* get_tid_range throws if it parses a negative number, for
1794 example. But a seemingly negative number may be the start of
1795 an option instead. */
1798 const char *cmd
= parser
.cur_tok ();
1802 /* No thread ID list yet. */
1806 /* Check if we're past a valid thread ID list already. */
1807 if (parser
.finished ()
1808 && cmd
> text
&& !isspace (cmd
[-1]))
1811 /* We're past the thread ID list, advance word point. */
1812 tracker
.advance_custom_word_point_by (cmd
- text
);
1815 const auto group
= make_thread_apply_options_def_group (nullptr);
1816 if (gdb::option::complete_options
1817 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1820 complete_nested_command_line (tracker
, text
);
1823 /* Completer for "thread apply all". */
1826 thread_apply_all_command_completer (cmd_list_element
*ignore
,
1827 completion_tracker
&tracker
,
1828 const char *text
, const char *word
)
1830 const auto group
= make_thread_apply_all_options_def_group (nullptr,
1832 if (gdb::option::complete_options
1833 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1836 complete_nested_command_line (tracker
, text
);
1839 /* Implementation of the "thread apply" command. */
1842 thread_apply_command (const char *tidlist
, int from_tty
)
1845 const char *cmd
= NULL
;
1846 tid_range_parser parser
;
1848 if (tidlist
== NULL
|| *tidlist
== '\000')
1849 error (_("Please specify a thread ID list"));
1851 parser
.init (tidlist
, current_inferior ()->num
);
1852 while (!parser
.finished ())
1854 int inf_num
, thr_start
, thr_end
;
1856 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1860 cmd
= parser
.cur_tok ();
1862 auto group
= make_thread_apply_options_def_group (&flags
);
1863 gdb::option::process_options
1864 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1866 validate_flags_qcs ("thread apply", &flags
);
1869 error (_("Please specify a command following the thread ID list"));
1871 if (tidlist
== cmd
|| isdigit (cmd
[0]))
1872 invalid_thread_id_error (cmd
);
1874 scoped_restore_current_thread restore_thread
;
1876 parser
.init (tidlist
, current_inferior ()->num
);
1877 while (!parser
.finished ())
1879 struct thread_info
*tp
= NULL
;
1880 struct inferior
*inf
;
1881 int inf_num
, thr_num
;
1883 parser
.get_tid (&inf_num
, &thr_num
);
1884 inf
= find_inferior_id (inf_num
);
1886 tp
= find_thread_id (inf
, thr_num
);
1888 if (parser
.in_star_range ())
1892 warning (_("Unknown inferior %d"), inf_num
);
1893 parser
.skip_range ();
1897 /* No use looking for threads past the highest thread number
1898 the inferior ever had. */
1899 if (thr_num
>= inf
->highest_thread_num
)
1900 parser
.skip_range ();
1902 /* Be quiet about unknown threads numbers. */
1909 if (show_inferior_qualified_tids () || parser
.tid_is_qualified ())
1910 warning (_("Unknown thread %d.%d"), inf_num
, thr_num
);
1912 warning (_("Unknown thread %d"), thr_num
);
1916 if (!switch_to_thread_if_alive (tp
))
1918 warning (_("Thread %s has terminated."), print_thread_id (tp
));
1922 thr_try_catch_cmd (tp
, cmd
, from_tty
, flags
);
1927 /* Implementation of the "taas" command. */
1930 taas_command (const char *cmd
, int from_tty
)
1932 if (cmd
== NULL
|| *cmd
== '\0')
1933 error (_("Please specify a command to apply on all threads"));
1934 std::string expanded
= std::string ("thread apply all -s ") + cmd
;
1935 execute_command (expanded
.c_str (), from_tty
);
1938 /* Implementation of the "tfaas" command. */
1941 tfaas_command (const char *cmd
, int from_tty
)
1943 if (cmd
== NULL
|| *cmd
== '\0')
1944 error (_("Please specify a command to apply on all frames of all threads"));
1945 std::string expanded
1946 = std::string ("thread apply all -s -- frame apply all -s ") + cmd
;
1947 execute_command (expanded
.c_str (), from_tty
);
1950 /* Switch to the specified thread, or print the current thread. */
1953 thread_command (const char *tidstr
, int from_tty
)
1957 if (inferior_ptid
== null_ptid
)
1958 error (_("No thread selected"));
1960 if (target_has_stack
)
1962 struct thread_info
*tp
= inferior_thread ();
1964 if (tp
->state
== THREAD_EXITED
)
1965 printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
1966 print_thread_id (tp
),
1967 target_pid_to_str (inferior_ptid
).c_str ());
1969 printf_filtered (_("[Current thread is %s (%s)]\n"),
1970 print_thread_id (tp
),
1971 target_pid_to_str (inferior_ptid
).c_str ());
1974 error (_("No stack."));
1978 ptid_t previous_ptid
= inferior_ptid
;
1980 thread_select (tidstr
, parse_thread_id (tidstr
, NULL
));
1982 /* Print if the thread has not changed, otherwise an event will
1984 if (inferior_ptid
== previous_ptid
)
1986 print_selected_thread_frame (current_uiout
,
1987 USER_SELECTED_THREAD
1988 | USER_SELECTED_FRAME
);
1992 gdb::observers::user_selected_context_changed
.notify
1993 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
1998 /* Implementation of `thread name'. */
2001 thread_name_command (const char *arg
, int from_tty
)
2003 struct thread_info
*info
;
2005 if (inferior_ptid
== null_ptid
)
2006 error (_("No thread selected"));
2008 arg
= skip_spaces (arg
);
2010 info
= inferior_thread ();
2012 info
->name
= arg
? xstrdup (arg
) : NULL
;
2015 /* Find thread ids with a name, target pid, or extra info matching ARG. */
2018 thread_find_command (const char *arg
, int from_tty
)
2021 unsigned long match
= 0;
2023 if (arg
== NULL
|| *arg
== '\0')
2024 error (_("Command requires an argument."));
2026 tmp
= re_comp (arg
);
2028 error (_("Invalid regexp (%s): %s"), tmp
, arg
);
2030 update_thread_list ();
2031 for (thread_info
*tp
: all_threads ())
2033 if (tp
->name
!= NULL
&& re_exec (tp
->name
))
2035 printf_filtered (_("Thread %s has name '%s'\n"),
2036 print_thread_id (tp
), tp
->name
);
2040 tmp
= target_thread_name (tp
);
2041 if (tmp
!= NULL
&& re_exec (tmp
))
2043 printf_filtered (_("Thread %s has target name '%s'\n"),
2044 print_thread_id (tp
), tmp
);
2048 std::string name
= target_pid_to_str (tp
->ptid
);
2049 if (!name
.empty () && re_exec (name
.c_str ()))
2051 printf_filtered (_("Thread %s has target id '%s'\n"),
2052 print_thread_id (tp
), name
.c_str ());
2056 tmp
= target_extra_thread_info (tp
);
2057 if (tmp
!= NULL
&& re_exec (tmp
))
2059 printf_filtered (_("Thread %s has extra info '%s'\n"),
2060 print_thread_id (tp
), tmp
);
2065 printf_filtered (_("No threads match '%s'\n"), arg
);
2068 /* Print notices when new threads are attached and detached. */
2069 bool print_thread_events
= true;
2071 show_print_thread_events (struct ui_file
*file
, int from_tty
,
2072 struct cmd_list_element
*c
, const char *value
)
2074 fprintf_filtered (file
,
2075 _("Printing of thread events is %s.\n"),
2079 /* See gdbthread.h. */
2082 thread_select (const char *tidstr
, thread_info
*tp
)
2084 if (!switch_to_thread_if_alive (tp
))
2085 error (_("Thread ID %s has terminated."), tidstr
);
2087 annotate_thread_changed ();
2089 /* Since the current thread may have changed, see if there is any
2090 exited thread we can now delete. */
2091 delete_exited_threads ();
2094 /* Print thread and frame switch command response. */
2097 print_selected_thread_frame (struct ui_out
*uiout
,
2098 user_selected_what selection
)
2100 struct thread_info
*tp
= inferior_thread ();
2102 if (selection
& USER_SELECTED_THREAD
)
2104 if (uiout
->is_mi_like_p ())
2106 uiout
->field_signed ("new-thread-id",
2107 inferior_thread ()->global_num
);
2111 uiout
->text ("[Switching to thread ");
2112 uiout
->field_string ("new-thread-id", print_thread_id (tp
));
2114 uiout
->text (target_pid_to_str (inferior_ptid
).c_str ());
2119 if (tp
->state
== THREAD_RUNNING
)
2121 if (selection
& USER_SELECTED_THREAD
)
2122 uiout
->text ("(running)\n");
2124 else if (selection
& USER_SELECTED_FRAME
)
2126 if (selection
& USER_SELECTED_THREAD
)
2129 if (has_stack_frames ())
2130 print_stack_frame_to_uiout (uiout
, get_selected_frame (NULL
),
2135 /* Update the 'threads_executing' global based on the threads we know
2136 about right now. This is used by infrun to tell whether we should
2137 pull events out of the current target. */
2140 update_threads_executing (void)
2142 process_stratum_target
*targ
= current_inferior ()->process_target ();
2147 targ
->threads_executing
= false;
2149 for (inferior
*inf
: all_non_exited_inferiors (targ
))
2151 if (!inf
->has_execution ())
2154 /* If the process has no threads, then it must be we have a
2155 process-exit event pending. */
2156 if (inf
->thread_list
== NULL
)
2158 targ
->threads_executing
= true;
2162 for (thread_info
*tp
: inf
->non_exited_threads ())
2166 targ
->threads_executing
= true;
2174 update_thread_list (void)
2176 target_update_thread_list ();
2177 update_threads_executing ();
2180 /* Return a new value for the selected thread's id. Return a value of
2181 0 if no thread is selected. If GLOBAL is true, return the thread's
2182 global number. Otherwise return the per-inferior number. */
2184 static struct value
*
2185 thread_num_make_value_helper (struct gdbarch
*gdbarch
, int global
)
2189 if (inferior_ptid
== null_ptid
)
2193 thread_info
*tp
= inferior_thread ();
2195 int_val
= tp
->global_num
;
2197 int_val
= tp
->per_inf_num
;
2200 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, int_val
);
2203 /* Return a new value for the selected thread's per-inferior thread
2204 number. Return a value of 0 if no thread is selected, or no
2207 static struct value
*
2208 thread_id_per_inf_num_make_value (struct gdbarch
*gdbarch
,
2209 struct internalvar
*var
,
2212 return thread_num_make_value_helper (gdbarch
, 0);
2215 /* Return a new value for the selected thread's global id. Return a
2216 value of 0 if no thread is selected, or no threads exist. */
2218 static struct value
*
2219 global_thread_id_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
2222 return thread_num_make_value_helper (gdbarch
, 1);
2225 /* Commands with a prefix of `thread'. */
2226 struct cmd_list_element
*thread_cmd_list
= NULL
;
2228 /* Implementation of `thread' variable. */
2230 static const struct internalvar_funcs thread_funcs
=
2232 thread_id_per_inf_num_make_value
,
2237 /* Implementation of `gthread' variable. */
2239 static const struct internalvar_funcs gthread_funcs
=
2241 global_thread_id_make_value
,
2246 void _initialize_thread ();
2248 _initialize_thread ()
2250 static struct cmd_list_element
*thread_apply_list
= NULL
;
2251 cmd_list_element
*c
;
2253 const auto info_threads_opts
= make_info_threads_options_def_group (nullptr);
2255 /* Note: keep this "ID" in sync with what "info threads [TAB]"
2257 static std::string info_threads_help
2258 = gdb::option::build_help (_("\
2259 Display currently known threads.\n\
2260 Usage: info threads [OPTION]... [ID]...\n\
2264 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2265 Otherwise, all threads are displayed."),
2268 c
= add_info ("threads", info_threads_command
, info_threads_help
.c_str ());
2269 set_cmd_completer_handle_brkchars (c
, info_threads_command_completer
);
2271 add_prefix_cmd ("thread", class_run
, thread_command
, _("\
2272 Use this command to switch between threads.\n\
2273 The new thread ID must be currently known."),
2274 &thread_cmd_list
, "thread ", 1, &cmdlist
);
2276 #define THREAD_APPLY_OPTION_HELP "\
2277 Prints per-inferior thread number and target system's thread id\n\
2278 followed by COMMAND output.\n\
2280 By default, an error raised during the execution of COMMAND\n\
2281 aborts \"thread apply\".\n\
2286 const auto thread_apply_opts
= make_thread_apply_options_def_group (nullptr);
2288 static std::string thread_apply_help
= gdb::option::build_help (_("\
2289 Apply a command to a list of threads.\n\
2290 Usage: thread apply ID... [OPTION]... COMMAND\n\
2291 ID is a space-separated list of IDs of threads to apply COMMAND on.\n"
2292 THREAD_APPLY_OPTION_HELP
),
2295 c
= add_prefix_cmd ("apply", class_run
, thread_apply_command
,
2296 thread_apply_help
.c_str (),
2297 &thread_apply_list
, "thread apply ", 1,
2299 set_cmd_completer_handle_brkchars (c
, thread_apply_command_completer
);
2301 const auto thread_apply_all_opts
2302 = make_thread_apply_all_options_def_group (nullptr, nullptr);
2304 static std::string thread_apply_all_help
= gdb::option::build_help (_("\
2305 Apply a command to all threads.\n\
2307 Usage: thread apply all [OPTION]... COMMAND\n"
2308 THREAD_APPLY_OPTION_HELP
),
2309 thread_apply_all_opts
);
2311 c
= add_cmd ("all", class_run
, thread_apply_all_command
,
2312 thread_apply_all_help
.c_str (),
2313 &thread_apply_list
);
2314 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2316 c
= add_com ("taas", class_run
, taas_command
, _("\
2317 Apply a command to all threads (ignoring errors and empty output).\n\
2318 Usage: taas [OPTION]... COMMAND\n\
2319 shortcut for 'thread apply all -s [OPTION]... COMMAND'\n\
2320 See \"help thread apply all\" for available options."));
2321 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2323 c
= add_com ("tfaas", class_run
, tfaas_command
, _("\
2324 Apply a command to all frames of all threads (ignoring errors and empty output).\n\
2325 Usage: tfaas [OPTION]... COMMAND\n\
2326 shortcut for 'thread apply all -s -- frame apply all -s [OPTION]... COMMAND'\n\
2327 See \"help frame apply all\" for available options."));
2328 set_cmd_completer_handle_brkchars (c
, frame_apply_all_cmd_completer
);
2330 add_cmd ("name", class_run
, thread_name_command
,
2331 _("Set the current thread's name.\n\
2332 Usage: thread name [NAME]\n\
2333 If NAME is not given, then any existing name is removed."), &thread_cmd_list
);
2335 add_cmd ("find", class_run
, thread_find_command
, _("\
2336 Find threads that match a regular expression.\n\
2337 Usage: thread find REGEXP\n\
2338 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2341 add_com_alias ("t", "thread", class_run
, 1);
2343 add_setshow_boolean_cmd ("thread-events", no_class
,
2344 &print_thread_events
, _("\
2345 Set printing of thread events (such as thread start and exit)."), _("\
2346 Show printing of thread events (such as thread start and exit)."), NULL
,
2348 show_print_thread_events
,
2349 &setprintlist
, &showprintlist
);
2351 create_internalvar_type_lazy ("_thread", &thread_funcs
, NULL
);
2352 create_internalvar_type_lazy ("_gthread", >hread_funcs
, NULL
);