GDB (xrefs)
Loading...
Searching...
No Matches
thread.c
Go to the documentation of this file.
1/* Multi-process/thread control for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
4
5 Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
6
7 This file is part of GDB.
8
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.
13
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.
18
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/>. */
21
22#include "defs.h"
23#include "symtab.h"
24#include "frame.h"
25#include "inferior.h"
26#include "gdbsupport/environ.h"
27#include "value.h"
28#include "target.h"
29#include "gdbthread.h"
30#include "command.h"
31#include "gdbcmd.h"
32#include "regcache.h"
33#include "btrace.h"
34
35#include <ctype.h>
36#include <sys/types.h>
37#include <signal.h>
38#include "ui-out.h"
39#include "observable.h"
40#include "annotate.h"
41#include "cli/cli-decode.h"
42#include "cli/cli-option.h"
43#include "gdbsupport/gdb_regex.h"
44#include "cli/cli-utils.h"
45#include "thread-fsm.h"
46#include "tid-parse.h"
47#include <algorithm>
48#include "gdbsupport/gdb_optional.h"
49#include "inline-frame.h"
50#include "stack.h"
51
52/* See gdbthread.h. */
53
54bool debug_threads = false;
55
56/* Implement 'show debug threads'. */
57
58static void
59show_debug_threads (struct ui_file *file, int from_tty,
60 struct cmd_list_element *c, const char *value)
61{
62 gdb_printf (file, _("Thread debugging is \"%s\".\n"), value);
63}
64
65/* Definition of struct thread_info exported to gdbthread.h. */
66
67/* Prototypes for local functions. */
68
70
71/* The current/selected thread. */
73
74/* Returns true if THR is the current thread. */
75
76static bool
78{
79 return thr == current_thread_;
80}
81
82struct thread_info*
84{
85 gdb_assert (current_thread_ != nullptr);
86 return current_thread_;
87}
88
89/* Delete the breakpoint pointed at by BP_P, if there's one. */
90
91static void
93{
94 if (*bp_p != NULL)
95 {
96 delete_breakpoint (*bp_p);
97 *bp_p = NULL;
98 }
99}
100
101void
103{
104 if (tp != NULL)
106}
107
108void
110{
111 if (tp != NULL)
113}
114
115/* See gdbthread.h. */
116
117void
119{
120 if (tp != NULL)
122}
123
124/* Delete the breakpoint pointed at by BP_P at the next stop, if
125 there's one. */
126
127static void
129{
130 if (*bp != NULL)
131 {
132 (*bp)->disposition = disp_del_at_next_stop;
133 *bp = NULL;
134 }
135}
136
137/* See gdbthread.h. */
138
139int
141{
142 return tp->control.single_step_breakpoints != NULL;
143}
144
145/* See gdbthread.h. */
146
147int
149 const address_space *aspace,
150 CORE_ADDR addr)
151{
152 struct breakpoint *ss_bps = tp->control.single_step_breakpoints;
153
154 return (ss_bps != NULL
155 && breakpoint_has_location_inserted_here (ss_bps, aspace, addr));
156}
157
158/* See gdbthread.h. */
159
160void
162{
163 if (thr->thread_fsm () != nullptr)
164 {
165 std::unique_ptr<thread_fsm> fsm = thr->release_thread_fsm ();
166 fsm->clean_up (thr);
167 }
168}
169
170static void
172{
173 /* NOTE: this will take care of any left-over step_resume breakpoints,
174 but not any user-specified thread-specific breakpoints. We can not
175 delete the breakpoint straight-off, because the inferior might not
176 be stopped at the moment. */
180
182
184
185 btrace_teardown (tp);
186
188
190}
191
192/* See gdbthread.h. */
193
194void
196{
197 /* Dead threads don't need to step-over. Remove from chain. */
200
201 if (tp->state != THREAD_EXITED)
202 {
203 process_stratum_target *proc_target = tp->inf->process_target ();
204
205 /* Some targets unpush themselves from the inferior's target stack before
206 clearing the inferior's thread list (which marks all threads as exited,
207 and therefore leads to this function). In this case, the inferior's
208 process target will be nullptr when we arrive here.
209
210 See also the comment in inferior::unpush_target. */
211 if (proc_target != nullptr)
213
215
216 /* Tag it as exited. */
217 tp->state = THREAD_EXITED;
218
219 /* Clear breakpoints, etc. associated with this thread. */
221
222 /* Remove from the ptid_t map. We don't want for
223 find_thread_ptid to find exited threads. Also, the target
224 may reuse the ptid for a new thread, and there can only be
225 one value per key; adding a new thread with the same ptid_t
226 would overwrite the exited thread's ptid entry. */
227 size_t nr_deleted = tp->inf->ptid_thread_map.erase (tp->ptid);
228 gdb_assert (nr_deleted == 1);
229 }
230}
231
232void
234{
236
237 for (inferior *inf : all_inferiors ())
238 inf->clear_thread_list (true);
239}
240
241/* Allocate a new thread of inferior INF with target id PTID and add
242 it to the thread list. */
243
244static struct thread_info *
245new_thread (struct inferior *inf, ptid_t ptid)
246{
247 thread_info *tp = new thread_info (inf, ptid);
248
249 threads_debug_printf ("creating a new thread object, inferior %d, ptid %s",
250 inf->num, ptid.to_string ().c_str ());
251
252 inf->thread_list.push_back (*tp);
253
254 /* A thread with this ptid should not exist in the map yet. */
255 gdb_assert (inf->ptid_thread_map.find (ptid) == inf->ptid_thread_map.end ());
256
257 inf->ptid_thread_map[ptid] = tp;
258
259 return tp;
260}
261
262struct thread_info *
264{
265 gdb_assert (targ != nullptr);
266
267 inferior *inf = find_inferior_ptid (targ, ptid);
268
269 threads_debug_printf ("add thread to inferior %d, ptid %s, target %s",
270 inf->num, ptid.to_string ().c_str (),
271 targ->shortname ());
272
273 /* We may have an old thread with the same id in the thread list.
274 If we do, it must be dead, otherwise we wouldn't be adding a new
275 thread with the same id. The OS is reusing this id --- delete
276 the old thread, and create a new one. */
277 thread_info *tp = find_thread_ptid (inf, ptid);
278 if (tp != nullptr)
279 delete_thread (tp);
280
281 tp = new_thread (inf, ptid);
282 gdb::observers::new_thread.notify (tp);
283
284 return tp;
285}
286
287struct thread_info *
290{
291 thread_info *result = add_thread_silent (targ, ptid);
292
293 result->priv.reset (priv);
294
296 gdb_printf (_("[New %s]\n"), target_pid_to_str (ptid).c_str ());
297
299 return result;
300}
301
302struct thread_info *
304{
305 return add_thread_with_info (targ, ptid, NULL);
306}
307
309
310thread_info::thread_info (struct inferior *inf_, ptid_t ptid_)
311 : ptid (ptid_), inf (inf_)
312{
313 gdb_assert (inf_ != NULL);
314
316 this->per_inf_num = ++inf_->highest_thread_num;
317
318 /* Nothing to follow yet. */
320}
321
322/* See gdbthread.h. */
323
325{
326 threads_debug_printf ("thread %s", this->ptid.to_string ().c_str ());
327}
328
329/* See gdbthread.h. */
330
331bool
333{
334 /* If this is the current thread, or there's code out there that
335 relies on it existing (refcount > 0) we can't delete yet. */
336 return refcount () == 0 && !is_current_thread (this);
337}
338
339/* See gdbthread.h. */
340
341void
343{
344 m_executing = executing;
345 if (executing)
346 this->clear_stop_pc ();
347}
348
349/* See gdbthread.h. */
350
351void
353{
354 if (resumed == m_resumed)
355 return;
356
357 process_stratum_target *proc_target = this->inf->process_target ();
358
359 /* If we transition from resumed to not resumed, we might need to remove
360 the thread from the resumed threads with pending statuses list. */
361 if (!resumed)
363
364 m_resumed = resumed;
365
366 /* If we transition from not resumed to resumed, we might need to add
367 the thread to the resumed threads with pending statuses list. */
368 if (resumed)
370}
371
372/* See gdbthread.h. */
373
374void
376{
377 gdb_assert (!this->has_pending_waitstatus ());
378
381
382 process_stratum_target *proc_target = this->inf->process_target ();
384}
385
386/* See gdbthread.h. */
387
388void
390{
391 gdb_assert (this->has_pending_waitstatus ());
392
393 process_stratum_target *proc_target = this->inf->process_target ();
395
397}
398
399/* See gdbthread.h. */
400
401int
403{
404 return tp->step_over_list_node.is_linked ();
405}
406
407/* See gdbthread.h. */
408
409int
411{
412 int num = 0;
413
414 for (const thread_info &thread ATTRIBUTE_UNUSED : l)
415 ++num;
416
417 return num;
418}
419
420/* See gdbthread.h. */
421
422void
424{
425 infrun_debug_printf ("enqueueing thread %s in global step over chain",
426 tp->ptid.to_string ().c_str ());
427
428 gdb_assert (!thread_is_in_step_over_chain (tp));
429 global_thread_step_over_list.push_back (*tp);
430}
431
432/* See gdbthread.h. */
433
434void
436{
437 global_thread_step_over_list.splice (std::move (list));
438}
439
440/* See gdbthread.h. */
441
442void
444{
445 infrun_debug_printf ("removing thread %s from global step over chain",
446 tp->ptid.to_string ().c_str ());
447
448 gdb_assert (thread_is_in_step_over_chain (tp));
449 auto it = global_thread_step_over_list.iterator_to (*tp);
451}
452
453/* Delete the thread referenced by THR. If SILENT, don't notify
454 the observer of this exit.
455
456 THR must not be NULL or a failed assertion will be raised. */
457
458static void
459delete_thread_1 (thread_info *thr, bool silent)
460{
461 gdb_assert (thr != nullptr);
462
463 threads_debug_printf ("deleting thread %s, silent = %d",
464 thr->ptid.to_string ().c_str (), silent);
465
466 set_thread_exited (thr, silent);
467
468 if (!thr->deletable ())
469 {
470 /* Will be really deleted some other time. */
471 return;
472 }
473
474 auto it = thr->inf->thread_list.iterator_to (*thr);
475 thr->inf->thread_list.erase (it);
476
477 delete thr;
478}
479
480/* See gdbthread.h. */
481
482void
484{
485 delete_thread_1 (thread, false /* not silent */);
486}
487
488void
490{
491 delete_thread_1 (thread, true /* silent */);
492}
493
494struct thread_info *
496{
497 for (thread_info *tp : all_threads ())
498 if (tp->global_num == global_id)
499 return tp;
500
501 return NULL;
502}
503
504static struct thread_info *
505find_thread_id (struct inferior *inf, int thr_num)
506{
507 for (thread_info *tp : inf->threads ())
508 if (tp->per_inf_num == thr_num)
509 return tp;
510
511 return NULL;
512}
513
514/* See gdbthread.h. */
515
516struct thread_info *
518{
519 inferior *inf = find_inferior_ptid (targ, ptid);
520 if (inf == NULL)
521 return NULL;
522 return find_thread_ptid (inf, ptid);
523}
524
525/* See gdbthread.h. */
526
527struct thread_info *
529{
530 gdb_assert (inf != nullptr);
531
532 auto it = inf->ptid_thread_map.find (ptid);
533 if (it != inf->ptid_thread_map.end ())
534 return it->second;
535 else
536 return nullptr;
537}
538
539/* See gdbthread.h. */
540
541struct thread_info *
542find_thread_by_handle (gdb::array_view<const gdb_byte> handle,
543 struct inferior *inf)
544{
545 return target_thread_handle_to_thread_info (handle.data (),
546 handle.size (),
547 inf);
548}
549
550/*
551 * Thread iterator function.
552 *
553 * Calls a callback function once for each thread, so long as
554 * the callback function returns false. If the callback function
555 * returns true, the iteration will end and the current thread
556 * will be returned. This can be useful for implementing a
557 * search for a thread with arbitrary attributes, or for applying
558 * some operation to every thread.
559 *
560 * FIXME: some of the existing functionality, such as
561 * "Thread apply all", might be rewritten using this functionality.
562 */
563
564struct thread_info *
565iterate_over_threads (int (*callback) (struct thread_info *, void *),
566 void *data)
567{
568 for (thread_info *tp : all_threads_safe ())
569 if ((*callback) (tp, data))
570 return tp;
571
572 return NULL;
573}
574
575/* See gdbthread.h. */
576
577bool
579{
580 for (thread_info *tp ATTRIBUTE_UNUSED : all_threads ())
581 return true;
582 return false;
583}
584
585int
587{
588 auto rng = all_threads (proc_target);
589 return std::distance (rng.begin (), rng.end ());
590}
591
592/* Return the number of non-exited threads in the thread list. */
593
594static int
596{
597 auto rng = all_non_exited_threads ();
598 return std::distance (rng.begin (), rng.end ());
599}
600
601int
603{
604 for (thread_info *tp : all_threads ())
605 if (tp->global_num == global_id)
606 return 1;
607
608 return 0;
609}
610
611bool
613{
614 return find_thread_ptid (targ, ptid) != nullptr;
615}
616
617/* Finds the first thread of the inferior. */
618
621{
622 if (inf->thread_list.empty ())
623 return nullptr;
624
625 return &inf->thread_list.front ();
626}
627
630{
631 gdb_assert (inf->pid != 0);
632
633 /* Prefer the current thread, if there's one. */
634 if (inf == current_inferior () && inferior_ptid != null_ptid)
635 return inferior_thread ();
636
637 for (thread_info *tp : inf->non_exited_threads ())
638 return tp;
639
640 return NULL;
641}
642
645{
646 struct thread_info *curr_tp = NULL;
647 struct thread_info *tp_executing = NULL;
648
649 gdb_assert (inf != NULL && inf->pid != 0);
650
651 /* Prefer the current thread if it's not executing. */
652 if (inferior_ptid != null_ptid && current_inferior () == inf)
653 {
654 /* If the current thread is dead, forget it. If it's not
655 executing, use it. Otherwise, still choose it (below), but
656 only if no other non-executing thread is found. */
657 curr_tp = inferior_thread ();
658 if (curr_tp->state == THREAD_EXITED)
659 curr_tp = NULL;
660 else if (!curr_tp->executing ())
661 return curr_tp;
662 }
663
664 for (thread_info *tp : inf->non_exited_threads ())
665 {
666 if (!tp->executing ())
667 return tp;
668
669 tp_executing = tp;
670 }
671
672 /* If both the current thread and all live threads are executing,
673 prefer the current thread. */
674 if (curr_tp != NULL)
675 return curr_tp;
676
677 /* Otherwise, just return an executing thread, if any. */
678 return tp_executing;
679}
680
681/* Return true if TP is an active thread. */
682static bool
684{
685 if (tp->state == THREAD_EXITED)
686 return false;
687
688 /* Ensure we're looking at the right target stack. */
689 gdb_assert (tp->inf == current_inferior ());
690
691 return target_thread_alive (tp->ptid);
692}
693
694/* See gdbthreads.h. */
695
696bool
698{
699 scoped_restore_current_thread restore_thread;
700
701 /* Switch inferior first, so that we're looking at the right target
702 stack. */
704
705 if (thread_alive (thr))
706 {
707 switch_to_thread (thr);
708 restore_thread.dont_restore ();
709 return true;
710 }
711
712 return false;
713}
714
715/* See gdbthreads.h. */
716
717void
719{
720 scoped_restore_current_thread restore_thread;
721
722 for (thread_info *tp : all_threads_safe ())
723 {
725
726 if (!thread_alive (tp))
727 delete_thread (tp);
728 }
729}
730
731/* See gdbthreads.h. */
732
733void
735{
736 for (thread_info *tp : all_threads_safe ())
737 if (tp->state == THREAD_EXITED)
738 delete_thread (tp);
739}
740
741/* Return true value if stack temporaries are enabled for the thread
742 TP. */
743
744bool
746{
747 if (tp == NULL)
748 return false;
749 else
750 return tp->stack_temporaries_enabled;
751}
752
753/* Push V on to the stack temporaries of the thread with id PTID. */
754
755void
757{
758 gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
759 tp->stack_temporaries.push_back (v);
760}
761
762/* Return true if VAL is among the stack temporaries of the thread
763 TP. Return false otherwise. */
764
765bool
767{
768 gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
769 for (value *v : tp->stack_temporaries)
770 if (v == val)
771 return true;
772
773 return false;
774}
775
776/* Return the last of the stack temporaries for thread with id PTID.
777 Return NULL if there are no stack temporaries for the thread. */
778
779value *
781{
782 struct value *lastval = NULL;
783
784 gdb_assert (tp != NULL);
785 if (!tp->stack_temporaries.empty ())
786 lastval = tp->stack_temporaries.back ();
787
788 return lastval;
789}
790
791void
793 ptid_t old_ptid, ptid_t new_ptid)
794{
795 struct inferior *inf;
796 struct thread_info *tp;
797
798 /* It can happen that what we knew as the target inferior id
799 changes. E.g, target remote may only discover the remote process
800 pid after adding the inferior to GDB's list. */
801 inf = find_inferior_ptid (targ, old_ptid);
802 inf->pid = new_ptid.pid ();
803
804 tp = find_thread_ptid (inf, old_ptid);
805 gdb_assert (tp != nullptr);
806
807 int num_erased = inf->ptid_thread_map.erase (old_ptid);
808 gdb_assert (num_erased == 1);
809
810 tp->ptid = new_ptid;
811 inf->ptid_thread_map[new_ptid] = tp;
812
813 gdb::observers::thread_ptid_changed.notify (targ, old_ptid, new_ptid);
814}
815
816/* See gdbthread.h. */
817
818void
819set_resumed (process_stratum_target *targ, ptid_t ptid, bool resumed)
820{
821 for (thread_info *tp : all_non_exited_threads (targ, ptid))
822 tp->set_resumed (resumed);
823}
824
825/* Helper for set_running, that marks one thread either running or
826 stopped. */
827
828static bool
829set_running_thread (struct thread_info *tp, bool running)
830{
831 bool started = false;
832
833 if (running && tp->state == THREAD_STOPPED)
834 started = true;
835 tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
836
837 threads_debug_printf ("thread: %s, running? %d%s",
838 tp->ptid.to_string ().c_str (), running,
839 (started ? " (started)" : ""));
840
841 if (!running)
842 {
843 /* If the thread is now marked stopped, remove it from
844 the step-over queue, so that we don't try to resume
845 it until the user wants it to. */
848 }
849
850 return started;
851}
852
853/* See gdbthread.h. */
854
855void
857{
858 if (set_running_thread (this, running))
860}
861
862void
863set_running (process_stratum_target *targ, ptid_t ptid, bool running)
864{
865 /* We try not to notify the observer if no thread has actually
866 changed the running state -- merely to reduce the number of
867 messages to the MI frontend. A frontend is supposed to handle
868 multiple *running notifications just fine. */
869 bool any_started = false;
870
871 for (thread_info *tp : all_non_exited_threads (targ, ptid))
872 if (set_running_thread (tp, running))
873 any_started = true;
874
875 if (any_started)
876 gdb::observers::target_resumed.notify (ptid);
877}
878
879void
880set_executing (process_stratum_target *targ, ptid_t ptid, bool executing)
881{
882 for (thread_info *tp : all_non_exited_threads (targ, ptid))
883 tp->set_executing (executing);
884
885 /* It only takes one running thread to spawn more threads. */
886 if (executing)
887 targ->threads_executing = true;
888 /* Only clear the flag if the caller is telling us everything is
889 stopped. */
890 else if (minus_one_ptid == ptid)
891 targ->threads_executing = false;
892}
893
894/* See gdbthread.h. */
895
896bool
898{
899 return target->threads_executing;
900}
901
902void
903set_stop_requested (process_stratum_target *targ, ptid_t ptid, bool stop)
904{
905 for (thread_info *tp : all_non_exited_threads (targ, ptid))
906 tp->stop_requested = stop;
907
908 /* Call the stop requested observer so other components of GDB can
909 react to this request. */
910 if (stop)
912}
913
914void
916{
917 bool any_started = false;
918
919 for (thread_info *tp : all_non_exited_threads (targ, ptid))
920 if (set_running_thread (tp, tp->executing ()))
921 any_started = true;
922
923 if (any_started)
924 gdb::observers::target_resumed.notify (ptid);
925}
926
927/* See gdbthread.h. */
928
929void
931{
932 /* No selected thread, no registers. */
933 if (inferior_ptid == null_ptid)
934 error (_("No thread selected."));
935
937
938 /* Don't try to read from a dead thread. */
939 if (tp->state == THREAD_EXITED)
940 error (_("The current thread has terminated"));
941
942 /* ... or from a spinning thread. FIXME: This isn't actually fully
943 correct. It'll allow an user-requested access (e.g., "print $pc"
944 at the prompt) when a thread is not executing for some internal
945 reason, but is marked running from the user's perspective. E.g.,
946 the thread is waiting for its turn in the step-over queue. */
947 if (tp->executing ())
948 error (_("Selected thread is running."));
949}
950
951/* See gdbthread.h. */
952
953bool
955{
956 /* No thread, no registers. */
957 if (thread == NULL)
958 return false;
959
960 /* Don't try to read from a dead thread. */
961 if (thread->state == THREAD_EXITED)
962 return false;
963
964 /* ... or from a spinning thread. FIXME: see validate_registers_access. */
965 if (thread->executing ())
966 return false;
967
968 return true;
969}
970
971int
972pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread)
973{
974 return (pc >= thread->control.step_range_start
975 && pc < thread->control.step_range_end);
976}
977
978/* Helper for print_thread_info. Returns true if THR should be
979 printed. If REQUESTED_THREADS, a list of GDB ids/ranges, is not
980 NULL, only print THR if its ID is included in the list. GLOBAL_IDS
981 is true if REQUESTED_THREADS is list of global IDs, false if a list
982 of per-inferior thread ids. If PID is not -1, only print THR if it
983 is a thread from the process PID. Otherwise, threads from all
984 attached PIDs are printed. If both REQUESTED_THREADS is not NULL
985 and PID is not -1, then the thread is printed if it belongs to the
986 specified process. Otherwise, an error is raised. */
987
988static int
989should_print_thread (const char *requested_threads, int default_inf_num,
990 int global_ids, int pid, struct thread_info *thr)
991{
992 if (requested_threads != NULL && *requested_threads != '\0')
993 {
994 int in_list;
995
996 if (global_ids)
997 in_list = number_is_in_list (requested_threads, thr->global_num);
998 else
999 in_list = tid_is_in_list (requested_threads, default_inf_num,
1000 thr->inf->num, thr->per_inf_num);
1001 if (!in_list)
1002 return 0;
1003 }
1004
1005 if (pid != -1 && thr->ptid.pid () != pid)
1006 {
1007 if (requested_threads != NULL && *requested_threads != '\0')
1008 error (_("Requested thread not found in requested process"));
1009 return 0;
1010 }
1011
1012 if (thr->state == THREAD_EXITED)
1013 return 0;
1014
1015 return 1;
1016}
1017
1018/* Return the string to display in "info threads"'s "Target Id"
1019 column, for TP. */
1020
1021static std::string
1023{
1024 std::string target_id = target_pid_to_str (tp->ptid);
1025 const char *extra_info = target_extra_thread_info (tp);
1026 const char *name = thread_name (tp);
1027
1028 if (extra_info != nullptr && name != nullptr)
1029 return string_printf ("%s \"%s\" (%s)", target_id.c_str (), name,
1030 extra_info);
1031 else if (extra_info != nullptr)
1032 return string_printf ("%s (%s)", target_id.c_str (), extra_info);
1033 else if (name != nullptr)
1034 return string_printf ("%s \"%s\"", target_id.c_str (), name);
1035 else
1036 return target_id;
1037}
1038
1039/* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1040 whether REQUESTED_THREADS is a list of global or per-inferior
1041 thread ids. */
1042
1043static void
1044print_thread_info_1 (struct ui_out *uiout, const char *requested_threads,
1045 int global_ids, int pid,
1046 int show_global_ids)
1047{
1048 int default_inf_num = current_inferior ()->num;
1049
1051
1052 /* Whether we saw any thread. */
1053 bool any_thread = false;
1054 /* Whether the current thread is exited. */
1055 bool current_exited = false;
1056
1057 thread_info *current_thread = (inferior_ptid != null_ptid
1058 ? inferior_thread () : NULL);
1059
1060 {
1061 /* For backward compatibility, we make a list for MI. A table is
1062 preferable for the CLI, though, because it shows table
1063 headers. */
1064 gdb::optional<ui_out_emit_list> list_emitter;
1065 gdb::optional<ui_out_emit_table> table_emitter;
1066
1067 /* We'll be switching threads temporarily below. */
1068 scoped_restore_current_thread restore_thread;
1069
1070 if (uiout->is_mi_like_p ())
1071 list_emitter.emplace (uiout, "threads");
1072 else
1073 {
1074 int n_threads = 0;
1075 /* The width of the "Target Id" column. Grown below to
1076 accommodate the largest entry. */
1077 size_t target_id_col_width = 17;
1078
1079 for (thread_info *tp : all_threads ())
1080 {
1081 if (!should_print_thread (requested_threads, default_inf_num,
1082 global_ids, pid, tp))
1083 continue;
1084
1085 if (!uiout->is_mi_like_p ())
1086 {
1087 /* Switch inferiors so we're looking at the right
1088 target stack. */
1090
1091 target_id_col_width
1092 = std::max (target_id_col_width,
1093 thread_target_id_str (tp).size ());
1094 }
1095
1096 ++n_threads;
1097 }
1098
1099 if (n_threads == 0)
1100 {
1101 if (requested_threads == NULL || *requested_threads == '\0')
1102 uiout->message (_("No threads.\n"));
1103 else
1104 uiout->message (_("No threads match '%s'.\n"),
1105 requested_threads);
1106 return;
1107 }
1108
1109 table_emitter.emplace (uiout, show_global_ids ? 5 : 4,
1110 n_threads, "threads");
1111
1112 uiout->table_header (1, ui_left, "current", "");
1113 uiout->table_header (4, ui_left, "id-in-tg", "Id");
1114 if (show_global_ids)
1115 uiout->table_header (4, ui_left, "id", "GId");
1116 uiout->table_header (target_id_col_width, ui_left,
1117 "target-id", "Target Id");
1118 uiout->table_header (1, ui_left, "frame", "Frame");
1119 uiout->table_body ();
1120 }
1121
1122 for (inferior *inf : all_inferiors ())
1123 for (thread_info *tp : inf->threads ())
1124 {
1125 int core;
1126
1127 any_thread = true;
1128 if (tp == current_thread && tp->state == THREAD_EXITED)
1129 current_exited = true;
1130
1131 if (!should_print_thread (requested_threads, default_inf_num,
1132 global_ids, pid, tp))
1133 continue;
1134
1135 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1136
1137 if (!uiout->is_mi_like_p ())
1138 {
1139 if (tp == current_thread)
1140 uiout->field_string ("current", "*");
1141 else
1142 uiout->field_skip ("current");
1143
1144 uiout->field_string ("id-in-tg", print_thread_id (tp));
1145 }
1146
1147 if (show_global_ids || uiout->is_mi_like_p ())
1148 uiout->field_signed ("id", tp->global_num);
1149
1150 /* Switch to the thread (and inferior / target). */
1151 switch_to_thread (tp);
1152
1153 /* For the CLI, we stuff everything into the target-id field.
1154 This is a gross hack to make the output come out looking
1155 correct. The underlying problem here is that ui-out has no
1156 way to specify that a field's space allocation should be
1157 shared by several fields. For MI, we do the right thing
1158 instead. */
1159
1160 if (uiout->is_mi_like_p ())
1161 {
1162 uiout->field_string ("target-id", target_pid_to_str (tp->ptid));
1163
1164 const char *extra_info = target_extra_thread_info (tp);
1165 if (extra_info != nullptr)
1166 uiout->field_string ("details", extra_info);
1167
1168 const char *name = thread_name (tp);
1169 if (name != NULL)
1170 uiout->field_string ("name", name);
1171 }
1172 else
1173 {
1174 uiout->field_string ("target-id", thread_target_id_str (tp));
1175 }
1176
1177 if (tp->state == THREAD_RUNNING)
1178 uiout->text ("(running)\n");
1179 else
1180 {
1181 /* The switch above put us at the top of the stack (leaf
1182 frame). */
1184 /* For MI output, print frame level. */
1185 uiout->is_mi_like_p (),
1186 LOCATION, 0);
1187 }
1188
1189 if (uiout->is_mi_like_p ())
1190 {
1191 const char *state = "stopped";
1192
1193 if (tp->state == THREAD_RUNNING)
1194 state = "running";
1195 uiout->field_string ("state", state);
1196 }
1197
1198 core = target_core_of_thread (tp->ptid);
1199 if (uiout->is_mi_like_p () && core != -1)
1200 uiout->field_signed ("core", core);
1201 }
1202
1203 /* This end scope restores the current thread and the frame
1204 selected before the "info threads" command, and it finishes the
1205 ui-out list or table. */
1206 }
1207
1208 if (pid == -1 && requested_threads == NULL)
1209 {
1210 if (uiout->is_mi_like_p () && inferior_ptid != null_ptid)
1211 uiout->field_signed ("current-thread-id", current_thread->global_num);
1212
1213 if (inferior_ptid != null_ptid && current_exited)
1214 uiout->message ("\n\
1215The current thread <Thread ID %s> has terminated. See `help thread'.\n",
1217 else if (any_thread && inferior_ptid == null_ptid)
1218 uiout->message ("\n\
1219No selected thread. See `help thread'.\n");
1220 }
1221}
1222
1223/* See gdbthread.h. */
1224
1225void
1226print_thread_info (struct ui_out *uiout, const char *requested_threads,
1227 int pid)
1228{
1229 print_thread_info_1 (uiout, requested_threads, 1, pid, 0);
1230}
1231
1232/* The options for the "info threads" command. */
1233
1235{
1236 /* For "-gid". */
1237 bool show_global_ids = false;
1238};
1239
1241
1243 "gid",
1244 [] (info_threads_opts *opts) { return &opts->show_global_ids; },
1245 N_("Show global thread IDs."),
1246 },
1247
1248};
1249
1250/* Create an option_def_group for the "info threads" options, with
1251 IT_OPTS as context. */
1252
1255{
1256 return {{info_threads_option_defs}, it_opts};
1257}
1258
1259/* Implementation of the "info threads" command.
1260
1261 Note: this has the drawback that it _really_ switches
1262 threads, which frees the frame cache. A no-side
1263 effects info-threads command would be nicer. */
1264
1265static void
1266info_threads_command (const char *arg, int from_tty)
1267{
1268 info_threads_opts it_opts;
1269
1270 auto grp = make_info_threads_options_def_group (&it_opts);
1273
1274 print_thread_info_1 (current_uiout, arg, 0, -1, it_opts.show_global_ids);
1275}
1276
1277/* Completer for the "info threads" command. */
1278
1279static void
1281 completion_tracker &tracker,
1282 const char *text, const char *word_ignored)
1283{
1284 const auto grp = make_info_threads_options_def_group (nullptr);
1285
1287 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, grp))
1288 return;
1289
1290 /* Convenience to let the user know what the option can accept. */
1291 if (*text == '\0')
1292 {
1294 /* Keep this "ID" in sync with what "help info threads"
1295 says. */
1296 tracker.add_completion (make_unique_xstrdup ("ID"));
1297 }
1298}
1299
1300/* See gdbthread.h. */
1301
1302void
1304{
1305 gdb_assert (thread != nullptr);
1306 threads_debug_printf ("thread = %s", thread->ptid.to_string ().c_str ());
1307
1308 struct inferior *inf = thread->inf;
1309
1312
1313 current_thread_ = thread;
1315}
1316
1317/* See gdbthread.h. */
1318
1319void
1321{
1322 if (current_thread_ == nullptr)
1323 return;
1324
1325 threads_debug_printf ("thread = NONE");
1326
1327 current_thread_ = nullptr;
1328 inferior_ptid = null_ptid;
1330}
1331
1332/* See gdbthread.h. */
1333
1334void
1336{
1337 gdb_assert (thr != NULL);
1338
1339 if (is_current_thread (thr))
1340 return;
1341
1343
1345}
1346
1347/* See gdbsupport/common-gdbthread.h. */
1348
1349void
1350switch_to_thread (process_stratum_target *proc_target, ptid_t ptid)
1351{
1352 thread_info *thr = find_thread_ptid (proc_target, ptid);
1353 switch_to_thread (thr);
1354}
1355
1356/* See frame.h. */
1357
1358void
1360{
1361 /* If an entry of thread_info was previously selected, it won't be
1362 deleted because we've increased its refcount. The thread represented
1363 by this thread_info entry may have already exited (due to normal exit,
1364 detach, etc), so the thread_info.state is THREAD_EXITED. */
1365 if (m_thread != NULL
1366 /* If the previously selected thread belonged to a process that has
1367 in the mean time exited (or killed, detached, etc.), then don't revert
1368 back to it, but instead simply drop back to no thread selected. */
1369 && m_inf->pid != 0)
1370 switch_to_thread (m_thread.get ());
1371 else
1373
1374 /* The running state of the originally selected thread may have
1375 changed, so we have to recheck it here. */
1376 if (inferior_ptid != null_ptid
1377 && m_was_stopped
1378 && m_thread->state == THREAD_STOPPED
1380 && target_has_stack ()
1381 && target_has_memory ())
1383
1385}
1386
1388{
1389 if (!m_dont_restore)
1390 restore ();
1391}
1392
1394{
1395 m_inf = inferior_ref::new_reference (current_inferior ());
1396
1398
1399 if (inferior_ptid != null_ptid)
1400 {
1401 m_thread = thread_info_ref::new_reference (inferior_thread ());
1402
1405 }
1406}
1407
1408/* See gdbthread.h. */
1409
1410int
1412{
1413 return highest_thread_num > 1;
1414}
1415
1416/* See gdbthread.h. */
1417
1418int
1420{
1421 auto inf = inferior_list.begin ();
1422 if (inf->num != 1)
1423 return true;
1424 ++inf;
1425 return inf != inferior_list.end ();
1426}
1427
1428/* See gdbthread.h. */
1429
1430const char *
1432{
1433 char *s = get_print_cell ();
1434
1436 xsnprintf (s, PRINT_CELL_SIZE, "%d.%d", thr->inf->num, thr->per_inf_num);
1437 else
1438 xsnprintf (s, PRINT_CELL_SIZE, "%d", thr->per_inf_num);
1439 return s;
1440}
1441
1442/* Sort an array of struct thread_info pointers by thread ID (first by
1443 inferior number, and then by per-inferior thread number). Sorts in
1444 ascending order. */
1445
1446static bool
1448{
1449 if (a->inf->num != b->inf->num)
1450 return a->inf->num < b->inf->num;
1451
1452 return (a->per_inf_num < b->per_inf_num);
1453}
1454
1455/* Sort an array of struct thread_info pointers by thread ID (first by
1456 inferior number, and then by per-inferior thread number). Sorts in
1457 descending order. */
1458
1459static bool
1461{
1462 if (a->inf->num != b->inf->num)
1463 return a->inf->num > b->inf->num;
1464
1465 return (a->per_inf_num > b->per_inf_num);
1466}
1467
1468/* See gdbthread.h. */
1469
1470void
1471thread_try_catch_cmd (thread_info *thr, gdb::optional<int> ada_task,
1472 const char *cmd, int from_tty,
1473 const qcs_flags &flags)
1474{
1475 gdb_assert (is_current_thread (thr));
1476
1477 /* The thread header is computed before running the command since
1478 the command can change the inferior, which is not permitted
1479 by thread_target_id_str. */
1480 std::string thr_header;
1481 if (ada_task.has_value ())
1482 thr_header = string_printf (_("\nTask ID %d:\n"), *ada_task);
1483 else
1484 thr_header = string_printf (_("\nThread %s (%s):\n"),
1485 print_thread_id (thr),
1486 thread_target_id_str (thr).c_str ());
1487
1488 try
1489 {
1490 std::string cmd_result;
1492 (cmd_result, cmd, from_tty, gdb_stdout->term_out ());
1493 if (!flags.silent || cmd_result.length () > 0)
1494 {
1495 if (!flags.quiet)
1496 gdb_printf ("%s", thr_header.c_str ());
1497 gdb_printf ("%s", cmd_result.c_str ());
1498 }
1499 }
1500 catch (const gdb_exception_error &ex)
1501 {
1502 if (!flags.silent)
1503 {
1504 if (!flags.quiet)
1505 gdb_printf ("%s", thr_header.c_str ());
1506 if (flags.cont)
1507 gdb_printf ("%s\n", ex.what ());
1508 else
1509 throw;
1510 }
1511 }
1512}
1513
1514/* Option definition of "thread apply"'s "-ascending" option. */
1515
1517 "ascending",
1518 N_("\
1519Call COMMAND for all threads in ascending order.\n\
1520The default is descending order."),
1521};
1522
1523/* The qcs command line flags for the "thread apply" commands. Keep
1524 this in sync with the "frame apply" commands. */
1525
1528
1531 "q", [] (qcs_flags *opt) { return &opt->quiet; },
1532 N_("Disables printing the thread information."),
1533 },
1534
1536 "c", [] (qcs_flags *opt) { return &opt->cont; },
1537 N_("Print any error raised by COMMAND and continue."),
1538 },
1539
1541 "s", [] (qcs_flags *opt) { return &opt->silent; },
1542 N_("Silently ignore any errors or empty output produced by COMMAND."),
1543 },
1544};
1545
1546/* Create an option_def_group for the "thread apply all" options, with
1547 ASCENDING and FLAGS as context. */
1548
1549static inline std::array<gdb::option::option_def_group, 2>
1552{
1553 return {{
1554 { {ascending_option_def.def ()}, ascending},
1556 }};
1557}
1558
1559/* Create an option_def_group for the "thread apply" options, with
1560 FLAGS as context. */
1561
1564{
1565 return {{thr_qcs_flags_option_defs}, flags};
1566}
1567
1568/* Apply a GDB command to a list of threads. List syntax is a whitespace
1569 separated list of numbers, or ranges, or the keyword `all'. Ranges consist
1570 of two numbers separated by a hyphen. Examples:
1571
1572 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1573 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1574 thread apply all x/i $pc Apply x/i $pc cmd to all threads. */
1575
1576static void
1577thread_apply_all_command (const char *cmd, int from_tty)
1578{
1579 bool ascending = false;
1581
1582 auto group = make_thread_apply_all_options_def_group (&ascending,
1583 &flags);
1586
1587 validate_flags_qcs ("thread apply all", &flags);
1588
1589 if (cmd == NULL || *cmd == '\000')
1590 error (_("Please specify a command at the end of 'thread apply all'"));
1591
1593
1594 int tc = live_threads_count ();
1595 if (tc != 0)
1596 {
1597 /* Save a copy of the thread list and increment each thread's
1598 refcount while executing the command in the context of each
1599 thread, in case the command is one that wipes threads. E.g.,
1600 detach, kill, disconnect, etc., or even normally continuing
1601 over an inferior or thread exit. */
1602 std::vector<thread_info_ref> thr_list_cpy;
1603 thr_list_cpy.reserve (tc);
1604
1605 for (thread_info *tp : all_non_exited_threads ())
1606 thr_list_cpy.push_back (thread_info_ref::new_reference (tp));
1607 gdb_assert (thr_list_cpy.size () == tc);
1608
1609 auto *sorter = (ascending
1612 std::sort (thr_list_cpy.begin (), thr_list_cpy.end (), sorter);
1613
1614 scoped_restore_current_thread restore_thread;
1615
1616 for (thread_info_ref &thr : thr_list_cpy)
1617 if (switch_to_thread_if_alive (thr.get ()))
1618 thread_try_catch_cmd (thr.get (), {}, cmd, from_tty, flags);
1619 }
1620}
1621
1622/* Completer for "thread apply [ID list]". */
1623
1624static void
1626 completion_tracker &tracker,
1627 const char *text, const char * /*word*/)
1628{
1629 /* Don't leave this to complete_options because there's an early
1630 return below. */
1631 tracker.set_use_custom_word_point (true);
1632
1633 tid_range_parser parser;
1634 parser.init (text, current_inferior ()->num);
1635
1636 try
1637 {
1638 while (!parser.finished ())
1639 {
1640 int inf_num, thr_start, thr_end;
1641
1642 if (!parser.get_tid_range (&inf_num, &thr_start, &thr_end))
1643 break;
1644
1645 if (parser.in_star_range () || parser.in_thread_range ())
1646 parser.skip_range ();
1647 }
1648 }
1649 catch (const gdb_exception_error &ex)
1650 {
1651 /* get_tid_range throws if it parses a negative number, for
1652 example. But a seemingly negative number may be the start of
1653 an option instead. */
1654 }
1655
1656 const char *cmd = parser.cur_tok ();
1657
1658 if (cmd == text)
1659 {
1660 /* No thread ID list yet. */
1661 return;
1662 }
1663
1664 /* Check if we're past a valid thread ID list already. */
1665 if (parser.finished ()
1666 && cmd > text && !isspace (cmd[-1]))
1667 return;
1668
1669 /* We're past the thread ID list, advance word point. */
1670 tracker.advance_custom_word_point_by (cmd - text);
1671 text = cmd;
1672
1673 const auto group = make_thread_apply_options_def_group (nullptr);
1675 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
1676 return;
1677
1678 complete_nested_command_line (tracker, text);
1679}
1680
1681/* Completer for "thread apply all". */
1682
1683static void
1685 completion_tracker &tracker,
1686 const char *text, const char *word)
1687{
1688 const auto group = make_thread_apply_all_options_def_group (nullptr,
1689 nullptr);
1691 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
1692 return;
1693
1694 complete_nested_command_line (tracker, text);
1695}
1696
1697/* Implementation of the "thread apply" command. */
1698
1699static void
1700thread_apply_command (const char *tidlist, int from_tty)
1701{
1703 const char *cmd = NULL;
1704 tid_range_parser parser;
1705
1706 if (tidlist == NULL || *tidlist == '\000')
1707 error (_("Please specify a thread ID list"));
1708
1709 parser.init (tidlist, current_inferior ()->num);
1710 while (!parser.finished ())
1711 {
1712 int inf_num, thr_start, thr_end;
1713
1714 if (!parser.get_tid_range (&inf_num, &thr_start, &thr_end))
1715 break;
1716 }
1717
1718 cmd = parser.cur_tok ();
1719
1723
1724 validate_flags_qcs ("thread apply", &flags);
1725
1726 if (*cmd == '\0')
1727 error (_("Please specify a command following the thread ID list"));
1728
1729 if (tidlist == cmd || isdigit (cmd[0]))
1731
1732 scoped_restore_current_thread restore_thread;
1733
1734 parser.init (tidlist, current_inferior ()->num);
1735 while (!parser.finished ())
1736 {
1737 struct thread_info *tp = NULL;
1738 struct inferior *inf;
1739 int inf_num, thr_num;
1740
1741 parser.get_tid (&inf_num, &thr_num);
1742 inf = find_inferior_id (inf_num);
1743 if (inf != NULL)
1744 tp = find_thread_id (inf, thr_num);
1745
1746 if (parser.in_star_range ())
1747 {
1748 if (inf == NULL)
1749 {
1750 warning (_("Unknown inferior %d"), inf_num);
1751 parser.skip_range ();
1752 continue;
1753 }
1754
1755 /* No use looking for threads past the highest thread number
1756 the inferior ever had. */
1757 if (thr_num >= inf->highest_thread_num)
1758 parser.skip_range ();
1759
1760 /* Be quiet about unknown threads numbers. */
1761 if (tp == NULL)
1762 continue;
1763 }
1764
1765 if (tp == NULL)
1766 {
1768 warning (_("Unknown thread %d.%d"), inf_num, thr_num);
1769 else
1770 warning (_("Unknown thread %d"), thr_num);
1771 continue;
1772 }
1773
1774 if (!switch_to_thread_if_alive (tp))
1775 {
1776 warning (_("Thread %s has terminated."), print_thread_id (tp));
1777 continue;
1778 }
1779
1780 thread_try_catch_cmd (tp, {}, cmd, from_tty, flags);
1781 }
1782}
1783
1784
1785/* Implementation of the "taas" command. */
1786
1787static void
1788taas_command (const char *cmd, int from_tty)
1789{
1790 if (cmd == NULL || *cmd == '\0')
1791 error (_("Please specify a command to apply on all threads"));
1792 std::string expanded = std::string ("thread apply all -s ") + cmd;
1793 execute_command (expanded.c_str (), from_tty);
1794}
1795
1796/* Implementation of the "tfaas" command. */
1797
1798static void
1799tfaas_command (const char *cmd, int from_tty)
1800{
1801 if (cmd == NULL || *cmd == '\0')
1802 error (_("Please specify a command to apply on all frames of all threads"));
1803 std::string expanded
1804 = std::string ("thread apply all -s -- frame apply all -s ") + cmd;
1805 execute_command (expanded.c_str (), from_tty);
1806}
1807
1808/* Switch to the specified thread, or print the current thread. */
1809
1810void
1811thread_command (const char *tidstr, int from_tty)
1812{
1813 if (tidstr == NULL)
1814 {
1815 if (inferior_ptid == null_ptid)
1816 error (_("No thread selected"));
1817
1818 if (target_has_stack ())
1819 {
1820 struct thread_info *tp = inferior_thread ();
1821
1822 if (tp->state == THREAD_EXITED)
1823 gdb_printf (_("[Current thread is %s (%s) (exited)]\n"),
1824 print_thread_id (tp),
1825 target_pid_to_str (inferior_ptid).c_str ());
1826 else
1827 gdb_printf (_("[Current thread is %s (%s)]\n"),
1828 print_thread_id (tp),
1829 target_pid_to_str (inferior_ptid).c_str ());
1830 }
1831 else
1832 error (_("No stack."));
1833 }
1834 else
1835 {
1836 ptid_t previous_ptid = inferior_ptid;
1837
1838 thread_select (tidstr, parse_thread_id (tidstr, NULL));
1839
1840 /* Print if the thread has not changed, otherwise an event will
1841 be sent. */
1842 if (inferior_ptid == previous_ptid)
1843 {
1847 }
1848 else
1849 {
1852 }
1853 }
1854}
1855
1856/* Implementation of `thread name'. */
1857
1858static void
1859thread_name_command (const char *arg, int from_tty)
1860{
1861 struct thread_info *info;
1862
1863 if (inferior_ptid == null_ptid)
1864 error (_("No thread selected"));
1865
1866 arg = skip_spaces (arg);
1867
1868 info = inferior_thread ();
1869 info->set_name (arg != nullptr ? make_unique_xstrdup (arg) : nullptr);
1870}
1871
1872/* Find thread ids with a name, target pid, or extra info matching ARG. */
1873
1874static void
1875thread_find_command (const char *arg, int from_tty)
1876{
1877 const char *tmp;
1878 unsigned long match = 0;
1879
1880 if (arg == NULL || *arg == '\0')
1881 error (_("Command requires an argument."));
1882
1883 tmp = re_comp (arg);
1884 if (tmp != 0)
1885 error (_("Invalid regexp (%s): %s"), tmp, arg);
1886
1887 /* We're going to be switching threads. */
1888 scoped_restore_current_thread restore_thread;
1889
1891
1892 for (thread_info *tp : all_threads ())
1893 {
1895
1896 if (tp->name () != nullptr && re_exec (tp->name ()))
1897 {
1898 gdb_printf (_("Thread %s has name '%s'\n"),
1899 print_thread_id (tp), tp->name ());
1900 match++;
1901 }
1902
1903 tmp = target_thread_name (tp);
1904 if (tmp != NULL && re_exec (tmp))
1905 {
1906 gdb_printf (_("Thread %s has target name '%s'\n"),
1907 print_thread_id (tp), tmp);
1908 match++;
1909 }
1910
1911 std::string name = target_pid_to_str (tp->ptid);
1912 if (!name.empty () && re_exec (name.c_str ()))
1913 {
1914 gdb_printf (_("Thread %s has target id '%s'\n"),
1915 print_thread_id (tp), name.c_str ());
1916 match++;
1917 }
1918
1919 tmp = target_extra_thread_info (tp);
1920 if (tmp != NULL && re_exec (tmp))
1921 {
1922 gdb_printf (_("Thread %s has extra info '%s'\n"),
1923 print_thread_id (tp), tmp);
1924 match++;
1925 }
1926 }
1927 if (!match)
1928 gdb_printf (_("No threads match '%s'\n"), arg);
1929}
1930
1931/* Print notices when new threads are attached and detached. */
1933static void
1934show_print_thread_events (struct ui_file *file, int from_tty,
1935 struct cmd_list_element *c, const char *value)
1936{
1937 gdb_printf (file,
1938 _("Printing of thread events is %s.\n"),
1939 value);
1940}
1941
1942/* See gdbthread.h. */
1943
1944void
1945thread_select (const char *tidstr, thread_info *tp)
1946{
1947 if (!switch_to_thread_if_alive (tp))
1948 error (_("Thread ID %s has terminated."), tidstr);
1949
1951
1952 /* Since the current thread may have changed, see if there is any
1953 exited thread we can now delete. */
1955}
1956
1957/* Print thread and frame switch command response. */
1958
1959void
1961 user_selected_what selection)
1962{
1963 struct thread_info *tp = inferior_thread ();
1964
1965 if (selection & USER_SELECTED_THREAD)
1966 {
1967 if (uiout->is_mi_like_p ())
1968 {
1969 uiout->field_signed ("new-thread-id",
1970 inferior_thread ()->global_num);
1971 }
1972 else
1973 {
1974 uiout->text ("[Switching to thread ");
1975 uiout->field_string ("new-thread-id", print_thread_id (tp));
1976 uiout->text (" (");
1978 uiout->text (")]");
1979 }
1980 }
1981
1982 if (tp->state == THREAD_RUNNING)
1983 {
1984 if (selection & USER_SELECTED_THREAD)
1985 uiout->text ("(running)\n");
1986 }
1987 else if (selection & USER_SELECTED_FRAME)
1988 {
1989 if (selection & USER_SELECTED_THREAD)
1990 uiout->text ("\n");
1991
1992 if (has_stack_frames ())
1994 1, SRC_AND_LOC, 1);
1995 }
1996}
1997
1998/* Update the 'threads_executing' global based on the threads we know
1999 about right now. This is used by infrun to tell whether we should
2000 pull events out of the current target. */
2001
2002static void
2004{
2006
2007 if (targ == NULL)
2008 return;
2009
2010 targ->threads_executing = false;
2011
2012 for (inferior *inf : all_non_exited_inferiors (targ))
2013 {
2014 if (!inf->has_execution ())
2015 continue;
2016
2017 /* If the process has no threads, then it must be we have a
2018 process-exit event pending. */
2019 if (inf->thread_list.empty ())
2020 {
2021 targ->threads_executing = true;
2022 return;
2023 }
2024
2025 for (thread_info *tp : inf->non_exited_threads ())
2026 {
2027 if (tp->executing ())
2028 {
2029 targ->threads_executing = true;
2030 return;
2031 }
2032 }
2033 }
2034}
2035
2036void
2038{
2041}
2042
2043/* See gdbthread.h. */
2044
2045const char *
2047{
2048 /* Use the manually set name if there is one. */
2049 const char *name = thread->name ();
2050 if (name != nullptr)
2051 return name;
2052
2053 /* Otherwise, ask the target. Ensure we query the right target stack. */
2054 scoped_restore_current_thread restore_thread;
2055 if (thread->inf != current_inferior ())
2057
2058 return target_thread_name (thread);
2059}
2060
2061/* See gdbthread.h. */
2062
2063const char *
2065{
2066 switch (state)
2067 {
2068 case THREAD_STOPPED:
2069 return "STOPPED";
2070
2071 case THREAD_RUNNING:
2072 return "RUNNING";
2073
2074 case THREAD_EXITED:
2075 return "EXITED";
2076 }
2077
2078 gdb_assert_not_reached ("unknown thread state");
2079}
2080
2081/* Return a new value for the selected thread's id. Return a value of
2082 0 if no thread is selected. If GLOBAL is true, return the thread's
2083 global number. Otherwise return the per-inferior number. */
2084
2085static struct value *
2087{
2088 int int_val;
2089
2090 if (inferior_ptid == null_ptid)
2091 int_val = 0;
2092 else
2093 {
2095 if (global)
2096 int_val = tp->global_num;
2097 else
2098 int_val = tp->per_inf_num;
2099 }
2100
2101 return value_from_longest (builtin_type (gdbarch)->builtin_int, int_val);
2102}
2103
2104/* Return a new value for the selected thread's per-inferior thread
2105 number. Return a value of 0 if no thread is selected, or no
2106 threads exist. */
2107
2108static struct value *
2110 struct internalvar *var,
2111 void *ignore)
2112{
2114}
2115
2116/* Return a new value for the selected thread's global id. Return a
2117 value of 0 if no thread is selected, or no threads exist. */
2118
2119static struct value *
2121 void *ignore)
2122{
2124}
2125
2126/* Return a new value for the number of non-exited threads in the current
2127 inferior. If there are no threads in the current inferior return a
2128 value of 0. */
2129
2130static struct value *
2132 struct internalvar *var, void *ignore)
2133{
2134 int int_val = 0;
2135
2136 if (inferior_ptid != null_ptid)
2137 int_val = current_inferior ()->non_exited_threads ().size ();
2138
2139 return value_from_longest (builtin_type (gdbarch)->builtin_int, int_val);
2140}
2141
2142/* Commands with a prefix of `thread'. */
2144
2145/* Implementation of `thread' variable. */
2146
2147static const struct internalvar_funcs thread_funcs =
2148{
2150 NULL,
2151};
2152
2153/* Implementation of `gthread' variable. */
2154
2156{
2158 NULL,
2159};
2160
2161/* Implementation of `_inferior_thread_count` convenience variable. */
2162
2164{
2166 NULL,
2167};
2168
2169void _initialize_thread ();
2170void
2172{
2173 static struct cmd_list_element *thread_apply_list = NULL;
2175
2177
2178 /* Note: keep this "ID" in sync with what "info threads [TAB]"
2179 suggests. */
2180 static std::string info_threads_help
2182Display currently known threads.\n\
2183Usage: info threads [OPTION]... [ID]...\n\
2184If ID is given, it is a space-separated list of IDs of threads to display.\n\
2185Otherwise, all threads are displayed.\n\
2186\n\
2187Options:\n\
2188%OPTIONS%"),
2190
2191 c = add_info ("threads", info_threads_command, info_threads_help.c_str ());
2193
2194 cmd_list_element *thread_cmd
2195 = add_prefix_cmd ("thread", class_run, thread_command, _("\
2196Use this command to switch between threads.\n\
2197The new thread ID must be currently known."),
2198 &thread_cmd_list, 1, &cmdlist);
2199
2200 add_com_alias ("t", thread_cmd, class_run, 1);
2201
2202#define THREAD_APPLY_OPTION_HELP "\
2203Prints per-inferior thread number and target system's thread id\n\
2204followed by COMMAND output.\n\
2205\n\
2206By default, an error raised during the execution of COMMAND\n\
2207aborts \"thread apply\".\n\
2208\n\
2209Options:\n\
2210%OPTIONS%"
2211
2212 const auto thread_apply_opts = make_thread_apply_options_def_group (nullptr);
2213
2214 static std::string thread_apply_help = gdb::option::build_help (_("\
2215Apply a command to a list of threads.\n\
2216Usage: thread apply ID... [OPTION]... COMMAND\n\
2217ID is a space-separated list of IDs of threads to apply COMMAND on.\n"
2219 thread_apply_opts);
2220
2222 thread_apply_help.c_str (),
2223 &thread_apply_list, 1,
2226
2227 const auto thread_apply_all_opts
2228 = make_thread_apply_all_options_def_group (nullptr, nullptr);
2229
2230 static std::string thread_apply_all_help = gdb::option::build_help (_("\
2231Apply a command to all threads.\n\
2232\n\
2233Usage: thread apply all [OPTION]... COMMAND\n"
2235 thread_apply_all_opts);
2236
2238 thread_apply_all_help.c_str (),
2239 &thread_apply_list);
2241
2242 c = add_com ("taas", class_run, taas_command, _("\
2243Apply a command to all threads (ignoring errors and empty output).\n\
2244Usage: taas [OPTION]... COMMAND\n\
2245shortcut for 'thread apply all -s [OPTION]... COMMAND'\n\
2246See \"help thread apply all\" for available options."));
2248
2249 c = add_com ("tfaas", class_run, tfaas_command, _("\
2250Apply a command to all frames of all threads (ignoring errors and empty output).\n\
2251Usage: tfaas [OPTION]... COMMAND\n\
2252shortcut for 'thread apply all -s -- frame apply all -s [OPTION]... COMMAND'\n\
2253See \"help frame apply all\" for available options."));
2255
2257 _("Set the current thread's name.\n\
2258Usage: thread name [NAME]\n\
2259If NAME is not given, then any existing name is removed."), &thread_cmd_list);
2260
2261 add_cmd ("find", class_run, thread_find_command, _("\
2262Find threads that match a regular expression.\n\
2263Usage: thread find REGEXP\n\
2264Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2266
2267 add_setshow_boolean_cmd ("thread-events", no_class,
2268 &print_thread_events, _("\
2269Set printing of thread events (such as thread start and exit)."), _("\
2270Show printing of thread events (such as thread start and exit)."), NULL,
2271 NULL,
2274
2276Set thread debugging."), _("\
2277Show thread debugging."), _("\
2278When on messages about thread creation and deletion are printed."),
2279 nullptr,
2282
2283 create_internalvar_type_lazy ("_thread", &thread_funcs, NULL);
2284 create_internalvar_type_lazy ("_gthread", &gthread_funcs, NULL);
2285 create_internalvar_type_lazy ("_inferior_thread_count",
2287}
const char *const name
void annotate_new_thread(void)
Definition annotate.c:216
void annotate_thread_changed(void)
Definition annotate.c:225
void delete_breakpoint(struct breakpoint *bpt)
void bpstat_clear(bpstat **bsp)
int breakpoint_has_location_inserted_here(struct breakpoint *bp, const address_space *aspace, CORE_ADDR pc)
void delete_longjmp_breakpoint_at_next_stop(int thread)
@ disp_del_at_next_stop
Definition breakpoint.h:238
void btrace_teardown(struct thread_info *tp)
Definition btrace.c:1685
void add_completion(gdb::unique_xmalloc_ptr< char > name, completion_match_for_lcd *match_for_lcd=NULL, const char *text=NULL, const char *word=NULL)
Definition completer.c:1579
void advance_custom_word_point_by(int len)
Definition completer.c:2049
void set_use_custom_word_point(bool enable)
Definition completer.h:349
int highest_thread_num
Definition inferior.h:531
struct process_stratum_target * process_target()
Definition inferior.h:419
std::unordered_map< ptid_t, thread_info *, hash_ptid > ptid_thread_map
Definition inferior.h:434
inf_non_exited_threads_range non_exited_threads()
Definition inferior.h:451
intrusive_list< thread_info > thread_list
Definition inferior.h:430
int num
Definition inferior.h:522
void maybe_remove_resumed_with_pending_wait_status(thread_info *thread)
void maybe_add_resumed_with_pending_wait_status(thread_info *thread)
thread_info(inferior *inf, ptid_t ptid)
Definition thread.c:310
void set_pending_waitstatus(const target_waitstatus &ws)
Definition thread.c:375
thread_suspend_state m_suspend
Definition gdbthread.h:569
std::vector< struct value * > stack_temporaries
Definition gdbthread.h:536
void set_resumed(bool resumed)
Definition thread.c:352
void clear_stop_pc()
Definition gdbthread.h:376
std::unique_ptr< struct thread_fsm > release_thread_fsm()
Definition gdbthread.h:458
intrusive_list_node< thread_info > step_over_list_node
Definition gdbthread.h:540
enum thread_state state
Definition gdbthread.h:336
int per_inf_num
Definition gdbthread.h:295
void set_running(bool running)
Definition thread.c:856
ptid_t ptid
Definition gdbthread.h:256
std::unique_ptr< private_thread_info > priv
Definition gdbthread.h:525
void set_executing(bool executing)
Definition thread.c:342
bool has_pending_waitstatus() const
Definition gdbthread.h:391
void clear_pending_waitstatus()
Definition thread.c:389
struct target_waitstatus pending_follow
Definition gdbthread.h:513
bool m_resumed
Definition gdbthread.h:559
bool m_executing
Definition gdbthread.h:565
bool deletable() const
Definition thread.c:332
struct thread_fsm * thread_fsm() const
Definition gdbthread.h:449
bool executing() const
Definition gdbthread.h:316
bool stack_temporaries_enabled
Definition gdbthread.h:532
struct inferior * inf
Definition gdbthread.h:298
const char * name() const
Definition gdbthread.h:303
~thread_info()
Definition thread.c:324
thread_control_state control
Definition gdbthread.h:340
const char * cur_tok() const
Definition tid-parse.c:160
bool in_thread_range() const
Definition tid-parse.c:311
bool tid_is_qualified() const
Definition tid-parse.c:187
bool finished() const
Definition tid-parse.c:137
bool get_tid_range(int *inf_num, int *thr_start, int *thr_end)
Definition tid-parse.c:284
void init(const char *tidlist, int default_inferior)
Definition tid-parse.c:125
bool get_tid(int *inf_num, int *thr_num)
Definition tid-parse.c:295
bool in_star_range() const
Definition tid-parse.c:305
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
Definition ui-out.c:511
void field_signed(const char *fldname, LONGEST value)
Definition ui-out.c:437
void field_skip(const char *fldname)
Definition ui-out.c:499
void text(const char *string)
Definition ui-out.c:566
void table_header(int width, ui_align align, const std::string &col_name, const std::string &col_hdr)
Definition ui-out.c:363
bool is_mi_like_p() const
Definition ui-out.c:810
void table_body()
Definition ui-out.c:376
void message(const char *format,...) ATTRIBUTE_PRINTF(2
Definition ui-out.c:774
struct cmd_list_element * showprintlist
Definition cli-cmds.c:161
struct cmd_list_element * cmdlist
Definition cli-cmds.c:85
struct cmd_list_element * setprintlist
Definition cli-cmds.c:159
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:165
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:163
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
void set_cmd_completer_handle_brkchars(struct cmd_list_element *cmd, completer_handle_brkchars_ftype *func)
Definition cli-decode.c:125
cmd_list_element * add_com_alias(const char *name, cmd_list_element *target, command_class theclass, int abbrev_flag)
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
Definition cli-decode.c:357
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:739
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
int number_is_in_list(const char *list, int number)
Definition cli-utils.c:348
void validate_flags_qcs(const char *which_command, qcs_flags *flags)
Definition cli-utils.c:436
@ class_maintenance
Definition command.h:65
@ class_run
Definition command.h:54
@ no_class
Definition command.h:53
void complete_nested_command_line(completion_tracker &tracker, const char *text)
Definition completer.c:464
EXTERN_C char * re_comp(const char *)
@ USER_SELECTED_THREAD
Definition defs.h:644
@ USER_SELECTED_FRAME
Definition defs.h:647
void restore_selected_frame(frame_id frame_id, int frame_level) noexcept
Definition frame.c:1695
void reinit_frame_cache(void)
Definition frame.c:2006
void save_selected_frame(frame_id *frame_id, int *frame_level) noexcept
Definition frame.c:1685
bool has_stack_frames()
Definition frame.c:1784
frame_info_ptr get_selected_frame(const char *message)
Definition frame.c:1813
@ LOCATION
Definition frame.h:592
@ SRC_AND_LOC
Definition frame.h:594
void print_stack_frame(frame_info_ptr, int print_level, enum print_what print_what, int set_current_sal)
Definition stack.c:356
void print_stack_frame_to_uiout(struct ui_out *uiout, frame_info_ptr, int print_level, enum print_what print_what, int set_current_sal)
Definition stack.c:340
void execute_command_to_string(std::string &res, const char *p, int from_tty, bool term_out)
Definition top.c:783
void execute_command(const char *, int)
Definition top.c:574
all_threads_safe_range all_threads_safe()
Definition gdbthread.h:760
all_matching_threads_range all_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
Definition gdbthread.h:732
all_non_exited_threads_range all_non_exited_threads(process_stratum_target *proc_target=nullptr, ptid_t filter_ptid=minus_one_ptid)
Definition gdbthread.h:743
thread_state
Definition gdbthread.h:70
@ THREAD_STOPPED
Definition gdbthread.h:72
@ THREAD_RUNNING
Definition gdbthread.h:75
@ THREAD_EXITED
Definition gdbthread.h:79
struct thread_info * inferior_thread(void)
Definition thread.c:83
void switch_to_thread(struct thread_info *thr)
Definition thread.c:1335
#define threads_debug_printf(fmt,...)
Definition gdbthread.h:49
gdb::ref_ptr< struct thread_info, refcounted_object_ref_policy > thread_info_ref
Definition gdbthread.h:592
intrusive_list< thread_info, thread_step_over_list_node > thread_step_over_list
Definition gdbthread.h:938
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1862
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition gnu-nat.c:1792
#define thread_info
Definition gnu-nat.h:26
size_t size
Definition go32-nat.c:241
ptid_t inferior_ptid
Definition infcmd.c:91
struct inferior * find_inferior_ptid(process_stratum_target *targ, ptid_t ptid)
Definition inferior.c:365
void set_current_inferior(struct inferior *inf)
Definition inferior.c:60
struct inferior * current_inferior(void)
Definition inferior.c:54
void switch_to_inferior_no_thread(inferior *inf)
Definition inferior.c:671
intrusive_list< inferior > inferior_list
Definition inferior.c:42
struct inferior * find_inferior_id(int num)
Definition inferior.c:338
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:758
all_non_exited_inferiors_range all_non_exited_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:767
thread_step_over_list global_thread_step_over_list
Definition infrun.c:1299
#define infrun_debug_printf(fmt,...)
Definition infrun.h:38
void clear_inline_frame_state(process_stratum_target *target, ptid_t filter_ptid)
const struct language_defn * current_language
Definition language.c:83
enum language set_language(enum language lang)
Definition language.c:361
observable< ptid_t > thread_stop_requested
observable< struct thread_info * > new_thread
observable< struct thread_info *, int > thread_exit
observable< user_selected_what > user_selected_context_changed
observable< process_stratum_target *, ptid_t, ptid_t > thread_ptid_changed
observable< ptid_t > target_resumed
bool process_options(const char **args, process_options_mode mode, gdb::array_view< const option_def_group > options_group)
Definition cli-option.c:616
@ PROCESS_OPTIONS_UNKNOWN_IS_ERROR
Definition cli-option.h:307
@ PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
Definition cli-option.h:311
std::string build_help(const char *help_tmpl, gdb::array_view< const option_def_group > options_group)
Definition cli-option.c:743
void complete_on_all_options(completion_tracker &tracker, gdb::array_view< const option_def_group > options_group)
Definition cli-option.c:170
bool complete_options(completion_tracker &tracker, const char **args, process_options_mode mode, gdb::array_view< const option_def_group > options_group)
Definition cli-option.c:457
void set_current_program_space(struct program_space *pspace)
Definition progspace.c:224
void frame_apply_all_cmd_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *)
Definition stack.c:3107
const option_def & def() const
Definition cli-option.h:115
Definition gnu-nat.c:154
pid_t pid
Definition gnu-nat.c:166
struct proc * threads
Definition gnu-nat.c:158
enum language la_language
Definition language.h:275
virtual ~private_thread_info()=0
const char * shortname() const
Definition target.h:451
target_waitstatus & set_spurious()
Definition waitstatus.h:300
CORE_ADDR step_range_start
Definition gdbthread.h:124
struct breakpoint * exception_resume_breakpoint
Definition gdbthread.h:105
struct breakpoint * step_resume_breakpoint
Definition gdbthread.h:102
struct breakpoint * single_step_breakpoints
Definition gdbthread.h:112
struct target_waitstatus waitstatus
Definition gdbthread.h:194
Definition value.c:181
int target_has_stack()
Definition target.c:178
int target_core_of_thread(ptid_t ptid)
Definition target.c:3942
void target_update_thread_list(void)
Definition target.c:3769
struct thread_info * target_thread_handle_to_thread_info(const gdb_byte *thread_handle, int handle_len, struct inferior *inf)
Definition target.c:2616
int target_has_registers()
Definition target.c:190
int target_has_memory()
Definition target.c:166
const char * target_thread_name(struct thread_info *info)
Definition target.c:2608
const char * target_extra_thread_info(thread_info *tp)
Definition target.c:419
std::string target_pid_to_str(ptid_t ptid)
Definition target.c:2602
int target_thread_alive(ptid_t ptid)
Definition target.c:3763
void switch_to_thread(thread_info *thr)
Definition thread.c:1335
void delete_exception_resume_breakpoint(struct thread_info *tp)
Definition thread.c:109
thread_info * any_thread_of_inferior(inferior *inf)
Definition thread.c:629
static thread_info * current_thread_
Definition thread.c:72
static const gdb::option::flag_option_def ascending_option_def
Definition thread.c:1516
static bool set_running_thread(struct thread_info *tp, bool running)
Definition thread.c:829
bool switch_to_thread_if_alive(thread_info *thr)
Definition thread.c:697
int thread_step_over_chain_length(const thread_step_over_list &l)
Definition thread.c:410
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:303
static const gdb::option::option_def thr_qcs_flags_option_defs[]
Definition thread.c:1529
const char * thread_state_string(enum thread_state state)
Definition thread.c:2064
static void tfaas_command(const char *cmd, int from_tty)
Definition thread.c:1799
void global_thread_step_over_chain_enqueue_chain(thread_step_over_list &&list)
Definition thread.c:435
static void thread_apply_all_command_completer(cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition thread.c:1684
int thread_count(process_stratum_target *proc_target)
Definition thread.c:586
void global_thread_step_over_chain_enqueue(struct thread_info *tp)
Definition thread.c:423
struct cmd_list_element * thread_cmd_list
Definition thread.c:2143
bool threads_are_executing(process_stratum_target *target)
Definition thread.c:897
struct thread_info * add_thread_silent(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:263
static bool is_current_thread(const thread_info *thr)
Definition thread.c:77
thread_info * first_thread_of_inferior(inferior *inf)
Definition thread.c:620
static const struct internalvar_funcs gthread_funcs
Definition thread.c:2155
void delete_step_resume_breakpoint(struct thread_info *tp)
Definition thread.c:102
void print_selected_thread_frame(struct ui_out *uiout, user_selected_what selection)
Definition thread.c:1960
void push_thread_stack_temporary(thread_info *tp, struct value *v)
Definition thread.c:756
void delete_thread(thread_info *thread)
Definition thread.c:483
void switch_to_thread_no_regs(struct thread_info *thread)
Definition thread.c:1303
static bool tp_array_compar_descending(const thread_info_ref &a, const thread_info_ref &b)
Definition thread.c:1460
int show_inferior_qualified_tids(void)
Definition thread.c:1419
void validate_registers_access(void)
Definition thread.c:930
static void info_threads_command(const char *arg, int from_tty)
Definition thread.c:1266
static struct value * thread_num_make_value_helper(struct gdbarch *gdbarch, int global)
Definition thread.c:2086
bool value_in_thread_stack_temporaries(struct value *val, thread_info *tp)
Definition thread.c:766
static void thread_apply_command(const char *tidlist, int from_tty)
Definition thread.c:1700
static void show_print_thread_events(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition thread.c:1934
int valid_global_thread_id(int global_id)
Definition thread.c:602
static std::array< gdb::option::option_def_group, 2 > make_thread_apply_all_options_def_group(bool *ascending, qcs_flags *flags)
Definition thread.c:1550
bool debug_threads
Definition thread.c:54
static void update_threads_executing(void)
Definition thread.c:2003
bool can_access_registers_thread(thread_info *thread)
Definition thread.c:954
int show_thread_that_caused_stop(void)
Definition thread.c:1411
static void info_threads_command_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word_ignored)
Definition thread.c:1280
value * get_last_thread_stack_temporary(thread_info *tp)
Definition thread.c:780
static struct value * thread_id_per_inf_num_make_value(struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
Definition thread.c:2109
static void delete_thread_1(thread_info *thr, bool silent)
Definition thread.c:459
bool any_thread_p()
Definition thread.c:578
static bool tp_array_compar_ascending(const thread_info_ref &a, const thread_info_ref &b)
Definition thread.c:1447
struct thread_info * find_thread_ptid(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:517
static void show_debug_threads(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition thread.c:59
void set_stop_requested(process_stratum_target *targ, ptid_t ptid, bool stop)
Definition thread.c:903
struct thread_info * iterate_over_threads(int(*callback)(struct thread_info *, void *), void *data)
Definition thread.c:565
struct thread_info * find_thread_global_id(int global_id)
Definition thread.c:495
static void taas_command(const char *cmd, int from_tty)
Definition thread.c:1788
int pc_in_thread_step_range(CORE_ADDR pc, struct thread_info *thread)
Definition thread.c:972
void finish_thread_state(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:915
thread_info * any_live_thread_of_inferior(inferior *inf)
Definition thread.c:644
static void thread_apply_command_completer(cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *)
Definition thread.c:1625
void update_thread_list(void)
Definition thread.c:2037
void set_executing(process_stratum_target *targ, ptid_t ptid, bool executing)
Definition thread.c:880
struct thread_info * inferior_thread(void)
Definition thread.c:83
void set_thread_exited(thread_info *tp, bool silent)
Definition thread.c:195
static gdb::option::option_def_group make_thread_apply_options_def_group(qcs_flags *flags)
Definition thread.c:1563
void thread_command(const char *tidstr, int from_tty)
Definition thread.c:1811
static void delete_thread_breakpoint(struct breakpoint **bp_p)
Definition thread.c:92
static void thread_find_command(const char *arg, int from_tty)
Definition thread.c:1875
void thread_try_catch_cmd(thread_info *thr, gdb::optional< int > ada_task, const char *cmd, int from_tty, const qcs_flags &flags)
Definition thread.c:1471
void set_running(process_stratum_target *targ, ptid_t ptid, bool running)
Definition thread.c:863
int thread_has_single_step_breakpoint_here(struct thread_info *tp, const address_space *aspace, CORE_ADDR addr)
Definition thread.c:148
bool thread_stack_temporaries_enabled_p(thread_info *tp)
Definition thread.c:745
static int highest_thread_num
Definition thread.c:69
void global_thread_step_over_chain_remove(struct thread_info *tp)
Definition thread.c:443
static std::string thread_target_id_str(thread_info *tp)
Definition thread.c:1022
bool print_thread_events
Definition thread.c:1932
static struct thread_info * new_thread(struct inferior *inf, ptid_t ptid)
Definition thread.c:245
void thread_change_ptid(process_stratum_target *targ, ptid_t old_ptid, ptid_t new_ptid)
Definition thread.c:792
static int live_threads_count(void)
Definition thread.c:595
static void delete_at_next_stop(struct breakpoint **bp)
Definition thread.c:128
void set_resumed(process_stratum_target *targ, ptid_t ptid, bool resumed)
Definition thread.c:819
static struct value * inferior_thread_count_make_value(struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
Definition thread.c:2131
static void thread_apply_all_command(const char *cmd, int from_tty)
Definition thread.c:1577
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
Definition thread.c:140
const char * thread_name(thread_info *thread)
Definition thread.c:2046
static int should_print_thread(const char *requested_threads, int default_inf_num, int global_ids, int pid, struct thread_info *thr)
Definition thread.c:989
int thread_is_in_step_over_chain(struct thread_info *tp)
Definition thread.c:402
static const gdb::option::option_def info_threads_option_defs[]
Definition thread.c:1240
void prune_threads(void)
Definition thread.c:718
static bool thread_alive(thread_info *tp)
Definition thread.c:683
#define THREAD_APPLY_OPTION_HELP
struct thread_info * find_thread_by_handle(gdb::array_view< const gdb_byte > handle, struct inferior *inf)
Definition thread.c:542
void _initialize_thread()
Definition thread.c:2171
static void thread_name_command(const char *arg, int from_tty)
Definition thread.c:1859
static void print_thread_info_1(struct ui_out *uiout, const char *requested_threads, int global_ids, int pid, int show_global_ids)
Definition thread.c:1044
void delete_single_step_breakpoints(struct thread_info *tp)
Definition thread.c:118
static void clear_thread_inferior_resources(struct thread_info *tp)
Definition thread.c:171
bool in_thread_list(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:612
void switch_to_no_thread()
Definition thread.c:1320
void print_thread_info(struct ui_out *uiout, const char *requested_threads, int pid)
Definition thread.c:1226
void thread_cancel_execution_command(struct thread_info *thr)
Definition thread.c:161
const char * print_thread_id(struct thread_info *thr)
Definition thread.c:1431
void thread_select(const char *tidstr, thread_info *tp)
Definition thread.c:1945
static struct thread_info * find_thread_id(struct inferior *inf, int thr_num)
Definition thread.c:505
void delete_exited_threads(void)
Definition thread.c:734
void delete_thread_silent(thread_info *thread)
Definition thread.c:489
static const struct internalvar_funcs thread_funcs
Definition thread.c:2147
static struct value * global_thread_id_make_value(struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
Definition thread.c:2120
static gdb::option::option_def_group make_info_threads_options_def_group(info_threads_opts *it_opts)
Definition thread.c:1254
static const struct internalvar_funcs inferior_thread_count_funcs
Definition thread.c:2163
void init_thread_list(void)
Definition thread.c:233
struct thread_info * add_thread_with_info(process_stratum_target *targ, ptid_t ptid, private_thread_info *priv)
Definition thread.c:288
struct thread_info * parse_thread_id(const char *tidstr, const char **end)
Definition tid-parse.c:54
int tid_is_in_list(const char *list, int default_inferior, int inf_num, int thr_num)
Definition tid-parse.c:319
void ATTRIBUTE_NORETURN invalid_thread_id_error(const char *string)
Definition tid-parse.c:29
@ ui_left
Definition ui-out.h:45
#define current_uiout
Definition ui-out.h:40
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1865
#define gdb_stdout
Definition utils.h:188
struct internalvar * create_internalvar_type_lazy(const char *name, const struct internalvar_funcs *funcs, void *data)
Definition value.c:2200
struct value * value_from_longest(struct type *type, LONGEST num)
Definition value.c:3625