1 /* Multi-process/thread control for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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 "common/environ.h"
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"
48 #include "inline-frame.h"
51 /* Definition of struct thread_info exported to gdbthread.h. */
53 /* Prototypes for local functions. */
55 static int highest_thread_num;
57 /* True if any thread is, or may be executing. We need to track this
58 separately because until we fully sync the thread list, we won't
59 know whether the target is fully stopped, even if we see stop
60 events for all known threads, because any of those threads may have
61 spawned new threads we haven't heard of yet. */
62 static int threads_executing;
64 static int thread_alive (struct thread_info *);
66 /* RAII type used to increase / decrease the refcount of each thread
67 in a given list of threads. */
69 class scoped_inc_dec_ref
72 explicit scoped_inc_dec_ref (const std::vector<thread_info *> &thrds)
75 for (thread_info *thr : m_thrds)
79 ~scoped_inc_dec_ref ()
81 for (thread_info *thr : m_thrds)
86 const std::vector<thread_info *> &m_thrds;
91 inferior_thread (void)
93 struct thread_info *tp = find_thread_ptid (inferior_ptid);
98 /* Delete the breakpoint pointed at by BP_P, if there's one. */
101 delete_thread_breakpoint (struct breakpoint **bp_p)
105 delete_breakpoint (*bp_p);
111 delete_step_resume_breakpoint (struct thread_info *tp)
114 delete_thread_breakpoint (&tp->control.step_resume_breakpoint);
118 delete_exception_resume_breakpoint (struct thread_info *tp)
121 delete_thread_breakpoint (&tp->control.exception_resume_breakpoint);
124 /* See gdbthread.h. */
127 delete_single_step_breakpoints (struct thread_info *tp)
130 delete_thread_breakpoint (&tp->control.single_step_breakpoints);
133 /* Delete the breakpoint pointed at by BP_P at the next stop, if
137 delete_at_next_stop (struct breakpoint **bp)
141 (*bp)->disposition = disp_del_at_next_stop;
146 /* See gdbthread.h. */
149 thread_has_single_step_breakpoints_set (struct thread_info *tp)
151 return tp->control.single_step_breakpoints != NULL;
154 /* See gdbthread.h. */
157 thread_has_single_step_breakpoint_here (struct thread_info *tp,
158 const address_space *aspace,
161 struct breakpoint *ss_bps = tp->control.single_step_breakpoints;
163 return (ss_bps != NULL
164 && breakpoint_has_location_inserted_here (ss_bps, aspace, addr));
167 /* See gdbthread.h. */
170 thread_cancel_execution_command (struct thread_info *thr)
172 if (thr->thread_fsm != NULL)
174 thr->thread_fsm->clean_up (thr);
175 delete thr->thread_fsm;
176 thr->thread_fsm = NULL;
181 clear_thread_inferior_resources (struct thread_info *tp)
183 /* NOTE: this will take care of any left-over step_resume breakpoints,
184 but not any user-specified thread-specific breakpoints. We can not
185 delete the breakpoint straight-off, because the inferior might not
186 be stopped at the moment. */
187 delete_at_next_stop (&tp->control.step_resume_breakpoint);
188 delete_at_next_stop (&tp->control.exception_resume_breakpoint);
189 delete_at_next_stop (&tp->control.single_step_breakpoints);
191 delete_longjmp_breakpoint_at_next_stop (tp->global_num);
193 bpstat_clear (&tp->control.stop_bpstat);
195 btrace_teardown (tp);
197 thread_cancel_execution_command (tp);
199 clear_inline_frame_state (tp->ptid);
202 /* Set the TP's state as exited. */
205 set_thread_exited (thread_info *tp, int silent)
207 /* Dead threads don't need to step-over. Remove from queue. */
208 if (tp->step_over_next != NULL)
209 thread_step_over_chain_remove (tp);
211 if (tp->state != THREAD_EXITED)
213 gdb::observers::thread_exit.notify (tp, silent);
215 /* Tag it as exited. */
216 tp->state = THREAD_EXITED;
218 /* Clear breakpoints, etc. associated with this thread. */
219 clear_thread_inferior_resources (tp);
224 init_thread_list (void)
226 highest_thread_num = 0;
228 for (thread_info *tp : all_threads_safe ())
230 inferior *inf = tp->inf;
232 if (tp->deletable ())
235 set_thread_exited (tp, 1);
237 inf->thread_list = NULL;
241 /* Allocate a new thread of inferior INF with target id PTID and add
242 it to the thread list. */
244 static struct thread_info *
245 new_thread (struct inferior *inf, ptid_t ptid)
247 thread_info *tp = new thread_info (inf, ptid);
249 if (inf->thread_list == NULL)
250 inf->thread_list = tp;
253 struct thread_info *last;
255 for (last = inf->thread_list; last->next != NULL; last = last->next)
264 add_thread_silent (ptid_t ptid)
266 struct inferior *inf = find_inferior_ptid (ptid);
267 gdb_assert (inf != NULL);
269 thread_info *tp = find_thread_ptid (inf, ptid);
271 /* Found an old thread with the same id. It has to be dead,
272 otherwise we wouldn't be adding a new thread with the same id.
273 The OS is reusing this id --- delete it, and recreate a new
276 /* In addition to deleting the thread, if this is the current
277 thread, then we need to take care that delete_thread doesn't
278 really delete the thread if it is inferior_ptid. Create a
279 new template thread in the list with an invalid ptid, switch
280 to it, delete the original thread, reset the new thread's
281 ptid, and switch to it. */
283 if (inferior_ptid == ptid)
285 thread_info *new_thr = new_thread (inf, null_ptid);
287 /* Make switch_to_thread not read from the thread. */
288 new_thr->state = THREAD_EXITED;
289 switch_to_no_thread ();
291 /* Now we can delete it. */
294 /* Now reset its ptid, and reswitch inferior_ptid to it. */
295 new_thr->ptid = ptid;
296 new_thr->state = THREAD_STOPPED;
297 switch_to_thread (new_thr);
299 gdb::observers::new_thread.notify (new_thr);
305 /* Just go ahead and delete it. */
309 tp = new_thread (inf, ptid);
310 gdb::observers::new_thread.notify (tp);
316 add_thread_with_info (ptid_t ptid, private_thread_info *priv)
318 struct thread_info *result = add_thread_silent (ptid);
320 result->priv.reset (priv);
322 if (print_thread_events)
323 printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid).c_str ());
325 annotate_new_thread ();
330 add_thread (ptid_t ptid)
332 return add_thread_with_info (ptid, NULL);
335 private_thread_info::~private_thread_info () = default;
337 thread_info::thread_info (struct inferior *inf_, ptid_t ptid_)
338 : ptid (ptid_), inf (inf_)
340 gdb_assert (inf_ != NULL);
342 this->global_num = ++highest_thread_num;
343 this->per_inf_num = ++inf_->highest_thread_num;
345 /* Nothing to follow yet. */
346 memset (&this->pending_follow, 0, sizeof (this->pending_follow));
347 this->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
348 this->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
351 thread_info::~thread_info ()
356 /* See gdbthread.h. */
359 thread_info::deletable () const
361 /* If this is the current thread, or there's code out there that
362 relies on it existing (refcount > 0) we can't delete yet. */
363 return refcount () == 0 && ptid != inferior_ptid;
366 /* Add TP to the end of the step-over chain LIST_P. */
369 step_over_chain_enqueue (struct thread_info **list_p, struct thread_info *tp)
371 gdb_assert (tp->step_over_next == NULL);
372 gdb_assert (tp->step_over_prev == NULL);
377 tp->step_over_prev = tp->step_over_next = tp;
381 struct thread_info *head = *list_p;
382 struct thread_info *tail = head->step_over_prev;
384 tp->step_over_prev = tail;
385 tp->step_over_next = head;
386 head->step_over_prev = tp;
387 tail->step_over_next = tp;
391 /* Remove TP from step-over chain LIST_P. */
394 step_over_chain_remove (struct thread_info **list_p, struct thread_info *tp)
396 gdb_assert (tp->step_over_next != NULL);
397 gdb_assert (tp->step_over_prev != NULL);
401 if (tp == tp->step_over_next)
404 *list_p = tp->step_over_next;
407 tp->step_over_prev->step_over_next = tp->step_over_next;
408 tp->step_over_next->step_over_prev = tp->step_over_prev;
409 tp->step_over_prev = tp->step_over_next = NULL;
412 /* See gdbthread.h. */
415 thread_step_over_chain_next (struct thread_info *tp)
417 struct thread_info *next = tp->step_over_next;
419 return (next == step_over_queue_head ? NULL : next);
422 /* See gdbthread.h. */
425 thread_is_in_step_over_chain (struct thread_info *tp)
427 return (tp->step_over_next != NULL);
430 /* See gdbthread.h. */
433 thread_step_over_chain_enqueue (struct thread_info *tp)
435 step_over_chain_enqueue (&step_over_queue_head, tp);
438 /* See gdbthread.h. */
441 thread_step_over_chain_remove (struct thread_info *tp)
443 step_over_chain_remove (&step_over_queue_head, tp);
446 /* Delete the thread referenced by THR. If SILENT, don't notifyi
447 the observer of this exit.
449 THR must not be NULL or a failed assertion will be raised. */
452 delete_thread_1 (thread_info *thr, bool silent)
454 gdb_assert (thr != nullptr);
456 struct thread_info *tp, *tpprev = NULL;
458 for (tp = thr->inf->thread_list; tp; tpprev = tp, tp = tp->next)
465 set_thread_exited (tp, silent);
467 if (!tp->deletable ())
469 /* Will be really deleted some other time. */
474 tpprev->next = tp->next;
476 tp->inf->thread_list = tp->next;
481 /* Delete thread THREAD and notify of thread exit. If this is the
482 current thread, don't actually delete it, but tag it as exited and
483 do the notification. If this is the user selected thread, clear
487 delete_thread (thread_info *thread)
489 delete_thread_1 (thread, false /* not silent */);
493 delete_thread_silent (thread_info *thread)
495 delete_thread_1 (thread, true /* silent */);
499 find_thread_global_id (int global_id)
501 for (thread_info *tp : all_threads ())
502 if (tp->global_num == global_id)
508 static struct thread_info *
509 find_thread_id (struct inferior *inf, int thr_num)
511 for (thread_info *tp : inf->threads ())
512 if (tp->per_inf_num == thr_num)
518 /* Find a thread_info by matching PTID. */
521 find_thread_ptid (ptid_t ptid)
523 inferior *inf = find_inferior_ptid (ptid);
526 return find_thread_ptid (inf, ptid);
529 /* See gdbthread.h. */
532 find_thread_ptid (inferior *inf, ptid_t ptid)
534 for (thread_info *tp : inf->threads ())
535 if (tp->ptid == ptid)
541 /* See gdbthread.h. */
544 find_thread_by_handle (gdb::array_view<const gdb_byte> handle,
545 struct inferior *inf)
547 return target_thread_handle_to_thread_info (handle.data (),
553 * Thread iterator function.
555 * Calls a callback function once for each thread, so long as
556 * the callback function returns false. If the callback function
557 * returns true, the iteration will end and the current thread
558 * will be returned. This can be useful for implementing a
559 * search for a thread with arbitrary attributes, or for applying
560 * some operation to every thread.
562 * FIXME: some of the existing functionality, such as
563 * "Thread apply all", might be rewritten using this functionality.
567 iterate_over_threads (int (*callback) (struct thread_info *, void *),
570 for (thread_info *tp : all_threads_safe ())
571 if ((*callback) (tp, data))
577 /* See gdbthread.h. */
582 for (thread_info *tp ATTRIBUTE_UNUSED : all_threads ())
590 auto rng = all_threads ();
591 return std::distance (rng.begin (), rng.end ());
594 /* Return the number of non-exited threads in the thread list. */
597 live_threads_count (void)
599 auto rng = all_non_exited_threads ();
600 return std::distance (rng.begin (), rng.end ());
604 valid_global_thread_id (int global_id)
606 for (thread_info *tp : all_threads ())
607 if (tp->global_num == global_id)
614 in_thread_list (ptid_t ptid)
616 return find_thread_ptid (ptid) != nullptr;
619 /* Finds the first thread of the inferior. */
622 first_thread_of_inferior (inferior *inf)
624 return inf->thread_list;
628 any_thread_of_inferior (inferior *inf)
630 gdb_assert (inf->pid != 0);
632 /* Prefer the current thread. */
633 if (inf == current_inferior ())
634 return inferior_thread ();
636 for (thread_info *tp : inf->non_exited_threads ())
643 any_live_thread_of_inferior (inferior *inf)
645 struct thread_info *curr_tp = NULL;
646 struct thread_info *tp_executing = NULL;
648 gdb_assert (inf != NULL && inf->pid != 0);
650 /* Prefer the current thread if it's not executing. */
651 if (inferior_ptid != null_ptid && current_inferior () == inf)
653 /* If the current thread is dead, forget it. If it's not
654 executing, use it. Otherwise, still choose it (below), but
655 only if no other non-executing thread is found. */
656 curr_tp = inferior_thread ();
657 if (curr_tp->state == THREAD_EXITED)
659 else if (!curr_tp->executing)
663 for (thread_info *tp : inf->non_exited_threads ())
671 /* If both the current thread and all live threads are executing,
672 prefer the current thread. */
676 /* Otherwise, just return an executing thread, if any. */
680 /* Return true if TP is an active thread. */
682 thread_alive (struct thread_info *tp)
684 if (tp->state == THREAD_EXITED)
686 if (!target_thread_alive (tp->ptid))
691 /* See gdbthreads.h. */
696 for (thread_info *tp : all_threads_safe ())
697 if (!thread_alive (tp))
701 /* See gdbthreads.h. */
704 delete_exited_threads (void)
706 for (thread_info *tp : all_threads_safe ())
707 if (tp->state == THREAD_EXITED)
711 /* Return true value if stack temporaies are enabled for the thread
715 thread_stack_temporaries_enabled_p (thread_info *tp)
720 return tp->stack_temporaries_enabled;
723 /* Push V on to the stack temporaries of the thread with id PTID. */
726 push_thread_stack_temporary (thread_info *tp, struct value *v)
728 gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
729 tp->stack_temporaries.push_back (v);
732 /* Return true if VAL is among the stack temporaries of the thread
733 TP. Return false otherwise. */
736 value_in_thread_stack_temporaries (struct value *val, thread_info *tp)
738 gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
739 for (value *v : tp->stack_temporaries)
746 /* Return the last of the stack temporaries for thread with id PTID.
747 Return NULL if there are no stack temporaries for the thread. */
750 get_last_thread_stack_temporary (thread_info *tp)
752 struct value *lastval = NULL;
754 gdb_assert (tp != NULL);
755 if (!tp->stack_temporaries.empty ())
756 lastval = tp->stack_temporaries.back ();
762 thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
764 struct inferior *inf;
765 struct thread_info *tp;
767 /* It can happen that what we knew as the target inferior id
768 changes. E.g, target remote may only discover the remote process
769 pid after adding the inferior to GDB's list. */
770 inf = find_inferior_ptid (old_ptid);
771 inf->pid = new_ptid.pid ();
773 tp = find_thread_ptid (inf, old_ptid);
776 gdb::observers::thread_ptid_changed.notify (old_ptid, new_ptid);
779 /* See gdbthread.h. */
782 set_resumed (ptid_t ptid, int resumed)
784 for (thread_info *tp : all_non_exited_threads (ptid))
785 tp->resumed = resumed;
788 /* Helper for set_running, that marks one thread either running or
792 set_running_thread (struct thread_info *tp, int running)
796 if (running && tp->state == THREAD_STOPPED)
798 tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
802 /* If the thread is now marked stopped, remove it from
803 the step-over queue, so that we don't try to resume
804 it until the user wants it to. */
805 if (tp->step_over_next != NULL)
806 thread_step_over_chain_remove (tp);
812 /* See gdbthread.h. */
815 thread_info::set_running (bool running)
817 if (set_running_thread (this, running))
818 gdb::observers::target_resumed.notify (this->ptid);
822 set_running (ptid_t ptid, int running)
824 /* We try not to notify the observer if no thread has actually
825 changed the running state -- merely to reduce the number of
826 messages to the MI frontend. A frontend is supposed to handle
827 multiple *running notifications just fine. */
828 bool any_started = false;
830 for (thread_info *tp : all_non_exited_threads (ptid))
831 if (set_running_thread (tp, running))
835 gdb::observers::target_resumed.notify (ptid);
839 /* Helper for set_executing. Set's the thread's 'executing' field
840 from EXECUTING, and if EXECUTING is true also clears the thread's
844 set_executing_thread (thread_info *thr, bool executing)
846 thr->executing = executing;
848 thr->suspend.stop_pc = ~(CORE_ADDR) 0;
852 set_executing (ptid_t ptid, int executing)
854 for (thread_info *tp : all_non_exited_threads (ptid))
855 set_executing_thread (tp, executing);
857 /* It only takes one running thread to spawn more threads. */
859 threads_executing = 1;
860 /* Only clear the flag if the caller is telling us everything is
862 else if (minus_one_ptid == ptid)
863 threads_executing = 0;
866 /* See gdbthread.h. */
869 threads_are_executing (void)
871 return threads_executing;
875 set_stop_requested (ptid_t ptid, int stop)
877 for (thread_info *tp : all_non_exited_threads (ptid))
878 tp->stop_requested = stop;
880 /* Call the stop requested observer so other components of GDB can
881 react to this request. */
883 gdb::observers::thread_stop_requested.notify (ptid);
887 finish_thread_state (ptid_t ptid)
889 bool any_started = false;
891 for (thread_info *tp : all_non_exited_threads (ptid))
892 if (set_running_thread (tp, tp->executing))
896 gdb::observers::target_resumed.notify (ptid);
899 /* See gdbthread.h. */
902 validate_registers_access (void)
904 /* No selected thread, no registers. */
905 if (inferior_ptid == null_ptid)
906 error (_("No thread selected."));
908 thread_info *tp = inferior_thread ();
910 /* Don't try to read from a dead thread. */
911 if (tp->state == THREAD_EXITED)
912 error (_("The current thread has terminated"));
914 /* ... or from a spinning thread. FIXME: This isn't actually fully
915 correct. It'll allow an user-requested access (e.g., "print $pc"
916 at the prompt) when a thread is not executing for some internal
917 reason, but is marked running from the user's perspective. E.g.,
918 the thread is waiting for its turn in the step-over queue. */
920 error (_("Selected thread is running."));
923 /* See gdbthread.h. */
926 can_access_registers_thread (thread_info *thread)
928 /* No thread, no registers. */
932 /* Don't try to read from a dead thread. */
933 if (thread->state == THREAD_EXITED)
936 /* ... or from a spinning thread. FIXME: see validate_registers_access. */
937 if (thread->executing)
944 pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread)
946 return (pc >= thread->control.step_range_start
947 && pc < thread->control.step_range_end);
950 /* Helper for print_thread_info. Returns true if THR should be
951 printed. If REQUESTED_THREADS, a list of GDB ids/ranges, is not
952 NULL, only print THR if its ID is included in the list. GLOBAL_IDS
953 is true if REQUESTED_THREADS is list of global IDs, false if a list
954 of per-inferior thread ids. If PID is not -1, only print THR if it
955 is a thread from the process PID. Otherwise, threads from all
956 attached PIDs are printed. If both REQUESTED_THREADS is not NULL
957 and PID is not -1, then the thread is printed if it belongs to the
958 specified process. Otherwise, an error is raised. */
961 should_print_thread (const char *requested_threads, int default_inf_num,
962 int global_ids, int pid, struct thread_info *thr)
964 if (requested_threads != NULL && *requested_threads != '\0')
969 in_list = number_is_in_list (requested_threads, thr->global_num);
971 in_list = tid_is_in_list (requested_threads, default_inf_num,
972 thr->inf->num, thr->per_inf_num);
977 if (pid != -1 && thr->ptid.pid () != pid)
979 if (requested_threads != NULL && *requested_threads != '\0')
980 error (_("Requested thread not found in requested process"));
984 if (thr->state == THREAD_EXITED)
990 /* Return the string to display in "info threads"'s "Target Id"
994 thread_target_id_str (thread_info *tp)
996 std::string target_id = target_pid_to_str (tp->ptid);
997 const char *extra_info = target_extra_thread_info (tp);
998 const char *name = tp->name != nullptr ? tp->name : target_thread_name (tp);
1000 if (extra_info != nullptr && name != nullptr)
1001 return string_printf ("%s \"%s\" (%s)", target_id.c_str (), name,
1003 else if (extra_info != nullptr)
1004 return string_printf ("%s (%s)", target_id.c_str (), extra_info);
1005 else if (name != nullptr)
1006 return string_printf ("%s \"%s\"", target_id.c_str (), name);
1011 /* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1012 whether REQUESTED_THREADS is a list of global or per-inferior
1016 print_thread_info_1 (struct ui_out *uiout, const char *requested_threads,
1017 int global_ids, int pid,
1018 int show_global_ids)
1020 int default_inf_num = current_inferior ()->num;
1022 update_thread_list ();
1024 /* Whether we saw any thread. */
1025 bool any_thread = false;
1026 /* Whether the current thread is exited. */
1027 bool current_exited = false;
1029 thread_info *current_thread = (inferior_ptid != null_ptid
1030 ? inferior_thread () : NULL);
1033 /* For backward compatibility, we make a list for MI. A table is
1034 preferable for the CLI, though, because it shows table
1036 gdb::optional<ui_out_emit_list> list_emitter;
1037 gdb::optional<ui_out_emit_table> table_emitter;
1039 if (uiout->is_mi_like_p ())
1040 list_emitter.emplace (uiout, "threads");
1044 /* The width of the "Target Id" column. Grown below to
1045 accommodate the largest entry. */
1046 size_t target_id_col_width = 17;
1048 for (thread_info *tp : all_threads ())
1050 if (!should_print_thread (requested_threads, default_inf_num,
1051 global_ids, pid, tp))
1054 if (!uiout->is_mi_like_p ())
1057 = std::max (target_id_col_width,
1058 thread_target_id_str (tp).size ());
1066 if (requested_threads == NULL || *requested_threads == '\0')
1067 uiout->message (_("No threads.\n"));
1069 uiout->message (_("No threads match '%s'.\n"),
1074 table_emitter.emplace (uiout, show_global_ids ? 5 : 4,
1075 n_threads, "threads");
1077 uiout->table_header (1, ui_left, "current", "");
1078 uiout->table_header (4, ui_left, "id-in-tg", "Id");
1079 if (show_global_ids)
1080 uiout->table_header (4, ui_left, "id", "GId");
1081 uiout->table_header (target_id_col_width, ui_left,
1082 "target-id", "Target Id");
1083 uiout->table_header (1, ui_left, "frame", "Frame");
1084 uiout->table_body ();
1087 /* We'll be switching threads temporarily. */
1088 scoped_restore_current_thread restore_thread;
1090 for (inferior *inf : all_inferiors ())
1091 for (thread_info *tp : inf->threads ())
1096 if (tp == current_thread && tp->state == THREAD_EXITED)
1097 current_exited = true;
1099 if (!should_print_thread (requested_threads, default_inf_num,
1100 global_ids, pid, tp))
1103 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1105 if (!uiout->is_mi_like_p ())
1107 if (tp == current_thread)
1108 uiout->field_string ("current", "*");
1110 uiout->field_skip ("current");
1112 uiout->field_string ("id-in-tg", print_thread_id (tp));
1115 if (show_global_ids || uiout->is_mi_like_p ())
1116 uiout->field_int ("id", tp->global_num);
1118 /* For the CLI, we stuff everything into the target-id field.
1119 This is a gross hack to make the output come out looking
1120 correct. The underlying problem here is that ui-out has no
1121 way to specify that a field's space allocation should be
1122 shared by several fields. For MI, we do the right thing
1125 if (uiout->is_mi_like_p ())
1127 uiout->field_string ("target-id", target_pid_to_str (tp->ptid));
1129 const char *extra_info = target_extra_thread_info (tp);
1130 if (extra_info != nullptr)
1131 uiout->field_string ("details", extra_info);
1133 const char *name = (tp->name != nullptr
1135 : target_thread_name (tp));
1137 uiout->field_string ("name", name);
1141 uiout->field_string ("target-id",
1142 thread_target_id_str (tp).c_str ());
1145 if (tp->state == THREAD_RUNNING)
1146 uiout->text ("(running)\n");
1149 /* The switch below puts us at the top of the stack (leaf
1151 switch_to_thread (tp);
1152 print_stack_frame (get_selected_frame (NULL),
1153 /* For MI output, print frame level. */
1154 uiout->is_mi_like_p (),
1158 if (uiout->is_mi_like_p ())
1160 const char *state = "stopped";
1162 if (tp->state == THREAD_RUNNING)
1164 uiout->field_string ("state", state);
1167 core = target_core_of_thread (tp->ptid);
1168 if (uiout->is_mi_like_p () && core != -1)
1169 uiout->field_int ("core", core);
1172 /* This end scope restores the current thread and the frame
1173 selected before the "info threads" command, and it finishes the
1174 ui-out list or table. */
1177 if (pid == -1 && requested_threads == NULL)
1179 if (uiout->is_mi_like_p () && inferior_ptid != null_ptid)
1180 uiout->field_int ("current-thread-id", current_thread->global_num);
1182 if (inferior_ptid != null_ptid && current_exited)
1183 uiout->message ("\n\
1184 The current thread <Thread ID %s> has terminated. See `help thread'.\n",
1185 print_thread_id (inferior_thread ()));
1186 else if (any_thread && inferior_ptid == null_ptid)
1187 uiout->message ("\n\
1188 No selected thread. See `help thread'.\n");
1192 /* See gdbthread.h. */
1195 print_thread_info (struct ui_out *uiout, const char *requested_threads,
1198 print_thread_info_1 (uiout, requested_threads, 1, pid, 0);
1201 /* Implementation of the "info threads" command.
1203 Note: this has the drawback that it _really_ switches
1204 threads, which frees the frame cache. A no-side
1205 effects info-threads command would be nicer. */
1208 info_threads_command (const char *arg, int from_tty)
1210 int show_global_ids = 0;
1213 && check_for_argument (&arg, "-gid", sizeof ("-gid") - 1))
1215 arg = skip_spaces (arg);
1216 show_global_ids = 1;
1219 print_thread_info_1 (current_uiout, arg, 0, -1, show_global_ids);
1222 /* See gdbthread.h. */
1225 switch_to_thread_no_regs (struct thread_info *thread)
1227 struct inferior *inf = thread->inf;
1229 set_current_program_space (inf->pspace);
1230 set_current_inferior (inf);
1232 inferior_ptid = thread->ptid;
1235 /* See gdbthread.h. */
1238 switch_to_no_thread ()
1240 if (inferior_ptid == null_ptid)
1243 inferior_ptid = null_ptid;
1244 reinit_frame_cache ();
1247 /* See gdbthread.h. */
1250 switch_to_thread (thread_info *thr)
1252 gdb_assert (thr != NULL);
1254 if (inferior_ptid == thr->ptid)
1257 switch_to_thread_no_regs (thr);
1259 reinit_frame_cache ();
1262 /* See common/common-gdbthread.h. */
1265 switch_to_thread (ptid_t ptid)
1267 thread_info *thr = find_thread_ptid (ptid);
1268 switch_to_thread (thr);
1272 restore_selected_frame (struct frame_id a_frame_id, int frame_level)
1274 struct frame_info *frame = NULL;
1277 /* This means there was no selected frame. */
1278 if (frame_level == -1)
1280 select_frame (NULL);
1284 gdb_assert (frame_level >= 0);
1286 /* Restore by level first, check if the frame id is the same as
1287 expected. If that fails, try restoring by frame id. If that
1288 fails, nothing to do, just warn the user. */
1290 count = frame_level;
1291 frame = find_relative_frame (get_current_frame (), &count);
1294 /* The frame ids must match - either both valid or both outer_frame_id.
1295 The latter case is not failsafe, but since it's highly unlikely
1296 the search by level finds the wrong frame, it's 99.9(9)% of
1297 the time (for all practical purposes) safe. */
1298 && frame_id_eq (get_frame_id (frame), a_frame_id))
1300 /* Cool, all is fine. */
1301 select_frame (frame);
1305 frame = frame_find_by_id (a_frame_id);
1308 /* Cool, refound it. */
1309 select_frame (frame);
1313 /* Nothing else to do, the frame layout really changed. Select the
1314 innermost stack frame. */
1315 select_frame (get_current_frame ());
1317 /* Warn the user. */
1318 if (frame_level > 0 && !current_uiout->is_mi_like_p ())
1320 warning (_("Couldn't restore frame #%d in "
1321 "current thread. Bottom (innermost) frame selected:"),
1323 /* For MI, we should probably have a notification about
1324 current frame change. But this error is not very
1325 likely, so don't bother for now. */
1326 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1330 scoped_restore_current_thread::~scoped_restore_current_thread ()
1332 /* If an entry of thread_info was previously selected, it won't be
1333 deleted because we've increased its refcount. The thread represented
1334 by this thread_info entry may have already exited (due to normal exit,
1335 detach, etc), so the thread_info.state is THREAD_EXITED. */
1336 if (m_thread != NULL
1337 /* If the previously selected thread belonged to a process that has
1338 in the mean time exited (or killed, detached, etc.), then don't revert
1339 back to it, but instead simply drop back to no thread selected. */
1341 switch_to_thread (m_thread);
1344 switch_to_no_thread ();
1345 set_current_inferior (m_inf);
1348 /* The running state of the originally selected thread may have
1349 changed, so we have to recheck it here. */
1350 if (inferior_ptid != null_ptid
1352 && m_thread->state == THREAD_STOPPED
1353 && target_has_registers
1355 && target_has_memory)
1356 restore_selected_frame (m_selected_frame_id, m_selected_frame_level);
1358 if (m_thread != NULL)
1359 m_thread->decref ();
1363 scoped_restore_current_thread::scoped_restore_current_thread ()
1366 m_inf = current_inferior ();
1368 if (inferior_ptid != null_ptid)
1370 thread_info *tp = inferior_thread ();
1371 struct frame_info *frame;
1373 m_was_stopped = tp->state == THREAD_STOPPED;
1375 && target_has_registers
1377 && target_has_memory)
1379 /* When processing internal events, there might not be a
1380 selected frame. If we naively call get_selected_frame
1381 here, then we can end up reading debuginfo for the
1382 current frame, but we don't generally need the debuginfo
1384 frame = get_selected_frame_if_set ();
1389 m_selected_frame_id = get_frame_id (frame);
1390 m_selected_frame_level = frame_relative_level (frame);
1399 /* See gdbthread.h. */
1402 show_thread_that_caused_stop (void)
1404 return highest_thread_num > 1;
1407 /* See gdbthread.h. */
1410 show_inferior_qualified_tids (void)
1412 return (inferior_list->next != NULL || inferior_list->num != 1);
1415 /* See gdbthread.h. */
1418 print_thread_id (struct thread_info *thr)
1420 char *s = get_print_cell ();
1422 if (show_inferior_qualified_tids ())
1423 xsnprintf (s, PRINT_CELL_SIZE, "%d.%d", thr->inf->num, thr->per_inf_num);
1425 xsnprintf (s, PRINT_CELL_SIZE, "%d", thr->per_inf_num);
1429 /* If true, tp_array_compar should sort in ascending order, otherwise
1430 in descending order. */
1432 static bool tp_array_compar_ascending;
1434 /* Sort an array for struct thread_info pointers by thread ID (first
1435 by inferior number, and then by per-inferior thread number). The
1436 order is determined by TP_ARRAY_COMPAR_ASCENDING. */
1439 tp_array_compar (const thread_info *a, const thread_info *b)
1441 if (a->inf->num != b->inf->num)
1443 if (tp_array_compar_ascending)
1444 return a->inf->num < b->inf->num;
1446 return a->inf->num > b->inf->num;
1449 if (tp_array_compar_ascending)
1450 return (a->per_inf_num < b->per_inf_num);
1452 return (a->per_inf_num > b->per_inf_num);
1455 /* Switch to thread THR and execute CMD.
1456 FLAGS.QUIET controls the printing of the thread information.
1457 FLAGS.CONT and FLAGS.SILENT control how to handle errors. */
1460 thr_try_catch_cmd (thread_info *thr, const char *cmd, int from_tty,
1461 const qcs_flags &flags)
1463 switch_to_thread (thr);
1466 std::string cmd_result = execute_command_to_string
1467 (cmd, from_tty, gdb_stdout->term_out ());
1468 if (!flags.silent || cmd_result.length () > 0)
1471 printf_filtered (_("\nThread %s (%s):\n"),
1472 print_thread_id (thr),
1473 target_pid_to_str (inferior_ptid).c_str ());
1474 printf_filtered ("%s", cmd_result.c_str ());
1477 catch (const gdb_exception_error &ex)
1482 printf_filtered (_("\nThread %s (%s):\n"),
1483 print_thread_id (thr),
1484 target_pid_to_str (inferior_ptid).c_str ());
1486 printf_filtered ("%s\n", ex.what ());
1493 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1494 separated list of numbers, or ranges, or the keyword `all'. Ranges consist
1495 of two numbers separated by a hyphen. Examples:
1497 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1498 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1499 thread apply all x/i $pc Apply x/i $pc cmd to all threads. */
1502 thread_apply_all_command (const char *cmd, int from_tty)
1506 tp_array_compar_ascending = false;
1510 if (check_for_argument (&cmd, "-ascending", strlen ("-ascending")))
1512 cmd = skip_spaces (cmd);
1513 tp_array_compar_ascending = true;
1517 if (parse_flags_qcs ("thread apply all", &cmd, &flags))
1523 if (cmd == NULL || *cmd == '\000')
1524 error (_("Please specify a command at the end of 'thread apply all'"));
1526 update_thread_list ();
1528 int tc = live_threads_count ();
1531 /* Save a copy of the thread list and increment each thread's
1532 refcount while executing the command in the context of each
1533 thread, in case the command is one that wipes threads. E.g.,
1534 detach, kill, disconnect, etc., or even normally continuing
1535 over an inferior or thread exit. */
1536 std::vector<thread_info *> thr_list_cpy;
1537 thr_list_cpy.reserve (tc);
1539 for (thread_info *tp : all_non_exited_threads ())
1540 thr_list_cpy.push_back (tp);
1541 gdb_assert (thr_list_cpy.size () == tc);
1543 /* Increment the refcounts, and restore them back on scope
1545 scoped_inc_dec_ref inc_dec_ref (thr_list_cpy);
1547 std::sort (thr_list_cpy.begin (), thr_list_cpy.end (), tp_array_compar);
1549 scoped_restore_current_thread restore_thread;
1551 for (thread_info *thr : thr_list_cpy)
1552 if (thread_alive (thr))
1553 thr_try_catch_cmd (thr, cmd, from_tty, flags);
1557 /* Implementation of the "thread apply" command. */
1560 thread_apply_command (const char *tidlist, int from_tty)
1563 const char *cmd = NULL;
1564 tid_range_parser parser;
1566 if (tidlist == NULL || *tidlist == '\000')
1567 error (_("Please specify a thread ID list"));
1569 parser.init (tidlist, current_inferior ()->num);
1570 while (!parser.finished ())
1572 int inf_num, thr_start, thr_end;
1574 if (!parser.get_tid_range (&inf_num, &thr_start, &thr_end))
1578 cmd = parser.cur_tok ();
1580 while (parse_flags_qcs ("thread apply", &cmd, &flags))
1584 error (_("Please specify a command following the thread ID list"));
1586 if (tidlist == cmd || isdigit (cmd[0]))
1587 invalid_thread_id_error (cmd);
1589 scoped_restore_current_thread restore_thread;
1591 parser.init (tidlist, current_inferior ()->num);
1592 while (!parser.finished ())
1594 struct thread_info *tp = NULL;
1595 struct inferior *inf;
1596 int inf_num, thr_num;
1598 parser.get_tid (&inf_num, &thr_num);
1599 inf = find_inferior_id (inf_num);
1601 tp = find_thread_id (inf, thr_num);
1603 if (parser.in_star_range ())
1607 warning (_("Unknown inferior %d"), inf_num);
1608 parser.skip_range ();
1612 /* No use looking for threads past the highest thread number
1613 the inferior ever had. */
1614 if (thr_num >= inf->highest_thread_num)
1615 parser.skip_range ();
1617 /* Be quiet about unknown threads numbers. */
1624 if (show_inferior_qualified_tids () || parser.tid_is_qualified ())
1625 warning (_("Unknown thread %d.%d"), inf_num, thr_num);
1627 warning (_("Unknown thread %d"), thr_num);
1631 if (!thread_alive (tp))
1633 warning (_("Thread %s has terminated."), print_thread_id (tp));
1637 thr_try_catch_cmd (tp, cmd, from_tty, flags);
1642 /* Implementation of the "taas" command. */
1645 taas_command (const char *cmd, int from_tty)
1647 std::string expanded = std::string ("thread apply all -s ") + cmd;
1648 execute_command (expanded.c_str (), from_tty);
1651 /* Implementation of the "tfaas" command. */
1654 tfaas_command (const char *cmd, int from_tty)
1656 std::string expanded
1657 = std::string ("thread apply all -s -- frame apply all -s ") + cmd;
1658 execute_command (expanded.c_str (), from_tty);
1661 /* Switch to the specified thread, or print the current thread. */
1664 thread_command (const char *tidstr, int from_tty)
1668 if (inferior_ptid == null_ptid)
1669 error (_("No thread selected"));
1671 if (target_has_stack)
1673 struct thread_info *tp = inferior_thread ();
1675 if (tp->state == THREAD_EXITED)
1676 printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
1677 print_thread_id (tp),
1678 target_pid_to_str (inferior_ptid).c_str ());
1680 printf_filtered (_("[Current thread is %s (%s)]\n"),
1681 print_thread_id (tp),
1682 target_pid_to_str (inferior_ptid).c_str ());
1685 error (_("No stack."));
1689 ptid_t previous_ptid = inferior_ptid;
1691 thread_select (tidstr, parse_thread_id (tidstr, NULL));
1693 /* Print if the thread has not changed, otherwise an event will
1695 if (inferior_ptid == previous_ptid)
1697 print_selected_thread_frame (current_uiout,
1698 USER_SELECTED_THREAD
1699 | USER_SELECTED_FRAME);
1703 gdb::observers::user_selected_context_changed.notify
1704 (USER_SELECTED_THREAD | USER_SELECTED_FRAME);
1709 /* Implementation of `thread name'. */
1712 thread_name_command (const char *arg, int from_tty)
1714 struct thread_info *info;
1716 if (inferior_ptid == null_ptid)
1717 error (_("No thread selected"));
1719 arg = skip_spaces (arg);
1721 info = inferior_thread ();
1723 info->name = arg ? xstrdup (arg) : NULL;
1726 /* Find thread ids with a name, target pid, or extra info matching ARG. */
1729 thread_find_command (const char *arg, int from_tty)
1732 unsigned long match = 0;
1734 if (arg == NULL || *arg == '\0')
1735 error (_("Command requires an argument."));
1737 tmp = re_comp (arg);
1739 error (_("Invalid regexp (%s): %s"), tmp, arg);
1741 update_thread_list ();
1742 for (thread_info *tp : all_threads ())
1744 if (tp->name != NULL && re_exec (tp->name))
1746 printf_filtered (_("Thread %s has name '%s'\n"),
1747 print_thread_id (tp), tp->name);
1751 tmp = target_thread_name (tp);
1752 if (tmp != NULL && re_exec (tmp))
1754 printf_filtered (_("Thread %s has target name '%s'\n"),
1755 print_thread_id (tp), tmp);
1759 std::string name = target_pid_to_str (tp->ptid);
1760 if (!name.empty () && re_exec (name.c_str ()))
1762 printf_filtered (_("Thread %s has target id '%s'\n"),
1763 print_thread_id (tp), name.c_str ());
1767 tmp = target_extra_thread_info (tp);
1768 if (tmp != NULL && re_exec (tmp))
1770 printf_filtered (_("Thread %s has extra info '%s'\n"),
1771 print_thread_id (tp), tmp);
1776 printf_filtered (_("No threads match '%s'\n"), arg);
1779 /* Print notices when new threads are attached and detached. */
1780 int print_thread_events = 1;
1782 show_print_thread_events (struct ui_file *file, int from_tty,
1783 struct cmd_list_element *c, const char *value)
1785 fprintf_filtered (file,
1786 _("Printing of thread events is %s.\n"),
1790 /* See gdbthread.h. */
1793 thread_select (const char *tidstr, thread_info *tp)
1795 if (!thread_alive (tp))
1796 error (_("Thread ID %s has terminated."), tidstr);
1798 switch_to_thread (tp);
1800 annotate_thread_changed ();
1802 /* Since the current thread may have changed, see if there is any
1803 exited thread we can now delete. */
1807 /* Print thread and frame switch command response. */
1810 print_selected_thread_frame (struct ui_out *uiout,
1811 user_selected_what selection)
1813 struct thread_info *tp = inferior_thread ();
1815 if (selection & USER_SELECTED_THREAD)
1817 if (uiout->is_mi_like_p ())
1819 uiout->field_int ("new-thread-id",
1820 inferior_thread ()->global_num);
1824 uiout->text ("[Switching to thread ");
1825 uiout->field_string ("new-thread-id", print_thread_id (tp));
1827 uiout->text (target_pid_to_str (inferior_ptid).c_str ());
1832 if (tp->state == THREAD_RUNNING)
1834 if (selection & USER_SELECTED_THREAD)
1835 uiout->text ("(running)\n");
1837 else if (selection & USER_SELECTED_FRAME)
1839 if (selection & USER_SELECTED_THREAD)
1842 if (has_stack_frames ())
1843 print_stack_frame_to_uiout (uiout, get_selected_frame (NULL),
1848 /* Update the 'threads_executing' global based on the threads we know
1852 update_threads_executing (void)
1854 threads_executing = 0;
1855 for (thread_info *tp : all_non_exited_threads ())
1859 threads_executing = 1;
1866 update_thread_list (void)
1868 target_update_thread_list ();
1869 update_threads_executing ();
1872 /* Return a new value for the selected thread's id. Return a value of
1873 0 if no thread is selected. If GLOBAL is true, return the thread's
1874 global number. Otherwise return the per-inferior number. */
1876 static struct value *
1877 thread_num_make_value_helper (struct gdbarch *gdbarch, int global)
1881 if (inferior_ptid == null_ptid)
1885 thread_info *tp = inferior_thread ();
1887 int_val = tp->global_num;
1889 int_val = tp->per_inf_num;
1892 return value_from_longest (builtin_type (gdbarch)->builtin_int, int_val);
1895 /* Return a new value for the selected thread's per-inferior thread
1896 number. Return a value of 0 if no thread is selected, or no
1899 static struct value *
1900 thread_id_per_inf_num_make_value (struct gdbarch *gdbarch,
1901 struct internalvar *var,
1904 return thread_num_make_value_helper (gdbarch, 0);
1907 /* Return a new value for the selected thread's global id. Return a
1908 value of 0 if no thread is selected, or no threads exist. */
1910 static struct value *
1911 global_thread_id_make_value (struct gdbarch *gdbarch, struct internalvar *var,
1914 return thread_num_make_value_helper (gdbarch, 1);
1917 /* Commands with a prefix of `thread'. */
1918 struct cmd_list_element *thread_cmd_list = NULL;
1920 /* Implementation of `thread' variable. */
1922 static const struct internalvar_funcs thread_funcs =
1924 thread_id_per_inf_num_make_value,
1929 /* Implementation of `gthread' variable. */
1931 static const struct internalvar_funcs gthread_funcs =
1933 global_thread_id_make_value,
1939 _initialize_thread (void)
1941 static struct cmd_list_element *thread_apply_list = NULL;
1942 cmd_list_element *c;
1944 add_info ("threads", info_threads_command,
1945 _("Display currently known threads.\n\
1946 Usage: info threads [-gid] [ID]...\n\
1947 -gid: Show global thread IDs.\n\
1948 If ID is given, it is a space-separated list of IDs of threads to display.\n\
1949 Otherwise, all threads are displayed."));
1951 add_prefix_cmd ("thread", class_run, thread_command, _("\
1952 Use this command to switch between threads.\n\
1953 The new thread ID must be currently known."),
1954 &thread_cmd_list, "thread ", 1, &cmdlist);
1956 #define THREAD_APPLY_FLAGS_HELP "\
1957 Prints per-inferior thread number and target system's thread id\n\
1958 followed by COMMAND output.\n\
1959 FLAG arguments are -q (quiet), -c (continue), -s (silent).\n\
1960 Flag -q disables printing the thread information.\n\
1961 By default, if a COMMAND raises an error, thread apply is aborted.\n\
1962 Flag -c indicates to print the error and continue.\n\
1963 Flag -s indicates to silently ignore a COMMAND that raises an error\n\
1964 or produces no output."
1966 add_prefix_cmd ("apply", class_run, thread_apply_command,
1967 _("Apply a command to a list of threads.\n\
1968 Usage: thread apply ID... [FLAG]... COMMAND\n\
1969 ID is a space-separated list of IDs of threads to apply COMMAND on.\n"
1970 THREAD_APPLY_FLAGS_HELP),
1971 &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
1973 add_cmd ("all", class_run, thread_apply_all_command,
1975 Apply a command to all threads.\n\
1977 Usage: thread apply all [-ascending] [FLAG]... COMMAND\n\
1978 -ascending: Call COMMAND for all threads in ascending order.\n\
1979 The default is descending order.\n"
1980 THREAD_APPLY_FLAGS_HELP),
1981 &thread_apply_list);
1983 add_com ("taas", class_run, taas_command, _("\
1984 Apply a command to all threads (ignoring errors and empty output).\n\
1985 Usage: taas COMMAND\n\
1986 shortcut for 'thread apply all -s COMMAND'"));
1988 c = add_com ("tfaas", class_run, tfaas_command, _("\
1989 Apply a command to all frames of all threads (ignoring errors and empty output).\n\
1990 Usage: tfaas [OPTION]... COMMAND\n\
1991 shortcut for 'thread apply all -s -- frame apply all -s [OPTION]... COMMAND'\n\
1992 See \"help frame apply all\" for available options."));
1993 set_cmd_completer_handle_brkchars (c, frame_apply_all_cmd_completer);
1995 add_cmd ("name", class_run, thread_name_command,
1996 _("Set the current thread's name.\n\
1997 Usage: thread name [NAME]\n\
1998 If NAME is not given, then any existing name is removed."), &thread_cmd_list);
2000 add_cmd ("find", class_run, thread_find_command, _("\
2001 Find threads that match a regular expression.\n\
2002 Usage: thread find REGEXP\n\
2003 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2006 add_com_alias ("t", "thread", class_run, 1);
2008 add_setshow_boolean_cmd ("thread-events", no_class,
2009 &print_thread_events, _("\
2010 Set printing of thread events (such as thread start and exit)."), _("\
2011 Show printing of thread events (such as thread start and exit)."), NULL,
2013 show_print_thread_events,
2014 &setprintlist, &showprintlist);
2016 create_internalvar_type_lazy ("_thread", &thread_funcs, NULL);
2017 create_internalvar_type_lazy ("_gthread", >hread_funcs, NULL);