GDB (xrefs)

/tmp/gdb-8.1/gdb/thread.c
Go to the documentation of this file.
1 /* Multi-process/thread control for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2018 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 "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 "observer.h"
40 #include "annotate.h"
41 #include "cli/cli-decode.h"
42 #include "gdb_regex.h"
43 #include "cli/cli-utils.h"
44 #include "thread-fsm.h"
45 #include "tid-parse.h"
46 #include <algorithm>
47 #include "common/gdb_optional.h"
48
49 /* Definition of struct thread_info exported to gdbthread.h. */
50
51 /* Prototypes for local functions. */
52
53 struct thread_info *thread_list = NULL;
54 static int highest_thread_num;
55
56 /* True if any thread is, or may be executing. We need to track this
57 separately because until we fully sync the thread list, we won't
58 know whether the target is fully stopped, even if we see stop
59 events for all known threads, because any of those threads may have
60 spawned new threads we haven't heard of yet. */
61 static int threads_executing;
62
63 static int thread_alive (struct thread_info *);
64
65 /* RAII type used to increase / decrease the refcount of each thread
66 in a given list of threads. */
67
68 class scoped_inc_dec_ref
69 {
70 public:
71 explicit scoped_inc_dec_ref (const std::vector<thread_info *> &thrds)
72 : m_thrds (thrds)
73 {
74 for (thread_info *thr : m_thrds)
75 thr->incref ();
76 }
77
78 ~scoped_inc_dec_ref ()
79 {
80 for (thread_info *thr : m_thrds)
81 thr->decref ();
82 }
83
84 private:
85 const std::vector<thread_info *> &m_thrds;
86 };
87
88
89 struct thread_info*
90 inferior_thread (void)
91 {
92 struct thread_info *tp = find_thread_ptid (inferior_ptid);
93 gdb_assert (tp);
94 return tp;
95 }
96
97 /* Delete the breakpoint pointed at by BP_P, if there's one. */
98
99 static void
100 delete_thread_breakpoint (struct breakpoint **bp_p)
101 {
102 if (*bp_p != NULL)
103 {
104 delete_breakpoint (*bp_p);
105 *bp_p = NULL;
106 }
107 }
108
109 void
110 delete_step_resume_breakpoint (struct thread_info *tp)
111 {
112 if (tp != NULL)
113 delete_thread_breakpoint (&tp->control.step_resume_breakpoint);
114 }
115
116 void
117 delete_exception_resume_breakpoint (struct thread_info *tp)
118 {
119 if (tp != NULL)
120 delete_thread_breakpoint (&tp->control.exception_resume_breakpoint);
121 }
122
123 /* See gdbthread.h. */
124
125 void
126 delete_single_step_breakpoints (struct thread_info *tp)
127 {
128 if (tp != NULL)
129 delete_thread_breakpoint (&tp->control.single_step_breakpoints);
130 }
131
132 /* Delete the breakpoint pointed at by BP_P at the next stop, if
133 there's one. */
134
135 static void
136 delete_at_next_stop (struct breakpoint **bp)
137 {
138 if (*bp != NULL)
139 {
140 (*bp)->disposition = disp_del_at_next_stop;
141 *bp = NULL;
142 }
143 }
144
145 /* See gdbthread.h. */
146
147 int
148 thread_has_single_step_breakpoints_set (struct thread_info *tp)
149 {
150 return tp->control.single_step_breakpoints != NULL;
151 }
152
153 /* See gdbthread.h. */
154
155 int
156 thread_has_single_step_breakpoint_here (struct thread_info *tp,
157 const address_space *aspace,
158 CORE_ADDR addr)
159 {
160 struct breakpoint *ss_bps = tp->control.single_step_breakpoints;
161
162 return (ss_bps != NULL
163 && breakpoint_has_location_inserted_here (ss_bps, aspace, addr));
164 }
165
166 /* See gdbthread.h. */
167
168 void
169 thread_cancel_execution_command (struct thread_info *thr)
170 {
171 if (thr->thread_fsm != NULL)
172 {
173 thread_fsm_clean_up (thr->thread_fsm, thr);
174 thread_fsm_delete (thr->thread_fsm);
175 thr->thread_fsm = NULL;
176 }
177 }
178
179 static void
180 clear_thread_inferior_resources (struct thread_info *tp)
181 {
182 /* NOTE: this will take care of any left-over step_resume breakpoints,
183 but not any user-specified thread-specific breakpoints. We can not
184 delete the breakpoint straight-off, because the inferior might not
185 be stopped at the moment. */
186 delete_at_next_stop (&tp->control.step_resume_breakpoint);
187 delete_at_next_stop (&tp->control.exception_resume_breakpoint);
188 delete_at_next_stop (&tp->control.single_step_breakpoints);
189
190 delete_longjmp_breakpoint_at_next_stop (tp->global_num);
191
192 bpstat_clear (&tp->control.stop_bpstat);
193
194 btrace_teardown (tp);
195
196 thread_cancel_execution_command (tp);
197 }
198
199 /* Set the TP's state as exited. */
200
201 static void
202 set_thread_exited (thread_info *tp, int silent)
203 {
204 /* Dead threads don't need to step-over. Remove from queue. */
205 if (tp->step_over_next != NULL)
206 thread_step_over_chain_remove (tp);
207
208 if (tp->state != THREAD_EXITED)
209 {
210 observer_notify_thread_exit (tp, silent);
211
212 /* Tag it as exited. */
213 tp->state = THREAD_EXITED;
214
215 /* Clear breakpoints, etc. associated with this thread. */
216 clear_thread_inferior_resources (tp);
217 }
218 }
219
220 void
221 init_thread_list (void)
222 {
223 struct thread_info *tp, *tpnext;
224
225 highest_thread_num = 0;
226
227 if (!thread_list)
228 return;
229
230 for (tp = thread_list; tp; tp = tpnext)
231 {
232 tpnext = tp->next;
233 if (tp->deletable ())
234 delete tp;
235 else
236 set_thread_exited (tp, 1);
237 }
238
239 thread_list = NULL;
240 threads_executing = 0;
241 }
242
243 /* Allocate a new thread of inferior INF with target id PTID and add
244 it to the thread list. */
245
246 static struct thread_info *
247 new_thread (struct inferior *inf, ptid_t ptid)
248 {
249 thread_info *tp = new thread_info (inf, ptid);
250
251 if (thread_list == NULL)
252 thread_list = tp;
253 else
254 {
255 struct thread_info *last;
256
257 for (last = thread_list; last->next != NULL; last = last->next)
258 ;
259 last->next = tp;
260 }
261
262 return tp;
263 }
264
265 struct thread_info *
266 add_thread_silent (ptid_t ptid)
267 {
268 struct thread_info *tp;
269 struct inferior *inf = find_inferior_ptid (ptid);
270 gdb_assert (inf != NULL);
271
272 tp = find_thread_ptid (ptid);
273 if (tp)
274 /* Found an old thread with the same id. It has to be dead,
275 otherwise we wouldn't be adding a new thread with the same id.
276 The OS is reusing this id --- delete it, and recreate a new
277 one. */
278 {
279 /* In addition to deleting the thread, if this is the current
280 thread, then we need to take care that delete_thread doesn't
281 really delete the thread if it is inferior_ptid. Create a
282 new template thread in the list with an invalid ptid, switch
283 to it, delete the original thread, reset the new thread's
284 ptid, and switch to it. */
285
286 if (inferior_ptid == ptid)
287 {
288 tp = new_thread (inf, null_ptid);
289
290 /* Make switch_to_thread not read from the thread. */
291 tp->state = THREAD_EXITED;
292 switch_to_thread (null_ptid);
293
294 /* Now we can delete it. */
295 delete_thread (ptid);
296
297 /* Now reset its ptid, and reswitch inferior_ptid to it. */
298 tp->ptid = ptid;
299 tp->state = THREAD_STOPPED;
300 switch_to_thread (ptid);
301
302 observer_notify_new_thread (tp);
303
304 /* All done. */
305 return tp;
306 }
307 else
308 /* Just go ahead and delete it. */
309 delete_thread (ptid);
310 }
311
312 tp = new_thread (inf, ptid);
313 observer_notify_new_thread (tp);
314
315 return tp;
316 }
317
318 struct thread_info *
319 add_thread_with_info (ptid_t ptid, private_thread_info *priv)
320 {
321 struct thread_info *result = add_thread_silent (ptid);
322
323 result->priv.reset (priv);
324
325 if (print_thread_events)
326 printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
327
328 annotate_new_thread ();
329 return result;
330 }
331
332 struct thread_info *
333 add_thread (ptid_t ptid)
334 {
335 return add_thread_with_info (ptid, NULL);
336 }
337
338 private_thread_info::~private_thread_info () = default;
339
340 thread_info::thread_info (struct inferior *inf_, ptid_t ptid_)
341 : ptid (ptid_), inf (inf_)
342 {
343 gdb_assert (inf_ != NULL);
344
345 this->global_num = ++highest_thread_num;
346 this->per_inf_num = ++inf_->highest_thread_num;
347
348 /* Nothing to follow yet. */
349 memset (&this->pending_follow, 0, sizeof (this->pending_follow));
350 this->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
351 this->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
352 }
353
354 thread_info::~thread_info ()
355 {
356 xfree (this->name);
357 }
358
359 /* Add TP to the end of the step-over chain LIST_P. */
360
361 static void
362 step_over_chain_enqueue (struct thread_info **list_p, struct thread_info *tp)
363 {
364 gdb_assert (tp->step_over_next == NULL);
365 gdb_assert (tp->step_over_prev == NULL);
366
367 if (*list_p == NULL)
368 {
369 *list_p = tp;
370 tp->step_over_prev = tp->step_over_next = tp;
371 }
372 else
373 {
374 struct thread_info *head = *list_p;
375 struct thread_info *tail = head->step_over_prev;
376
377 tp->step_over_prev = tail;
378 tp->step_over_next = head;
379 head->step_over_prev = tp;
380 tail->step_over_next = tp;
381 }
382 }
383
384 /* Remove TP from step-over chain LIST_P. */
385
386 static void
387 step_over_chain_remove (struct thread_info **list_p, struct thread_info *tp)
388 {
389 gdb_assert (tp->step_over_next != NULL);
390 gdb_assert (tp->step_over_prev != NULL);
391
392 if (*list_p == tp)
393 {
394 if (tp == tp->step_over_next)
395 *list_p = NULL;
396 else
397 *list_p = tp->step_over_next;
398 }
399
400 tp->step_over_prev->step_over_next = tp->step_over_next;
401 tp->step_over_next->step_over_prev = tp->step_over_prev;
402 tp->step_over_prev = tp->step_over_next = NULL;
403 }
404
405 /* See gdbthread.h. */
406
407 struct thread_info *
408 thread_step_over_chain_next (struct thread_info *tp)
409 {
410 struct thread_info *next = tp->step_over_next;
411
412 return (next == step_over_queue_head ? NULL : next);
413 }
414
415 /* See gdbthread.h. */
416
417 int
418 thread_is_in_step_over_chain (struct thread_info *tp)
419 {
420 return (tp->step_over_next != NULL);
421 }
422
423 /* See gdbthread.h. */
424
425 void
426 thread_step_over_chain_enqueue (struct thread_info *tp)
427 {
428 step_over_chain_enqueue (&step_over_queue_head, tp);
429 }
430
431 /* See gdbthread.h. */
432
433 void
434 thread_step_over_chain_remove (struct thread_info *tp)
435 {
436 step_over_chain_remove (&step_over_queue_head, tp);
437 }
438
439 /* Delete thread PTID. If SILENT, don't notify the observer of this
440 exit. */
441 static void
442 delete_thread_1 (ptid_t ptid, int silent)
443 {
444 struct thread_info *tp, *tpprev;
445
446 tpprev = NULL;
447
448 for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
449 if (tp->ptid == ptid)
450 break;
451
452 if (!tp)
453 return;
454
455 set_thread_exited (tp, silent);
456
457 if (!tp->deletable ())
458 {
459 /* Will be really deleted some other time. */
460 return;
461 }
462
463 if (tpprev)
464 tpprev->next = tp->next;
465 else
466 thread_list = tp->next;
467
468 delete tp;
469 }
470
471 /* Delete thread PTID and notify of thread exit. If this is
472 inferior_ptid, don't actually delete it, but tag it as exited and
473 do the notification. If PTID is the user selected thread, clear
474 it. */
475 void
476 delete_thread (ptid_t ptid)
477 {
478 delete_thread_1 (ptid, 0 /* not silent */);
479 }
480
481 void
482 delete_thread_silent (ptid_t ptid)
483 {
484 delete_thread_1 (ptid, 1 /* silent */);
485 }
486
487 struct thread_info *
488 find_thread_global_id (int global_id)
489 {
490 struct thread_info *tp;
491
492 for (tp = thread_list; tp; tp = tp->next)
493 if (tp->global_num == global_id)
494 return tp;
495
496 return NULL;
497 }
498
499 static struct thread_info *
500 find_thread_id (struct inferior *inf, int thr_num)
501 {
502 struct thread_info *tp;
503
504 for (tp = thread_list; tp; tp = tp->next)
505 if (tp->inf == inf && tp->per_inf_num == thr_num)
506 return tp;
507
508 return NULL;
509 }
510
511 /* Find a thread_info by matching PTID. */
512
513 struct thread_info *
514 find_thread_ptid (ptid_t ptid)
515 {
516 struct thread_info *tp;
517
518 for (tp = thread_list; tp; tp = tp->next)
519 if (tp->ptid == ptid)
520 return tp;
521
522 return NULL;
523 }
524
525 /* See gdbthread.h. */
526
527 struct thread_info *
528 find_thread_by_handle (struct value *thread_handle, struct inferior *inf)
529 {
530 return target_thread_handle_to_thread_info
531 (value_contents_all (thread_handle),
532 TYPE_LENGTH (value_type (thread_handle)),
533 inf);
534 }
535
536 /*
537 * Thread iterator function.
538 *
539 * Calls a callback function once for each thread, so long as
540 * the callback function returns false. If the callback function
541 * returns true, the iteration will end and the current thread
542 * will be returned. This can be useful for implementing a
543 * search for a thread with arbitrary attributes, or for applying
544 * some operation to every thread.
545 *
546 * FIXME: some of the existing functionality, such as
547 * "Thread apply all", might be rewritten using this functionality.
548 */
549
550 struct thread_info *
551 iterate_over_threads (int (*callback) (struct thread_info *, void *),
552 void *data)
553 {
554 struct thread_info *tp, *next;
555
556 for (tp = thread_list; tp; tp = next)
557 {
558 next = tp->next;
559 if ((*callback) (tp, data))
560 return tp;
561 }
562
563 return NULL;
564 }
565
566 int
567 thread_count (void)
568 {
569 int result = 0;
570 struct thread_info *tp;
571
572 for (tp = thread_list; tp; tp = tp->next)
573 ++result;
574
575 return result;
576 }
577
578 /* Return the number of non-exited threads in the thread list. */
579
580 static int
581 live_threads_count (void)
582 {
583 int result = 0;
584 struct thread_info *tp;
585
586 ALL_NON_EXITED_THREADS (tp)
587 ++result;
588
589 return result;
590 }
591
592 int
593 valid_global_thread_id (int global_id)
594 {
595 struct thread_info *tp;
596
597 for (tp = thread_list; tp; tp = tp->next)
598 if (tp->global_num == global_id)
599 return 1;
600
601 return 0;
602 }
603
604 int
605 ptid_to_global_thread_id (ptid_t ptid)
606 {
607 struct thread_info *tp;
608
609 for (tp = thread_list; tp; tp = tp->next)
610 if (tp->ptid == ptid)
611 return tp->global_num;
612
613 return 0;
614 }
615
616 ptid_t
617 global_thread_id_to_ptid (int global_id)
618 {
619 struct thread_info *thread = find_thread_global_id (global_id);
620
621 if (thread)
622 return thread->ptid;
623 else
624 return minus_one_ptid;
625 }
626
627 int
628 in_thread_list (ptid_t ptid)
629 {
630 struct thread_info *tp;
631
632 for (tp = thread_list; tp; tp = tp->next)
633 if (tp->ptid == ptid)
634 return 1;
635
636 return 0; /* Never heard of 'im. */
637 }
638
639 /* Finds the first thread of the inferior given by PID. If PID is -1,
640 return the first thread in the list. */
641
642 struct thread_info *
643 first_thread_of_process (int pid)
644 {
645 struct thread_info *tp, *ret = NULL;
646
647 for (tp = thread_list; tp; tp = tp->next)
648 if (pid == -1 || ptid_get_pid (tp->ptid) == pid)
649 if (ret == NULL || tp->global_num < ret->global_num)
650 ret = tp;
651
652 return ret;
653 }
654
655 struct thread_info *
656 any_thread_of_process (int pid)
657 {
658 struct thread_info *tp;
659
660 gdb_assert (pid != 0);
661
662 /* Prefer the current thread. */
663 if (ptid_get_pid (inferior_ptid) == pid)
664 return inferior_thread ();
665
666 ALL_NON_EXITED_THREADS (tp)
667 if (ptid_get_pid (tp->ptid) == pid)
668 return tp;
669
670 return NULL;
671 }
672
673 struct thread_info *
674 any_live_thread_of_process (int pid)
675 {
676 struct thread_info *curr_tp = NULL;
677 struct thread_info *tp;
678 struct thread_info *tp_executing = NULL;
679
680 gdb_assert (pid != 0);
681
682 /* Prefer the current thread if it's not executing. */
683 if (ptid_get_pid (inferior_ptid) == pid)
684 {
685 /* If the current thread is dead, forget it. If it's not
686 executing, use it. Otherwise, still choose it (below), but
687 only if no other non-executing thread is found. */
688 curr_tp = inferior_thread ();
689 if (curr_tp->state == THREAD_EXITED)
690 curr_tp = NULL;
691 else if (!curr_tp->executing)
692 return curr_tp;
693 }
694
695 ALL_NON_EXITED_THREADS (tp)
696 if (ptid_get_pid (tp->ptid) == pid)
697 {
698 if (!tp->executing)
699 return tp;
700
701 tp_executing = tp;
702 }
703
704 /* If both the current thread and all live threads are executing,
705 prefer the current thread. */
706 if (curr_tp != NULL)
707 return curr_tp;
708
709 /* Otherwise, just return an executing thread, if any. */
710 return tp_executing;
711 }
712
713 /* Return true if TP is an active thread. */
714 static int
715 thread_alive (struct thread_info *tp)
716 {
717 if (tp->state == THREAD_EXITED)
718 return 0;
719 if (!target_thread_alive (tp->ptid))
720 return 0;
721 return 1;
722 }
723
724 /* See gdbthreads.h. */
725
726 void
727 prune_threads (void)
728 {
729 struct thread_info *tp, *tmp;
730
731 ALL_THREADS_SAFE (tp, tmp)
732 {
733 if (!thread_alive (tp))
734 delete_thread (tp->ptid);
735 }
736 }
737
738 /* See gdbthreads.h. */
739
740 void
741 delete_exited_threads (void)
742 {
743 struct thread_info *tp, *tmp;
744
745 ALL_THREADS_SAFE (tp, tmp)
746 {
747 if (tp->state == THREAD_EXITED)
748 delete_thread (tp->ptid);
749 }
750 }
751
752 /* Disable storing stack temporaries for the thread whose id is
753 stored in DATA. */
754
755 static void
756 disable_thread_stack_temporaries (void *data)
757 {
758 ptid_t *pd = (ptid_t *) data;
759 struct thread_info *tp = find_thread_ptid (*pd);
760
761 if (tp != NULL)
762 {
763 tp->stack_temporaries_enabled = 0;
764 VEC_free (value_ptr, tp->stack_temporaries);
765 }
766
767 xfree (pd);
768 }
769
770 /* Enable storing stack temporaries for thread with id PTID and return a
771 cleanup which can disable and clear the stack temporaries. */
772
773 struct cleanup *
774 enable_thread_stack_temporaries (ptid_t ptid)
775 {
776 struct thread_info *tp = find_thread_ptid (ptid);
777 ptid_t *data;
778 struct cleanup *c;
779
780 gdb_assert (tp != NULL);
781
782 tp->stack_temporaries_enabled = 1;
783 tp->stack_temporaries = NULL;
784 data = XNEW (ptid_t);
785 *data = ptid;
786 c = make_cleanup (disable_thread_stack_temporaries, data);
787
788 return c;
789 }
790
791 /* Return non-zero value if stack temporaies are enabled for the thread
792 with id PTID. */
793
794 int
795 thread_stack_temporaries_enabled_p (ptid_t ptid)
796 {
797 struct thread_info *tp = find_thread_ptid (ptid);
798
799 if (tp == NULL)
800 return 0;
801 else
802 return tp->stack_temporaries_enabled;
803 }
804
805 /* Push V on to the stack temporaries of the thread with id PTID. */
806
807 void
808 push_thread_stack_temporary (ptid_t ptid, struct value *v)
809 {
810 struct thread_info *tp = find_thread_ptid (ptid);
811
812 gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
813 VEC_safe_push (value_ptr, tp->stack_temporaries, v);
814 }
815
816 /* Return 1 if VAL is among the stack temporaries of the thread
817 with id PTID. Return 0 otherwise. */
818
819 int
820 value_in_thread_stack_temporaries (struct value *val, ptid_t ptid)
821 {
822 struct thread_info *tp = find_thread_ptid (ptid);
823
824 gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
825 if (!VEC_empty (value_ptr, tp->stack_temporaries))
826 {
827 struct value *v;
828 int i;
829
830 for (i = 0; VEC_iterate (value_ptr, tp->stack_temporaries, i, v); i++)
831 if (v == val)
832 return 1;
833 }
834
835 return 0;
836 }
837
838 /* Return the last of the stack temporaries for thread with id PTID.
839 Return NULL if there are no stack temporaries for the thread. */
840
841 struct value *
842 get_last_thread_stack_temporary (ptid_t ptid)
843 {
844 struct value *lastval = NULL;
845 struct thread_info *tp = find_thread_ptid (ptid);
846
847 gdb_assert (tp != NULL);
848 if (!VEC_empty (value_ptr, tp->stack_temporaries))
849 lastval = VEC_last (value_ptr, tp->stack_temporaries);
850
851 return lastval;
852 }
853
854 void
855 thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
856 {
857 struct inferior *inf;
858 struct thread_info *tp;
859
860 /* It can happen that what we knew as the target inferior id
861 changes. E.g, target remote may only discover the remote process
862 pid after adding the inferior to GDB's list. */
863 inf = find_inferior_ptid (old_ptid);
864 inf->pid = ptid_get_pid (new_ptid);
865
866 tp = find_thread_ptid (old_ptid);
867 tp->ptid = new_ptid;
868
869 observer_notify_thread_ptid_changed (old_ptid, new_ptid);
870 }
871
872 /* See gdbthread.h. */
873
874 void
875 set_resumed (ptid_t ptid, int resumed)
876 {
877 struct thread_info *tp;
878 int all = ptid == minus_one_ptid;
879
880 if (all || ptid_is_pid (ptid))
881 {
882 for (tp = thread_list; tp; tp = tp->next)
883 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
884 tp->resumed = resumed;
885 }
886 else
887 {
888 tp = find_thread_ptid (ptid);
889 gdb_assert (tp != NULL);
890 tp->resumed = resumed;
891 }
892 }
893
894 /* Helper for set_running, that marks one thread either running or
895 stopped. */
896
897 static int
898 set_running_thread (struct thread_info *tp, int running)
899 {
900 int started = 0;
901
902 if (running && tp->state == THREAD_STOPPED)
903 started = 1;
904 tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
905
906 if (!running)
907 {
908 /* If the thread is now marked stopped, remove it from
909 the step-over queue, so that we don't try to resume
910 it until the user wants it to. */
911 if (tp->step_over_next != NULL)
912 thread_step_over_chain_remove (tp);
913 }
914
915 return started;
916 }
917
918 void
919 set_running (ptid_t ptid, int running)
920 {
921 struct thread_info *tp;
922 int all = ptid == minus_one_ptid;
923 int any_started = 0;
924
925 /* We try not to notify the observer if no thread has actually changed
926 the running state -- merely to reduce the number of messages to
927 frontend. Frontend is supposed to handle multiple *running just fine. */
928 if (all || ptid_is_pid (ptid))
929 {
930 for (tp = thread_list; tp; tp = tp->next)
931 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
932 {
933 if (tp->state == THREAD_EXITED)
934 continue;
935
936 if (set_running_thread (tp, running))
937 any_started = 1;
938 }
939 }
940 else
941 {
942 tp = find_thread_ptid (ptid);
943 gdb_assert (tp != NULL);
944 gdb_assert (tp->state != THREAD_EXITED);
945 if (set_running_thread (tp, running))
946 any_started = 1;
947 }
948 if (any_started)
949 observer_notify_target_resumed (ptid);
950 }
951
952 static int
953 is_thread_state (ptid_t ptid, enum thread_state state)
954 {
955 struct thread_info *tp;
956
957 tp = find_thread_ptid (ptid);
958 gdb_assert (tp);
959 return tp->state == state;
960 }
961
962 int
963 is_stopped (ptid_t ptid)
964 {
965 return is_thread_state (ptid, THREAD_STOPPED);
966 }
967
968 int
969 is_exited (ptid_t ptid)
970 {
971 return is_thread_state (ptid, THREAD_EXITED);
972 }
973
974 int
975 is_running (ptid_t ptid)
976 {
977 return is_thread_state (ptid, THREAD_RUNNING);
978 }
979
980 int
981 is_executing (ptid_t ptid)
982 {
983 struct thread_info *tp;
984
985 tp = find_thread_ptid (ptid);
986 gdb_assert (tp);
987 return tp->executing;
988 }
989
990 void
991 set_executing (ptid_t ptid, int executing)
992 {
993 struct thread_info *tp;
994 int all = ptid == minus_one_ptid;
995
996 if (all || ptid_is_pid (ptid))
997 {
998 for (tp = thread_list; tp; tp = tp->next)
999 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
1000 tp->executing = executing;
1001 }
1002 else
1003 {
1004 tp = find_thread_ptid (ptid);
1005 gdb_assert (tp);
1006 tp->executing = executing;
1007 }
1008
1009 /* It only takes one running thread to spawn more threads.*/
1010 if (executing)
1011 threads_executing = 1;
1012 /* Only clear the flag if the caller is telling us everything is
1013 stopped. */
1014 else if (minus_one_ptid == ptid)
1015 threads_executing = 0;
1016 }
1017
1018 /* See gdbthread.h. */
1019
1020 int
1021 threads_are_executing (void)
1022 {
1023 return threads_executing;
1024 }
1025
1026 void
1027 set_stop_requested (ptid_t ptid, int stop)
1028 {
1029 struct thread_info *tp;
1030 int all = ptid == minus_one_ptid;
1031
1032 if (all || ptid_is_pid (ptid))
1033 {
1034 for (tp = thread_list; tp; tp = tp->next)
1035 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
1036 tp->stop_requested = stop;
1037 }
1038 else
1039 {
1040 tp = find_thread_ptid (ptid);
1041 gdb_assert (tp);
1042 tp->stop_requested = stop;
1043 }
1044
1045 /* Call the stop requested observer so other components of GDB can
1046 react to this request. */
1047 if (stop)
1048 observer_notify_thread_stop_requested (ptid);
1049 }
1050
1051 void
1052 finish_thread_state (ptid_t ptid)
1053 {
1054 struct thread_info *tp;
1055 int all;
1056 int any_started = 0;
1057
1058 all = ptid == minus_one_ptid;
1059
1060 if (all || ptid_is_pid (ptid))
1061 {
1062 for (tp = thread_list; tp; tp = tp->next)
1063 {
1064 if (tp->state == THREAD_EXITED)
1065 continue;
1066 if (all || ptid_get_pid (ptid) == ptid_get_pid (tp->ptid))
1067 {
1068 if (set_running_thread (tp, tp->executing))
1069 any_started = 1;
1070 }
1071 }
1072 }
1073 else
1074 {
1075 tp = find_thread_ptid (ptid);
1076 gdb_assert (tp);
1077 if (tp->state != THREAD_EXITED)
1078 {
1079 if (set_running_thread (tp, tp->executing))
1080 any_started = 1;
1081 }
1082 }
1083
1084 if (any_started)
1085 observer_notify_target_resumed (ptid);
1086 }
1087
1088 void
1089 finish_thread_state_cleanup (void *arg)
1090 {
1091 ptid_t *ptid_p = (ptid_t *) arg;
1092
1093 gdb_assert (arg);
1094
1095 finish_thread_state (*ptid_p);
1096 }
1097
1098 /* See gdbthread.h. */
1099
1100 void
1101 validate_registers_access (void)
1102 {
1103 /* No selected thread, no registers. */
1104 if (inferior_ptid == null_ptid)
1105 error (_("No thread selected."));
1106
1107 /* Don't try to read from a dead thread. */
1108 if (is_exited (inferior_ptid))
1109 error (_("The current thread has terminated"));
1110
1111 /* ... or from a spinning thread. FIXME: This isn't actually fully
1112 correct. It'll allow an user-requested access (e.g., "print $pc"
1113 at the prompt) when a thread is not executing for some internal
1114 reason, but is marked running from the user's perspective. E.g.,
1115 the thread is waiting for its turn in the step-over queue. */
1116 if (is_executing (inferior_ptid))
1117 error (_("Selected thread is running."));
1118 }
1119
1120 /* See gdbthread.h. */
1121
1122 bool
1123 can_access_registers_ptid (ptid_t ptid)
1124 {
1125 /* No thread, no registers. */
1126 if (ptid == null_ptid)
1127 return false;
1128
1129 /* Don't try to read from a dead thread. */
1130 if (is_exited (ptid))
1131 return false;
1132
1133 /* ... or from a spinning thread. FIXME: see validate_registers_access. */
1134 if (is_executing (ptid))
1135 return false;
1136
1137 return true;
1138 }
1139
1140 int
1141 pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread)
1142 {
1143 return (pc >= thread->control.step_range_start
1144 && pc < thread->control.step_range_end);
1145 }
1146
1147 /* Helper for print_thread_info. Returns true if THR should be
1148 printed. If REQUESTED_THREADS, a list of GDB ids/ranges, is not
1149 NULL, only print THR if its ID is included in the list. GLOBAL_IDS
1150 is true if REQUESTED_THREADS is list of global IDs, false if a list
1151 of per-inferior thread ids. If PID is not -1, only print THR if it
1152 is a thread from the process PID. Otherwise, threads from all
1153 attached PIDs are printed. If both REQUESTED_THREADS is not NULL
1154 and PID is not -1, then the thread is printed if it belongs to the
1155 specified process. Otherwise, an error is raised. */
1156
1157 static int
1158 should_print_thread (const char *requested_threads, int default_inf_num,
1159 int global_ids, int pid, struct thread_info *thr)
1160 {
1161 if (requested_threads != NULL && *requested_threads != '\0')
1162 {
1163 int in_list;
1164
1165 if (global_ids)
1166 in_list = number_is_in_list (requested_threads, thr->global_num);
1167 else
1168 in_list = tid_is_in_list (requested_threads, default_inf_num,
1169 thr->inf->num, thr->per_inf_num);
1170 if (!in_list)
1171 return 0;
1172 }
1173
1174 if (pid != -1 && ptid_get_pid (thr->ptid) != pid)
1175 {
1176 if (requested_threads != NULL && *requested_threads != '\0')
1177 error (_("Requested thread not found in requested process"));
1178 return 0;
1179 }
1180
1181 if (thr->state == THREAD_EXITED)
1182 return 0;
1183
1184 return 1;
1185 }
1186
1187 /* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1188 whether REQUESTED_THREADS is a list of global or per-inferior
1189 thread ids. */
1190
1191 static void
1192 print_thread_info_1 (struct ui_out *uiout, const char *requested_threads,
1193 int global_ids, int pid,
1194 int show_global_ids)
1195 {
1196 struct thread_info *tp;
1197 ptid_t current_ptid;
1198 const char *extra_info, *name, *target_id;
1199 struct inferior *inf;
1200 int default_inf_num = current_inferior ()->num;
1201
1202 update_thread_list ();
1203 current_ptid = inferior_ptid;
1204
1205 {
1206 /* For backward compatibility, we make a list for MI. A table is
1207 preferable for the CLI, though, because it shows table
1208 headers. */
1209 gdb::optional<ui_out_emit_list> list_emitter;
1210 gdb::optional<ui_out_emit_table> table_emitter;
1211
1212 if (uiout->is_mi_like_p ())
1213 list_emitter.emplace (uiout, "threads");
1214 else
1215 {
1216 int n_threads = 0;
1217
1218 for (tp = thread_list; tp; tp = tp->next)
1219 {
1220 if (!should_print_thread (requested_threads, default_inf_num,
1221 global_ids, pid, tp))
1222 continue;
1223
1224 ++n_threads;
1225 }
1226
1227 if (n_threads == 0)
1228 {
1229 if (requested_threads == NULL || *requested_threads == '\0')
1230 uiout->message (_("No threads.\n"));
1231 else
1232 uiout->message (_("No threads match '%s'.\n"),
1233 requested_threads);
1234 return;
1235 }
1236
1237 table_emitter.emplace (uiout, show_global_ids ? 5 : 4,
1238 n_threads, "threads");
1239
1240 uiout->table_header (1, ui_left, "current", "");
1241 uiout->table_header (4, ui_left, "id-in-tg", "Id");
1242 if (show_global_ids)
1243 uiout->table_header (4, ui_left, "id", "GId");
1244 uiout->table_header (17, ui_left, "target-id", "Target Id");
1245 uiout->table_header (1, ui_left, "frame", "Frame");
1246 uiout->table_body ();
1247 }
1248
1249 /* We'll be switching threads temporarily. */
1250 scoped_restore_current_thread restore_thread;
1251
1252 ALL_THREADS_BY_INFERIOR (inf, tp)
1253 {
1254 int core;
1255
1256 if (!should_print_thread (requested_threads, default_inf_num,
1257 global_ids, pid, tp))
1258 continue;
1259
1260 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1261
1262 if (!uiout->is_mi_like_p ())
1263 {
1264 if (tp->ptid == current_ptid)
1265 uiout->field_string ("current", "*");
1266 else
1267 uiout->field_skip ("current");
1268
1269 uiout->field_string ("id-in-tg", print_thread_id (tp));
1270 }
1271
1272 if (show_global_ids || uiout->is_mi_like_p ())
1273 uiout->field_int ("id", tp->global_num);
1274
1275 /* For the CLI, we stuff everything into the target-id field.
1276 This is a gross hack to make the output come out looking
1277 correct. The underlying problem here is that ui-out has no
1278 way to specify that a field's space allocation should be
1279 shared by several fields. For MI, we do the right thing
1280 instead. */
1281
1282 target_id = target_pid_to_str (tp->ptid);
1283 extra_info = target_extra_thread_info (tp);
1284 name = tp->name ? tp->name : target_thread_name (tp);
1285
1286 if (uiout->is_mi_like_p ())
1287 {
1288 uiout->field_string ("target-id", target_id);
1289 if (extra_info)
1290 uiout->field_string ("details", extra_info);
1291 if (name)
1292 uiout->field_string ("name", name);
1293 }
1294 else
1295 {
1296 std::string contents;
1297
1298 if (extra_info && name)
1299 contents = string_printf ("%s \"%s\" (%s)", target_id,
1300 name, extra_info);
1301 else if (extra_info)
1302 contents = string_printf ("%s (%s)", target_id, extra_info);
1303 else if (name)
1304 contents = string_printf ("%s \"%s\"", target_id, name);
1305 else
1306 contents = target_id;
1307
1308 uiout->field_string ("target-id", contents.c_str ());
1309 }
1310
1311 if (tp->state == THREAD_RUNNING)
1312 uiout->text ("(running)\n");
1313 else
1314 {
1315 /* The switch below puts us at the top of the stack (leaf
1316 frame). */
1317 switch_to_thread (tp->ptid);
1318 print_stack_frame (get_selected_frame (NULL),
1319 /* For MI output, print frame level. */
1320 uiout->is_mi_like_p (),
1321 LOCATION, 0);
1322 }
1323
1324 if (uiout->is_mi_like_p ())
1325 {
1326 const char *state = "stopped";
1327
1328 if (tp->state == THREAD_RUNNING)
1329 state = "running";
1330 uiout->field_string ("state", state);
1331 }
1332
1333 core = target_core_of_thread (tp->ptid);
1334 if (uiout->is_mi_like_p () && core != -1)
1335 uiout->field_int ("core", core);
1336 }
1337
1338 /* This end scope restores the current thread and the frame
1339 selected before the "info threads" command, and it finishes the
1340 ui-out list or table. */
1341 }
1342
1343 if (pid == -1 && requested_threads == NULL)
1344 {
1345 if (uiout->is_mi_like_p ()
1346 && inferior_ptid != null_ptid)
1347 {
1348 int num = ptid_to_global_thread_id (inferior_ptid);
1349
1350 gdb_assert (num != 0);
1351 uiout->field_int ("current-thread-id", num);
1352 }
1353
1354 if (inferior_ptid != null_ptid && is_exited (inferior_ptid))
1355 uiout->message ("\n\
1356 The current thread <Thread ID %s> has terminated. See `help thread'.\n",
1357 print_thread_id (inferior_thread ()));
1358 else if (thread_list != NULL && inferior_ptid == null_ptid)
1359 uiout->message ("\n\
1360 No selected thread. See `help thread'.\n");
1361 }
1362 }
1363
1364 /* See gdbthread.h. */
1365
1366 void
1367 print_thread_info (struct ui_out *uiout, char *requested_threads, int pid)
1368 {
1369 print_thread_info_1 (uiout, requested_threads, 1, pid, 0);
1370 }
1371
1372 /* Implementation of the "info threads" command.
1373
1374 Note: this has the drawback that it _really_ switches
1375 threads, which frees the frame cache. A no-side
1376 effects info-threads command would be nicer. */
1377
1378 static void
1379 info_threads_command (const char *arg, int from_tty)
1380 {
1381 int show_global_ids = 0;
1382
1383 if (arg != NULL
1384 && check_for_argument (&arg, "-gid", sizeof ("-gid") - 1))
1385 {
1386 arg = skip_spaces (arg);
1387 show_global_ids = 1;
1388 }
1389
1390 print_thread_info_1 (current_uiout, arg, 0, -1, show_global_ids);
1391 }
1392
1393 /* See gdbthread.h. */
1394
1395 void
1396 switch_to_thread_no_regs (struct thread_info *thread)
1397 {
1398 struct inferior *inf = thread->inf;
1399
1400 set_current_program_space (inf->pspace);
1401 set_current_inferior (inf);
1402
1403 inferior_ptid = thread->ptid;
1404 stop_pc = ~(CORE_ADDR) 0;
1405 }
1406
1407 /* Switch to no thread selected. */
1408
1409 static void
1410 switch_to_no_thread ()
1411 {
1412 if (inferior_ptid == null_ptid)
1413 return;
1414
1415 inferior_ptid = null_ptid;
1416 reinit_frame_cache ();
1417 stop_pc = ~(CORE_ADDR) 0;
1418 }
1419
1420 /* Switch from one thread to another. */
1421
1422 static void
1423 switch_to_thread (thread_info *thr)
1424 {
1425 gdb_assert (thr != NULL);
1426
1427 if (inferior_ptid == thr->ptid)
1428 return;
1429
1430 switch_to_thread_no_regs (thr);
1431
1432 reinit_frame_cache ();
1433
1434 /* We don't check for is_stopped, because we're called at times
1435 while in the TARGET_RUNNING state, e.g., while handling an
1436 internal event. */
1437 if (thr->state != THREAD_EXITED
1438 && !thr->executing)
1439 stop_pc = regcache_read_pc (get_thread_regcache (thr->ptid));
1440 }
1441
1442 /* See gdbthread.h. */
1443
1444 void
1445 switch_to_thread (ptid_t ptid)
1446 {
1447 if (ptid == null_ptid)
1448 switch_to_no_thread ();
1449 else
1450 switch_to_thread (find_thread_ptid (ptid));
1451 }
1452
1453 static void
1454 restore_selected_frame (struct frame_id a_frame_id, int frame_level)
1455 {
1456 struct frame_info *frame = NULL;
1457 int count;
1458
1459 /* This means there was no selected frame. */
1460 if (frame_level == -1)
1461 {
1462 select_frame (NULL);
1463 return;
1464 }
1465
1466 gdb_assert (frame_level >= 0);
1467
1468 /* Restore by level first, check if the frame id is the same as
1469 expected. If that fails, try restoring by frame id. If that
1470 fails, nothing to do, just warn the user. */
1471
1472 count = frame_level;
1473 frame = find_relative_frame (get_current_frame (), &count);
1474 if (count == 0
1475 && frame != NULL
1476 /* The frame ids must match - either both valid or both outer_frame_id.
1477 The latter case is not failsafe, but since it's highly unlikely
1478 the search by level finds the wrong frame, it's 99.9(9)% of
1479 the time (for all practical purposes) safe. */
1480 && frame_id_eq (get_frame_id (frame), a_frame_id))
1481 {
1482 /* Cool, all is fine. */
1483 select_frame (frame);
1484 return;
1485 }
1486
1487 frame = frame_find_by_id (a_frame_id);
1488 if (frame != NULL)
1489 {
1490 /* Cool, refound it. */
1491 select_frame (frame);
1492 return;
1493 }
1494
1495 /* Nothing else to do, the frame layout really changed. Select the
1496 innermost stack frame. */
1497 select_frame (get_current_frame ());
1498
1499 /* Warn the user. */
1500 if (frame_level > 0 && !current_uiout->is_mi_like_p ())
1501 {
1502 warning (_("Couldn't restore frame #%d in "
1503 "current thread. Bottom (innermost) frame selected:"),
1504 frame_level);
1505 /* For MI, we should probably have a notification about
1506 current frame change. But this error is not very
1507 likely, so don't bother for now. */
1508 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1509 }
1510 }
1511
1512 scoped_restore_current_thread::~scoped_restore_current_thread ()
1513 {
1514 /* If an entry of thread_info was previously selected, it won't be
1515 deleted because we've increased its refcount. The thread represented
1516 by this thread_info entry may have already exited (due to normal exit,
1517 detach, etc), so the thread_info.state is THREAD_EXITED. */
1518 if (m_thread != NULL
1519 /* If the previously selected thread belonged to a process that has
1520 in the mean time exited (or killed, detached, etc.), then don't revert
1521 back to it, but instead simply drop back to no thread selected. */
1522 && m_inf->pid != 0)
1523 switch_to_thread (m_thread);
1524 else
1525 {
1526 switch_to_no_thread ();
1527 set_current_inferior (m_inf);
1528 }
1529
1530 /* The running state of the originally selected thread may have
1531 changed, so we have to recheck it here. */
1532 if (inferior_ptid != null_ptid
1533 && m_was_stopped
1534 && is_stopped (inferior_ptid)
1535 && target_has_registers
1536 && target_has_stack
1537 && target_has_memory)
1538 restore_selected_frame (m_selected_frame_id, m_selected_frame_level);
1539
1540 if (m_thread != NULL)
1541 m_thread->decref ();
1542 m_inf->decref ();
1543 }
1544
1545 scoped_restore_current_thread::scoped_restore_current_thread ()
1546 {
1547 m_thread = NULL;
1548 m_inf = current_inferior ();
1549
1550 if (inferior_ptid != null_ptid)
1551 {
1552 thread_info *tp = find_thread_ptid (inferior_ptid);
1553 struct frame_info *frame;
1554
1555 gdb_assert (tp != NULL);
1556
1557 m_was_stopped = tp->state == THREAD_STOPPED;
1558 if (m_was_stopped
1559 && target_has_registers
1560 && target_has_stack
1561 && target_has_memory)
1562 {
1563 /* When processing internal events, there might not be a
1564 selected frame. If we naively call get_selected_frame
1565 here, then we can end up reading debuginfo for the
1566 current frame, but we don't generally need the debuginfo
1567 at this point. */
1568 frame = get_selected_frame_if_set ();
1569 }
1570 else
1571 frame = NULL;
1572
1573 m_selected_frame_id = get_frame_id (frame);
1574 m_selected_frame_level = frame_relative_level (frame);
1575
1576 tp->incref ();
1577 m_thread = tp;
1578 }
1579
1580 m_inf->incref ();
1581 }
1582
1583 /* See gdbthread.h. */
1584
1585 int
1586 show_thread_that_caused_stop (void)
1587 {
1588 return highest_thread_num > 1;
1589 }
1590
1591 /* See gdbthread.h. */
1592
1593 int
1594 show_inferior_qualified_tids (void)
1595 {
1596 return (inferior_list->next != NULL || inferior_list->num != 1);
1597 }
1598
1599 /* See gdbthread.h. */
1600
1601 const char *
1602 print_thread_id (struct thread_info *thr)
1603 {
1604 char *s = get_print_cell ();
1605
1606 if (show_inferior_qualified_tids ())
1607 xsnprintf (s, PRINT_CELL_SIZE, "%d.%d", thr->inf->num, thr->per_inf_num);
1608 else
1609 xsnprintf (s, PRINT_CELL_SIZE, "%d", thr->per_inf_num);
1610 return s;
1611 }
1612
1613 /* If true, tp_array_compar should sort in ascending order, otherwise
1614 in descending order. */
1615
1616 static bool tp_array_compar_ascending;
1617
1618 /* Sort an array for struct thread_info pointers by thread ID (first
1619 by inferior number, and then by per-inferior thread number). The
1620 order is determined by TP_ARRAY_COMPAR_ASCENDING. */
1621
1622 static bool
1623 tp_array_compar (const thread_info *a, const thread_info *b)
1624 {
1625 if (a->inf->num != b->inf->num)
1626 {
1627 if (tp_array_compar_ascending)
1628 return a->inf->num < b->inf->num;
1629 else
1630 return a->inf->num > b->inf->num;
1631 }
1632
1633 if (tp_array_compar_ascending)
1634 return (a->per_inf_num < b->per_inf_num);
1635 else
1636 return (a->per_inf_num > b->per_inf_num);
1637 }
1638
1639 /* Apply a GDB command to a list of threads. List syntax is a whitespace
1640 seperated list of numbers, or ranges, or the keyword `all'. Ranges consist
1641 of two numbers seperated by a hyphen. Examples:
1642
1643 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1644 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
1645 thread apply all p x/i $pc Apply x/i $pc cmd to all threads. */
1646
1647 static void
1648 thread_apply_all_command (const char *cmd, int from_tty)
1649 {
1650 tp_array_compar_ascending = false;
1651 if (cmd != NULL
1652 && check_for_argument (&cmd, "-ascending", strlen ("-ascending")))
1653 {
1654 cmd = skip_spaces (cmd);
1655 tp_array_compar_ascending = true;
1656 }
1657
1658 if (cmd == NULL || *cmd == '\000')
1659 error (_("Please specify a command following the thread ID list"));
1660
1661 update_thread_list ();
1662
1663 int tc = live_threads_count ();
1664 if (tc != 0)
1665 {
1666 /* Save a copy of the thread list and increment each thread's
1667 refcount while executing the command in the context of each
1668 thread, in case the command is one that wipes threads. E.g.,
1669 detach, kill, disconnect, etc., or even normally continuing
1670 over an inferior or thread exit. */
1671 std::vector<thread_info *> thr_list_cpy;
1672 thr_list_cpy.reserve (tc);
1673
1674 {
1675 thread_info *tp;
1676
1677 ALL_NON_EXITED_THREADS (tp)
1678 {
1679 thr_list_cpy.push_back (tp);
1680 }
1681
1682 gdb_assert (thr_list_cpy.size () == tc);
1683 }
1684
1685 /* Increment the refcounts, and restore them back on scope
1686 exit. */
1687 scoped_inc_dec_ref inc_dec_ref (thr_list_cpy);
1688
1689 std::sort (thr_list_cpy.begin (), thr_list_cpy.end (), tp_array_compar);
1690
1691 scoped_restore_current_thread restore_thread;
1692
1693 for (thread_info *thr : thr_list_cpy)
1694 if (thread_alive (thr))
1695 {
1696 switch_to_thread (thr->ptid);
1697 printf_filtered (_("\nThread %s (%s):\n"),
1698 print_thread_id (thr),
1699 target_pid_to_str (inferior_ptid));
1700
1701 execute_command (cmd, from_tty);
1702 }
1703 }
1704 }
1705
1706 /* Implementation of the "thread apply" command. */
1707
1708 static void
1709 thread_apply_command (const char *tidlist, int from_tty)
1710 {
1711 const char *cmd = NULL;
1712 tid_range_parser parser;
1713
1714 if (tidlist == NULL || *tidlist == '\000')
1715 error (_("Please specify a thread ID list"));
1716
1717 parser.init (tidlist, current_inferior ()->num);
1718 while (!parser.finished ())
1719 {
1720 int inf_num, thr_start, thr_end;
1721
1722 if (!parser.get_tid_range (&inf_num, &thr_start, &thr_end))
1723 {
1724 cmd = parser.cur_tok ();
1725 break;
1726 }
1727 }
1728
1729 if (cmd == NULL)
1730 error (_("Please specify a command following the thread ID list"));
1731
1732 if (tidlist == cmd || !isalpha (cmd[0]))
1733 invalid_thread_id_error (cmd);
1734
1735 scoped_restore_current_thread restore_thread;
1736
1737 parser.init (tidlist, current_inferior ()->num);
1738 while (!parser.finished () && parser.cur_tok () < cmd)
1739 {
1740 struct thread_info *tp = NULL;
1741 struct inferior *inf;
1742 int inf_num, thr_num;
1743
1744 parser.get_tid (&inf_num, &thr_num);
1745 inf = find_inferior_id (inf_num);
1746 if (inf != NULL)
1747 tp = find_thread_id (inf, thr_num);
1748
1749 if (parser.in_star_range ())
1750 {
1751 if (inf == NULL)
1752 {
1753 warning (_("Unknown inferior %d"), inf_num);
1754 parser.skip_range ();
1755 continue;
1756 }
1757
1758 /* No use looking for threads past the highest thread number
1759 the inferior ever had. */
1760 if (thr_num >= inf->highest_thread_num)
1761 parser.skip_range ();
1762
1763 /* Be quiet about unknown threads numbers. */
1764 if (tp == NULL)
1765 continue;
1766 }
1767
1768 if (tp == NULL)
1769 {
1770 if (show_inferior_qualified_tids () || parser.tid_is_qualified ())
1771 warning (_("Unknown thread %d.%d"), inf_num, thr_num);
1772 else
1773 warning (_("Unknown thread %d"), thr_num);
1774 continue;
1775 }
1776
1777 if (!thread_alive (tp))
1778 {
1779 warning (_("Thread %s has terminated."), print_thread_id (tp));
1780 continue;
1781 }
1782
1783 switch_to_thread (tp->ptid);
1784
1785 printf_filtered (_("\nThread %s (%s):\n"), print_thread_id (tp),
1786 target_pid_to_str (inferior_ptid));
1787 execute_command (cmd, from_tty);
1788 }
1789 }
1790
1791 /* Switch to the specified thread. Will dispatch off to thread_apply_command
1792 if prefix of arg is `apply'. */
1793
1794 void
1795 thread_command (const char *tidstr, int from_tty)
1796 {
1797 if (tidstr == NULL)
1798 {
1799 if (inferior_ptid == null_ptid)
1800 error (_("No thread selected"));
1801
1802 if (target_has_stack)
1803 {
1804 struct thread_info *tp = inferior_thread ();
1805
1806 if (is_exited (inferior_ptid))
1807 printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
1808 print_thread_id (tp),
1809 target_pid_to_str (inferior_ptid));
1810 else
1811 printf_filtered (_("[Current thread is %s (%s)]\n"),
1812 print_thread_id (tp),
1813 target_pid_to_str (inferior_ptid));
1814 }
1815 else
1816 error (_("No stack."));
1817 }
1818 else
1819 {
1820 ptid_t previous_ptid = inferior_ptid;
1821
1822 thread_select (tidstr, parse_thread_id (tidstr, NULL));
1823
1824 /* Print if the thread has not changed, otherwise an event will
1825 be sent. */
1826 if (inferior_ptid == previous_ptid)
1827 {
1828 print_selected_thread_frame (current_uiout,
1829 USER_SELECTED_THREAD
1830 | USER_SELECTED_FRAME);
1831 }
1832 else
1833 {
1834 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
1835 | USER_SELECTED_FRAME);
1836 }
1837 }
1838 }
1839
1840 /* Implementation of `thread name'. */
1841
1842 static void
1843 thread_name_command (const char *arg, int from_tty)
1844 {
1845 struct thread_info *info;
1846
1847 if (inferior_ptid == null_ptid)
1848 error (_("No thread selected"));
1849
1850 arg = skip_spaces (arg);
1851
1852 info = inferior_thread ();
1853 xfree (info->name);
1854 info->name = arg ? xstrdup (arg) : NULL;
1855 }
1856
1857 /* Find thread ids with a name, target pid, or extra info matching ARG. */
1858
1859 static void
1860 thread_find_command (const char *arg, int from_tty)
1861 {
1862 struct thread_info *tp;
1863 const char *tmp;
1864 unsigned long match = 0;
1865
1866 if (arg == NULL || *arg == '\0')
1867 error (_("Command requires an argument."));
1868
1869 tmp = re_comp (arg);
1870 if (tmp != 0)
1871 error (_("Invalid regexp (%s): %s"), tmp, arg);
1872
1873 update_thread_list ();
1874 for (tp = thread_list; tp; tp = tp->next)
1875 {
1876 if (tp->name != NULL && re_exec (tp->name))
1877 {
1878 printf_filtered (_("Thread %s has name '%s'\n"),
1879 print_thread_id (tp), tp->name);
1880 match++;
1881 }
1882
1883 tmp = target_thread_name (tp);
1884 if (tmp != NULL && re_exec (tmp))
1885 {
1886 printf_filtered (_("Thread %s has target name '%s'\n"),
1887 print_thread_id (tp), tmp);
1888 match++;
1889 }
1890
1891 tmp = target_pid_to_str (tp->ptid);
1892 if (tmp != NULL && re_exec (tmp))
1893 {
1894 printf_filtered (_("Thread %s has target id '%s'\n"),
1895 print_thread_id (tp), tmp);
1896 match++;
1897 }
1898
1899 tmp = target_extra_thread_info (tp);
1900 if (tmp != NULL && re_exec (tmp))
1901 {
1902 printf_filtered (_("Thread %s has extra info '%s'\n"),
1903 print_thread_id (tp), tmp);
1904 match++;
1905 }
1906 }
1907 if (!match)
1908 printf_filtered (_("No threads match '%s'\n"), arg);
1909 }
1910
1911 /* Print notices when new threads are attached and detached. */
1912 int print_thread_events = 1;
1913 static void
1914 show_print_thread_events (struct ui_file *file, int from_tty,
1915 struct cmd_list_element *c, const char *value)
1916 {
1917 fprintf_filtered (file,
1918 _("Printing of thread events is %s.\n"),
1919 value);
1920 }
1921
1922 /* See gdbthread.h. */
1923
1924 void
1925 thread_select (const char *tidstr, thread_info *tp)
1926 {
1927 if (!thread_alive (tp))
1928 error (_("Thread ID %s has terminated."), tidstr);
1929
1930 switch_to_thread (tp->ptid);
1931
1932 annotate_thread_changed ();
1933
1934 /* Since the current thread may have changed, see if there is any
1935 exited thread we can now delete. */
1936 prune_threads ();
1937 }
1938
1939 /* Print thread and frame switch command response. */
1940
1941 void
1942 print_selected_thread_frame (struct ui_out *uiout,
1943 user_selected_what selection)
1944 {
1945 struct thread_info *tp = inferior_thread ();
1946
1947 if (selection & USER_SELECTED_THREAD)
1948 {
1949 if (uiout->is_mi_like_p ())
1950 {
1951 uiout->field_int ("new-thread-id",
1952 inferior_thread ()->global_num);
1953 }
1954 else
1955 {
1956 uiout->text ("[Switching to thread ");
1957 uiout->field_string ("new-thread-id", print_thread_id (tp));
1958 uiout->text (" (");
1959 uiout->text (target_pid_to_str (inferior_ptid));
1960 uiout->text (")]");
1961 }
1962 }
1963
1964 if (tp->state == THREAD_RUNNING)
1965 {
1966 if (selection & USER_SELECTED_THREAD)
1967 uiout->text ("(running)\n");
1968 }
1969 else if (selection & USER_SELECTED_FRAME)
1970 {
1971 if (selection & USER_SELECTED_THREAD)
1972 uiout->text ("\n");
1973
1974 if (has_stack_frames ())
1975 print_stack_frame_to_uiout (uiout, get_selected_frame (NULL),
1976 1, SRC_AND_LOC, 1);
1977 }
1978 }
1979
1980 /* Update the 'threads_executing' global based on the threads we know
1981 about right now. */
1982
1983 static void
1984 update_threads_executing (void)
1985 {
1986 struct thread_info *tp;
1987
1988 threads_executing = 0;
1989 ALL_NON_EXITED_THREADS (tp)
1990 {
1991 if (tp->executing)
1992 {
1993 threads_executing = 1;
1994 break;
1995 }
1996 }
1997 }
1998
1999 void
2000 update_thread_list (void)
2001 {
2002 target_update_thread_list ();
2003 update_threads_executing ();
2004 }
2005
2006 /* Return a new value for the selected thread's id. Return a value of
2007 0 if no thread is selected. If GLOBAL is true, return the thread's
2008 global number. Otherwise return the per-inferior number. */
2009
2010 static struct value *
2011 thread_num_make_value_helper (struct gdbarch *gdbarch, int global)
2012 {
2013 struct thread_info *tp = find_thread_ptid (inferior_ptid);
2014 int int_val;
2015
2016 if (tp == NULL)
2017 int_val = 0;
2018 else if (global)
2019 int_val = tp->global_num;
2020 else
2021 int_val = tp->per_inf_num;
2022
2023 return value_from_longest (builtin_type (gdbarch)->builtin_int, int_val);
2024 }
2025
2026 /* Return a new value for the selected thread's per-inferior thread
2027 number. Return a value of 0 if no thread is selected, or no
2028 threads exist. */
2029
2030 static struct value *
2031 thread_id_per_inf_num_make_value (struct gdbarch *gdbarch,
2032 struct internalvar *var,
2033 void *ignore)
2034 {
2035 return thread_num_make_value_helper (gdbarch, 0);
2036 }
2037
2038 /* Return a new value for the selected thread's global id. Return a
2039 value of 0 if no thread is selected, or no threads exist. */
2040
2041 static struct value *
2042 global_thread_id_make_value (struct gdbarch *gdbarch, struct internalvar *var,
2043 void *ignore)
2044 {
2045 return thread_num_make_value_helper (gdbarch, 1);
2046 }
2047
2048 /* Commands with a prefix of `thread'. */
2049 struct cmd_list_element *thread_cmd_list = NULL;
2050
2051 /* Implementation of `thread' variable. */
2052
2053 static const struct internalvar_funcs thread_funcs =
2054 {
2055 thread_id_per_inf_num_make_value,
2056 NULL,
2057 NULL
2058 };
2059
2060 /* Implementation of `gthread' variable. */
2061
2062 static const struct internalvar_funcs gthread_funcs =
2063 {
2064 global_thread_id_make_value,
2065 NULL,
2066 NULL
2067 };
2068
2069 void
2070 _initialize_thread (void)
2071 {
2072 static struct cmd_list_element *thread_apply_list = NULL;
2073
2074 add_info ("threads", info_threads_command,
2075 _("Display currently known threads.\n\
2076 Usage: info threads [-gid] [ID]...\n\
2077 -gid: Show global thread IDs.\n\
2078 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2079 Otherwise, all threads are displayed."));
2080
2081 add_prefix_cmd ("thread", class_run, thread_command, _("\
2082 Use this command to switch between threads.\n\
2083 The new thread ID must be currently known."),
2084 &thread_cmd_list, "thread ", 1, &cmdlist);
2085
2086 add_prefix_cmd ("apply", class_run, thread_apply_command,
2087 _("Apply a command to a list of threads."),
2088 &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
2089
2090 add_cmd ("all", class_run, thread_apply_all_command,
2091 _("\
2092 Apply a command to all threads.\n\
2093 \n\
2094 Usage: thread apply all [-ascending] <command>\n\
2095 -ascending: Call <command> for all threads in ascending order.\n\
2096 The default is descending order.\
2097 "),
2098 &thread_apply_list);
2099
2100 add_cmd ("name", class_run, thread_name_command,
2101 _("Set the current thread's name.\n\
2102 Usage: thread name [NAME]\n\
2103 If NAME is not given, then any existing name is removed."), &thread_cmd_list);
2104
2105 add_cmd ("find", class_run, thread_find_command, _("\
2106 Find threads that match a regular expression.\n\
2107 Usage: thread find REGEXP\n\
2108 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2109 &thread_cmd_list);
2110
2111 add_com_alias ("t", "thread", class_run, 1);
2112
2113 add_setshow_boolean_cmd ("thread-events", no_class,
2114 &print_thread_events, _("\
2115 Set printing of thread events (such as thread start and exit)."), _("\
2116 Show printing of thread events (such as thread start and exit)."), NULL,
2117 NULL,
2118 show_print_thread_events,
2119 &setprintlist, &showprintlist);
2120
2121 create_internalvar_type_lazy ("_thread", &thread_funcs, NULL);
2122 create_internalvar_type_lazy ("_gthread", &gthread_funcs, NULL);
2123 }
gdbarch
Definition: gdbarch.c:127
frame_find_by_id
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:803
string
const char * string
Definition: signals.c:50
print_selected_thread_frame
void print_selected_thread_frame(struct ui_out *uiout, user_selected_what selection)
Definition: thread.c:1942
thread_info::resumed
int resumed
Definition: gdbthread.h:280
target_thread_alive
int target_thread_alive(ptid_t ptid)
Definition: target.c:3304
target_has_registers
#define target_has_registers
Definition: target.h:1740
find_thread_id
static struct thread_info * find_thread_id(struct inferior *inf, int thr_num)
Definition: thread.c:500
THREAD_STOPPED
Definition: gdbthread.h:41
enable_thread_stack_temporaries
struct cleanup * enable_thread_stack_temporaries(ptid_t ptid)
Definition: thread.c:774
thread_control_state::stop_bpstat
bpstat stop_bpstat
Definition: gdbthread.h:139
thread_info::stop_requested
int stop_requested
Definition: gdbthread.h:345
ptid_is_pid
int ptid_is_pid(const ptid_t &ptid)
Definition: ptid.c:79
get_selected_frame
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1638
pc_in_thread_step_range
int pc_in_thread_step_range(CORE_ADDR pc, struct thread_info *thread)
Definition: thread.c:1141
thread_control_state::step_range_start
CORE_ADDR step_range_start
Definition: gdbthread.h:77
update_thread_list
void update_thread_list(void)
Definition: thread.c:2000
global_thread_id_to_ptid
ptid_t global_thread_id_to_ptid(int global_id)
Definition: thread.c:617
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
ui_out::field_string
void field_string(const char *fldname, const char *string)
Definition: ui-out.c:544
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
ui_out_emit_type
Definition: ui-out.h:192
ptid_get_pid
int ptid_get_pid(const ptid_t &ptid)
Definition: ptid.c:47
command.h
get_thread_regcache
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:434
bpstat_clear
void bpstat_clear(bpstat *bsp)
Definition: breakpoint.c:4212
thread_info::deletable
bool deletable() const
Definition: gdbthread.h:211
pid
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:1824
xfree
void xfree(void *)
valid_global_thread_id
int valid_global_thread_id(int global_id)
Definition: thread.c:593
no_class
Definition: command.h:41
disp_del_at_next_stop
Definition: breakpoint.h:220
step_over_chain_remove
static void step_over_chain_remove(struct thread_info **list_p, struct thread_info *tp)
Definition: thread.c:387
cmd_list_element
Definition: cli-decode.h:46
number_is_in_list
int number_is_in_list(const char *list, int number)
Definition: cli-utils.c:227
gdb_regex.h
warning
void warning(const char *fmt,...)
Definition: errors.c:26
add_thread
struct thread_info * add_thread(ptid_t ptid)
Definition: thread.c:333
thread_fsm_delete
void thread_fsm_delete(struct thread_fsm *self)
Definition: thread-fsm.c:36
thread_info::stack_temporaries
value_vec * stack_temporaries
Definition: gdbthread.h:365
set_stop_requested
void set_stop_requested(ptid_t ptid, int stop)
Definition: thread.c:1027
in_thread_list
int in_thread_list(ptid_t ptid)
Definition: thread.c:628
USER_SELECTED_FRAME
Definition: defs.h:702
invalid_thread_id_error
void ATTRIBUTE_NORETURN invalid_thread_id_error(const char *string)
Definition: tid-parse.c:29
ui_out::field_skip
void field_skip(const char *fldname)
Definition: ui-out.c:532
finish_thread_state_cleanup
void finish_thread_state_cleanup(void *arg)
Definition: thread.c:1089
thread_apply_all_command
static void thread_apply_all_command(const char *cmd, int from_tty)
Definition: thread.c:1648
add_info
struct cmd_list_element * add_info(const char *name, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:886
select_frame
void select_frame(struct frame_info *fi)
Definition: frame.c:1677
thread_apply_command
static void thread_apply_command(const char *tidlist, int from_tty)
Definition: thread.c:1709
memset
void * memset(T *s, int c, size_t n)=delete
inferior::pid
int pid
Definition: inferior.h:328
ui_out::table_header
void table_header(int width, ui_align align, const std::string &col_name, const std::string &col_hdr)
Definition: ui-out.c:365
breakpoint::silent
bool silent
Definition: breakpoint.h:706
is_executing
int is_executing(ptid_t ptid)
Definition: thread.c:981
inferior
Definition: inferior.h:310
scoped_restore_current_thread::m_was_stopped
bool m_was_stopped
Definition: gdbthread.h:615
observer_notify_user_selected_context_changed
void observer_notify_user_selected_context_changed(user_selected_what selection)
tid_range_parser::get_tid
bool get_tid(int *inf_num, int *thr_num)
Definition: tid-parse.c:289
inferior::highest_thread_num
int highest_thread_num
Definition: inferior.h:333
add_cmd
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:262
delete_thread_silent
void delete_thread_silent(ptid_t ptid)
Definition: thread.c:482
selftests::scoped_restore_tests::global
static int global
Definition: scoped_restore-selftests.c:30
tid_range_parser::tid_is_qualified
bool tid_is_qualified() const
Definition: tid-parse.c:181
tid_is_in_list
int tid_is_in_list(const char *list, int default_inferior, int inf_num, int thr_num)
Definition: tid-parse.c:307
btrace.h
frame_info
Definition: frame.c:85
thread_fsm_clean_up
void thread_fsm_clean_up(struct thread_fsm *self, struct thread_info *thread)
Definition: thread-fsm.c:49
get_print_cell
char * get_print_cell(void)
Definition: print-utils.c:30
VEC_safe_push
#define VEC_safe_push(T, V, O)
Definition: vec.h:276
find_inferior_ptid
struct inferior * find_inferior_ptid(ptid_t ptid)
Definition: inferior.c:321
cmdlist
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:79
thread_info::state
enum thread_state state
Definition: gdbthread.h:287
delete_step_resume_breakpoint
void delete_step_resume_breakpoint(struct thread_info *tp)
Definition: thread.c:110
thread_command
void thread_command(const char *tidstr, int from_tty)
Definition: thread.c:1795
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
cleanup
Definition: cleanups.c:38
_
#define _(String)
Definition: gdb_locale.h:35
ui_file
Definition: ui-file.h:26
scoped_restore_current_thread::m_thread
class thread_info * m_thread
Definition: gdbthread.h:611
switch_to_thread
static void switch_to_thread(thread_info *thr)
Definition: thread.c:1423
ui_left
Definition: ui-out.h:44
defs.h
THREAD_EXITED
Definition: gdbthread.h:43
builtin_type
Definition: gdbtypes.h:1495
internalvar
Definition: value.c:2070
THREAD_RUNNING
Definition: gdbthread.h:42
threads_executing
static int threads_executing
Definition: thread.c:61
ui_out::text
void text(const char *string)
Definition: ui-out.c:581
arm-linux.inf
inf
Definition: arm-linux.py:13
tp_array_compar_ascending
static bool tp_array_compar_ascending
Definition: thread.c:1616
printf_filtered
void printf_filtered(const char *format,...)
Definition: utils.c:2045
thread_state
thread_state
Definition: gdbthread.h:39
cli-decode.h
thread_step_over_chain_remove
void thread_step_over_chain_remove(struct thread_info *tp)
Definition: thread.c:434
scoped_restore_current_thread::~scoped_restore_current_thread
~scoped_restore_current_thread()
Definition: thread.c:1512
XNEW
#define XNEW(T)
Definition: poison.h:109
set_current_program_space
void set_current_program_space(struct program_space *pspace)
Definition: progspace.c:190
execute_command
void execute_command(const char *, int)
Definition: top.c:540
tid_range_parser::finished
bool finished() const
Definition: tid-parse.c:137
observer.h
add_thread_silent
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:266
disable_thread_stack_temporaries
static void disable_thread_stack_temporaries(void *data)
Definition: thread.c:756
add_prefix_cmd
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:367
symtab.h
frame_id_eq
int frame_id_eq(struct frame_id l, struct frame_id r)
Definition: frame.c:674
global_thread_id_make_value
static struct value * global_thread_id_make_value(struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
Definition: thread.c:2042
extract_bp_kind::bp
name
const char *const name
Definition: aarch64-tdep.c:76
thread_info::next
struct thread_info * next
Definition: gdbthread.h:218
VEC_iterate
#define VEC_iterate(T, V, I, P)
Definition: vec.h:181
internalvar_funcs
Definition: value.h:946
gdb_optional.h
get_frame_id
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:520
thread_info::per_inf_num
int per_inf_num
Definition: gdbthread.h:258
thread_has_single_step_breakpoints_set
int thread_has_single_step_breakpoints_set(struct thread_info *tp)
Definition: thread.c:148
thread_select
void thread_select(const char *tidstr, thread_info *tp)
Definition: thread.c:1925
thread_cmd_list
struct cmd_list_element * thread_cmd_list
Definition: thread.c:2049
thread_is_in_step_over_chain
int thread_is_in_step_over_chain(struct thread_info *tp)
Definition: thread.c:418
thread_info::suspend
thread_suspend_state suspend
Definition: gdbthread.h:295
btrace_teardown
void btrace_teardown(struct thread_info *tp)
Definition: btrace.c:1655
tid_range_parser::get_tid_range
bool get_tid_range(int *inf_num, int *thr_start, int *thr_end)
Definition: tid-parse.c:278
live_threads_count
static int live_threads_count(void)
Definition: thread.c:581
thread_control_state::exception_resume_breakpoint
struct breakpoint * exception_resume_breakpoint
Definition: gdbthread.h:58
print_thread_id
const char * print_thread_id(struct thread_info *thr)
Definition: thread.c:1602
init_thread_list
void init_thread_list(void)
Definition: thread.c:221
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
thread_info::executing
int executing
Definition: gdbthread.h:271
find_relative_frame
struct frame_info * find_relative_frame(struct frame_info *, int *)
Definition: stack.c:2234
LOCATION
Definition: frame.h:666
regcache.h
thread_name_command
static void thread_name_command(const char *arg, int from_tty)
Definition: thread.c:1843
thread_info::thread_info
thread_info(inferior *inf, ptid_t ptid)
Definition: thread.c:340
ptid_t
Definition: ptid.h:35
tid_range_parser::cur_tok
const char * cur_tok() const
Definition: tid-parse.c:154
set_running_thread
static int set_running_thread(struct thread_info *tp, int running)
Definition: thread.c:898
add_com_alias
struct cmd_list_element * add_com_alias(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag)
Definition: cli-decode.c:912
value_contents_all
const gdb_byte * value_contents_all(struct value *value)
Definition: value.c:1265
cli-utils.h
frame.h
observer_notify_target_resumed
void observer_notify_target_resumed(ptid_t ptid)
thread_info::global_num
int global_num
Definition: gdbthread.h:253
private_thread_info::~private_thread_info
virtual ~private_thread_info()=0
thread_num_make_value_helper
static struct value * thread_num_make_value_helper(struct gdbarch *gdbarch, int global)
Definition: thread.c:2011
tid_range_parser::in_star_range
bool in_star_range() const
Definition: tid-parse.c:299
gdbthread.h
current_uiout
#define current_uiout
Definition: ui-out.h:39
get_selected_frame_if_set
struct frame_info * get_selected_frame_if_set(void)
Definition: frame.c:1657
breakpoint
Definition: breakpoint.h:684
inferior.h
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
value_in_thread_stack_temporaries
int value_in_thread_stack_temporaries(struct value *val, ptid_t ptid)
Definition: thread.c:820
inferior_list
struct inferior * inferior_list
Definition: inferior.c:45
scoped_inc_dec_ref::scoped_inc_dec_ref
scoped_inc_dec_ref(const std::vector< thread_info *> &thrds)
Definition: thread.c:71
private_thread_info
Definition: gdbthread.h:183
SRC_AND_LOC
Definition: frame.h:668
_initialize_thread
void _initialize_thread(void)
Definition: thread.c:2070
push_thread_stack_temporary
void push_thread_stack_temporary(ptid_t ptid, struct value *v)
Definition: thread.c:808
scoped_inc_dec_ref::~scoped_inc_dec_ref
~scoped_inc_dec_ref()
Definition: thread.c:78
update_threads_executing
static void update_threads_executing(void)
Definition: thread.c:1984
thread_info::pending_follow
struct target_waitstatus pending_follow
Definition: gdbthread.h:342
inf
Definition: gnu-nat.c:174
value_from_longest
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3534
inferior_thread
struct thread_info * inferior_thread(void)
Definition: thread.c:90
finish_thread_state
void finish_thread_state(ptid_t ptid)
Definition: thread.c:1052
set_executing
void set_executing(ptid_t ptid, int executing)
Definition: thread.c:991
can_access_registers_ptid
bool can_access_registers_ptid(ptid_t ptid)
Definition: thread.c:1123
observer_notify_new_thread
void observer_notify_new_thread(struct thread_info *t)
thread_info::thread_fsm
struct thread_fsm * thread_fsm
Definition: gdbthread.h:337
show_inferior_qualified_tids
int show_inferior_qualified_tids(void)
Definition: thread.c:1594
refcounted_object::decref
void decref()
Definition: refcounted-object.h:39
thread_info::ptid
ptid_t ptid
Definition: gdbthread.h:219
highest_thread_num
static int highest_thread_num
Definition: thread.c:54
setprintlist
struct cmd_list_element * setprintlist
Definition: cli-cmds.c:149
target_has_memory
#define target_has_memory
Definition: target.h:1729
tid_range_parser::init
void init(const char *tidlist, int default_inferior)
Definition: tid-parse.c:125
find_thread_by_handle
struct thread_info * find_thread_by_handle(struct value *thread_handle, struct inferior *inf)
Definition: thread.c:528
new_thread
static struct thread_info * new_thread(struct inferior *inf, ptid_t ptid)
Definition: thread.c:247
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
all
Definition: mi-cmd-stack.c:39
step_over_queue_head
struct thread_info * step_over_queue_head
Definition: infrun.c:1260
is_running
int is_running(ptid_t ptid)
Definition: thread.c:975
annotate_thread_changed
void annotate_thread_changed(void)
Definition: annotate.c:236
show_thread_that_caused_stop
int show_thread_that_caused_stop(void)
Definition: thread.c:1586
inferior::num
int num
Definition: inferior.h:324
print_thread_info_1
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:1192
iterate_over_threads
struct thread_info * iterate_over_threads(int(*callback)(struct thread_info *, void *), void *data)
Definition: thread.c:551
environ.h
thread_info::step_over_prev
struct thread_info * step_over_prev
Definition: gdbthread.h:370
delete_single_step_breakpoints
void delete_single_step_breakpoints(struct thread_info *tp)
Definition: thread.c:126
find_thread_ptid
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:514
first_thread_of_process
struct thread_info * first_thread_of_process(int pid)
Definition: thread.c:643
set_thread_exited
static void set_thread_exited(thread_info *tp, int silent)
Definition: thread.c:202
thread_cancel_execution_command
void thread_cancel_execution_command(struct thread_info *thr)
Definition: thread.c:169
thread_funcs
static const struct internalvar_funcs thread_funcs
Definition: thread.c:2053
delete_exception_resume_breakpoint
void delete_exception_resume_breakpoint(struct thread_info *tp)
Definition: thread.c:117
VEC_last
#define VEC_last(T, V)
Definition: vec.h:158
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
VEC_empty
#define VEC_empty(T, V)
Definition: vec.h:148
thread_step_over_chain_next
struct thread_info * thread_step_over_chain_next(struct thread_info *tp)
Definition: thread.c:408
value
Definition: value.c:169
ui_out
Definition: ui-out.h:77
switch_to_thread_no_regs
void switch_to_thread_no_regs(struct thread_info *thread)
Definition: thread.c:1396
target_thread_name
const char * target_thread_name(struct thread_info *info)
Definition: target.c:2200
get_last_thread_stack_temporary
struct value * get_last_thread_stack_temporary(ptid_t ptid)
Definition: thread.c:842
tid_range_parser
Definition: tid-parse.h:54
print_stack_frame
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:165
scoped_restore_current_thread::scoped_restore_current_thread
scoped_restore_current_thread()
Definition: thread.c:1545
breakpoint_has_location_inserted_here
int breakpoint_has_location_inserted_here(struct breakpoint *bp, const address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:14647
add_thread_with_info
struct thread_info * add_thread_with_info(ptid_t ptid, private_thread_info *priv)
Definition: thread.c:319
parse_thread_id
struct thread_info * parse_thread_id(const char *tidstr, const char **end)
Definition: tid-parse.c:54
thread_find_command
static void thread_find_command(const char *arg, int from_tty)
Definition: thread.c:1860
target_update_thread_list
void target_update_thread_list(void)
Definition: target.c:3310
inferior::next
struct inferior * next
Definition: inferior.h:320
clear_thread_inferior_resources
static void clear_thread_inferior_resources(struct thread_info *tp)
Definition: thread.c:180
set_running
void set_running(ptid_t ptid, int running)
Definition: thread.c:919
gdb::optional::emplace
T & emplace(Args &&... args)
Definition: gdb_optional.h:152
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
target_has_stack
#define target_has_stack
Definition: target.h:1735
thread_alive
static int thread_alive(struct thread_info *)
Definition: thread.c:715
thread-fsm.h
prune_threads
void prune_threads(void)
Definition: thread.c:727
ALL_NON_EXITED_THREADS
#define ALL_NON_EXITED_THREADS(T)
Definition: gdbthread.h:490
gdb::optional
Definition: gdb_optional.h:51
address_space
Definition: progspace.h:216
thread_info::priv
std::unique_ptr< private_thread_info > priv
Definition: gdbthread.h:354
thread_info::name
char * name
Definition: gdbthread.h:265
info_threads_command
static void info_threads_command(const char *arg, int from_tty)
Definition: thread.c:1379
inf::pid
pid_t pid
Definition: gnu-nat.c:187
frame_relative_level
int frame_relative_level(struct frame_info *fi)
Definition: frame.c:2610
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
thread_info::control
thread_control_state control
Definition: gdbthread.h:291
target_waitstatus::kind
enum target_waitkind kind
Definition: waitstatus.h:106
ui_out::field_int
void field_int(const char *fldname, int value)
Definition: ui-out.c:486
TARGET_WAITKIND_SPURIOUS
Definition: waitstatus.h:77
regcache_read_pc
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1229
scoped_restore_current_thread::m_selected_frame_id
frame_id m_selected_frame_id
Definition: gdbthread.h:613
should_print_thread
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:1158
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
validate_registers_access
void validate_registers_access(void)
Definition: thread.c:1101
ui_out::table_body
void table_body()
Definition: ui-out.c:379
tid_range_parser::skip_range
void skip_range()
Definition: tid-parse.c:169
target_pid_to_str
const char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2194
print_thread_events
int print_thread_events
Definition: thread.c:1912
is_stopped
int is_stopped(ptid_t ptid)
Definition: thread.c:963
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
observer_notify_thread_exit
void observer_notify_thread_exit(struct thread_info *t, int silent)
VEC_free
#define VEC_free(T, V)
Definition: vec.h:196
thread_stack_temporaries_enabled_p
int thread_stack_temporaries_enabled_p(ptid_t ptid)
Definition: thread.c:795
thread_has_single_step_breakpoint_here
int thread_has_single_step_breakpoint_here(struct thread_info *tp, const address_space *aspace, CORE_ADDR addr)
Definition: thread.c:156
stop_pc
CORE_ADDR stop_pc
Definition: infcmd.c:98
set_resumed
void set_resumed(ptid_t ptid, int resumed)
Definition: thread.c:875
ui_out::message
void message(const char *format,...) ATTRIBUTE_PRINTF(2
Definition: ui-out.c:587
target.h
observer_notify_thread_ptid_changed
void observer_notify_thread_ptid_changed(ptid_t old_ptid, ptid_t new_ptid)
string_printf
std::string string_printf(const char *fmt,...)
Definition: common-utils.c:150
thread_control_state::single_step_breakpoints
struct breakpoint * single_step_breakpoints
Definition: gdbthread.h:65
value.h
any_live_thread_of_process
struct thread_info * any_live_thread_of_process(int pid)
Definition: thread.c:674
any_thread_of_process
struct thread_info * any_thread_of_process(int pid)
Definition: thread.c:656
find_inferior_id
struct inferior * find_inferior_id(int num)
Definition: inferior.c:290
thread_info::inf
struct inferior * inf
Definition: gdbthread.h:261
showprintlist
struct cmd_list_element * showprintlist
Definition: cli-cmds.c:151
switch_to_no_thread
static void switch_to_no_thread()
Definition: thread.c:1410
target_core_of_thread
int target_core_of_thread(ptid_t ptid)
Definition: target.c:3458
ALL_THREADS_BY_INFERIOR
#define ALL_THREADS_BY_INFERIOR(inf, tp)
Definition: gdbthread.h:482
is_thread_state
static int is_thread_state(ptid_t ptid, enum thread_state state)
Definition: thread.c:953
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
delete_exited_threads
void delete_exited_threads(void)
Definition: thread.c:741
thread_count
int thread_count(void)
Definition: thread.c:567
re_comp
EXTERN_C char * re_comp(const char *)
observer_notify_thread_stop_requested
void observer_notify_thread_stop_requested(ptid_t ptid)
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
thread_info::~thread_info
~thread_info()
Definition: thread.c:354
class_run
Definition: command.h:41
threads_are_executing
int threads_are_executing(void)
Definition: thread.c:1021
PRINT_CELL_SIZE
#define PRINT_CELL_SIZE
Definition: print-utils.h:25
thread_step_over_chain_enqueue
void thread_step_over_chain_enqueue(struct thread_info *tp)
Definition: thread.c:426
scoped_inc_dec_ref::m_thrds
const std::vector< thread_info * > & m_thrds
Definition: thread.c:85
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
delete_thread_breakpoint
static void delete_thread_breakpoint(struct breakpoint **bp_p)
Definition: thread.c:100
scoped_inc_dec_ref
Definition: thread.c:68
tid-parse.h
refcounted_object::incref
void incref()
Definition: refcounted-object.h:32
ptid_to_global_thread_id
int ptid_to_global_thread_id(ptid_t ptid)
Definition: thread.c:605
target_thread_handle_to_thread_info
struct thread_info * target_thread_handle_to_thread_info(const gdb_byte *thread_handle, int handle_len, struct inferior *inf)
Definition: target.c:2206
thread_info::stack_temporaries_enabled
int stack_temporaries_enabled
Definition: gdbthread.h:361
step_over_chain_enqueue
static void step_over_chain_enqueue(struct thread_info **list_p, struct thread_info *tp)
Definition: thread.c:362
find_thread_global_id
struct thread_info * find_thread_global_id(int global_id)
Definition: thread.c:488
thread_suspend_state::waitstatus
struct target_waitstatus waitstatus
Definition: gdbthread.h:165
USER_SELECTED_THREAD
Definition: defs.h:699
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
thread_control_state::step_resume_breakpoint
struct breakpoint * step_resume_breakpoint
Definition: gdbthread.h:55
restore_selected_frame
static void restore_selected_frame(struct frame_id a_frame_id, int frame_level)
Definition: thread.c:1454
thread_list
struct thread_info * thread_list
Definition: thread.c:53
reinit_frame_cache
void reinit_frame_cache(void)
Definition: frame.c:1809
thread_info::step_over_next
struct thread_info * step_over_next
Definition: gdbthread.h:371
thread_id_per_inf_num_make_value
static struct value * thread_id_per_inf_num_make_value(struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
Definition: thread.c:2031
annotate.h
annotate_new_thread
void annotate_new_thread(void)
Definition: annotate.c:227
scoped_restore_current_thread::m_selected_frame_level
int m_selected_frame_level
Definition: gdbthread.h:614
TARGET_WAITKIND_IGNORE
Definition: waitstatus.h:88
scoped_restore_current_thread::m_inf
inferior * m_inf
Definition: gdbthread.h:612
delete_longjmp_breakpoint_at_next_stop
void delete_longjmp_breakpoint_at_next_stop(int thread)
Definition: breakpoint.c:7337
gdbcmd.h
has_stack_frames
int has_stack_frames(void)
Definition: frame.c:1609
delete_breakpoint
void delete_breakpoint(struct breakpoint *bpt)
Definition: breakpoint.c:13226
create_internalvar_type_lazy
struct internalvar * create_internalvar_type_lazy(const char *name, const struct internalvar_funcs *funcs, void *data)
Definition: value.c:2177
is_exited
int is_exited(ptid_t ptid)
Definition: thread.c:969
delete_thread_1
static void delete_thread_1(ptid_t ptid, int silent)
Definition: thread.c:442
thread_info
Definition: gdbthread.h:205
error
void error(const char *fmt,...)
Definition: errors.c:38
minus_one_ptid
ptid_t minus_one_ptid
Definition: ptid.c:26
check_for_argument
int check_for_argument(const char **str, const char *arg, int arg_len)
Definition: cli-utils.c:297
target_extra_thread_info
#define target_extra_thread_info(TP)
Definition: target.h:1813
frame_id
Definition: frame.h:111
thread_change_ptid
void thread_change_ptid(ptid_t old_ptid, ptid_t new_ptid)
Definition: thread.c:855
set_current_inferior
void set_current_inferior(struct inferior *inf)
Definition: inferior.c:64
delete_at_next_stop
static void delete_at_next_stop(struct breakpoint **bp)
Definition: thread.c:136
scoped_restore_current_thread
Definition: gdbthread.h:600
delete_thread
void delete_thread(ptid_t ptid)
Definition: thread.c:476
print_stack_frame_to_uiout
void print_stack_frame_to_uiout(struct ui_out *uiout, struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:149
thread_control_state::step_range_end
CORE_ADDR step_range_end
Definition: gdbthread.h:78
ui_out::is_mi_like_p
bool is_mi_like_p()
Definition: ui-out.c:622
gthread_funcs
static const struct internalvar_funcs gthread_funcs
Definition: thread.c:2062
ui-out.h
show_print_thread_events
static void show_print_thread_events(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: thread.c:1914
ALL_THREADS_SAFE
#define ALL_THREADS_SAFE(T, TMP)
Definition: gdbthread.h:496
tp_array_compar
static bool tp_array_compar(const thread_info *a, const thread_info *b)
Definition: thread.c:1623
print_thread_info
void print_thread_info(struct ui_out *uiout, char *requested_threads, int pid)
Definition: thread.c:1367