1 /* Multi-process/thread control for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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/>. */
29 #include "gdbthread.h"
36 #include <sys/types.h>
39 #include "observable.h"
41 #include "cli/cli-decode.h"
42 #include "gdb_regex.h"
43 #include "cli/cli-utils.h"
44 #include "thread-fsm.h"
45 #include "tid-parse.h"
47 #include "common/gdb_optional.h"
49 /* Definition of struct thread_info exported to gdbthread.h. */
51 /* Prototypes for local functions. */
53 struct thread_info *thread_list = NULL;
54 static int highest_thread_num;
56 /* True if any thread is, or may be executing. We need to track this
57 separately because until we fully sync the thread list, we won't
58 know whether the target is fully stopped, even if we see stop
59 events for all known threads, because any of those threads may have
60 spawned new threads we haven't heard of yet. */
61 static int threads_executing;
63 static int thread_alive (struct thread_info *);
65 /* RAII type used to increase / decrease the refcount of each thread
66 in a given list of threads. */
68 class scoped_inc_dec_ref
71 explicit scoped_inc_dec_ref (const std::vector<thread_info *> &thrds)
74 for (thread_info *thr : m_thrds)
78 ~scoped_inc_dec_ref ()
80 for (thread_info *thr : m_thrds)
85 const std::vector<thread_info *> &m_thrds;
90 inferior_thread (void)
92 struct thread_info *tp = find_thread_ptid (inferior_ptid);
97 /* Delete the breakpoint pointed at by BP_P, if there's one. */
100 delete_thread_breakpoint (struct breakpoint **bp_p)
104 delete_breakpoint (*bp_p);
110 delete_step_resume_breakpoint (struct thread_info *tp)
113 delete_thread_breakpoint (&tp->control.step_resume_breakpoint);
117 delete_exception_resume_breakpoint (struct thread_info *tp)
120 delete_thread_breakpoint (&tp->control.exception_resume_breakpoint);
123 /* See gdbthread.h. */
126 delete_single_step_breakpoints (struct thread_info *tp)
129 delete_thread_breakpoint (&tp->control.single_step_breakpoints);
132 /* Delete the breakpoint pointed at by BP_P at the next stop, if
136 delete_at_next_stop (struct breakpoint **bp)
140 (*bp)->disposition = disp_del_at_next_stop;
145 /* See gdbthread.h. */
148 thread_has_single_step_breakpoints_set (struct thread_info *tp)
150 return tp->control.single_step_breakpoints != NULL;
153 /* See gdbthread.h. */
156 thread_has_single_step_breakpoint_here (struct thread_info *tp,
157 const address_space *aspace,
160 struct breakpoint *ss_bps = tp->control.single_step_breakpoints;
162 return (ss_bps != NULL
163 && breakpoint_has_location_inserted_here (ss_bps, aspace, addr));
166 /* See gdbthread.h. */
169 thread_cancel_execution_command (struct thread_info *thr)
171 if (thr->thread_fsm != NULL)
173 thread_fsm_clean_up (thr->thread_fsm, thr);
174 thread_fsm_delete (thr->thread_fsm);
175 thr->thread_fsm = NULL;
180 clear_thread_inferior_resources (struct thread_info *tp)
182 /* NOTE: this will take care of any left-over step_resume breakpoints,
183 but not any user-specified thread-specific breakpoints. We can not
184 delete the breakpoint straight-off, because the inferior might not
185 be stopped at the moment. */
186 delete_at_next_stop (&tp->control.step_resume_breakpoint);
187 delete_at_next_stop (&tp->control.exception_resume_breakpoint);
188 delete_at_next_stop (&tp->control.single_step_breakpoints);
190 delete_longjmp_breakpoint_at_next_stop (tp->global_num);
192 bpstat_clear (&tp->control.stop_bpstat);
194 btrace_teardown (tp);
196 thread_cancel_execution_command (tp);
199 /* Set the TP's state as exited. */
202 set_thread_exited (thread_info *tp, int silent)
204 /* Dead threads don't need to step-over. Remove from queue. */
205 if (tp->step_over_next != NULL)
206 thread_step_over_chain_remove (tp);
208 if (tp->state != THREAD_EXITED)
210 gdb::observers::thread_exit.notify (tp, silent);
212 /* Tag it as exited. */
213 tp->state = THREAD_EXITED;
215 /* Clear breakpoints, etc. associated with this thread. */
216 clear_thread_inferior_resources (tp);
221 init_thread_list (void)
223 struct thread_info *tp, *tpnext;
225 highest_thread_num = 0;
230 for (tp = thread_list; tp; tp = tpnext)
233 if (tp->deletable ())
236 set_thread_exited (tp, 1);
240 threads_executing = 0;
243 /* Allocate a new thread of inferior INF with target id PTID and add
244 it to the thread list. */
246 static struct thread_info *
247 new_thread (struct inferior *inf, ptid_t ptid)
249 thread_info *tp = new thread_info (inf, ptid);
251 if (thread_list == NULL)
255 struct thread_info *last;
257 for (last = thread_list; last->next != NULL; last = last->next)
266 add_thread_silent (ptid_t ptid)
268 struct thread_info *tp;
269 struct inferior *inf = find_inferior_ptid (ptid);
270 gdb_assert (inf != NULL);
272 tp = find_thread_ptid (ptid);
274 /* Found an old thread with the same id. It has to be dead,
275 otherwise we wouldn't be adding a new thread with the same id.
276 The OS is reusing this id --- delete it, and recreate a new
279 /* In addition to deleting the thread, if this is the current
280 thread, then we need to take care that delete_thread doesn't
281 really delete the thread if it is inferior_ptid. Create a
282 new template thread in the list with an invalid ptid, switch
283 to it, delete the original thread, reset the new thread's
284 ptid, and switch to it. */
286 if (inferior_ptid == ptid)
288 tp = new_thread (inf, null_ptid);
290 /* Make switch_to_thread not read from the thread. */
291 tp->state = THREAD_EXITED;
292 switch_to_thread (null_ptid);
294 /* Now we can delete it. */
295 delete_thread (ptid);
297 /* Now reset its ptid, and reswitch inferior_ptid to it. */
299 tp->state = THREAD_STOPPED;
300 switch_to_thread (ptid);
302 gdb::observers::new_thread.notify (tp);
308 /* Just go ahead and delete it. */
309 delete_thread (ptid);
312 tp = new_thread (inf, ptid);
313 gdb::observers::new_thread.notify (tp);
319 add_thread_with_info (ptid_t ptid, private_thread_info *priv)
321 struct thread_info *result = add_thread_silent (ptid);
323 result->priv.reset (priv);
325 if (print_thread_events)
326 printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
328 annotate_new_thread ();
333 add_thread (ptid_t ptid)
335 return add_thread_with_info (ptid, NULL);
338 private_thread_info::~private_thread_info () = default;
340 thread_info::thread_info (struct inferior *inf_, ptid_t ptid_)
341 : ptid (ptid_), inf (inf_)
343 gdb_assert (inf_ != NULL);
345 this->global_num = ++highest_thread_num;
346 this->per_inf_num = ++inf_->highest_thread_num;
348 /* Nothing to follow yet. */
349 memset (&this->pending_follow, 0, sizeof (this->pending_follow));
350 this->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
351 this->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
354 thread_info::~thread_info ()
359 /* Add TP to the end of the step-over chain LIST_P. */
362 step_over_chain_enqueue (struct thread_info **list_p, struct thread_info *tp)
364 gdb_assert (tp->step_over_next == NULL);
365 gdb_assert (tp->step_over_prev == NULL);
370 tp->step_over_prev = tp->step_over_next = tp;
374 struct thread_info *head = *list_p;
375 struct thread_info *tail = head->step_over_prev;
377 tp->step_over_prev = tail;
378 tp->step_over_next = head;
379 head->step_over_prev = tp;
380 tail->step_over_next = tp;
384 /* Remove TP from step-over chain LIST_P. */
387 step_over_chain_remove (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);
394 if (tp == tp->step_over_next)
397 *list_p = tp->step_over_next;
400 tp->step_over_prev->step_over_next = tp->step_over_next;
401 tp->step_over_next->step_over_prev = tp->step_over_prev;
402 tp->step_over_prev = tp->step_over_next = NULL;
405 /* See gdbthread.h. */
408 thread_step_over_chain_next (struct thread_info *tp)
410 struct thread_info *next = tp->step_over_next;
412 return (next == step_over_queue_head ? NULL : next);
415 /* See gdbthread.h. */
418 thread_is_in_step_over_chain (struct thread_info *tp)
420 return (tp->step_over_next != NULL);
423 /* See gdbthread.h. */
426 thread_step_over_chain_enqueue (struct thread_info *tp)
428 step_over_chain_enqueue (&step_over_queue_head, tp);
431 /* See gdbthread.h. */
434 thread_step_over_chain_remove (struct thread_info *tp)
436 step_over_chain_remove (&step_over_queue_head, tp);
439 /* Delete thread PTID. If SILENT, don't notify the observer of this
442 delete_thread_1 (ptid_t ptid, int silent)
444 struct thread_info *tp, *tpprev;
448 for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
449 if (tp->ptid == ptid)
455 set_thread_exited (tp, silent);
457 if (!tp->deletable ())
459 /* Will be really deleted some other time. */
464 tpprev->next = tp->next;
466 thread_list = tp->next;
471 /* Delete thread PTID and notify of thread exit. If this is
472 inferior_ptid, don't actually delete it, but tag it as exited and
473 do the notification. If PTID is the user selected thread, clear
476 delete_thread (ptid_t ptid)
478 delete_thread_1 (ptid, 0 /* not silent */);
482 delete_thread_silent (ptid_t ptid)
484 delete_thread_1 (ptid, 1 /* silent */);
488 find_thread_global_id (int global_id)
490 struct thread_info *tp;
492 for (tp = thread_list; tp; tp = tp->next)
493 if (tp->global_num == global_id)
499 static struct thread_info *
500 find_thread_id (struct inferior *inf, int thr_num)
502 struct thread_info *tp;
504 for (tp = thread_list; tp; tp = tp->next)
505 if (tp->inf == inf && tp->per_inf_num == thr_num)
511 /* Find a thread_info by matching PTID. */
514 find_thread_ptid (ptid_t ptid)
516 struct thread_info *tp;
518 for (tp = thread_list; tp; tp = tp->next)
519 if (tp->ptid == ptid)
525 /* See gdbthread.h. */
528 find_thread_by_handle (struct value *thread_handle, struct inferior *inf)
530 return target_thread_handle_to_thread_info
531 (value_contents_all (thread_handle),
532 TYPE_LENGTH (value_type (thread_handle)),
537 * Thread iterator function.
539 * Calls a callback function once for each thread, so long as
540 * the callback function returns false. If the callback function
541 * returns true, the iteration will end and the current thread
542 * will be returned. This can be useful for implementing a
543 * search for a thread with arbitrary attributes, or for applying
544 * some operation to every thread.
546 * FIXME: some of the existing functionality, such as
547 * "Thread apply all", might be rewritten using this functionality.
551 iterate_over_threads (int (*callback) (struct thread_info *, void *),
554 struct thread_info *tp, *next;
556 for (tp = thread_list; tp; tp = next)
559 if ((*callback) (tp, data))
570 struct thread_info *tp;
572 for (tp = thread_list; tp; tp = tp->next)
578 /* Return the number of non-exited threads in the thread list. */
581 live_threads_count (void)
584 struct thread_info *tp;
586 ALL_NON_EXITED_THREADS (tp)
593 valid_global_thread_id (int global_id)
595 struct thread_info *tp;
597 for (tp = thread_list; tp; tp = tp->next)
598 if (tp->global_num == global_id)
605 ptid_to_global_thread_id (ptid_t ptid)
607 struct thread_info *tp;
609 for (tp = thread_list; tp; tp = tp->next)
610 if (tp->ptid == ptid)
611 return tp->global_num;
617 global_thread_id_to_ptid (int global_id)
619 struct thread_info *thread = find_thread_global_id (global_id);
624 return minus_one_ptid;
628 in_thread_list (ptid_t ptid)
630 struct thread_info *tp;
632 for (tp = thread_list; tp; tp = tp->next)
633 if (tp->ptid == ptid)
636 return 0; /* Never heard of 'im. */
639 /* Finds the first thread of the inferior given by PID. If PID is -1,
640 return the first thread in the list. */
643 first_thread_of_process (int pid)
645 struct thread_info *tp, *ret = NULL;
647 for (tp = thread_list; tp; tp = tp->next)
648 if (pid == -1 || ptid_get_pid (tp->ptid) == pid)
649 if (ret == NULL || tp->global_num < ret->global_num)
656 any_thread_of_process (int pid)
658 struct thread_info *tp;
660 gdb_assert (pid != 0);
662 /* Prefer the current thread. */
663 if (ptid_get_pid (inferior_ptid) == pid)
664 return inferior_thread ();
666 ALL_NON_EXITED_THREADS (tp)
667 if (ptid_get_pid (tp->ptid) == pid)
674 any_live_thread_of_process (int pid)
676 struct thread_info *curr_tp = NULL;
677 struct thread_info *tp;
678 struct thread_info *tp_executing = NULL;
680 gdb_assert (pid != 0);
682 /* Prefer the current thread if it's not executing. */
683 if (ptid_get_pid (inferior_ptid) == pid)
685 /* If the current thread is dead, forget it. If it's not
686 executing, use it. Otherwise, still choose it (below), but
687 only if no other non-executing thread is found. */
688 curr_tp = inferior_thread ();
689 if (curr_tp->state == THREAD_EXITED)
691 else if (!curr_tp->executing)
695 ALL_NON_EXITED_THREADS (tp)
696 if (ptid_get_pid (tp->ptid) == pid)
704 /* If both the current thread and all live threads are executing,
705 prefer the current thread. */
709 /* Otherwise, just return an executing thread, if any. */
713 /* Return true if TP is an active thread. */
715 thread_alive (struct thread_info *tp)
717 if (tp->state == THREAD_EXITED)
719 if (!target_thread_alive (tp->ptid))
724 /* See gdbthreads.h. */
729 struct thread_info *tp, *tmp;
731 ALL_THREADS_SAFE (tp, tmp)
733 if (!thread_alive (tp))
734 delete_thread (tp->ptid);
738 /* See gdbthreads.h. */
741 delete_exited_threads (void)
743 struct thread_info *tp, *tmp;
745 ALL_THREADS_SAFE (tp, tmp)
747 if (tp->state == THREAD_EXITED)
748 delete_thread (tp->ptid);
752 /* Return true value if stack temporaies are enabled for the thread
756 thread_stack_temporaries_enabled_p (ptid_t ptid)
758 struct thread_info *tp = find_thread_ptid (ptid);
763 return tp->stack_temporaries_enabled;
766 /* Push V on to the stack temporaries of the thread with id PTID. */
769 push_thread_stack_temporary (ptid_t ptid, struct value *v)
771 struct thread_info *tp = find_thread_ptid (ptid);
773 gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
774 tp->stack_temporaries.push_back (v);
777 /* Return true if VAL is among the stack temporaries of the thread
778 with id PTID. Return false otherwise. */
781 value_in_thread_stack_temporaries (struct value *val, ptid_t ptid)
783 struct thread_info *tp = find_thread_ptid (ptid);
785 gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
786 for (struct value *v : tp->stack_temporaries)
793 /* Return the last of the stack temporaries for thread with id PTID.
794 Return NULL if there are no stack temporaries for the thread. */
797 get_last_thread_stack_temporary (ptid_t ptid)
799 struct value *lastval = NULL;
800 struct thread_info *tp = find_thread_ptid (ptid);
802 gdb_assert (tp != NULL);
803 if (!tp->stack_temporaries.empty ())
804 lastval = tp->stack_temporaries.back ();
810 thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
812 struct inferior *inf;
813 struct thread_info *tp;
815 /* It can happen that what we knew as the target inferior id
816 changes. E.g, target remote may only discover the remote process
817 pid after adding the inferior to GDB's list. */
818 inf = find_inferior_ptid (old_ptid);
819 inf->pid = ptid_get_pid (new_ptid);
821 tp = find_thread_ptid (old_ptid);
824 gdb::observers::thread_ptid_changed.notify (old_ptid, new_ptid);
827 /* See gdbthread.h. */
830 set_resumed (ptid_t ptid, int resumed)
832 struct thread_info *tp;
833 int all = ptid == minus_one_ptid;
835 if (all || ptid_is_pid (ptid))
837 for (tp = thread_list; tp; tp = tp->next)
838 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
839 tp->resumed = resumed;
843 tp = find_thread_ptid (ptid);
844 gdb_assert (tp != NULL);
845 tp->resumed = resumed;
849 /* Helper for set_running, that marks one thread either running or
853 set_running_thread (struct thread_info *tp, int running)
857 if (running && tp->state == THREAD_STOPPED)
859 tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
863 /* If the thread is now marked stopped, remove it from
864 the step-over queue, so that we don't try to resume
865 it until the user wants it to. */
866 if (tp->step_over_next != NULL)
867 thread_step_over_chain_remove (tp);
874 set_running (ptid_t ptid, int running)
876 struct thread_info *tp;
877 int all = ptid == minus_one_ptid;
880 /* We try not to notify the observer if no thread has actually changed
881 the running state -- merely to reduce the number of messages to
882 frontend. Frontend is supposed to handle multiple *running just fine. */
883 if (all || ptid_is_pid (ptid))
885 for (tp = thread_list; tp; tp = tp->next)
886 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
888 if (tp->state == THREAD_EXITED)
891 if (set_running_thread (tp, running))
897 tp = find_thread_ptid (ptid);
898 gdb_assert (tp != NULL);
899 gdb_assert (tp->state != THREAD_EXITED);
900 if (set_running_thread (tp, running))
904 gdb::observers::target_resumed.notify (ptid);
908 is_thread_state (ptid_t ptid, enum thread_state state)
910 struct thread_info *tp;
912 tp = find_thread_ptid (ptid);
914 return tp->state == state;
918 is_stopped (ptid_t ptid)
920 return is_thread_state (ptid, THREAD_STOPPED);
924 is_exited (ptid_t ptid)
926 return is_thread_state (ptid, THREAD_EXITED);
930 is_running (ptid_t ptid)
932 return is_thread_state (ptid, THREAD_RUNNING);
936 is_executing (ptid_t ptid)
938 struct thread_info *tp;
940 tp = find_thread_ptid (ptid);
942 return tp->executing;
946 set_executing (ptid_t ptid, int executing)
948 struct thread_info *tp;
949 int all = ptid == minus_one_ptid;
951 if (all || ptid_is_pid (ptid))
953 for (tp = thread_list; tp; tp = tp->next)
954 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
955 tp->executing = executing;
959 tp = find_thread_ptid (ptid);
961 tp->executing = executing;
964 /* It only takes one running thread to spawn more threads.*/
966 threads_executing = 1;
967 /* Only clear the flag if the caller is telling us everything is
969 else if (minus_one_ptid == ptid)
970 threads_executing = 0;
973 /* See gdbthread.h. */
976 threads_are_executing (void)
978 return threads_executing;
982 set_stop_requested (ptid_t ptid, int stop)
984 struct thread_info *tp;
985 int all = ptid == minus_one_ptid;
987 if (all || ptid_is_pid (ptid))
989 for (tp = thread_list; tp; tp = tp->next)
990 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
991 tp->stop_requested = stop;
995 tp = find_thread_ptid (ptid);
997 tp->stop_requested = stop;
1000 /* Call the stop requested observer so other components of GDB can
1001 react to this request. */
1003 gdb::observers::thread_stop_requested.notify (ptid);
1007 finish_thread_state (ptid_t ptid)
1009 struct thread_info *tp;
1011 int any_started = 0;
1013 all = ptid == minus_one_ptid;
1015 if (all || ptid_is_pid (ptid))
1017 for (tp = thread_list; tp; tp = tp->next)
1019 if (tp->state == THREAD_EXITED)
1021 if (all || ptid_get_pid (ptid) == ptid_get_pid (tp->ptid))
1023 if (set_running_thread (tp, tp->executing))
1030 tp = find_thread_ptid (ptid);
1032 if (tp->state != THREAD_EXITED)
1034 if (set_running_thread (tp, tp->executing))
1040 gdb::observers::target_resumed.notify (ptid);
1043 /* See gdbthread.h. */
1046 validate_registers_access (void)
1048 /* No selected thread, no registers. */
1049 if (inferior_ptid == null_ptid)
1050 error (_("No thread selected."));
1052 /* Don't try to read from a dead thread. */
1053 if (is_exited (inferior_ptid))
1054 error (_("The current thread has terminated"));
1056 /* ... or from a spinning thread. FIXME: This isn't actually fully
1057 correct. It'll allow an user-requested access (e.g., "print $pc"
1058 at the prompt) when a thread is not executing for some internal
1059 reason, but is marked running from the user's perspective. E.g.,
1060 the thread is waiting for its turn in the step-over queue. */
1061 if (is_executing (inferior_ptid))
1062 error (_("Selected thread is running."));
1065 /* See gdbthread.h. */
1068 can_access_registers_ptid (ptid_t ptid)
1070 /* No thread, no registers. */
1071 if (ptid == null_ptid)
1074 /* Don't try to read from a dead thread. */
1075 if (is_exited (ptid))
1078 /* ... or from a spinning thread. FIXME: see validate_registers_access. */
1079 if (is_executing (ptid))
1086 pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread)
1088 return (pc >= thread->control.step_range_start
1089 && pc < thread->control.step_range_end);
1092 /* Helper for print_thread_info. Returns true if THR should be
1093 printed. If REQUESTED_THREADS, a list of GDB ids/ranges, is not
1094 NULL, only print THR if its ID is included in the list. GLOBAL_IDS
1095 is true if REQUESTED_THREADS is list of global IDs, false if a list
1096 of per-inferior thread ids. If PID is not -1, only print THR if it
1097 is a thread from the process PID. Otherwise, threads from all
1098 attached PIDs are printed. If both REQUESTED_THREADS is not NULL
1099 and PID is not -1, then the thread is printed if it belongs to the
1100 specified process. Otherwise, an error is raised. */
1103 should_print_thread (const char *requested_threads, int default_inf_num,
1104 int global_ids, int pid, struct thread_info *thr)
1106 if (requested_threads != NULL && *requested_threads != '\0')
1111 in_list = number_is_in_list (requested_threads, thr->global_num);
1113 in_list = tid_is_in_list (requested_threads, default_inf_num,
1114 thr->inf->num, thr->per_inf_num);
1119 if (pid != -1 && ptid_get_pid (thr->ptid) != pid)
1121 if (requested_threads != NULL && *requested_threads != '\0')
1122 error (_("Requested thread not found in requested process"));
1126 if (thr->state == THREAD_EXITED)
1132 /* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1133 whether REQUESTED_THREADS is a list of global or per-inferior
1137 print_thread_info_1 (struct ui_out *uiout, const char *requested_threads,
1138 int global_ids, int pid,
1139 int show_global_ids)
1141 struct thread_info *tp;
1142 ptid_t current_ptid;
1143 const char *extra_info, *name, *target_id;
1144 struct inferior *inf;
1145 int default_inf_num = current_inferior ()->num;
1147 update_thread_list ();
1148 current_ptid = inferior_ptid;
1151 /* For backward compatibility, we make a list for MI. A table is
1152 preferable for the CLI, though, because it shows table
1154 gdb::optional<ui_out_emit_list> list_emitter;
1155 gdb::optional<ui_out_emit_table> table_emitter;
1157 if (uiout->is_mi_like_p ())
1158 list_emitter.emplace (uiout, "threads");
1163 for (tp = thread_list; tp; tp = tp->next)
1165 if (!should_print_thread (requested_threads, default_inf_num,
1166 global_ids, pid, tp))
1174 if (requested_threads == NULL || *requested_threads == '\0')
1175 uiout->message (_("No threads.\n"));
1177 uiout->message (_("No threads match '%s'.\n"),
1182 table_emitter.emplace (uiout, show_global_ids ? 5 : 4,
1183 n_threads, "threads");
1185 uiout->table_header (1, ui_left, "current", "");
1186 uiout->table_header (4, ui_left, "id-in-tg", "Id");
1187 if (show_global_ids)
1188 uiout->table_header (4, ui_left, "id", "GId");
1189 uiout->table_header (17, ui_left, "target-id", "Target Id");
1190 uiout->table_header (1, ui_left, "frame", "Frame");
1191 uiout->table_body ();
1194 /* We'll be switching threads temporarily. */
1195 scoped_restore_current_thread restore_thread;
1197 ALL_THREADS_BY_INFERIOR (inf, tp)
1201 if (!should_print_thread (requested_threads, default_inf_num,
1202 global_ids, pid, tp))
1205 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1207 if (!uiout->is_mi_like_p ())
1209 if (tp->ptid == current_ptid)
1210 uiout->field_string ("current", "*");
1212 uiout->field_skip ("current");
1214 uiout->field_string ("id-in-tg", print_thread_id (tp));
1217 if (show_global_ids || uiout->is_mi_like_p ())
1218 uiout->field_int ("id", tp->global_num);
1220 /* For the CLI, we stuff everything into the target-id field.
1221 This is a gross hack to make the output come out looking
1222 correct. The underlying problem here is that ui-out has no
1223 way to specify that a field's space allocation should be
1224 shared by several fields. For MI, we do the right thing
1227 target_id = target_pid_to_str (tp->ptid);
1228 extra_info = target_extra_thread_info (tp);
1229 name = tp->name ? tp->name : target_thread_name (tp);
1231 if (uiout->is_mi_like_p ())
1233 uiout->field_string ("target-id", target_id);
1235 uiout->field_string ("details", extra_info);
1237 uiout->field_string ("name", name);
1241 std::string contents;
1243 if (extra_info && name)
1244 contents = string_printf ("%s \"%s\" (%s)", target_id,
1246 else if (extra_info)
1247 contents = string_printf ("%s (%s)", target_id, extra_info);
1249 contents = string_printf ("%s \"%s\"", target_id, name);
1251 contents = target_id;
1253 uiout->field_string ("target-id", contents.c_str ());
1256 if (tp->state == THREAD_RUNNING)
1257 uiout->text ("(running)\n");
1260 /* The switch below puts us at the top of the stack (leaf
1262 switch_to_thread (tp->ptid);
1263 print_stack_frame (get_selected_frame (NULL),
1264 /* For MI output, print frame level. */
1265 uiout->is_mi_like_p (),
1269 if (uiout->is_mi_like_p ())
1271 const char *state = "stopped";
1273 if (tp->state == THREAD_RUNNING)
1275 uiout->field_string ("state", state);
1278 core = target_core_of_thread (tp->ptid);
1279 if (uiout->is_mi_like_p () && core != -1)
1280 uiout->field_int ("core", core);
1283 /* This end scope restores the current thread and the frame
1284 selected before the "info threads" command, and it finishes the
1285 ui-out list or table. */
1288 if (pid == -1 && requested_threads == NULL)
1290 if (uiout->is_mi_like_p ()
1291 && inferior_ptid != null_ptid)
1293 int num = ptid_to_global_thread_id (inferior_ptid);
1295 gdb_assert (num != 0);
1296 uiout->field_int ("current-thread-id", num);
1299 if (inferior_ptid != null_ptid && is_exited (inferior_ptid))
1300 uiout->message ("\n\
1301 The current thread <Thread ID %s> has terminated. See `help thread'.\n",
1302 print_thread_id (inferior_thread ()));
1303 else if (thread_list != NULL && inferior_ptid == null_ptid)
1304 uiout->message ("\n\
1305 No selected thread. See `help thread'.\n");
1309 /* See gdbthread.h. */
1312 print_thread_info (struct ui_out *uiout, char *requested_threads, int pid)
1314 print_thread_info_1 (uiout, requested_threads, 1, pid, 0);
1317 /* Implementation of the "info threads" command.
1319 Note: this has the drawback that it _really_ switches
1320 threads, which frees the frame cache. A no-side
1321 effects info-threads command would be nicer. */
1324 info_threads_command (const char *arg, int from_tty)
1326 int show_global_ids = 0;
1329 && check_for_argument (&arg, "-gid", sizeof ("-gid") - 1))
1331 arg = skip_spaces (arg);
1332 show_global_ids = 1;
1335 print_thread_info_1 (current_uiout, arg, 0, -1, show_global_ids);
1338 /* See gdbthread.h. */
1341 switch_to_thread_no_regs (struct thread_info *thread)
1343 struct inferior *inf = thread->inf;
1345 set_current_program_space (inf->pspace);
1346 set_current_inferior (inf);
1348 inferior_ptid = thread->ptid;
1349 stop_pc = ~(CORE_ADDR) 0;
1352 /* Switch to no thread selected. */
1355 switch_to_no_thread ()
1357 if (inferior_ptid == null_ptid)
1360 inferior_ptid = null_ptid;
1361 reinit_frame_cache ();
1362 stop_pc = ~(CORE_ADDR) 0;
1365 /* Switch from one thread to another. */
1368 switch_to_thread (thread_info *thr)
1370 gdb_assert (thr != NULL);
1372 if (inferior_ptid == thr->ptid)
1375 switch_to_thread_no_regs (thr);
1377 reinit_frame_cache ();
1379 /* We don't check for is_stopped, because we're called at times
1380 while in the TARGET_RUNNING state, e.g., while handling an
1382 if (thr->state != THREAD_EXITED
1384 stop_pc = regcache_read_pc (get_thread_regcache (thr->ptid));
1387 /* See gdbthread.h. */
1390 switch_to_thread (ptid_t ptid)
1392 if (ptid == null_ptid)
1393 switch_to_no_thread ();
1395 switch_to_thread (find_thread_ptid (ptid));
1399 restore_selected_frame (struct frame_id a_frame_id, int frame_level)
1401 struct frame_info *frame = NULL;
1404 /* This means there was no selected frame. */
1405 if (frame_level == -1)
1407 select_frame (NULL);
1411 gdb_assert (frame_level >= 0);
1413 /* Restore by level first, check if the frame id is the same as
1414 expected. If that fails, try restoring by frame id. If that
1415 fails, nothing to do, just warn the user. */
1417 count = frame_level;
1418 frame = find_relative_frame (get_current_frame (), &count);
1421 /* The frame ids must match - either both valid or both outer_frame_id.
1422 The latter case is not failsafe, but since it's highly unlikely
1423 the search by level finds the wrong frame, it's 99.9(9)% of
1424 the time (for all practical purposes) safe. */
1425 && frame_id_eq (get_frame_id (frame), a_frame_id))
1427 /* Cool, all is fine. */
1428 select_frame (frame);
1432 frame = frame_find_by_id (a_frame_id);
1435 /* Cool, refound it. */
1436 select_frame (frame);
1440 /* Nothing else to do, the frame layout really changed. Select the
1441 innermost stack frame. */
1442 select_frame (get_current_frame ());
1444 /* Warn the user. */
1445 if (frame_level > 0 && !current_uiout->is_mi_like_p ())
1447 warning (_("Couldn't restore frame #%d in "
1448 "current thread. Bottom (innermost) frame selected:"),
1450 /* For MI, we should probably have a notification about
1451 current frame change. But this error is not very
1452 likely, so don't bother for now. */
1453 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1457 scoped_restore_current_thread::~scoped_restore_current_thread ()
1459 /* If an entry of thread_info was previously selected, it won't be
1460 deleted because we've increased its refcount. The thread represented
1461 by this thread_info entry may have already exited (due to normal exit,
1462 detach, etc), so the thread_info.state is THREAD_EXITED. */
1463 if (m_thread != NULL
1464 /* If the previously selected thread belonged to a process that has
1465 in the mean time exited (or killed, detached, etc.), then don't revert
1466 back to it, but instead simply drop back to no thread selected. */
1468 switch_to_thread (m_thread);
1471 switch_to_no_thread ();
1472 set_current_inferior (m_inf);
1475 /* The running state of the originally selected thread may have
1476 changed, so we have to recheck it here. */
1477 if (inferior_ptid != null_ptid
1479 && is_stopped (inferior_ptid)
1480 && target_has_registers
1482 && target_has_memory)
1483 restore_selected_frame (m_selected_frame_id, m_selected_frame_level);
1485 if (m_thread != NULL)
1486 m_thread->decref ();
1490 scoped_restore_current_thread::scoped_restore_current_thread ()
1493 m_inf = current_inferior ();
1495 if (inferior_ptid != null_ptid)
1497 thread_info *tp = find_thread_ptid (inferior_ptid);
1498 struct frame_info *frame;
1500 gdb_assert (tp != NULL);
1502 m_was_stopped = tp->state == THREAD_STOPPED;
1504 && target_has_registers
1506 && target_has_memory)
1508 /* When processing internal events, there might not be a
1509 selected frame. If we naively call get_selected_frame
1510 here, then we can end up reading debuginfo for the
1511 current frame, but we don't generally need the debuginfo
1513 frame = get_selected_frame_if_set ();
1518 m_selected_frame_id = get_frame_id (frame);
1519 m_selected_frame_level = frame_relative_level (frame);
1528 /* See gdbthread.h. */
1531 show_thread_that_caused_stop (void)
1533 return highest_thread_num > 1;
1536 /* See gdbthread.h. */
1539 show_inferior_qualified_tids (void)
1541 return (inferior_list->next != NULL || inferior_list->num != 1);
1544 /* See gdbthread.h. */
1547 print_thread_id (struct thread_info *thr)
1549 char *s = get_print_cell ();
1551 if (show_inferior_qualified_tids ())
1552 xsnprintf (s, PRINT_CELL_SIZE, "%d.%d", thr->inf->num, thr->per_inf_num);
1554 xsnprintf (s, PRINT_CELL_SIZE, "%d", thr->per_inf_num);
1558 /* If true, tp_array_compar should sort in ascending order, otherwise
1559 in descending order. */
1561 static bool tp_array_compar_ascending;
1563 /* Sort an array for struct thread_info pointers by thread ID (first
1564 by inferior number, and then by per-inferior thread number). The
1565 order is determined by TP_ARRAY_COMPAR_ASCENDING. */
1568 tp_array_compar (const thread_info *a, const thread_info *b)
1570 if (a->inf->num != b->inf->num)
1572 if (tp_array_compar_ascending)
1573 return a->inf->num < b->inf->num;
1575 return a->inf->num > b->inf->num;
1578 if (tp_array_compar_ascending)
1579 return (a->per_inf_num < b->per_inf_num);
1581 return (a->per_inf_num > b->per_inf_num);
1584 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1585 separated list of numbers, or ranges, or the keyword `all'. Ranges consist
1586 of two numbers separated by a hyphen. Examples:
1588 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1589 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1590 thread apply all x/i $pc Apply x/i $pc cmd to all threads. */
1593 thread_apply_all_command (const char *cmd, int from_tty)
1595 tp_array_compar_ascending = false;
1597 && check_for_argument (&cmd, "-ascending", strlen ("-ascending")))
1599 cmd = skip_spaces (cmd);
1600 tp_array_compar_ascending = true;
1603 if (cmd == NULL || *cmd == '\000')
1604 error (_("Please specify a command following the thread ID list"));
1606 update_thread_list ();
1608 int tc = live_threads_count ();
1611 /* Save a copy of the thread list and increment each thread's
1612 refcount while executing the command in the context of each
1613 thread, in case the command is one that wipes threads. E.g.,
1614 detach, kill, disconnect, etc., or even normally continuing
1615 over an inferior or thread exit. */
1616 std::vector<thread_info *> thr_list_cpy;
1617 thr_list_cpy.reserve (tc);
1622 ALL_NON_EXITED_THREADS (tp)
1624 thr_list_cpy.push_back (tp);
1627 gdb_assert (thr_list_cpy.size () == tc);
1630 /* Increment the refcounts, and restore them back on scope
1632 scoped_inc_dec_ref inc_dec_ref (thr_list_cpy);
1634 std::sort (thr_list_cpy.begin (), thr_list_cpy.end (), tp_array_compar);
1636 scoped_restore_current_thread restore_thread;
1638 for (thread_info *thr : thr_list_cpy)
1639 if (thread_alive (thr))
1641 switch_to_thread (thr->ptid);
1642 printf_filtered (_("\nThread %s (%s):\n"),
1643 print_thread_id (thr),
1644 target_pid_to_str (inferior_ptid));
1646 execute_command (cmd, from_tty);
1651 /* Implementation of the "thread apply" command. */
1654 thread_apply_command (const char *tidlist, int from_tty)
1656 const char *cmd = NULL;
1657 tid_range_parser parser;
1659 if (tidlist == NULL || *tidlist == '\000')
1660 error (_("Please specify a thread ID list"));
1662 parser.init (tidlist, current_inferior ()->num);
1663 while (!parser.finished ())
1665 int inf_num, thr_start, thr_end;
1667 if (!parser.get_tid_range (&inf_num, &thr_start, &thr_end))
1669 cmd = parser.cur_tok ();
1675 error (_("Please specify a command following the thread ID list"));
1677 if (tidlist == cmd || !isalpha (cmd[0]))
1678 invalid_thread_id_error (cmd);
1680 scoped_restore_current_thread restore_thread;
1682 parser.init (tidlist, current_inferior ()->num);
1683 while (!parser.finished () && parser.cur_tok () < cmd)
1685 struct thread_info *tp = NULL;
1686 struct inferior *inf;
1687 int inf_num, thr_num;
1689 parser.get_tid (&inf_num, &thr_num);
1690 inf = find_inferior_id (inf_num);
1692 tp = find_thread_id (inf, thr_num);
1694 if (parser.in_star_range ())
1698 warning (_("Unknown inferior %d"), inf_num);
1699 parser.skip_range ();
1703 /* No use looking for threads past the highest thread number
1704 the inferior ever had. */
1705 if (thr_num >= inf->highest_thread_num)
1706 parser.skip_range ();
1708 /* Be quiet about unknown threads numbers. */
1715 if (show_inferior_qualified_tids () || parser.tid_is_qualified ())
1716 warning (_("Unknown thread %d.%d"), inf_num, thr_num);
1718 warning (_("Unknown thread %d"), thr_num);
1722 if (!thread_alive (tp))
1724 warning (_("Thread %s has terminated."), print_thread_id (tp));
1728 switch_to_thread (tp->ptid);
1730 printf_filtered (_("\nThread %s (%s):\n"), print_thread_id (tp),
1731 target_pid_to_str (inferior_ptid));
1732 execute_command (cmd, from_tty);
1736 /* Switch to the specified thread, or print the current thread. */
1739 thread_command (const char *tidstr, int from_tty)
1743 if (inferior_ptid == null_ptid)
1744 error (_("No thread selected"));
1746 if (target_has_stack)
1748 struct thread_info *tp = inferior_thread ();
1750 if (is_exited (inferior_ptid))
1751 printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
1752 print_thread_id (tp),
1753 target_pid_to_str (inferior_ptid));
1755 printf_filtered (_("[Current thread is %s (%s)]\n"),
1756 print_thread_id (tp),
1757 target_pid_to_str (inferior_ptid));
1760 error (_("No stack."));
1764 ptid_t previous_ptid = inferior_ptid;
1766 thread_select (tidstr, parse_thread_id (tidstr, NULL));
1768 /* Print if the thread has not changed, otherwise an event will
1770 if (inferior_ptid == previous_ptid)
1772 print_selected_thread_frame (current_uiout,
1773 USER_SELECTED_THREAD
1774 | USER_SELECTED_FRAME);
1778 gdb::observers::user_selected_context_changed.notify
1779 (USER_SELECTED_THREAD | USER_SELECTED_FRAME);
1784 /* Implementation of `thread name'. */
1787 thread_name_command (const char *arg, int from_tty)
1789 struct thread_info *info;
1791 if (inferior_ptid == null_ptid)
1792 error (_("No thread selected"));
1794 arg = skip_spaces (arg);
1796 info = inferior_thread ();
1798 info->name = arg ? xstrdup (arg) : NULL;
1801 /* Find thread ids with a name, target pid, or extra info matching ARG. */
1804 thread_find_command (const char *arg, int from_tty)
1806 struct thread_info *tp;
1808 unsigned long match = 0;
1810 if (arg == NULL || *arg == '\0')
1811 error (_("Command requires an argument."));
1813 tmp = re_comp (arg);
1815 error (_("Invalid regexp (%s): %s"), tmp, arg);
1817 update_thread_list ();
1818 for (tp = thread_list; tp; tp = tp->next)
1820 if (tp->name != NULL && re_exec (tp->name))
1822 printf_filtered (_("Thread %s has name '%s'\n"),
1823 print_thread_id (tp), tp->name);
1827 tmp = target_thread_name (tp);
1828 if (tmp != NULL && re_exec (tmp))
1830 printf_filtered (_("Thread %s has target name '%s'\n"),
1831 print_thread_id (tp), tmp);
1835 tmp = target_pid_to_str (tp->ptid);
1836 if (tmp != NULL && re_exec (tmp))
1838 printf_filtered (_("Thread %s has target id '%s'\n"),
1839 print_thread_id (tp), tmp);
1843 tmp = target_extra_thread_info (tp);
1844 if (tmp != NULL && re_exec (tmp))
1846 printf_filtered (_("Thread %s has extra info '%s'\n"),
1847 print_thread_id (tp), tmp);
1852 printf_filtered (_("No threads match '%s'\n"), arg);
1855 /* Print notices when new threads are attached and detached. */
1856 int print_thread_events = 1;
1858 show_print_thread_events (struct ui_file *file, int from_tty,
1859 struct cmd_list_element *c, const char *value)
1861 fprintf_filtered (file,
1862 _("Printing of thread events is %s.\n"),
1866 /* See gdbthread.h. */
1869 thread_select (const char *tidstr, thread_info *tp)
1871 if (!thread_alive (tp))
1872 error (_("Thread ID %s has terminated."), tidstr);
1874 switch_to_thread (tp->ptid);
1876 annotate_thread_changed ();
1878 /* Since the current thread may have changed, see if there is any
1879 exited thread we can now delete. */
1883 /* Print thread and frame switch command response. */
1886 print_selected_thread_frame (struct ui_out *uiout,
1887 user_selected_what selection)
1889 struct thread_info *tp = inferior_thread ();
1891 if (selection & USER_SELECTED_THREAD)
1893 if (uiout->is_mi_like_p ())
1895 uiout->field_int ("new-thread-id",
1896 inferior_thread ()->global_num);
1900 uiout->text ("[Switching to thread ");
1901 uiout->field_string ("new-thread-id", print_thread_id (tp));
1903 uiout->text (target_pid_to_str (inferior_ptid));
1908 if (tp->state == THREAD_RUNNING)
1910 if (selection & USER_SELECTED_THREAD)
1911 uiout->text ("(running)\n");
1913 else if (selection & USER_SELECTED_FRAME)
1915 if (selection & USER_SELECTED_THREAD)
1918 if (has_stack_frames ())
1919 print_stack_frame_to_uiout (uiout, get_selected_frame (NULL),
1924 /* Update the 'threads_executing' global based on the threads we know
1928 update_threads_executing (void)
1930 struct thread_info *tp;
1932 threads_executing = 0;
1933 ALL_NON_EXITED_THREADS (tp)
1937 threads_executing = 1;
1944 update_thread_list (void)
1946 target_update_thread_list ();
1947 update_threads_executing ();
1950 /* Return a new value for the selected thread's id. Return a value of
1951 0 if no thread is selected. If GLOBAL is true, return the thread's
1952 global number. Otherwise return the per-inferior number. */
1954 static struct value *
1955 thread_num_make_value_helper (struct gdbarch *gdbarch, int global)
1957 struct thread_info *tp = find_thread_ptid (inferior_ptid);
1963 int_val = tp->global_num;
1965 int_val = tp->per_inf_num;
1967 return value_from_longest (builtin_type (gdbarch)->builtin_int, int_val);
1970 /* Return a new value for the selected thread's per-inferior thread
1971 number. Return a value of 0 if no thread is selected, or no
1974 static struct value *
1975 thread_id_per_inf_num_make_value (struct gdbarch *gdbarch,
1976 struct internalvar *var,
1979 return thread_num_make_value_helper (gdbarch, 0);
1982 /* Return a new value for the selected thread's global id. Return a
1983 value of 0 if no thread is selected, or no threads exist. */
1985 static struct value *
1986 global_thread_id_make_value (struct gdbarch *gdbarch, struct internalvar *var,
1989 return thread_num_make_value_helper (gdbarch, 1);
1992 /* Commands with a prefix of `thread'. */
1993 struct cmd_list_element *thread_cmd_list = NULL;
1995 /* Implementation of `thread' variable. */
1997 static const struct internalvar_funcs thread_funcs =
1999 thread_id_per_inf_num_make_value,
2004 /* Implementation of `gthread' variable. */
2006 static const struct internalvar_funcs gthread_funcs =
2008 global_thread_id_make_value,
2014 _initialize_thread (void)
2016 static struct cmd_list_element *thread_apply_list = NULL;
2018 add_info ("threads", info_threads_command,
2019 _("Display currently known threads.\n\
2020 Usage: info threads [-gid] [ID]...\n\
2021 -gid: Show global thread IDs.\n\
2022 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2023 Otherwise, all threads are displayed."));
2025 add_prefix_cmd ("thread", class_run, thread_command, _("\
2026 Use this command to switch between threads.\n\
2027 The new thread ID must be currently known."),
2028 &thread_cmd_list, "thread ", 1, &cmdlist);
2030 add_prefix_cmd ("apply", class_run, thread_apply_command,
2031 _("Apply a command to a list of threads."),
2032 &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
2034 add_cmd ("all", class_run, thread_apply_all_command,
2036 Apply a command to all threads.\n\
2038 Usage: thread apply all [-ascending] <command>\n\
2039 -ascending: Call <command> for all threads in ascending order.\n\
2040 The default is descending order.\
2042 &thread_apply_list);
2044 add_cmd ("name", class_run, thread_name_command,
2045 _("Set the current thread's name.\n\
2046 Usage: thread name [NAME]\n\
2047 If NAME is not given, then any existing name is removed."), &thread_cmd_list);
2049 add_cmd ("find", class_run, thread_find_command, _("\
2050 Find threads that match a regular expression.\n\
2051 Usage: thread find REGEXP\n\
2052 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2055 add_com_alias ("t", "thread", class_run, 1);
2057 add_setshow_boolean_cmd ("thread-events", no_class,
2058 &print_thread_events, _("\
2059 Set printing of thread events (such as thread start and exit)."), _("\
2060 Show printing of thread events (such as thread start and exit)."), NULL,
2062 show_print_thread_events,
2063 &setprintlist, &showprintlist);
2065 create_internalvar_type_lazy ("_thread", &thread_funcs, NULL);
2066 create_internalvar_type_lazy ("_gthread", >hread_funcs, NULL);