1 /* Multi-process/thread control for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 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"
37 #include <sys/types.h>
42 #include "cli/cli-decode.h"
43 #include "gdb_regex.h"
44 #include "cli/cli-utils.h"
45 #include "thread-fsm.h"
46 #include "tid-parse.h"
49 /* Definition of struct thread_info exported to gdbthread.h. */
51 /* Prototypes for exported functions. */
53 void _initialize_thread (void);
55 /* Prototypes for local functions. */
57 struct thread_info
*thread_list
= NULL
;
58 static int highest_thread_num
;
60 /* True if any thread is, or may be executing. We need to track this
61 separately because until we fully sync the thread list, we won't
62 know whether the target is fully stopped, even if we see stop
63 events for all known threads, because any of those threads may have
64 spawned new threads we haven't heard of yet. */
65 static int threads_executing
;
67 static void thread_apply_all_command (char *, int);
68 static int thread_alive (struct thread_info
*);
69 static void info_threads_command (char *, int);
70 static void thread_apply_command (char *, int);
72 /* RAII type used to increase / decrease the refcount of each thread
73 in a given list of threads. */
75 class scoped_inc_dec_ref
78 explicit scoped_inc_dec_ref (const std::vector
<thread_info
*> &thrds
)
81 for (thread_info
*thr
: m_thrds
)
85 ~scoped_inc_dec_ref ()
87 for (thread_info
*thr
: m_thrds
)
92 const std::vector
<thread_info
*> &m_thrds
;
97 inferior_thread (void)
99 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
104 /* Delete the breakpoint pointed at by BP_P, if there's one. */
107 delete_thread_breakpoint (struct breakpoint
**bp_p
)
111 delete_breakpoint (*bp_p
);
117 delete_step_resume_breakpoint (struct thread_info
*tp
)
120 delete_thread_breakpoint (&tp
->control
.step_resume_breakpoint
);
124 delete_exception_resume_breakpoint (struct thread_info
*tp
)
127 delete_thread_breakpoint (&tp
->control
.exception_resume_breakpoint
);
130 /* See gdbthread.h. */
133 delete_single_step_breakpoints (struct thread_info
*tp
)
136 delete_thread_breakpoint (&tp
->control
.single_step_breakpoints
);
139 /* Delete the breakpoint pointed at by BP_P at the next stop, if
143 delete_at_next_stop (struct breakpoint
**bp
)
147 (*bp
)->disposition
= disp_del_at_next_stop
;
152 /* See gdbthread.h. */
155 thread_has_single_step_breakpoints_set (struct thread_info
*tp
)
157 return tp
->control
.single_step_breakpoints
!= NULL
;
160 /* See gdbthread.h. */
163 thread_has_single_step_breakpoint_here (struct thread_info
*tp
,
164 struct address_space
*aspace
,
167 struct breakpoint
*ss_bps
= tp
->control
.single_step_breakpoints
;
169 return (ss_bps
!= NULL
170 && breakpoint_has_location_inserted_here (ss_bps
, aspace
, addr
));
173 /* See gdbthread.h. */
176 thread_cancel_execution_command (struct thread_info
*thr
)
178 if (thr
->thread_fsm
!= NULL
)
180 thread_fsm_clean_up (thr
->thread_fsm
, thr
);
181 thread_fsm_delete (thr
->thread_fsm
);
182 thr
->thread_fsm
= NULL
;
187 clear_thread_inferior_resources (struct thread_info
*tp
)
189 /* NOTE: this will take care of any left-over step_resume breakpoints,
190 but not any user-specified thread-specific breakpoints. We can not
191 delete the breakpoint straight-off, because the inferior might not
192 be stopped at the moment. */
193 delete_at_next_stop (&tp
->control
.step_resume_breakpoint
);
194 delete_at_next_stop (&tp
->control
.exception_resume_breakpoint
);
195 delete_at_next_stop (&tp
->control
.single_step_breakpoints
);
197 delete_longjmp_breakpoint_at_next_stop (tp
->global_num
);
199 bpstat_clear (&tp
->control
.stop_bpstat
);
201 btrace_teardown (tp
);
203 thread_cancel_execution_command (tp
);
206 /* Set the TP's state as exited. */
209 set_thread_exited (thread_info
*tp
, int silent
)
211 /* Dead threads don't need to step-over. Remove from queue. */
212 if (tp
->step_over_next
!= NULL
)
213 thread_step_over_chain_remove (tp
);
215 if (tp
->state
!= THREAD_EXITED
)
217 observer_notify_thread_exit (tp
, silent
);
219 /* Tag it as exited. */
220 tp
->state
= THREAD_EXITED
;
222 /* Clear breakpoints, etc. associated with this thread. */
223 clear_thread_inferior_resources (tp
);
228 init_thread_list (void)
230 struct thread_info
*tp
, *tpnext
;
232 highest_thread_num
= 0;
237 for (tp
= thread_list
; tp
; tp
= tpnext
)
240 if (tp
->deletable ())
243 set_thread_exited (tp
, 1);
247 threads_executing
= 0;
250 /* Allocate a new thread of inferior INF with target id PTID and add
251 it to the thread list. */
253 static struct thread_info
*
254 new_thread (struct inferior
*inf
, ptid_t ptid
)
256 thread_info
*tp
= new thread_info (inf
, ptid
);
258 if (thread_list
== NULL
)
262 struct thread_info
*last
;
264 for (last
= thread_list
; last
->next
!= NULL
; last
= last
->next
)
273 add_thread_silent (ptid_t ptid
)
275 struct thread_info
*tp
;
276 struct inferior
*inf
= find_inferior_ptid (ptid
);
277 gdb_assert (inf
!= NULL
);
279 tp
= find_thread_ptid (ptid
);
281 /* Found an old thread with the same id. It has to be dead,
282 otherwise we wouldn't be adding a new thread with the same id.
283 The OS is reusing this id --- delete it, and recreate a new
286 /* In addition to deleting the thread, if this is the current
287 thread, then we need to take care that delete_thread doesn't
288 really delete the thread if it is inferior_ptid. Create a
289 new template thread in the list with an invalid ptid, switch
290 to it, delete the original thread, reset the new thread's
291 ptid, and switch to it. */
293 if (inferior_ptid
== ptid
)
295 tp
= new_thread (inf
, null_ptid
);
297 /* Make switch_to_thread not read from the thread. */
298 tp
->state
= THREAD_EXITED
;
299 switch_to_thread (null_ptid
);
301 /* Now we can delete it. */
302 delete_thread (ptid
);
304 /* Now reset its ptid, and reswitch inferior_ptid to it. */
306 tp
->state
= THREAD_STOPPED
;
307 switch_to_thread (ptid
);
309 observer_notify_new_thread (tp
);
315 /* Just go ahead and delete it. */
316 delete_thread (ptid
);
319 tp
= new_thread (inf
, ptid
);
320 observer_notify_new_thread (tp
);
326 add_thread_with_info (ptid_t ptid
, struct private_thread_info
*priv
)
328 struct thread_info
*result
= add_thread_silent (ptid
);
332 if (print_thread_events
)
333 printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid
));
335 annotate_new_thread ();
340 add_thread (ptid_t ptid
)
342 return add_thread_with_info (ptid
, NULL
);
345 thread_info::thread_info (struct inferior
*inf_
, ptid_t ptid_
)
346 : ptid (ptid_
), inf (inf_
)
348 gdb_assert (inf_
!= NULL
);
350 this->global_num
= ++highest_thread_num
;
351 this->per_inf_num
= ++inf_
->highest_thread_num
;
353 /* Nothing to follow yet. */
354 memset (&this->pending_follow
, 0, sizeof (this->pending_follow
));
355 this->pending_follow
.kind
= TARGET_WAITKIND_SPURIOUS
;
356 this->suspend
.waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
359 thread_info::~thread_info ()
363 if (this->private_dtor
)
364 this->private_dtor (this->priv
);
372 /* Add TP to the end of the step-over chain LIST_P. */
375 step_over_chain_enqueue (struct thread_info
**list_p
, struct thread_info
*tp
)
377 gdb_assert (tp
->step_over_next
== NULL
);
378 gdb_assert (tp
->step_over_prev
== NULL
);
383 tp
->step_over_prev
= tp
->step_over_next
= tp
;
387 struct thread_info
*head
= *list_p
;
388 struct thread_info
*tail
= head
->step_over_prev
;
390 tp
->step_over_prev
= tail
;
391 tp
->step_over_next
= head
;
392 head
->step_over_prev
= tp
;
393 tail
->step_over_next
= tp
;
397 /* Remove TP from step-over chain LIST_P. */
400 step_over_chain_remove (struct thread_info
**list_p
, struct thread_info
*tp
)
402 gdb_assert (tp
->step_over_next
!= NULL
);
403 gdb_assert (tp
->step_over_prev
!= NULL
);
407 if (tp
== tp
->step_over_next
)
410 *list_p
= tp
->step_over_next
;
413 tp
->step_over_prev
->step_over_next
= tp
->step_over_next
;
414 tp
->step_over_next
->step_over_prev
= tp
->step_over_prev
;
415 tp
->step_over_prev
= tp
->step_over_next
= NULL
;
418 /* See gdbthread.h. */
421 thread_step_over_chain_next (struct thread_info
*tp
)
423 struct thread_info
*next
= tp
->step_over_next
;
425 return (next
== step_over_queue_head
? NULL
: next
);
428 /* See gdbthread.h. */
431 thread_is_in_step_over_chain (struct thread_info
*tp
)
433 return (tp
->step_over_next
!= NULL
);
436 /* See gdbthread.h. */
439 thread_step_over_chain_enqueue (struct thread_info
*tp
)
441 step_over_chain_enqueue (&step_over_queue_head
, tp
);
444 /* See gdbthread.h. */
447 thread_step_over_chain_remove (struct thread_info
*tp
)
449 step_over_chain_remove (&step_over_queue_head
, tp
);
452 /* Delete thread PTID. If SILENT, don't notify the observer of this
455 delete_thread_1 (ptid_t ptid
, int silent
)
457 struct thread_info
*tp
, *tpprev
;
461 for (tp
= thread_list
; tp
; tpprev
= tp
, tp
= tp
->next
)
462 if (tp
->ptid
== ptid
)
468 set_thread_exited (tp
, silent
);
470 if (!tp
->deletable ())
472 /* Will be really deleted some other time. */
477 tpprev
->next
= tp
->next
;
479 thread_list
= tp
->next
;
484 /* Delete thread PTID and notify of thread exit. If this is
485 inferior_ptid, don't actually delete it, but tag it as exited and
486 do the notification. If PTID is the user selected thread, clear
489 delete_thread (ptid_t ptid
)
491 delete_thread_1 (ptid
, 0 /* not silent */);
495 delete_thread_silent (ptid_t ptid
)
497 delete_thread_1 (ptid
, 1 /* silent */);
501 find_thread_global_id (int global_id
)
503 struct thread_info
*tp
;
505 for (tp
= thread_list
; tp
; tp
= tp
->next
)
506 if (tp
->global_num
== global_id
)
512 static struct thread_info
*
513 find_thread_id (struct inferior
*inf
, int thr_num
)
515 struct thread_info
*tp
;
517 for (tp
= thread_list
; tp
; tp
= tp
->next
)
518 if (tp
->inf
== inf
&& tp
->per_inf_num
== thr_num
)
524 /* Find a thread_info by matching PTID. */
526 find_thread_ptid (ptid_t ptid
)
528 struct thread_info
*tp
;
530 for (tp
= thread_list
; tp
; tp
= tp
->next
)
531 if (tp
->ptid
== ptid
)
538 * Thread iterator function.
540 * Calls a callback function once for each thread, so long as
541 * the callback function returns false. If the callback function
542 * returns true, the iteration will end and the current thread
543 * will be returned. This can be useful for implementing a
544 * search for a thread with arbitrary attributes, or for applying
545 * some operation to every thread.
547 * FIXME: some of the existing functionality, such as
548 * "Thread apply all", might be rewritten using this functionality.
552 iterate_over_threads (int (*callback
) (struct thread_info
*, void *),
555 struct thread_info
*tp
, *next
;
557 for (tp
= thread_list
; tp
; tp
= next
)
560 if ((*callback
) (tp
, data
))
571 struct thread_info
*tp
;
573 for (tp
= thread_list
; tp
; tp
= tp
->next
)
579 /* Return the number of non-exited threads in the thread list. */
582 live_threads_count (void)
585 struct thread_info
*tp
;
587 ALL_NON_EXITED_THREADS (tp
)
594 valid_global_thread_id (int global_id
)
596 struct thread_info
*tp
;
598 for (tp
= thread_list
; tp
; tp
= tp
->next
)
599 if (tp
->global_num
== global_id
)
606 ptid_to_global_thread_id (ptid_t ptid
)
608 struct thread_info
*tp
;
610 for (tp
= thread_list
; tp
; tp
= tp
->next
)
611 if (tp
->ptid
== ptid
)
612 return tp
->global_num
;
618 global_thread_id_to_ptid (int global_id
)
620 struct thread_info
*thread
= find_thread_global_id (global_id
);
625 return minus_one_ptid
;
629 in_thread_list (ptid_t ptid
)
631 struct thread_info
*tp
;
633 for (tp
= thread_list
; tp
; tp
= tp
->next
)
634 if (tp
->ptid
== ptid
)
637 return 0; /* Never heard of 'im. */
640 /* Finds the first thread of the inferior given by PID. If PID is -1,
641 return the first thread in the list. */
644 first_thread_of_process (int pid
)
646 struct thread_info
*tp
, *ret
= NULL
;
648 for (tp
= thread_list
; tp
; tp
= tp
->next
)
649 if (pid
== -1 || ptid_get_pid (tp
->ptid
) == pid
)
650 if (ret
== NULL
|| tp
->global_num
< ret
->global_num
)
657 any_thread_of_process (int pid
)
659 struct thread_info
*tp
;
661 gdb_assert (pid
!= 0);
663 /* Prefer the current thread. */
664 if (ptid_get_pid (inferior_ptid
) == pid
)
665 return inferior_thread ();
667 ALL_NON_EXITED_THREADS (tp
)
668 if (ptid_get_pid (tp
->ptid
) == pid
)
675 any_live_thread_of_process (int pid
)
677 struct thread_info
*curr_tp
= NULL
;
678 struct thread_info
*tp
;
679 struct thread_info
*tp_executing
= NULL
;
681 gdb_assert (pid
!= 0);
683 /* Prefer the current thread if it's not executing. */
684 if (ptid_get_pid (inferior_ptid
) == pid
)
686 /* If the current thread is dead, forget it. If it's not
687 executing, use it. Otherwise, still choose it (below), but
688 only if no other non-executing thread is found. */
689 curr_tp
= inferior_thread ();
690 if (curr_tp
->state
== THREAD_EXITED
)
692 else if (!curr_tp
->executing
)
696 ALL_NON_EXITED_THREADS (tp
)
697 if (ptid_get_pid (tp
->ptid
) == pid
)
705 /* If both the current thread and all live threads are executing,
706 prefer the current thread. */
710 /* Otherwise, just return an executing thread, if any. */
714 /* Print a list of thread ids currently known, and the total number of
715 threads. To be used from within catch_errors. */
717 do_captured_list_thread_ids (struct ui_out
*uiout
, void *arg
)
719 struct thread_info
*tp
;
721 int current_thread
= -1;
723 update_thread_list ();
726 ui_out_emit_tuple
tuple_emitter (uiout
, "thread-ids");
728 for (tp
= thread_list
; tp
; tp
= tp
->next
)
730 if (tp
->state
== THREAD_EXITED
)
733 if (tp
->ptid
== inferior_ptid
)
734 current_thread
= tp
->global_num
;
737 uiout
->field_int ("thread-id", tp
->global_num
);
741 if (current_thread
!= -1)
742 uiout
->field_int ("current-thread-id", current_thread
);
743 uiout
->field_int ("number-of-threads", num
);
747 /* Official gdblib interface function to get a list of thread ids and
750 gdb_list_thread_ids (struct ui_out
*uiout
, char **error_message
)
752 if (catch_exceptions_with_msg (uiout
, do_captured_list_thread_ids
, NULL
,
753 error_message
, RETURN_MASK_ALL
) < 0)
758 /* Return true if TP is an active thread. */
760 thread_alive (struct thread_info
*tp
)
762 if (tp
->state
== THREAD_EXITED
)
764 if (!target_thread_alive (tp
->ptid
))
769 /* See gdbthreads.h. */
774 struct thread_info
*tp
, *tmp
;
776 ALL_THREADS_SAFE (tp
, tmp
)
778 if (!thread_alive (tp
))
779 delete_thread (tp
->ptid
);
783 /* See gdbthreads.h. */
786 delete_exited_threads (void)
788 struct thread_info
*tp
, *tmp
;
790 ALL_THREADS_SAFE (tp
, tmp
)
792 if (tp
->state
== THREAD_EXITED
)
793 delete_thread (tp
->ptid
);
797 /* Disable storing stack temporaries for the thread whose id is
801 disable_thread_stack_temporaries (void *data
)
803 ptid_t
*pd
= (ptid_t
*) data
;
804 struct thread_info
*tp
= find_thread_ptid (*pd
);
808 tp
->stack_temporaries_enabled
= 0;
809 VEC_free (value_ptr
, tp
->stack_temporaries
);
815 /* Enable storing stack temporaries for thread with id PTID and return a
816 cleanup which can disable and clear the stack temporaries. */
819 enable_thread_stack_temporaries (ptid_t ptid
)
821 struct thread_info
*tp
= find_thread_ptid (ptid
);
825 gdb_assert (tp
!= NULL
);
827 tp
->stack_temporaries_enabled
= 1;
828 tp
->stack_temporaries
= NULL
;
829 data
= XNEW (ptid_t
);
831 c
= make_cleanup (disable_thread_stack_temporaries
, data
);
836 /* Return non-zero value if stack temporaies are enabled for the thread
840 thread_stack_temporaries_enabled_p (ptid_t ptid
)
842 struct thread_info
*tp
= find_thread_ptid (ptid
);
847 return tp
->stack_temporaries_enabled
;
850 /* Push V on to the stack temporaries of the thread with id PTID. */
853 push_thread_stack_temporary (ptid_t ptid
, struct value
*v
)
855 struct thread_info
*tp
= find_thread_ptid (ptid
);
857 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
858 VEC_safe_push (value_ptr
, tp
->stack_temporaries
, v
);
861 /* Return 1 if VAL is among the stack temporaries of the thread
862 with id PTID. Return 0 otherwise. */
865 value_in_thread_stack_temporaries (struct value
*val
, ptid_t ptid
)
867 struct thread_info
*tp
= find_thread_ptid (ptid
);
869 gdb_assert (tp
!= NULL
&& tp
->stack_temporaries_enabled
);
870 if (!VEC_empty (value_ptr
, tp
->stack_temporaries
))
875 for (i
= 0; VEC_iterate (value_ptr
, tp
->stack_temporaries
, i
, v
); i
++)
883 /* Return the last of the stack temporaries for thread with id PTID.
884 Return NULL if there are no stack temporaries for the thread. */
887 get_last_thread_stack_temporary (ptid_t ptid
)
889 struct value
*lastval
= NULL
;
890 struct thread_info
*tp
= find_thread_ptid (ptid
);
892 gdb_assert (tp
!= NULL
);
893 if (!VEC_empty (value_ptr
, tp
->stack_temporaries
))
894 lastval
= VEC_last (value_ptr
, tp
->stack_temporaries
);
900 thread_change_ptid (ptid_t old_ptid
, ptid_t new_ptid
)
902 struct inferior
*inf
;
903 struct thread_info
*tp
;
905 /* It can happen that what we knew as the target inferior id
906 changes. E.g, target remote may only discover the remote process
907 pid after adding the inferior to GDB's list. */
908 inf
= find_inferior_ptid (old_ptid
);
909 inf
->pid
= ptid_get_pid (new_ptid
);
911 tp
= find_thread_ptid (old_ptid
);
914 observer_notify_thread_ptid_changed (old_ptid
, new_ptid
);
917 /* See gdbthread.h. */
920 set_resumed (ptid_t ptid
, int resumed
)
922 struct thread_info
*tp
;
923 int all
= ptid
== minus_one_ptid
;
925 if (all
|| ptid_is_pid (ptid
))
927 for (tp
= thread_list
; tp
; tp
= tp
->next
)
928 if (all
|| ptid_get_pid (tp
->ptid
) == ptid_get_pid (ptid
))
929 tp
->resumed
= resumed
;
933 tp
= find_thread_ptid (ptid
);
934 gdb_assert (tp
!= NULL
);
935 tp
->resumed
= resumed
;
939 /* Helper for set_running, that marks one thread either running or
943 set_running_thread (struct thread_info
*tp
, int running
)
947 if (running
&& tp
->state
== THREAD_STOPPED
)
949 tp
->state
= running
? THREAD_RUNNING
: THREAD_STOPPED
;
953 /* If the thread is now marked stopped, remove it from
954 the step-over queue, so that we don't try to resume
955 it until the user wants it to. */
956 if (tp
->step_over_next
!= NULL
)
957 thread_step_over_chain_remove (tp
);
964 set_running (ptid_t ptid
, int running
)
966 struct thread_info
*tp
;
967 int all
= ptid
== minus_one_ptid
;
970 /* We try not to notify the observer if no thread has actually changed
971 the running state -- merely to reduce the number of messages to
972 frontend. Frontend is supposed to handle multiple *running just fine. */
973 if (all
|| ptid_is_pid (ptid
))
975 for (tp
= thread_list
; tp
; tp
= tp
->next
)
976 if (all
|| ptid_get_pid (tp
->ptid
) == ptid_get_pid (ptid
))
978 if (tp
->state
== THREAD_EXITED
)
981 if (set_running_thread (tp
, running
))
987 tp
= find_thread_ptid (ptid
);
988 gdb_assert (tp
!= NULL
);
989 gdb_assert (tp
->state
!= THREAD_EXITED
);
990 if (set_running_thread (tp
, running
))
994 observer_notify_target_resumed (ptid
);
998 is_thread_state (ptid_t ptid
, enum thread_state state
)
1000 struct thread_info
*tp
;
1002 tp
= find_thread_ptid (ptid
);
1004 return tp
->state
== state
;
1008 is_stopped (ptid_t ptid
)
1010 return is_thread_state (ptid
, THREAD_STOPPED
);
1014 is_exited (ptid_t ptid
)
1016 return is_thread_state (ptid
, THREAD_EXITED
);
1020 is_running (ptid_t ptid
)
1022 return is_thread_state (ptid
, THREAD_RUNNING
);
1026 is_executing (ptid_t ptid
)
1028 struct thread_info
*tp
;
1030 tp
= find_thread_ptid (ptid
);
1032 return tp
->executing
;
1036 set_executing (ptid_t ptid
, int executing
)
1038 struct thread_info
*tp
;
1039 int all
= ptid
== minus_one_ptid
;
1041 if (all
|| ptid_is_pid (ptid
))
1043 for (tp
= thread_list
; tp
; tp
= tp
->next
)
1044 if (all
|| ptid_get_pid (tp
->ptid
) == ptid_get_pid (ptid
))
1045 tp
->executing
= executing
;
1049 tp
= find_thread_ptid (ptid
);
1051 tp
->executing
= executing
;
1054 /* It only takes one running thread to spawn more threads.*/
1056 threads_executing
= 1;
1057 /* Only clear the flag if the caller is telling us everything is
1059 else if (minus_one_ptid
== ptid
)
1060 threads_executing
= 0;
1063 /* See gdbthread.h. */
1066 threads_are_executing (void)
1068 return threads_executing
;
1072 set_stop_requested (ptid_t ptid
, int stop
)
1074 struct thread_info
*tp
;
1075 int all
= ptid
== minus_one_ptid
;
1077 if (all
|| ptid_is_pid (ptid
))
1079 for (tp
= thread_list
; tp
; tp
= tp
->next
)
1080 if (all
|| ptid_get_pid (tp
->ptid
) == ptid_get_pid (ptid
))
1081 tp
->stop_requested
= stop
;
1085 tp
= find_thread_ptid (ptid
);
1087 tp
->stop_requested
= stop
;
1090 /* Call the stop requested observer so other components of GDB can
1091 react to this request. */
1093 observer_notify_thread_stop_requested (ptid
);
1097 finish_thread_state (ptid_t ptid
)
1099 struct thread_info
*tp
;
1101 int any_started
= 0;
1103 all
= ptid
== minus_one_ptid
;
1105 if (all
|| ptid_is_pid (ptid
))
1107 for (tp
= thread_list
; tp
; tp
= tp
->next
)
1109 if (tp
->state
== THREAD_EXITED
)
1111 if (all
|| ptid_get_pid (ptid
) == ptid_get_pid (tp
->ptid
))
1113 if (set_running_thread (tp
, tp
->executing
))
1120 tp
= find_thread_ptid (ptid
);
1122 if (tp
->state
!= THREAD_EXITED
)
1124 if (set_running_thread (tp
, tp
->executing
))
1130 observer_notify_target_resumed (ptid
);
1134 finish_thread_state_cleanup (void *arg
)
1136 ptid_t
*ptid_p
= (ptid_t
*) arg
;
1140 finish_thread_state (*ptid_p
);
1143 /* See gdbthread.h. */
1146 validate_registers_access (void)
1148 /* No selected thread, no registers. */
1149 if (inferior_ptid
== null_ptid
)
1150 error (_("No thread selected."));
1152 /* Don't try to read from a dead thread. */
1153 if (is_exited (inferior_ptid
))
1154 error (_("The current thread has terminated"));
1156 /* ... or from a spinning thread. FIXME: This isn't actually fully
1157 correct. It'll allow an user-requested access (e.g., "print $pc"
1158 at the prompt) when a thread is not executing for some internal
1159 reason, but is marked running from the user's perspective. E.g.,
1160 the thread is waiting for its turn in the step-over queue. */
1161 if (is_executing (inferior_ptid
))
1162 error (_("Selected thread is running."));
1165 /* See gdbthread.h. */
1168 can_access_registers_ptid (ptid_t ptid
)
1170 /* No thread, no registers. */
1171 if (ptid
== null_ptid
)
1174 /* Don't try to read from a dead thread. */
1175 if (is_exited (ptid
))
1178 /* ... or from a spinning thread. FIXME: see validate_registers_access. */
1179 if (is_executing (ptid
))
1186 pc_in_thread_step_range (CORE_ADDR pc
, struct thread_info
*thread
)
1188 return (pc
>= thread
->control
.step_range_start
1189 && pc
< thread
->control
.step_range_end
);
1192 /* Helper for print_thread_info. Returns true if THR should be
1193 printed. If REQUESTED_THREADS, a list of GDB ids/ranges, is not
1194 NULL, only print THR if its ID is included in the list. GLOBAL_IDS
1195 is true if REQUESTED_THREADS is list of global IDs, false if a list
1196 of per-inferior thread ids. If PID is not -1, only print THR if it
1197 is a thread from the process PID. Otherwise, threads from all
1198 attached PIDs are printed. If both REQUESTED_THREADS is not NULL
1199 and PID is not -1, then the thread is printed if it belongs to the
1200 specified process. Otherwise, an error is raised. */
1203 should_print_thread (const char *requested_threads
, int default_inf_num
,
1204 int global_ids
, int pid
, struct thread_info
*thr
)
1206 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1211 in_list
= number_is_in_list (requested_threads
, thr
->global_num
);
1213 in_list
= tid_is_in_list (requested_threads
, default_inf_num
,
1214 thr
->inf
->num
, thr
->per_inf_num
);
1219 if (pid
!= -1 && ptid_get_pid (thr
->ptid
) != pid
)
1221 if (requested_threads
!= NULL
&& *requested_threads
!= '\0')
1222 error (_("Requested thread not found in requested process"));
1226 if (thr
->state
== THREAD_EXITED
)
1232 /* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1233 whether REQUESTED_THREADS is a list of global or per-inferior
1237 print_thread_info_1 (struct ui_out
*uiout
, char *requested_threads
,
1238 int global_ids
, int pid
,
1239 int show_global_ids
)
1241 struct thread_info
*tp
;
1242 ptid_t current_ptid
;
1243 struct cleanup
*old_chain
;
1244 const char *extra_info
, *name
, *target_id
;
1245 struct inferior
*inf
;
1246 int default_inf_num
= current_inferior ()->num
;
1248 update_thread_list ();
1249 current_ptid
= inferior_ptid
;
1251 /* We'll be switching threads temporarily. */
1252 old_chain
= make_cleanup_restore_current_thread ();
1254 /* For backward compatibility, we make a list for MI. A table is
1255 preferable for the CLI, though, because it shows table
1257 if (uiout
->is_mi_like_p ())
1258 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
1263 for (tp
= thread_list
; tp
; tp
= tp
->next
)
1265 if (!should_print_thread (requested_threads
, default_inf_num
,
1266 global_ids
, pid
, tp
))
1274 if (requested_threads
== NULL
|| *requested_threads
== '\0')
1275 uiout
->message (_("No threads.\n"));
1277 uiout
->message (_("No threads match '%s'.\n"),
1279 do_cleanups (old_chain
);
1283 if (show_global_ids
|| uiout
->is_mi_like_p ())
1284 make_cleanup_ui_out_table_begin_end (uiout
, 5, n_threads
, "threads");
1286 make_cleanup_ui_out_table_begin_end (uiout
, 4, n_threads
, "threads");
1288 uiout
->table_header (1, ui_left
, "current", "");
1290 if (!uiout
->is_mi_like_p ())
1291 uiout
->table_header (4, ui_left
, "id-in-tg", "Id");
1292 if (show_global_ids
|| uiout
->is_mi_like_p ())
1293 uiout
->table_header (4, ui_left
, "id", "GId");
1294 uiout
->table_header (17, ui_left
, "target-id", "Target Id");
1295 uiout
->table_header (1, ui_left
, "frame", "Frame");
1296 uiout
->table_body ();
1299 ALL_THREADS_BY_INFERIOR (inf
, tp
)
1303 if (!should_print_thread (requested_threads
, default_inf_num
,
1304 global_ids
, pid
, tp
))
1307 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1309 if (!uiout
->is_mi_like_p ())
1311 if (tp
->ptid
== current_ptid
)
1312 uiout
->field_string ("current", "*");
1314 uiout
->field_skip ("current");
1317 if (!uiout
->is_mi_like_p ())
1318 uiout
->field_string ("id-in-tg", print_thread_id (tp
));
1320 if (show_global_ids
|| uiout
->is_mi_like_p ())
1321 uiout
->field_int ("id", tp
->global_num
);
1323 /* For the CLI, we stuff everything into the target-id field.
1324 This is a gross hack to make the output come out looking
1325 correct. The underlying problem here is that ui-out has no
1326 way to specify that a field's space allocation should be
1327 shared by several fields. For MI, we do the right thing
1330 target_id
= target_pid_to_str (tp
->ptid
);
1331 extra_info
= target_extra_thread_info (tp
);
1332 name
= tp
->name
? tp
->name
: target_thread_name (tp
);
1334 if (uiout
->is_mi_like_p ())
1336 uiout
->field_string ("target-id", target_id
);
1338 uiout
->field_string ("details", extra_info
);
1340 uiout
->field_string ("name", name
);
1344 struct cleanup
*str_cleanup
;
1347 if (extra_info
&& name
)
1348 contents
= xstrprintf ("%s \"%s\" (%s)", target_id
,
1350 else if (extra_info
)
1351 contents
= xstrprintf ("%s (%s)", target_id
, extra_info
);
1353 contents
= xstrprintf ("%s \"%s\"", target_id
, name
);
1355 contents
= xstrdup (target_id
);
1356 str_cleanup
= make_cleanup (xfree
, contents
);
1358 uiout
->field_string ("target-id", contents
);
1359 do_cleanups (str_cleanup
);
1362 if (tp
->state
== THREAD_RUNNING
)
1363 uiout
->text ("(running)\n");
1366 /* The switch below puts us at the top of the stack (leaf
1368 switch_to_thread (tp
->ptid
);
1369 print_stack_frame (get_selected_frame (NULL
),
1370 /* For MI output, print frame level. */
1371 uiout
->is_mi_like_p (),
1375 if (uiout
->is_mi_like_p ())
1377 const char *state
= "stopped";
1379 if (tp
->state
== THREAD_RUNNING
)
1381 uiout
->field_string ("state", state
);
1384 core
= target_core_of_thread (tp
->ptid
);
1385 if (uiout
->is_mi_like_p () && core
!= -1)
1386 uiout
->field_int ("core", core
);
1389 /* Restores the current thread and the frame selected before
1390 the "info threads" command. */
1391 do_cleanups (old_chain
);
1393 if (pid
== -1 && requested_threads
== NULL
)
1395 if (uiout
->is_mi_like_p ()
1396 && inferior_ptid
!= null_ptid
)
1398 int num
= ptid_to_global_thread_id (inferior_ptid
);
1400 gdb_assert (num
!= 0);
1401 uiout
->field_int ("current-thread-id", num
);
1404 if (inferior_ptid
!= null_ptid
&& is_exited (inferior_ptid
))
1405 uiout
->message ("\n\
1406 The current thread <Thread ID %s> has terminated. See `help thread'.\n",
1407 print_thread_id (inferior_thread ()));
1408 else if (thread_list
!= NULL
&& inferior_ptid
== null_ptid
)
1409 uiout
->message ("\n\
1410 No selected thread. See `help thread'.\n");
1414 /* See gdbthread.h. */
1417 print_thread_info (struct ui_out
*uiout
, char *requested_threads
, int pid
)
1419 print_thread_info_1 (uiout
, requested_threads
, 1, pid
, 0);
1422 /* Implementation of the "info threads" command.
1424 Note: this has the drawback that it _really_ switches
1425 threads, which frees the frame cache. A no-side
1426 effects info-threads command would be nicer. */
1429 info_threads_command (char *arg
, int from_tty
)
1431 int show_global_ids
= 0;
1434 && check_for_argument (&arg
, "-gid", sizeof ("-gid") - 1))
1436 arg
= skip_spaces (arg
);
1437 show_global_ids
= 1;
1440 print_thread_info_1 (current_uiout
, arg
, 0, -1, show_global_ids
);
1443 /* See gdbthread.h. */
1446 switch_to_thread_no_regs (struct thread_info
*thread
)
1448 struct inferior
*inf
= thread
->inf
;
1450 set_current_program_space (inf
->pspace
);
1451 set_current_inferior (inf
);
1453 inferior_ptid
= thread
->ptid
;
1454 stop_pc
= ~(CORE_ADDR
) 0;
1457 /* Switch to no thread selected. */
1460 switch_to_no_thread ()
1462 if (inferior_ptid
== null_ptid
)
1465 inferior_ptid
= null_ptid
;
1466 reinit_frame_cache ();
1467 stop_pc
= ~(CORE_ADDR
) 0;
1470 /* Switch from one thread to another. */
1473 switch_to_thread (thread_info
*thr
)
1475 gdb_assert (thr
!= NULL
);
1477 if (inferior_ptid
== thr
->ptid
)
1480 switch_to_thread_no_regs (thr
);
1482 reinit_frame_cache ();
1484 /* We don't check for is_stopped, because we're called at times
1485 while in the TARGET_RUNNING state, e.g., while handling an
1487 if (thr
->state
!= THREAD_EXITED
1489 stop_pc
= regcache_read_pc (get_thread_regcache (thr
->ptid
));
1492 /* See gdbthread.h. */
1495 switch_to_thread (ptid_t ptid
)
1497 if (ptid
== null_ptid
)
1498 switch_to_no_thread ();
1500 switch_to_thread (find_thread_ptid (ptid
));
1504 restore_selected_frame (struct frame_id a_frame_id
, int frame_level
)
1506 struct frame_info
*frame
= NULL
;
1509 /* This means there was no selected frame. */
1510 if (frame_level
== -1)
1512 select_frame (NULL
);
1516 gdb_assert (frame_level
>= 0);
1518 /* Restore by level first, check if the frame id is the same as
1519 expected. If that fails, try restoring by frame id. If that
1520 fails, nothing to do, just warn the user. */
1522 count
= frame_level
;
1523 frame
= find_relative_frame (get_current_frame (), &count
);
1526 /* The frame ids must match - either both valid or both outer_frame_id.
1527 The latter case is not failsafe, but since it's highly unlikely
1528 the search by level finds the wrong frame, it's 99.9(9)% of
1529 the time (for all practical purposes) safe. */
1530 && frame_id_eq (get_frame_id (frame
), a_frame_id
))
1532 /* Cool, all is fine. */
1533 select_frame (frame
);
1537 frame
= frame_find_by_id (a_frame_id
);
1540 /* Cool, refound it. */
1541 select_frame (frame
);
1545 /* Nothing else to do, the frame layout really changed. Select the
1546 innermost stack frame. */
1547 select_frame (get_current_frame ());
1549 /* Warn the user. */
1550 if (frame_level
> 0 && !current_uiout
->is_mi_like_p ())
1552 warning (_("Couldn't restore frame #%d in "
1553 "current thread. Bottom (innermost) frame selected:"),
1555 /* For MI, we should probably have a notification about
1556 current frame change. But this error is not very
1557 likely, so don't bother for now. */
1558 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1562 /* Data used by the cleanup installed by
1563 'make_cleanup_restore_current_thread'. */
1565 struct current_thread_cleanup
1567 thread_info
*thread
;
1568 struct frame_id selected_frame_id
;
1569 int selected_frame_level
;
1575 do_restore_current_thread_cleanup (void *arg
)
1577 struct current_thread_cleanup
*old
= (struct current_thread_cleanup
*) arg
;
1579 /* If an entry of thread_info was previously selected, it won't be
1580 deleted because we've increased its refcount. The thread represented
1581 by this thread_info entry may have already exited (due to normal exit,
1582 detach, etc), so the thread_info.state is THREAD_EXITED. */
1583 if (old
->thread
!= NULL
1584 /* If the previously selected thread belonged to a process that has
1585 in the mean time exited (or killed, detached, etc.), then don't revert
1586 back to it, but instead simply drop back to no thread selected. */
1587 && old
->inf
->pid
!= 0)
1588 switch_to_thread (old
->thread
);
1591 switch_to_no_thread ();
1592 set_current_inferior (old
->inf
);
1595 /* The running state of the originally selected thread may have
1596 changed, so we have to recheck it here. */
1597 if (inferior_ptid
!= null_ptid
1599 && is_stopped (inferior_ptid
)
1600 && target_has_registers
1602 && target_has_memory
)
1603 restore_selected_frame (old
->selected_frame_id
,
1604 old
->selected_frame_level
);
1608 restore_current_thread_cleanup_dtor (void *arg
)
1610 struct current_thread_cleanup
*old
= (struct current_thread_cleanup
*) arg
;
1612 if (old
->thread
!= NULL
)
1613 old
->thread
->decref ();
1615 old
->inf
->decref ();
1620 make_cleanup_restore_current_thread (void)
1622 struct current_thread_cleanup
*old
= XNEW (struct current_thread_cleanup
);
1625 old
->inf
= current_inferior ();
1627 if (inferior_ptid
!= null_ptid
)
1629 struct frame_info
*frame
;
1631 old
->was_stopped
= is_stopped (inferior_ptid
);
1632 if (old
->was_stopped
1633 && target_has_registers
1635 && target_has_memory
)
1637 /* When processing internal events, there might not be a
1638 selected frame. If we naively call get_selected_frame
1639 here, then we can end up reading debuginfo for the
1640 current frame, but we don't generally need the debuginfo
1642 frame
= get_selected_frame_if_set ();
1647 old
->selected_frame_id
= get_frame_id (frame
);
1648 old
->selected_frame_level
= frame_relative_level (frame
);
1650 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
1657 old
->inf
->incref ();
1659 return make_cleanup_dtor (do_restore_current_thread_cleanup
, old
,
1660 restore_current_thread_cleanup_dtor
);
1663 /* See gdbthread.h. */
1666 show_thread_that_caused_stop (void)
1668 return highest_thread_num
> 1;
1671 /* See gdbthread.h. */
1674 show_inferior_qualified_tids (void)
1676 return (inferior_list
->next
!= NULL
|| inferior_list
->num
!= 1);
1679 /* See gdbthread.h. */
1682 print_thread_id (struct thread_info
*thr
)
1684 char *s
= get_print_cell ();
1686 if (show_inferior_qualified_tids ())
1687 xsnprintf (s
, PRINT_CELL_SIZE
, "%d.%d", thr
->inf
->num
, thr
->per_inf_num
);
1689 xsnprintf (s
, PRINT_CELL_SIZE
, "%d", thr
->per_inf_num
);
1693 /* If true, tp_array_compar should sort in ascending order, otherwise
1694 in descending order. */
1696 static bool tp_array_compar_ascending
;
1698 /* Sort an array for struct thread_info pointers by thread ID (first
1699 by inferior number, and then by per-inferior thread number). The
1700 order is determined by TP_ARRAY_COMPAR_ASCENDING. */
1703 tp_array_compar (const thread_info
*a
, const thread_info
*b
)
1705 if (a
->inf
->num
!= b
->inf
->num
)
1707 if (tp_array_compar_ascending
)
1708 return a
->inf
->num
< b
->inf
->num
;
1710 return a
->inf
->num
> b
->inf
->num
;
1713 if (tp_array_compar_ascending
)
1714 return (a
->per_inf_num
< b
->per_inf_num
);
1716 return (a
->per_inf_num
> b
->per_inf_num
);
1719 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1720 seperated list of numbers, or ranges, or the keyword `all'. Ranges consist
1721 of two numbers seperated by a hyphen. Examples:
1723 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1724 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1725 thread apply all p x/i $pc Apply x/i $pc cmd to all threads. */
1728 thread_apply_all_command (char *cmd
, int from_tty
)
1730 struct cleanup
*old_chain
;
1733 tp_array_compar_ascending
= false;
1735 && check_for_argument (&cmd
, "-ascending", strlen ("-ascending")))
1737 cmd
= skip_spaces (cmd
);
1738 tp_array_compar_ascending
= true;
1741 if (cmd
== NULL
|| *cmd
== '\000')
1742 error (_("Please specify a command following the thread ID list"));
1744 update_thread_list ();
1746 old_chain
= make_cleanup_restore_current_thread ();
1748 /* Save a copy of the command in case it is clobbered by
1750 saved_cmd
= xstrdup (cmd
);
1751 make_cleanup (xfree
, saved_cmd
);
1753 int tc
= live_threads_count ();
1756 /* Save a copy of the thread list and increment each thread's
1757 refcount while executing the command in the context of each
1758 thread, in case the command is one that wipes threads. E.g.,
1759 detach, kill, disconnect, etc., or even normally continuing
1760 over an inferior or thread exit. */
1761 std::vector
<thread_info
*> thr_list_cpy
;
1762 thr_list_cpy
.reserve (tc
);
1767 ALL_NON_EXITED_THREADS (tp
)
1769 thr_list_cpy
.push_back (tp
);
1772 gdb_assert (thr_list_cpy
.size () == tc
);
1775 /* Increment the refcounts, and restore them back on scope
1777 scoped_inc_dec_ref
inc_dec_ref (thr_list_cpy
);
1779 std::sort (thr_list_cpy
.begin (), thr_list_cpy
.end (), tp_array_compar
);
1781 for (thread_info
*thr
: thr_list_cpy
)
1782 if (thread_alive (thr
))
1784 switch_to_thread (thr
->ptid
);
1785 printf_filtered (_("\nThread %s (%s):\n"),
1786 print_thread_id (thr
),
1787 target_pid_to_str (inferior_ptid
));
1788 execute_command (cmd
, from_tty
);
1790 /* Restore exact command used previously. */
1791 strcpy (cmd
, saved_cmd
);
1795 do_cleanups (old_chain
);
1798 /* Implementation of the "thread apply" command. */
1801 thread_apply_command (char *tidlist
, int from_tty
)
1804 struct cleanup
*old_chain
;
1806 tid_range_parser parser
;
1808 if (tidlist
== NULL
|| *tidlist
== '\000')
1809 error (_("Please specify a thread ID list"));
1811 parser
.init (tidlist
, current_inferior ()->num
);
1812 while (!parser
.finished ())
1814 int inf_num
, thr_start
, thr_end
;
1816 if (!parser
.get_tid_range (&inf_num
, &thr_start
, &thr_end
))
1818 cmd
= (char *) parser
.cur_tok ();
1824 error (_("Please specify a command following the thread ID list"));
1826 if (tidlist
== cmd
|| !isalpha (cmd
[0]))
1827 invalid_thread_id_error (cmd
);
1829 /* Save a copy of the command in case it is clobbered by
1831 saved_cmd
= xstrdup (cmd
);
1832 old_chain
= make_cleanup (xfree
, saved_cmd
);
1834 make_cleanup_restore_current_thread ();
1836 parser
.init (tidlist
, current_inferior ()->num
);
1837 while (!parser
.finished () && parser
.cur_tok () < cmd
)
1839 struct thread_info
*tp
= NULL
;
1840 struct inferior
*inf
;
1841 int inf_num
, thr_num
;
1843 parser
.get_tid (&inf_num
, &thr_num
);
1844 inf
= find_inferior_id (inf_num
);
1846 tp
= find_thread_id (inf
, thr_num
);
1848 if (parser
.in_star_range ())
1852 warning (_("Unknown inferior %d"), inf_num
);
1853 parser
.skip_range ();
1857 /* No use looking for threads past the highest thread number
1858 the inferior ever had. */
1859 if (thr_num
>= inf
->highest_thread_num
)
1860 parser
.skip_range ();
1862 /* Be quiet about unknown threads numbers. */
1869 if (show_inferior_qualified_tids () || parser
.tid_is_qualified ())
1870 warning (_("Unknown thread %d.%d"), inf_num
, thr_num
);
1872 warning (_("Unknown thread %d"), thr_num
);
1876 if (!thread_alive (tp
))
1878 warning (_("Thread %s has terminated."), print_thread_id (tp
));
1882 switch_to_thread (tp
->ptid
);
1884 printf_filtered (_("\nThread %s (%s):\n"), print_thread_id (tp
),
1885 target_pid_to_str (inferior_ptid
));
1886 execute_command (cmd
, from_tty
);
1888 /* Restore exact command used previously. */
1889 strcpy (cmd
, saved_cmd
);
1892 do_cleanups (old_chain
);
1895 /* Switch to the specified thread. Will dispatch off to thread_apply_command
1896 if prefix of arg is `apply'. */
1899 thread_command (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 (is_exited (inferior_ptid
))
1911 printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
1912 print_thread_id (tp
),
1913 target_pid_to_str (inferior_ptid
));
1915 printf_filtered (_("[Current thread is %s (%s)]\n"),
1916 print_thread_id (tp
),
1917 target_pid_to_str (inferior_ptid
));
1920 error (_("No stack."));
1924 ptid_t previous_ptid
= inferior_ptid
;
1927 result
= gdb_thread_select (current_uiout
, tidstr
, NULL
);
1929 /* If thread switch did not succeed don't notify or print. */
1930 if (result
== GDB_RC_FAIL
)
1933 /* Print if the thread has not changed, otherwise an event will
1935 if (inferior_ptid
== previous_ptid
)
1937 print_selected_thread_frame (current_uiout
,
1938 USER_SELECTED_THREAD
1939 | USER_SELECTED_FRAME
);
1943 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
1944 | USER_SELECTED_FRAME
);
1949 /* Implementation of `thread name'. */
1952 thread_name_command (char *arg
, int from_tty
)
1954 struct thread_info
*info
;
1956 if (inferior_ptid
== null_ptid
)
1957 error (_("No thread selected"));
1959 arg
= skip_spaces (arg
);
1961 info
= inferior_thread ();
1963 info
->name
= arg
? xstrdup (arg
) : NULL
;
1966 /* Find thread ids with a name, target pid, or extra info matching ARG. */
1969 thread_find_command (char *arg
, int from_tty
)
1971 struct thread_info
*tp
;
1973 unsigned long match
= 0;
1975 if (arg
== NULL
|| *arg
== '\0')
1976 error (_("Command requires an argument."));
1978 tmp
= re_comp (arg
);
1980 error (_("Invalid regexp (%s): %s"), tmp
, arg
);
1982 update_thread_list ();
1983 for (tp
= thread_list
; tp
; tp
= tp
->next
)
1985 if (tp
->name
!= NULL
&& re_exec (tp
->name
))
1987 printf_filtered (_("Thread %s has name '%s'\n"),
1988 print_thread_id (tp
), tp
->name
);
1992 tmp
= target_thread_name (tp
);
1993 if (tmp
!= NULL
&& re_exec (tmp
))
1995 printf_filtered (_("Thread %s has target name '%s'\n"),
1996 print_thread_id (tp
), tmp
);
2000 tmp
= target_pid_to_str (tp
->ptid
);
2001 if (tmp
!= NULL
&& re_exec (tmp
))
2003 printf_filtered (_("Thread %s has target id '%s'\n"),
2004 print_thread_id (tp
), tmp
);
2008 tmp
= target_extra_thread_info (tp
);
2009 if (tmp
!= NULL
&& re_exec (tmp
))
2011 printf_filtered (_("Thread %s has extra info '%s'\n"),
2012 print_thread_id (tp
), tmp
);
2017 printf_filtered (_("No threads match '%s'\n"), arg
);
2020 /* Print notices when new threads are attached and detached. */
2021 int print_thread_events
= 1;
2023 show_print_thread_events (struct ui_file
*file
, int from_tty
,
2024 struct cmd_list_element
*c
, const char *value
)
2026 fprintf_filtered (file
,
2027 _("Printing of thread events is %s.\n"),
2032 do_captured_thread_select (struct ui_out
*uiout
, void *tidstr_v
)
2034 const char *tidstr
= (const char *) tidstr_v
;
2035 struct thread_info
*tp
;
2037 if (uiout
->is_mi_like_p ())
2039 int num
= value_as_long (parse_and_eval (tidstr
));
2041 tp
= find_thread_global_id (num
);
2043 error (_("Thread ID %d not known."), num
);
2047 tp
= parse_thread_id (tidstr
, NULL
);
2048 gdb_assert (tp
!= NULL
);
2051 if (!thread_alive (tp
))
2052 error (_("Thread ID %s has terminated."), tidstr
);
2054 switch_to_thread (tp
->ptid
);
2056 annotate_thread_changed ();
2058 /* Since the current thread may have changed, see if there is any
2059 exited thread we can now delete. */
2065 /* Print thread and frame switch command response. */
2068 print_selected_thread_frame (struct ui_out
*uiout
,
2069 user_selected_what selection
)
2071 struct thread_info
*tp
= inferior_thread ();
2072 struct inferior
*inf
= current_inferior ();
2074 if (selection
& USER_SELECTED_THREAD
)
2076 if (uiout
->is_mi_like_p ())
2078 uiout
->field_int ("new-thread-id",
2079 inferior_thread ()->global_num
);
2083 uiout
->text ("[Switching to thread ");
2084 uiout
->field_string ("new-thread-id", print_thread_id (tp
));
2086 uiout
->text (target_pid_to_str (inferior_ptid
));
2091 if (tp
->state
== THREAD_RUNNING
)
2093 if (selection
& USER_SELECTED_THREAD
)
2094 uiout
->text ("(running)\n");
2096 else if (selection
& USER_SELECTED_FRAME
)
2098 if (selection
& USER_SELECTED_THREAD
)
2101 if (has_stack_frames ())
2102 print_stack_frame_to_uiout (uiout
, get_selected_frame (NULL
),
2108 gdb_thread_select (struct ui_out
*uiout
, char *tidstr
, char **error_message
)
2110 if (catch_exceptions_with_msg (uiout
, do_captured_thread_select
, tidstr
,
2111 error_message
, RETURN_MASK_ALL
) < 0)
2116 /* Update the 'threads_executing' global based on the threads we know
2120 update_threads_executing (void)
2122 struct thread_info
*tp
;
2124 threads_executing
= 0;
2125 ALL_NON_EXITED_THREADS (tp
)
2129 threads_executing
= 1;
2136 update_thread_list (void)
2138 target_update_thread_list ();
2139 update_threads_executing ();
2142 /* Return a new value for the selected thread's id. Return a value of
2143 0 if no thread is selected. If GLOBAL is true, return the thread's
2144 global number. Otherwise return the per-inferior number. */
2146 static struct value
*
2147 thread_num_make_value_helper (struct gdbarch
*gdbarch
, int global
)
2149 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
2155 int_val
= tp
->global_num
;
2157 int_val
= tp
->per_inf_num
;
2159 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, int_val
);
2162 /* Return a new value for the selected thread's per-inferior thread
2163 number. Return a value of 0 if no thread is selected, or no
2166 static struct value
*
2167 thread_id_per_inf_num_make_value (struct gdbarch
*gdbarch
,
2168 struct internalvar
*var
,
2171 return thread_num_make_value_helper (gdbarch
, 0);
2174 /* Return a new value for the selected thread's global id. Return a
2175 value of 0 if no thread is selected, or no threads exist. */
2177 static struct value
*
2178 global_thread_id_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
2181 return thread_num_make_value_helper (gdbarch
, 1);
2184 /* Commands with a prefix of `thread'. */
2185 struct cmd_list_element
*thread_cmd_list
= NULL
;
2187 /* Implementation of `thread' variable. */
2189 static const struct internalvar_funcs thread_funcs
=
2191 thread_id_per_inf_num_make_value
,
2196 /* Implementation of `gthread' variable. */
2198 static const struct internalvar_funcs gthread_funcs
=
2200 global_thread_id_make_value
,
2206 _initialize_thread (void)
2208 static struct cmd_list_element
*thread_apply_list
= NULL
;
2210 add_info ("threads", info_threads_command
,
2211 _("Display currently known threads.\n\
2212 Usage: info threads [-gid] [ID]...\n\
2213 -gid: Show global thread IDs.\n\
2214 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2215 Otherwise, all threads are displayed."));
2217 add_prefix_cmd ("thread", class_run
, thread_command
, _("\
2218 Use this command to switch between threads.\n\
2219 The new thread ID must be currently known."),
2220 &thread_cmd_list
, "thread ", 1, &cmdlist
);
2222 add_prefix_cmd ("apply", class_run
, thread_apply_command
,
2223 _("Apply a command to a list of threads."),
2224 &thread_apply_list
, "thread apply ", 1, &thread_cmd_list
);
2226 add_cmd ("all", class_run
, thread_apply_all_command
,
2228 Apply a command to all threads.\n\
2230 Usage: thread apply all [-ascending] <command>\n\
2231 -ascending: Call <command> for all threads in ascending order.\n\
2232 The default is descending order.\
2234 &thread_apply_list
);
2236 add_cmd ("name", class_run
, thread_name_command
,
2237 _("Set the current thread's name.\n\
2238 Usage: thread name [NAME]\n\
2239 If NAME is not given, then any existing name is removed."), &thread_cmd_list
);
2241 add_cmd ("find", class_run
, thread_find_command
, _("\
2242 Find threads that match a regular expression.\n\
2243 Usage: thread find REGEXP\n\
2244 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2247 add_com_alias ("t", "thread", class_run
, 1);
2249 add_setshow_boolean_cmd ("thread-events", no_class
,
2250 &print_thread_events
, _("\
2251 Set printing of thread events (such as thread start and exit)."), _("\
2252 Show printing of thread events (such as thread start and exit)."), NULL
,
2254 show_print_thread_events
,
2255 &setprintlist
, &showprintlist
);
2257 create_internalvar_type_lazy ("_thread", &thread_funcs
, NULL
);
2258 create_internalvar_type_lazy ("_gthread", >hread_funcs
, NULL
);