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