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 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 /* Add TP to the end of the step-over chain LIST_P. */
373 step_over_chain_enqueue (struct thread_info
**list_p
, struct thread_info
*tp
)
375 gdb_assert (tp
->step_over_next
== NULL
);
376 gdb_assert (tp
->step_over_prev
== NULL
);
381 tp
->step_over_prev
= tp
->step_over_next
= tp
;
385 struct thread_info
*head
= *list_p
;
386 struct thread_info
*tail
= head
->step_over_prev
;
388 tp
->step_over_prev
= tail
;
389 tp
->step_over_next
= head
;
390 head
->step_over_prev
= tp
;
391 tail
->step_over_next
= tp
;
395 /* Remove TP from step-over chain LIST_P. */
398 step_over_chain_remove (struct thread_info
**list_p
, struct thread_info
*tp
)
400 gdb_assert (tp
->step_over_next
!= NULL
);
401 gdb_assert (tp
->step_over_prev
!= NULL
);
405 if (tp
== tp
->step_over_next
)
408 *list_p
= tp
->step_over_next
;
411 tp
->step_over_prev
->step_over_next
= tp
->step_over_next
;
412 tp
->step_over_next
->step_over_prev
= tp
->step_over_prev
;
413 tp
->step_over_prev
= tp
->step_over_next
= NULL
;
416 /* See gdbthread.h. */
419 thread_step_over_chain_next (struct thread_info
*tp
)
421 struct thread_info
*next
= tp
->step_over_next
;
423 return (next
== step_over_queue_head
? NULL
: next
);
426 /* See gdbthread.h. */
429 thread_is_in_step_over_chain (struct thread_info
*tp
)
431 return (tp
->step_over_next
!= NULL
);
434 /* See gdbthread.h. */
437 thread_step_over_chain_enqueue (struct thread_info
*tp
)
439 step_over_chain_enqueue (&step_over_queue_head
, tp
);
442 /* See gdbthread.h. */
445 thread_step_over_chain_remove (struct thread_info
*tp
)
447 step_over_chain_remove (&step_over_queue_head
, tp
);
450 /* Delete the thread referenced by THR. If SILENT, don't notify
451 the observer of this exit.
453 THR must not be NULL or a failed assertion will be raised. */
456 delete_thread_1 (thread_info
*thr
, bool silent
)
458 gdb_assert (thr
!= nullptr);
460 struct thread_info
*tp
, *tpprev
= NULL
;
462 for (tp
= thr
->inf
->thread_list
; tp
; tpprev
= tp
, tp
= tp
->next
)
469 set_thread_exited (tp
, silent
);
471 if (!tp
->deletable ())
473 /* Will be really deleted some other time. */
478 tpprev
->next
= tp
->next
;
480 tp
->inf
->thread_list
= tp
->next
;
485 /* Delete thread THREAD and notify of thread exit. If this is the
486 current thread, don't actually delete it, but tag it as exited and
487 do the notification. If this is the user selected thread, clear
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
->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 (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
, int running
)
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 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 inferior_ptid
= thread
->ptid
;
1323 /* See gdbthread.h. */
1326 switch_to_no_thread ()
1328 if (inferior_ptid
== null_ptid
)
1331 inferior_ptid
= null_ptid
;
1332 reinit_frame_cache ();
1335 /* See gdbthread.h. */
1338 switch_to_thread (thread_info
*thr
)
1340 gdb_assert (thr
!= NULL
);
1342 if (is_current_thread (thr
))
1345 switch_to_thread_no_regs (thr
);
1347 reinit_frame_cache ();
1350 /* See gdbsupport/common-gdbthread.h. */
1353 switch_to_thread (process_stratum_target
*proc_target
, ptid_t ptid
)
1355 thread_info
*thr
= find_thread_ptid (proc_target
, ptid
);
1356 switch_to_thread (thr
);
1360 restore_selected_frame (struct frame_id a_frame_id
, int frame_level
)
1362 struct frame_info
*frame
= NULL
;
1365 /* This means there was no selected frame. */
1366 if (frame_level
== -1)
1368 select_frame (NULL
);
1372 gdb_assert (frame_level
>= 0);
1374 /* Restore by level first, check if the frame id is the same as
1375 expected. If that fails, try restoring by frame id. If that
1376 fails, nothing to do, just warn the user. */
1378 count
= frame_level
;
1379 frame
= find_relative_frame (get_current_frame (), &count
);
1382 /* The frame ids must match - either both valid or both outer_frame_id.
1383 The latter case is not failsafe, but since it's highly unlikely
1384 the search by level finds the wrong frame, it's 99.9(9)% of
1385 the time (for all practical purposes) safe. */
1386 && frame_id_eq (get_frame_id (frame
), a_frame_id
))
1388 /* Cool, all is fine. */
1389 select_frame (frame
);
1393 frame
= frame_find_by_id (a_frame_id
);
1396 /* Cool, refound it. */
1397 select_frame (frame
);
1401 /* Nothing else to do, the frame layout really changed. Select the
1402 innermost stack frame. */
1403 select_frame (get_current_frame ());
1405 /* Warn the user. */
1406 if (frame_level
> 0 && !current_uiout
->is_mi_like_p ())
1408 warning (_("Couldn't restore frame #%d in "
1409 "current thread. Bottom (innermost) frame selected:"),
1411 /* For MI, we should probably have a notification about
1412 current frame change. But this error is not very
1413 likely, so don't bother for now. */
1414 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1419 scoped_restore_current_thread::restore ()
1421 /* If an entry of thread_info was previously selected, it won't be
1422 deleted because we've increased its refcount. The thread represented
1423 by this thread_info entry may have already exited (due to normal exit,
1424 detach, etc), so the thread_info.state is THREAD_EXITED. */
1425 if (m_thread
!= NULL
1426 /* If the previously selected thread belonged to a process that has
1427 in the mean time exited (or killed, detached, etc.), then don't revert
1428 back to it, but instead simply drop back to no thread selected. */
1430 switch_to_thread (m_thread
);
1433 switch_to_no_thread ();
1434 set_current_inferior (m_inf
);
1437 /* The running state of the originally selected thread may have
1438 changed, so we have to recheck it here. */
1439 if (inferior_ptid
!= null_ptid
1441 && m_thread
->state
== THREAD_STOPPED
1442 && target_has_registers
1444 && target_has_memory
)
1445 restore_selected_frame (m_selected_frame_id
, m_selected_frame_level
);
1448 scoped_restore_current_thread::~scoped_restore_current_thread ()
1450 if (!m_dont_restore
)
1456 catch (const gdb_exception
&ex
)
1458 /* We're in a dtor, there's really nothing else we can do
1459 but swallow the exception. */
1463 if (m_thread
!= NULL
)
1464 m_thread
->decref ();
1468 scoped_restore_current_thread::scoped_restore_current_thread ()
1471 m_inf
= current_inferior ();
1473 if (inferior_ptid
!= null_ptid
)
1475 thread_info
*tp
= inferior_thread ();
1476 struct frame_info
*frame
;
1478 m_was_stopped
= tp
->state
== THREAD_STOPPED
;
1480 && target_has_registers
1482 && target_has_memory
)
1484 /* When processing internal events, there might not be a
1485 selected frame. If we naively call get_selected_frame
1486 here, then we can end up reading debuginfo for the
1487 current frame, but we don't generally need the debuginfo
1489 frame
= get_selected_frame_if_set ();
1494 m_selected_frame_id
= get_frame_id (frame
);
1495 m_selected_frame_level
= frame_relative_level (frame
);
1504 /* See gdbthread.h. */
1507 show_thread_that_caused_stop (void)
1509 return highest_thread_num
> 1;
1512 /* See gdbthread.h. */
1515 show_inferior_qualified_tids (void)
1517 return (inferior_list
->next
!= NULL
|| inferior_list
->num
!= 1);
1520 /* See gdbthread.h. */
1523 print_thread_id (struct thread_info
*thr
)
1525 char *s
= get_print_cell ();
1527 if (show_inferior_qualified_tids ())
1528 xsnprintf (s
, PRINT_CELL_SIZE
, "%d.%d", thr
->inf
->num
, thr
->per_inf_num
);
1530 xsnprintf (s
, PRINT_CELL_SIZE
, "%d", thr
->per_inf_num
);
1534 /* Sort an array of struct thread_info pointers by thread ID (first by
1535 inferior number, and then by per-inferior thread number). Sorts in
1539 tp_array_compar_ascending (const thread_info
*a
, const thread_info
*b
)
1541 if (a
->inf
->num
!= b
->inf
->num
)
1542 return a
->inf
->num
< b
->inf
->num
;
1544 return (a
->per_inf_num
< b
->per_inf_num
);
1547 /* Sort an array of struct thread_info pointers by thread ID (first by
1548 inferior number, and then by per-inferior thread number). Sorts in
1549 descending order. */
1552 tp_array_compar_descending (const thread_info
*a
, const thread_info
*b
)
1554 if (a
->inf
->num
!= b
->inf
->num
)
1555 return a
->inf
->num
> b
->inf
->num
;
1557 return (a
->per_inf_num
> b
->per_inf_num
);
1560 /* Switch to thread THR and execute CMD.
1561 FLAGS.QUIET controls the printing of the thread information.
1562 FLAGS.CONT and FLAGS.SILENT control how to handle errors. */
1565 thr_try_catch_cmd (thread_info
*thr
, const char *cmd
, int from_tty
,
1566 const qcs_flags
&flags
)
1568 switch_to_thread (thr
);
1571 std::string cmd_result
= execute_command_to_string
1572 (cmd
, from_tty
, gdb_stdout
->term_out ());
1573 if (!flags
.silent
|| cmd_result
.length () > 0)
1576 printf_filtered (_("\nThread %s (%s):\n"),
1577 print_thread_id (thr
),
1578 target_pid_to_str (inferior_ptid
).c_str ());
1579 printf_filtered ("%s", cmd_result
.c_str ());
1582 catch (const gdb_exception_error
&ex
)
1587 printf_filtered (_("\nThread %s (%s):\n"),
1588 print_thread_id (thr
),
1589 target_pid_to_str (inferior_ptid
).c_str ());
1591 printf_filtered ("%s\n", ex
.what ());
1598 /* Option definition of "thread apply"'s "-ascending" option. */
1600 static const gdb::option::flag_option_def
<> ascending_option_def
= {
1603 Call COMMAND for all threads in ascending order.\n\
1604 The default is descending order."),
1607 /* The qcs command line flags for the "thread apply" commands. Keep
1608 this in sync with the "frame apply" commands. */
1610 using qcs_flag_option_def
1611 = gdb::option::flag_option_def
<qcs_flags
>;
1613 static const gdb::option::option_def thr_qcs_flags_option_defs
[] = {
1614 qcs_flag_option_def
{
1615 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
1616 N_("Disables printing the thread information."),
1619 qcs_flag_option_def
{
1620 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
1621 N_("Print any error raised by COMMAND and continue."),
1624 qcs_flag_option_def
{
1625 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
1626 N_("Silently ignore any errors or empty output produced by COMMAND."),
1630 /* Create an option_def_group for the "thread apply all" options, with
1631 ASCENDING and FLAGS as context. */
1633 static inline std::array
<gdb::option::option_def_group
, 2>
1634 make_thread_apply_all_options_def_group (bool *ascending
,
1638 { {ascending_option_def
.def ()}, ascending
},
1639 { {thr_qcs_flags_option_defs
}, flags
},
1643 /* Create an option_def_group for the "thread apply" options, with
1644 FLAGS as context. */
1646 static inline gdb::option::option_def_group
1647 make_thread_apply_options_def_group (qcs_flags
*flags
)
1649 return {{thr_qcs_flags_option_defs
}, flags
};
1652 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1653 separated list of numbers, or ranges, or the keyword `all'. Ranges consist
1654 of two numbers separated by a hyphen. Examples:
1656 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1657 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1658 thread apply all x/i $pc Apply x/i $pc cmd to all threads. */
1661 thread_apply_all_command (const char *cmd
, int from_tty
)
1663 bool ascending
= false;
1666 auto group
= make_thread_apply_all_options_def_group (&ascending
,
1668 gdb::option::process_options
1669 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1671 validate_flags_qcs ("thread apply all", &flags
);
1673 if (cmd
== NULL
|| *cmd
== '\000')
1674 error (_("Please specify a command at the end of 'thread apply all'"));
1676 update_thread_list ();
1678 int tc
= live_threads_count ();
1681 /* Save a copy of the thread list and increment each thread's
1682 refcount while executing the command in the context of each
1683 thread, in case the command is one that wipes threads. E.g.,
1684 detach, kill, disconnect, etc., or even normally continuing
1685 over an inferior or thread exit. */
1686 std::vector
<thread_info
*> thr_list_cpy
;
1687 thr_list_cpy
.reserve (tc
);
1689 for (thread_info
*tp
: all_non_exited_threads ())
1690 thr_list_cpy
.push_back (tp
);
1691 gdb_assert (thr_list_cpy
.size () == tc
);
1693 /* Increment the refcounts, and restore them back on scope
1695 scoped_inc_dec_ref
inc_dec_ref (thr_list_cpy
);
1697 auto *sorter
= (ascending
1698 ? tp_array_compar_ascending
1699 : tp_array_compar_descending
);
1700 std::sort (thr_list_cpy
.begin (), thr_list_cpy
.end (), sorter
);
1702 scoped_restore_current_thread restore_thread
;
1704 for (thread_info
*thr
: thr_list_cpy
)
1705 if (switch_to_thread_if_alive (thr
))
1706 thr_try_catch_cmd (thr
, cmd
, from_tty
, flags
);
1710 /* Completer for "thread apply [ID list]". */
1713 thread_apply_command_completer (cmd_list_element
*ignore
,
1714 completion_tracker
&tracker
,
1715 const char *text
, const char * /*word*/)
1717 /* Don't leave this to complete_options because there's an early
1719 tracker
.set_use_custom_word_point (true);
1721 tid_range_parser parser
;
1722 parser
.init (text
, current_inferior ()->num
);
1726 while (!parser
.finished ())
1728 int inf_num
, thr_start
, thr_end
;
1730 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1733 if (parser
.in_star_range () || parser
.in_thread_range ())
1734 parser
.skip_range ();
1737 catch (const gdb_exception_error
&ex
)
1739 /* get_tid_range throws if it parses a negative number, for
1740 example. But a seemingly negative number may be the start of
1741 an option instead. */
1744 const char *cmd
= parser
.cur_tok ();
1748 /* No thread ID list yet. */
1752 /* Check if we're past a valid thread ID list already. */
1753 if (parser
.finished ()
1754 && cmd
> text
&& !isspace (cmd
[-1]))
1757 /* We're past the thread ID list, advance word point. */
1758 tracker
.advance_custom_word_point_by (cmd
- text
);
1761 const auto group
= make_thread_apply_options_def_group (nullptr);
1762 if (gdb::option::complete_options
1763 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1766 complete_nested_command_line (tracker
, text
);
1769 /* Completer for "thread apply all". */
1772 thread_apply_all_command_completer (cmd_list_element
*ignore
,
1773 completion_tracker
&tracker
,
1774 const char *text
, const char *word
)
1776 const auto group
= make_thread_apply_all_options_def_group (nullptr,
1778 if (gdb::option::complete_options
1779 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
1782 complete_nested_command_line (tracker
, text
);
1785 /* Implementation of the "thread apply" command. */
1788 thread_apply_command (const char *tidlist
, int from_tty
)
1791 const char *cmd
= NULL
;
1792 tid_range_parser parser
;
1794 if (tidlist
== NULL
|| *tidlist
== '\000')
1795 error (_("Please specify a thread ID list"));
1797 parser
.init (tidlist
, current_inferior ()->num
);
1798 while (!parser
.finished ())
1800 int inf_num
, thr_start
, thr_end
;
1802 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1806 cmd
= parser
.cur_tok ();
1808 auto group
= make_thread_apply_options_def_group (&flags
);
1809 gdb::option::process_options
1810 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
1812 validate_flags_qcs ("thread apply", &flags
);
1815 error (_("Please specify a command following the thread ID list"));
1817 if (tidlist
== cmd
|| isdigit (cmd
[0]))
1818 invalid_thread_id_error (cmd
);
1820 scoped_restore_current_thread restore_thread
;
1822 parser
.init (tidlist
, current_inferior ()->num
);
1823 while (!parser
.finished ())
1825 struct thread_info
*tp
= NULL
;
1826 struct inferior
*inf
;
1827 int inf_num
, thr_num
;
1829 parser
.get_tid (&inf_num
, &thr_num
);
1830 inf
= find_inferior_id (inf_num
);
1832 tp
= find_thread_id (inf
, thr_num
);
1834 if (parser
.in_star_range ())
1838 warning (_("Unknown inferior %d"), inf_num
);
1839 parser
.skip_range ();
1843 /* No use looking for threads past the highest thread number
1844 the inferior ever had. */
1845 if (thr_num
>= inf
->highest_thread_num
)
1846 parser
.skip_range ();
1848 /* Be quiet about unknown threads numbers. */
1855 if (show_inferior_qualified_tids () || parser
.tid_is_qualified ())
1856 warning (_("Unknown thread %d.%d"), inf_num
, thr_num
);
1858 warning (_("Unknown thread %d"), thr_num
);
1862 if (!switch_to_thread_if_alive (tp
))
1864 warning (_("Thread %s has terminated."), print_thread_id (tp
));
1868 thr_try_catch_cmd (tp
, cmd
, from_tty
, flags
);
1873 /* Implementation of the "taas" command. */
1876 taas_command (const char *cmd
, int from_tty
)
1878 if (cmd
== NULL
|| *cmd
== '\0')
1879 error (_("Please specify a command to apply on all threads"));
1880 std::string expanded
= std::string ("thread apply all -s ") + cmd
;
1881 execute_command (expanded
.c_str (), from_tty
);
1884 /* Implementation of the "tfaas" command. */
1887 tfaas_command (const char *cmd
, int from_tty
)
1889 if (cmd
== NULL
|| *cmd
== '\0')
1890 error (_("Please specify a command to apply on all frames of all threads"));
1891 std::string expanded
1892 = std::string ("thread apply all -s -- frame apply all -s ") + cmd
;
1893 execute_command (expanded
.c_str (), from_tty
);
1896 /* Switch to the specified thread, or print the current thread. */
1899 thread_command (const char *tidstr
, int from_tty
)
1903 if (inferior_ptid
== null_ptid
)
1904 error (_("No thread selected"));
1906 if (target_has_stack
)
1908 struct thread_info
*tp
= inferior_thread ();
1910 if (tp
->state
== THREAD_EXITED
)
1911 printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
1912 print_thread_id (tp
),
1913 target_pid_to_str (inferior_ptid
).c_str ());
1915 printf_filtered (_("[Current thread is %s (%s)]\n"),
1916 print_thread_id (tp
),
1917 target_pid_to_str (inferior_ptid
).c_str ());
1920 error (_("No stack."));
1924 ptid_t previous_ptid
= inferior_ptid
;
1926 thread_select (tidstr
, parse_thread_id (tidstr
, NULL
));
1928 /* Print if the thread has not changed, otherwise an event will
1930 if (inferior_ptid
== previous_ptid
)
1932 print_selected_thread_frame (current_uiout
,
1933 USER_SELECTED_THREAD
1934 | USER_SELECTED_FRAME
);
1938 gdb::observers::user_selected_context_changed
.notify
1939 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
1944 /* Implementation of `thread name'. */
1947 thread_name_command (const char *arg
, int from_tty
)
1949 struct thread_info
*info
;
1951 if (inferior_ptid
== null_ptid
)
1952 error (_("No thread selected"));
1954 arg
= skip_spaces (arg
);
1956 info
= inferior_thread ();
1958 info
->name
= arg
? xstrdup (arg
) : NULL
;
1961 /* Find thread ids with a name, target pid, or extra info matching ARG. */
1964 thread_find_command (const char *arg
, int from_tty
)
1967 unsigned long match
= 0;
1969 if (arg
== NULL
|| *arg
== '\0')
1970 error (_("Command requires an argument."));
1972 tmp
= re_comp (arg
);
1974 error (_("Invalid regexp (%s): %s"), tmp
, arg
);
1976 update_thread_list ();
1977 for (thread_info
*tp
: all_threads ())
1979 if (tp
->name
!= NULL
&& re_exec (tp
->name
))
1981 printf_filtered (_("Thread %s has name '%s'\n"),
1982 print_thread_id (tp
), tp
->name
);
1986 tmp
= target_thread_name (tp
);
1987 if (tmp
!= NULL
&& re_exec (tmp
))
1989 printf_filtered (_("Thread %s has target name '%s'\n"),
1990 print_thread_id (tp
), tmp
);
1994 std::string name
= target_pid_to_str (tp
->ptid
);
1995 if (!name
.empty () && re_exec (name
.c_str ()))
1997 printf_filtered (_("Thread %s has target id '%s'\n"),
1998 print_thread_id (tp
), name
.c_str ());
2002 tmp
= target_extra_thread_info (tp
);
2003 if (tmp
!= NULL
&& re_exec (tmp
))
2005 printf_filtered (_("Thread %s has extra info '%s'\n"),
2006 print_thread_id (tp
), tmp
);
2011 printf_filtered (_("No threads match '%s'\n"), arg
);
2014 /* Print notices when new threads are attached and detached. */
2015 bool print_thread_events
= true;
2017 show_print_thread_events (struct ui_file
*file
, int from_tty
,
2018 struct cmd_list_element
*c
, const char *value
)
2020 fprintf_filtered (file
,
2021 _("Printing of thread events is %s.\n"),
2025 /* See gdbthread.h. */
2028 thread_select (const char *tidstr
, thread_info
*tp
)
2030 if (!switch_to_thread_if_alive (tp
))
2031 error (_("Thread ID %s has terminated."), tidstr
);
2033 annotate_thread_changed ();
2035 /* Since the current thread may have changed, see if there is any
2036 exited thread we can now delete. */
2040 /* Print thread and frame switch command response. */
2043 print_selected_thread_frame (struct ui_out
*uiout
,
2044 user_selected_what selection
)
2046 struct thread_info
*tp
= inferior_thread ();
2048 if (selection
& USER_SELECTED_THREAD
)
2050 if (uiout
->is_mi_like_p ())
2052 uiout
->field_signed ("new-thread-id",
2053 inferior_thread ()->global_num
);
2057 uiout
->text ("[Switching to thread ");
2058 uiout
->field_string ("new-thread-id", print_thread_id (tp
));
2060 uiout
->text (target_pid_to_str (inferior_ptid
).c_str ());
2065 if (tp
->state
== THREAD_RUNNING
)
2067 if (selection
& USER_SELECTED_THREAD
)
2068 uiout
->text ("(running)\n");
2070 else if (selection
& USER_SELECTED_FRAME
)
2072 if (selection
& USER_SELECTED_THREAD
)
2075 if (has_stack_frames ())
2076 print_stack_frame_to_uiout (uiout
, get_selected_frame (NULL
),
2081 /* Update the 'threads_executing' global based on the threads we know
2082 about right now. This is used by infrun to tell whether we should
2083 pull events out of the current target. */
2086 update_threads_executing (void)
2088 process_stratum_target
*targ
= current_inferior ()->process_target ();
2093 targ
->threads_executing
= false;
2095 for (inferior
*inf
: all_non_exited_inferiors (targ
))
2097 if (!inf
->has_execution ())
2100 /* If the process has no threads, then it must be we have a
2101 process-exit event pending. */
2102 if (inf
->thread_list
== NULL
)
2104 targ
->threads_executing
= true;
2108 for (thread_info
*tp
: inf
->non_exited_threads ())
2112 targ
->threads_executing
= true;
2120 update_thread_list (void)
2122 target_update_thread_list ();
2123 update_threads_executing ();
2126 /* Return a new value for the selected thread's id. Return a value of
2127 0 if no thread is selected. If GLOBAL is true, return the thread's
2128 global number. Otherwise return the per-inferior number. */
2130 static struct value
*
2131 thread_num_make_value_helper (struct gdbarch
*gdbarch
, int global
)
2135 if (inferior_ptid
== null_ptid
)
2139 thread_info
*tp
= inferior_thread ();
2141 int_val
= tp
->global_num
;
2143 int_val
= tp
->per_inf_num
;
2146 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, int_val
);
2149 /* Return a new value for the selected thread's per-inferior thread
2150 number. Return a value of 0 if no thread is selected, or no
2153 static struct value
*
2154 thread_id_per_inf_num_make_value (struct gdbarch
*gdbarch
,
2155 struct internalvar
*var
,
2158 return thread_num_make_value_helper (gdbarch
, 0);
2161 /* Return a new value for the selected thread's global id. Return a
2162 value of 0 if no thread is selected, or no threads exist. */
2164 static struct value
*
2165 global_thread_id_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
2168 return thread_num_make_value_helper (gdbarch
, 1);
2171 /* Commands with a prefix of `thread'. */
2172 struct cmd_list_element
*thread_cmd_list
= NULL
;
2174 /* Implementation of `thread' variable. */
2176 static const struct internalvar_funcs thread_funcs
=
2178 thread_id_per_inf_num_make_value
,
2183 /* Implementation of `gthread' variable. */
2185 static const struct internalvar_funcs gthread_funcs
=
2187 global_thread_id_make_value
,
2193 _initialize_thread (void)
2195 static struct cmd_list_element
*thread_apply_list
= NULL
;
2196 cmd_list_element
*c
;
2198 const auto info_threads_opts
= make_info_threads_options_def_group (nullptr);
2200 /* Note: keep this "ID" in sync with what "info threads [TAB]"
2202 static std::string info_threads_help
2203 = gdb::option::build_help (_("\
2204 Display currently known threads.\n\
2205 Usage: info threads [OPTION]... [ID]...\n\
2209 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2210 Otherwise, all threads are displayed."),
2213 c
= add_info ("threads", info_threads_command
, info_threads_help
.c_str ());
2214 set_cmd_completer_handle_brkchars (c
, info_threads_command_completer
);
2216 add_prefix_cmd ("thread", class_run
, thread_command
, _("\
2217 Use this command to switch between threads.\n\
2218 The new thread ID must be currently known."),
2219 &thread_cmd_list
, "thread ", 1, &cmdlist
);
2221 #define THREAD_APPLY_OPTION_HELP "\
2222 Prints per-inferior thread number and target system's thread id\n\
2223 followed by COMMAND output.\n\
2225 By default, an error raised during the execution of COMMAND\n\
2226 aborts \"thread apply\".\n\
2231 const auto thread_apply_opts
= make_thread_apply_options_def_group (nullptr);
2233 static std::string thread_apply_help
= gdb::option::build_help (_("\
2234 Apply a command to a list of threads.\n\
2235 Usage: thread apply ID... [OPTION]... COMMAND\n\
2236 ID is a space-separated list of IDs of threads to apply COMMAND on.\n"
2237 THREAD_APPLY_OPTION_HELP
),
2240 c
= add_prefix_cmd ("apply", class_run
, thread_apply_command
,
2241 thread_apply_help
.c_str (),
2242 &thread_apply_list
, "thread apply ", 1,
2244 set_cmd_completer_handle_brkchars (c
, thread_apply_command_completer
);
2246 const auto thread_apply_all_opts
2247 = make_thread_apply_all_options_def_group (nullptr, nullptr);
2249 static std::string thread_apply_all_help
= gdb::option::build_help (_("\
2250 Apply a command to all threads.\n\
2252 Usage: thread apply all [OPTION]... COMMAND\n"
2253 THREAD_APPLY_OPTION_HELP
),
2254 thread_apply_all_opts
);
2256 c
= add_cmd ("all", class_run
, thread_apply_all_command
,
2257 thread_apply_all_help
.c_str (),
2258 &thread_apply_list
);
2259 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2261 c
= add_com ("taas", class_run
, taas_command
, _("\
2262 Apply a command to all threads (ignoring errors and empty output).\n\
2263 Usage: taas [OPTION]... COMMAND\n\
2264 shortcut for 'thread apply all -s [OPTION]... COMMAND'\n\
2265 See \"help thread apply all\" for available options."));
2266 set_cmd_completer_handle_brkchars (c
, thread_apply_all_command_completer
);
2268 c
= add_com ("tfaas", class_run
, tfaas_command
, _("\
2269 Apply a command to all frames of all threads (ignoring errors and empty output).\n\
2270 Usage: tfaas [OPTION]... COMMAND\n\
2271 shortcut for 'thread apply all -s -- frame apply all -s [OPTION]... COMMAND'\n\
2272 See \"help frame apply all\" for available options."));
2273 set_cmd_completer_handle_brkchars (c
, frame_apply_all_cmd_completer
);
2275 add_cmd ("name", class_run
, thread_name_command
,
2276 _("Set the current thread's name.\n\
2277 Usage: thread name [NAME]\n\
2278 If NAME is not given, then any existing name is removed."), &thread_cmd_list
);
2280 add_cmd ("find", class_run
, thread_find_command
, _("\
2281 Find threads that match a regular expression.\n\
2282 Usage: thread find REGEXP\n\
2283 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2286 add_com_alias ("t", "thread", class_run
, 1);
2288 add_setshow_boolean_cmd ("thread-events", no_class
,
2289 &print_thread_events
, _("\
2290 Set printing of thread events (such as thread start and exit)."), _("\
2291 Show printing of thread events (such as thread start and exit)."), NULL
,
2293 show_print_thread_events
,
2294 &setprintlist
, &showprintlist
);
2296 create_internalvar_type_lazy ("_thread", &thread_funcs
, NULL
);
2297 create_internalvar_type_lazy ("_gthread", >hread_funcs
, NULL
);