Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / thread.c
CommitLineData
5796c8dc
SS
1/* Multi-process/thread control for GDB, the GNU debugger.
2
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
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 "exceptions.h"
31#include "command.h"
32#include "gdbcmd.h"
33#include "regcache.h"
34#include "gdb.h"
35#include "gdb_string.h"
ef5ccd6c 36#include "btrace.h"
5796c8dc
SS
37
38#include <ctype.h>
39#include <sys/types.h>
40#include <signal.h>
41#include "ui-out.h"
42#include "observer.h"
43#include "annotate.h"
44#include "cli/cli-decode.h"
c50c785c
JM
45#include "gdb_regex.h"
46#include "cli/cli-utils.h"
a45ae5f8 47#include "continuations.h"
5796c8dc 48
c50c785c 49/* Definition of struct thread_info exported to gdbthread.h. */
5796c8dc 50
c50c785c 51/* Prototypes for exported functions. */
5796c8dc
SS
52
53void _initialize_thread (void);
54
c50c785c 55/* Prototypes for local functions. */
5796c8dc 56
ef5ccd6c 57struct thread_info *thread_list = NULL;
5796c8dc
SS
58static int highest_thread_num;
59
60static void thread_command (char *tidstr, int from_tty);
61static void thread_apply_all_command (char *, int);
62static int thread_alive (struct thread_info *);
63static void info_threads_command (char *, int);
64static void thread_apply_command (char *, int);
65static void restore_current_thread (ptid_t);
66static void prune_threads (void);
67
5796c8dc
SS
68struct thread_info*
69inferior_thread (void)
70{
71 struct thread_info *tp = find_thread_ptid (inferior_ptid);
72 gdb_assert (tp);
73 return tp;
74}
75
76void
77delete_step_resume_breakpoint (struct thread_info *tp)
78{
c50c785c 79 if (tp && tp->control.step_resume_breakpoint)
5796c8dc 80 {
c50c785c
JM
81 delete_breakpoint (tp->control.step_resume_breakpoint);
82 tp->control.step_resume_breakpoint = NULL;
83 }
84}
85
86void
87delete_exception_resume_breakpoint (struct thread_info *tp)
88{
89 if (tp && tp->control.exception_resume_breakpoint)
90 {
91 delete_breakpoint (tp->control.exception_resume_breakpoint);
92 tp->control.exception_resume_breakpoint = NULL;
5796c8dc
SS
93 }
94}
95
96static void
97clear_thread_inferior_resources (struct thread_info *tp)
98{
99 /* NOTE: this will take care of any left-over step_resume breakpoints,
100 but not any user-specified thread-specific breakpoints. We can not
101 delete the breakpoint straight-off, because the inferior might not
102 be stopped at the moment. */
c50c785c 103 if (tp->control.step_resume_breakpoint)
5796c8dc 104 {
c50c785c
JM
105 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
106 tp->control.step_resume_breakpoint = NULL;
5796c8dc
SS
107 }
108
c50c785c
JM
109 if (tp->control.exception_resume_breakpoint)
110 {
111 tp->control.exception_resume_breakpoint->disposition
112 = disp_del_at_next_stop;
113 tp->control.exception_resume_breakpoint = NULL;
114 }
115
ef5ccd6c
JM
116 delete_longjmp_breakpoint_at_next_stop (tp->num);
117
c50c785c 118 bpstat_clear (&tp->control.stop_bpstat);
5796c8dc 119
ef5ccd6c
JM
120 btrace_teardown (tp);
121
a45ae5f8
JM
122 do_all_intermediate_continuations_thread (tp, 1);
123 do_all_continuations_thread (tp, 1);
5796c8dc
SS
124}
125
126static void
127free_thread (struct thread_info *tp)
128{
5796c8dc 129 if (tp->private)
cf7f2e2d
JM
130 {
131 if (tp->private_dtor)
132 tp->private_dtor (tp->private);
133 else
134 xfree (tp->private);
135 }
5796c8dc 136
c50c785c 137 xfree (tp->name);
5796c8dc
SS
138 xfree (tp);
139}
140
141void
142init_thread_list (void)
143{
144 struct thread_info *tp, *tpnext;
145
146 highest_thread_num = 0;
147
148 if (!thread_list)
149 return;
150
151 for (tp = thread_list; tp; tp = tpnext)
152 {
153 tpnext = tp->next;
154 free_thread (tp);
155 }
156
157 thread_list = NULL;
158}
159
160/* Allocate a new thread with target id PTID and add it to the thread
161 list. */
162
163static struct thread_info *
164new_thread (ptid_t ptid)
165{
166 struct thread_info *tp;
167
168 tp = xcalloc (1, sizeof (*tp));
169
170 tp->ptid = ptid;
171 tp->num = ++highest_thread_num;
172 tp->next = thread_list;
173 thread_list = tp;
174
175 /* Nothing to follow yet. */
176 tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
a45ae5f8 177 tp->state = THREAD_STOPPED;
5796c8dc
SS
178
179 return tp;
180}
181
182struct thread_info *
183add_thread_silent (ptid_t ptid)
184{
185 struct thread_info *tp;
186
187 tp = find_thread_ptid (ptid);
188 if (tp)
189 /* Found an old thread with the same id. It has to be dead,
190 otherwise we wouldn't be adding a new thread with the same id.
191 The OS is reusing this id --- delete it, and recreate a new
192 one. */
193 {
194 /* In addition to deleting the thread, if this is the current
195 thread, then we need to take care that delete_thread doesn't
196 really delete the thread if it is inferior_ptid. Create a
197 new template thread in the list with an invalid ptid, switch
198 to it, delete the original thread, reset the new thread's
199 ptid, and switch to it. */
200
201 if (ptid_equal (inferior_ptid, ptid))
202 {
cf7f2e2d 203 tp = new_thread (null_ptid);
5796c8dc
SS
204
205 /* Make switch_to_thread not read from the thread. */
a45ae5f8 206 tp->state = THREAD_EXITED;
cf7f2e2d 207 switch_to_thread (null_ptid);
5796c8dc
SS
208
209 /* Now we can delete it. */
210 delete_thread (ptid);
211
212 /* Now reset its ptid, and reswitch inferior_ptid to it. */
213 tp->ptid = ptid;
a45ae5f8 214 tp->state = THREAD_STOPPED;
5796c8dc
SS
215 switch_to_thread (ptid);
216
217 observer_notify_new_thread (tp);
218
219 /* All done. */
220 return tp;
221 }
222 else
223 /* Just go ahead and delete it. */
224 delete_thread (ptid);
225 }
226
227 tp = new_thread (ptid);
228 observer_notify_new_thread (tp);
229
230 return tp;
231}
232
233struct thread_info *
234add_thread_with_info (ptid_t ptid, struct private_thread_info *private)
235{
236 struct thread_info *result = add_thread_silent (ptid);
237
238 result->private = private;
239
240 if (print_thread_events)
241 printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
242
243 annotate_new_thread ();
244 return result;
245}
246
247struct thread_info *
248add_thread (ptid_t ptid)
249{
250 return add_thread_with_info (ptid, NULL);
251}
252
253/* Delete thread PTID. If SILENT, don't notify the observer of this
254 exit. */
255static void
256delete_thread_1 (ptid_t ptid, int silent)
257{
258 struct thread_info *tp, *tpprev;
259
260 tpprev = NULL;
261
262 for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
263 if (ptid_equal (tp->ptid, ptid))
264 break;
265
266 if (!tp)
267 return;
268
269 /* If this is the current thread, or there's code out there that
270 relies on it existing (refcount > 0) we can't delete yet. Mark
271 it as exited, and notify it. */
272 if (tp->refcount > 0
273 || ptid_equal (tp->ptid, inferior_ptid))
274 {
a45ae5f8 275 if (tp->state != THREAD_EXITED)
5796c8dc
SS
276 {
277 observer_notify_thread_exit (tp, silent);
278
279 /* Tag it as exited. */
a45ae5f8 280 tp->state = THREAD_EXITED;
5796c8dc
SS
281
282 /* Clear breakpoints, etc. associated with this thread. */
283 clear_thread_inferior_resources (tp);
284 }
285
286 /* Will be really deleted some other time. */
287 return;
288 }
289
a45ae5f8
JM
290 /* Notify thread exit, but only if we haven't already. */
291 if (tp->state != THREAD_EXITED)
292 observer_notify_thread_exit (tp, silent);
293
294 /* Tag it as exited. */
295 tp->state = THREAD_EXITED;
296 clear_thread_inferior_resources (tp);
297
5796c8dc
SS
298 if (tpprev)
299 tpprev->next = tp->next;
300 else
301 thread_list = tp->next;
302
5796c8dc
SS
303 free_thread (tp);
304}
305
306/* Delete thread PTID and notify of thread exit. If this is
307 inferior_ptid, don't actually delete it, but tag it as exited and
308 do the notification. If PTID is the user selected thread, clear
309 it. */
310void
311delete_thread (ptid_t ptid)
312{
313 delete_thread_1 (ptid, 0 /* not silent */);
314}
315
316void
317delete_thread_silent (ptid_t ptid)
318{
319 delete_thread_1 (ptid, 1 /* silent */);
320}
321
322struct thread_info *
323find_thread_id (int num)
324{
325 struct thread_info *tp;
326
327 for (tp = thread_list; tp; tp = tp->next)
328 if (tp->num == num)
329 return tp;
330
331 return NULL;
332}
333
334/* Find a thread_info by matching PTID. */
335struct thread_info *
336find_thread_ptid (ptid_t ptid)
337{
338 struct thread_info *tp;
339
340 for (tp = thread_list; tp; tp = tp->next)
341 if (ptid_equal (tp->ptid, ptid))
342 return tp;
343
344 return NULL;
345}
346
347/*
348 * Thread iterator function.
349 *
350 * Calls a callback function once for each thread, so long as
351 * the callback function returns false. If the callback function
352 * returns true, the iteration will end and the current thread
353 * will be returned. This can be useful for implementing a
354 * search for a thread with arbitrary attributes, or for applying
355 * some operation to every thread.
356 *
357 * FIXME: some of the existing functionality, such as
358 * "Thread apply all", might be rewritten using this functionality.
359 */
360
361struct thread_info *
362iterate_over_threads (int (*callback) (struct thread_info *, void *),
363 void *data)
364{
365 struct thread_info *tp, *next;
366
367 for (tp = thread_list; tp; tp = next)
368 {
369 next = tp->next;
370 if ((*callback) (tp, data))
371 return tp;
372 }
373
374 return NULL;
375}
376
377int
378thread_count (void)
379{
380 int result = 0;
381 struct thread_info *tp;
382
383 for (tp = thread_list; tp; tp = tp->next)
384 ++result;
385
386 return result;
387}
388
389int
390valid_thread_id (int num)
391{
392 struct thread_info *tp;
393
394 for (tp = thread_list; tp; tp = tp->next)
395 if (tp->num == num)
396 return 1;
397
398 return 0;
399}
400
401int
402pid_to_thread_id (ptid_t ptid)
403{
404 struct thread_info *tp;
405
406 for (tp = thread_list; tp; tp = tp->next)
407 if (ptid_equal (tp->ptid, ptid))
408 return tp->num;
409
410 return 0;
411}
412
413ptid_t
414thread_id_to_pid (int num)
415{
416 struct thread_info *thread = find_thread_id (num);
cf7f2e2d 417
5796c8dc
SS
418 if (thread)
419 return thread->ptid;
420 else
421 return pid_to_ptid (-1);
422}
423
424int
425in_thread_list (ptid_t ptid)
426{
427 struct thread_info *tp;
428
429 for (tp = thread_list; tp; tp = tp->next)
430 if (ptid_equal (tp->ptid, ptid))
431 return 1;
432
c50c785c 433 return 0; /* Never heard of 'im. */
5796c8dc
SS
434}
435
436/* Finds the first thread of the inferior given by PID. If PID is -1,
437 return the first thread in the list. */
438
439struct thread_info *
440first_thread_of_process (int pid)
441{
442 struct thread_info *tp, *ret = NULL;
443
444 for (tp = thread_list; tp; tp = tp->next)
445 if (pid == -1 || ptid_get_pid (tp->ptid) == pid)
446 if (ret == NULL || tp->num < ret->num)
447 ret = tp;
448
449 return ret;
450}
451
452struct thread_info *
453any_thread_of_process (int pid)
454{
455 struct thread_info *tp;
456
457 for (tp = thread_list; tp; tp = tp->next)
458 if (ptid_get_pid (tp->ptid) == pid)
459 return tp;
460
461 return NULL;
462}
463
cf7f2e2d
JM
464struct thread_info *
465any_live_thread_of_process (int pid)
466{
467 struct thread_info *tp;
c50c785c 468 struct thread_info *tp_executing = NULL;
cf7f2e2d
JM
469
470 for (tp = thread_list; tp; tp = tp->next)
a45ae5f8 471 if (tp->state != THREAD_EXITED && ptid_get_pid (tp->ptid) == pid)
cf7f2e2d 472 {
a45ae5f8 473 if (tp->executing)
c50c785c
JM
474 tp_executing = tp;
475 else
cf7f2e2d 476 return tp;
cf7f2e2d
JM
477 }
478
c50c785c 479 return tp_executing;
cf7f2e2d
JM
480}
481
5796c8dc 482/* Print a list of thread ids currently known, and the total number of
c50c785c 483 threads. To be used from within catch_errors. */
5796c8dc
SS
484static int
485do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
486{
487 struct thread_info *tp;
488 int num = 0;
489 struct cleanup *cleanup_chain;
490 int current_thread = -1;
491
cf7f2e2d 492 update_thread_list ();
5796c8dc
SS
493
494 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids");
495
496 for (tp = thread_list; tp; tp = tp->next)
497 {
a45ae5f8 498 if (tp->state == THREAD_EXITED)
5796c8dc
SS
499 continue;
500
501 if (ptid_equal (tp->ptid, inferior_ptid))
502 current_thread = tp->num;
503
504 num++;
505 ui_out_field_int (uiout, "thread-id", tp->num);
506 }
507
508 do_cleanups (cleanup_chain);
509
510 if (current_thread != -1)
511 ui_out_field_int (uiout, "current-thread-id", current_thread);
512 ui_out_field_int (uiout, "number-of-threads", num);
513 return GDB_RC_OK;
514}
515
516/* Official gdblib interface function to get a list of thread ids and
c50c785c 517 the total number. */
5796c8dc
SS
518enum gdb_rc
519gdb_list_thread_ids (struct ui_out *uiout, char **error_message)
520{
521 if (catch_exceptions_with_msg (uiout, do_captured_list_thread_ids, NULL,
522 error_message, RETURN_MASK_ALL) < 0)
523 return GDB_RC_FAIL;
524 return GDB_RC_OK;
525}
526
c50c785c 527/* Return true if TP is an active thread. */
5796c8dc
SS
528static int
529thread_alive (struct thread_info *tp)
530{
a45ae5f8 531 if (tp->state == THREAD_EXITED)
5796c8dc
SS
532 return 0;
533 if (!target_thread_alive (tp->ptid))
534 return 0;
535 return 1;
536}
537
538static void
539prune_threads (void)
540{
541 struct thread_info *tp, *next;
542
543 for (tp = thread_list; tp; tp = next)
544 {
545 next = tp->next;
546 if (!thread_alive (tp))
547 delete_thread (tp->ptid);
548 }
549}
550
551void
552thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
553{
554 struct inferior *inf;
555 struct thread_info *tp;
556
557 /* It can happen that what we knew as the target inferior id
558 changes. E.g, target remote may only discover the remote process
559 pid after adding the inferior to GDB's list. */
560 inf = find_inferior_pid (ptid_get_pid (old_ptid));
561 inf->pid = ptid_get_pid (new_ptid);
562
563 tp = find_thread_ptid (old_ptid);
564 tp->ptid = new_ptid;
565
566 observer_notify_thread_ptid_changed (old_ptid, new_ptid);
567}
568
569void
570set_running (ptid_t ptid, int running)
571{
572 struct thread_info *tp;
573 int all = ptid_equal (ptid, minus_one_ptid);
574
575 /* We try not to notify the observer if no thread has actually changed
576 the running state -- merely to reduce the number of messages to
577 frontend. Frontend is supposed to handle multiple *running just fine. */
578 if (all || ptid_is_pid (ptid))
579 {
580 int any_started = 0;
cf7f2e2d 581
5796c8dc
SS
582 for (tp = thread_list; tp; tp = tp->next)
583 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
584 {
a45ae5f8 585 if (tp->state == THREAD_EXITED)
5796c8dc 586 continue;
a45ae5f8 587 if (running && tp->state == THREAD_STOPPED)
5796c8dc 588 any_started = 1;
a45ae5f8 589 tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
5796c8dc
SS
590 }
591 if (any_started)
592 observer_notify_target_resumed (ptid);
593 }
594 else
595 {
596 int started = 0;
cf7f2e2d 597
5796c8dc
SS
598 tp = find_thread_ptid (ptid);
599 gdb_assert (tp);
a45ae5f8
JM
600 gdb_assert (tp->state != THREAD_EXITED);
601 if (running && tp->state == THREAD_STOPPED)
5796c8dc 602 started = 1;
a45ae5f8 603 tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
5796c8dc
SS
604 if (started)
605 observer_notify_target_resumed (ptid);
606 }
607}
608
609static int
610is_thread_state (ptid_t ptid, enum thread_state state)
611{
612 struct thread_info *tp;
613
614 tp = find_thread_ptid (ptid);
615 gdb_assert (tp);
a45ae5f8 616 return tp->state == state;
5796c8dc
SS
617}
618
619int
620is_stopped (ptid_t ptid)
621{
622 return is_thread_state (ptid, THREAD_STOPPED);
623}
624
625int
626is_exited (ptid_t ptid)
627{
628 return is_thread_state (ptid, THREAD_EXITED);
629}
630
631int
632is_running (ptid_t ptid)
633{
634 return is_thread_state (ptid, THREAD_RUNNING);
635}
636
637int
638any_running (void)
639{
640 struct thread_info *tp;
641
642 for (tp = thread_list; tp; tp = tp->next)
a45ae5f8 643 if (tp->state == THREAD_RUNNING)
5796c8dc
SS
644 return 1;
645
646 return 0;
647}
648
649int
650is_executing (ptid_t ptid)
651{
652 struct thread_info *tp;
653
654 tp = find_thread_ptid (ptid);
655 gdb_assert (tp);
a45ae5f8 656 return tp->executing;
5796c8dc
SS
657}
658
659void
660set_executing (ptid_t ptid, int executing)
661{
662 struct thread_info *tp;
663 int all = ptid_equal (ptid, minus_one_ptid);
664
665 if (all || ptid_is_pid (ptid))
666 {
667 for (tp = thread_list; tp; tp = tp->next)
668 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
a45ae5f8 669 tp->executing = executing;
5796c8dc
SS
670 }
671 else
672 {
673 tp = find_thread_ptid (ptid);
674 gdb_assert (tp);
a45ae5f8 675 tp->executing = executing;
5796c8dc
SS
676 }
677}
678
679void
680set_stop_requested (ptid_t ptid, int stop)
681{
682 struct thread_info *tp;
683 int all = ptid_equal (ptid, minus_one_ptid);
684
685 if (all || ptid_is_pid (ptid))
686 {
687 for (tp = thread_list; tp; tp = tp->next)
688 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
689 tp->stop_requested = stop;
690 }
691 else
692 {
693 tp = find_thread_ptid (ptid);
694 gdb_assert (tp);
695 tp->stop_requested = stop;
696 }
697
698 /* Call the stop requested observer so other components of GDB can
699 react to this request. */
700 if (stop)
701 observer_notify_thread_stop_requested (ptid);
702}
703
704void
705finish_thread_state (ptid_t ptid)
706{
707 struct thread_info *tp;
708 int all;
709 int any_started = 0;
710
711 all = ptid_equal (ptid, minus_one_ptid);
712
713 if (all || ptid_is_pid (ptid))
714 {
715 for (tp = thread_list; tp; tp = tp->next)
716 {
a45ae5f8 717 if (tp->state == THREAD_EXITED)
5796c8dc
SS
718 continue;
719 if (all || ptid_get_pid (ptid) == ptid_get_pid (tp->ptid))
720 {
a45ae5f8 721 if (tp->executing && tp->state == THREAD_STOPPED)
5796c8dc 722 any_started = 1;
a45ae5f8 723 tp->state = tp->executing ? THREAD_RUNNING : THREAD_STOPPED;
5796c8dc
SS
724 }
725 }
726 }
727 else
728 {
729 tp = find_thread_ptid (ptid);
730 gdb_assert (tp);
a45ae5f8 731 if (tp->state != THREAD_EXITED)
5796c8dc 732 {
a45ae5f8 733 if (tp->executing && tp->state == THREAD_STOPPED)
5796c8dc 734 any_started = 1;
a45ae5f8 735 tp->state = tp->executing ? THREAD_RUNNING : THREAD_STOPPED;
5796c8dc
SS
736 }
737 }
738
739 if (any_started)
740 observer_notify_target_resumed (ptid);
741}
742
743void
744finish_thread_state_cleanup (void *arg)
745{
746 ptid_t *ptid_p = arg;
747
748 gdb_assert (arg);
749
750 finish_thread_state (*ptid_p);
751}
752
753/* Prints the list of threads and their details on UIOUT.
c50c785c
JM
754 This is a version of 'info_threads_command' suitable for
755 use from MI.
5796c8dc
SS
756 If REQUESTED_THREAD is not -1, it's the GDB id of the thread
757 that should be printed. Otherwise, all threads are
c50c785c 758 printed.
5796c8dc 759 If PID is not -1, only print threads from the process PID.
c50c785c 760 Otherwise, threads from all attached PIDs are printed.
5796c8dc
SS
761 If both REQUESTED_THREAD and PID are not -1, then the thread
762 is printed if it belongs to the specified process. Otherwise,
763 an error is raised. */
764void
c50c785c 765print_thread_info (struct ui_out *uiout, char *requested_threads, int pid)
5796c8dc
SS
766{
767 struct thread_info *tp;
768 ptid_t current_ptid;
769 struct cleanup *old_chain;
c50c785c 770 char *extra_info, *name, *target_id;
5796c8dc
SS
771 int current_thread = -1;
772
cf7f2e2d 773 update_thread_list ();
5796c8dc
SS
774 current_ptid = inferior_ptid;
775
776 /* We'll be switching threads temporarily. */
777 old_chain = make_cleanup_restore_current_thread ();
778
c50c785c
JM
779 /* For backward compatibility, we make a list for MI. A table is
780 preferable for the CLI, though, because it shows table
781 headers. */
782 if (ui_out_is_mi_like_p (uiout))
783 make_cleanup_ui_out_list_begin_end (uiout, "threads");
784 else
785 {
786 int n_threads = 0;
787
788 for (tp = thread_list; tp; tp = tp->next)
789 {
790 if (!number_is_in_list (requested_threads, tp->num))
791 continue;
792
793 if (pid != -1 && PIDGET (tp->ptid) != pid)
794 continue;
795
a45ae5f8 796 if (tp->state == THREAD_EXITED)
c50c785c
JM
797 continue;
798
799 ++n_threads;
800 }
801
802 if (n_threads == 0)
803 {
804 if (requested_threads == NULL || *requested_threads == '\0')
805 ui_out_message (uiout, 0, _("No threads.\n"));
806 else
807 ui_out_message (uiout, 0, _("No threads match '%s'.\n"),
808 requested_threads);
809 do_cleanups (old_chain);
810 return;
811 }
812
813 make_cleanup_ui_out_table_begin_end (uiout, 4, n_threads, "threads");
814
815 ui_out_table_header (uiout, 1, ui_left, "current", "");
816 ui_out_table_header (uiout, 4, ui_left, "id", "Id");
817 ui_out_table_header (uiout, 17, ui_left, "target-id", "Target Id");
818 ui_out_table_header (uiout, 1, ui_left, "frame", "Frame");
819 ui_out_table_body (uiout);
820 }
821
5796c8dc
SS
822 for (tp = thread_list; tp; tp = tp->next)
823 {
824 struct cleanup *chain2;
cf7f2e2d 825 int core;
5796c8dc 826
c50c785c 827 if (!number_is_in_list (requested_threads, tp->num))
5796c8dc
SS
828 continue;
829
830 if (pid != -1 && PIDGET (tp->ptid) != pid)
831 {
c50c785c 832 if (requested_threads != NULL && *requested_threads != '\0')
5796c8dc
SS
833 error (_("Requested thread not found in requested process"));
834 continue;
835 }
836
837 if (ptid_equal (tp->ptid, current_ptid))
838 current_thread = tp->num;
839
a45ae5f8 840 if (tp->state == THREAD_EXITED)
5796c8dc
SS
841 continue;
842
843 chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
844
c50c785c
JM
845 if (ui_out_is_mi_like_p (uiout))
846 {
847 /* Compatibility. */
848 if (ptid_equal (tp->ptid, current_ptid))
849 ui_out_text (uiout, "* ");
850 else
851 ui_out_text (uiout, " ");
852 }
5796c8dc 853 else
c50c785c
JM
854 {
855 if (ptid_equal (tp->ptid, current_ptid))
856 ui_out_field_string (uiout, "current", "*");
857 else
858 ui_out_field_skip (uiout, "current");
859 }
5796c8dc
SS
860
861 ui_out_field_int (uiout, "id", tp->num);
5796c8dc 862
c50c785c
JM
863 /* For the CLI, we stuff everything into the target-id field.
864 This is a gross hack to make the output come out looking
865 correct. The underlying problem here is that ui-out has no
866 way to specify that a field's space allocation should be
867 shared by several fields. For MI, we do the right thing
868 instead. */
869
870 target_id = target_pid_to_str (tp->ptid);
5796c8dc 871 extra_info = target_extra_thread_info (tp);
c50c785c
JM
872 name = tp->name ? tp->name : target_thread_name (tp);
873
874 if (ui_out_is_mi_like_p (uiout))
5796c8dc 875 {
c50c785c
JM
876 ui_out_field_string (uiout, "target-id", target_id);
877 if (extra_info)
878 ui_out_field_string (uiout, "details", extra_info);
879 if (name)
880 ui_out_field_string (uiout, "name", name);
881 }
882 else
883 {
884 struct cleanup *str_cleanup;
885 char *contents;
886
887 if (extra_info && name)
888 contents = xstrprintf ("%s \"%s\" (%s)", target_id,
889 name, extra_info);
890 else if (extra_info)
891 contents = xstrprintf ("%s (%s)", target_id, extra_info);
892 else if (name)
893 contents = xstrprintf ("%s \"%s\"", target_id, name);
894 else
895 contents = xstrdup (target_id);
896 str_cleanup = make_cleanup (xfree, contents);
897
898 ui_out_field_string (uiout, "target-id", contents);
899 do_cleanups (str_cleanup);
5796c8dc 900 }
5796c8dc 901
a45ae5f8 902 if (tp->state == THREAD_RUNNING)
5796c8dc
SS
903 ui_out_text (uiout, "(running)\n");
904 else
905 {
906 /* The switch below puts us at the top of the stack (leaf
907 frame). */
908 switch_to_thread (tp->ptid);
909 print_stack_frame (get_selected_frame (NULL),
910 /* For MI output, print frame level. */
911 ui_out_is_mi_like_p (uiout),
912 LOCATION);
913 }
914
915 if (ui_out_is_mi_like_p (uiout))
916 {
917 char *state = "stopped";
cf7f2e2d 918
a45ae5f8 919 if (tp->state == THREAD_RUNNING)
5796c8dc
SS
920 state = "running";
921 ui_out_field_string (uiout, "state", state);
922 }
923
cf7f2e2d
JM
924 core = target_core_of_thread (tp->ptid);
925 if (ui_out_is_mi_like_p (uiout) && core != -1)
926 ui_out_field_int (uiout, "core", core);
927
5796c8dc
SS
928 do_cleanups (chain2);
929 }
930
931 /* Restores the current thread and the frame selected before
932 the "info threads" command. */
933 do_cleanups (old_chain);
934
c50c785c 935 if (pid == -1 && requested_threads == NULL)
5796c8dc
SS
936 {
937 gdb_assert (current_thread != -1
938 || !thread_list
939 || ptid_equal (inferior_ptid, null_ptid));
940 if (current_thread != -1 && ui_out_is_mi_like_p (uiout))
941 ui_out_field_int (uiout, "current-thread-id", current_thread);
942
943 if (current_thread != -1 && is_exited (current_ptid))
944 ui_out_message (uiout, 0, "\n\
945The current thread <Thread ID %d> has terminated. See `help thread'.\n",
946 current_thread);
947 else if (thread_list
948 && current_thread == -1
949 && ptid_equal (current_ptid, null_ptid))
950 ui_out_message (uiout, 0, "\n\
951No selected thread. See `help thread'.\n");
952 }
953}
954
5796c8dc
SS
955/* Print information about currently known threads
956
c50c785c
JM
957 Optional ARG is a thread id, or list of thread ids.
958
959 Note: this has the drawback that it _really_ switches
960 threads, which frees the frame cache. A no-side
961 effects info-threads command would be nicer. */
5796c8dc
SS
962
963static void
964info_threads_command (char *arg, int from_tty)
965{
a45ae5f8 966 print_thread_info (current_uiout, arg, -1);
5796c8dc
SS
967}
968
c50c785c 969/* Switch from one thread to another. */
5796c8dc
SS
970
971void
972switch_to_thread (ptid_t ptid)
973{
cf7f2e2d
JM
974 /* Switch the program space as well, if we can infer it from the now
975 current thread. Otherwise, it's up to the caller to select the
976 space it wants. */
977 if (!ptid_equal (ptid, null_ptid))
978 {
979 struct inferior *inf;
980
981 inf = find_inferior_pid (ptid_get_pid (ptid));
982 gdb_assert (inf != NULL);
983 set_current_program_space (inf->pspace);
984 set_current_inferior (inf);
985 }
986
5796c8dc
SS
987 if (ptid_equal (ptid, inferior_ptid))
988 return;
989
990 inferior_ptid = ptid;
991 reinit_frame_cache ();
5796c8dc
SS
992
993 /* We don't check for is_stopped, because we're called at times
994 while in the TARGET_RUNNING state, e.g., while handling an
995 internal event. */
996 if (!ptid_equal (inferior_ptid, null_ptid)
997 && !is_exited (ptid)
998 && !is_executing (ptid))
999 stop_pc = regcache_read_pc (get_thread_regcache (ptid));
1000 else
1001 stop_pc = ~(CORE_ADDR) 0;
1002}
1003
1004static void
1005restore_current_thread (ptid_t ptid)
1006{
1007 switch_to_thread (ptid);
1008}
1009
1010static void
1011restore_selected_frame (struct frame_id a_frame_id, int frame_level)
1012{
1013 struct frame_info *frame = NULL;
1014 int count;
1015
c50c785c
JM
1016 /* This means there was no selected frame. */
1017 if (frame_level == -1)
1018 {
1019 select_frame (NULL);
1020 return;
1021 }
1022
5796c8dc
SS
1023 gdb_assert (frame_level >= 0);
1024
1025 /* Restore by level first, check if the frame id is the same as
1026 expected. If that fails, try restoring by frame id. If that
1027 fails, nothing to do, just warn the user. */
1028
1029 count = frame_level;
1030 frame = find_relative_frame (get_current_frame (), &count);
1031 if (count == 0
1032 && frame != NULL
1033 /* The frame ids must match - either both valid or both outer_frame_id.
1034 The latter case is not failsafe, but since it's highly unlikely
1035 the search by level finds the wrong frame, it's 99.9(9)% of
1036 the time (for all practical purposes) safe. */
1037 && frame_id_eq (get_frame_id (frame), a_frame_id))
1038 {
1039 /* Cool, all is fine. */
1040 select_frame (frame);
1041 return;
1042 }
1043
1044 frame = frame_find_by_id (a_frame_id);
1045 if (frame != NULL)
1046 {
1047 /* Cool, refound it. */
1048 select_frame (frame);
1049 return;
1050 }
1051
1052 /* Nothing else to do, the frame layout really changed. Select the
1053 innermost stack frame. */
1054 select_frame (get_current_frame ());
1055
1056 /* Warn the user. */
a45ae5f8 1057 if (frame_level > 0 && !ui_out_is_mi_like_p (current_uiout))
5796c8dc 1058 {
c50c785c
JM
1059 warning (_("Couldn't restore frame #%d in "
1060 "current thread, at reparsed frame #0\n"),
5796c8dc
SS
1061 frame_level);
1062 /* For MI, we should probably have a notification about
1063 current frame change. But this error is not very
1064 likely, so don't bother for now. */
1065 print_stack_frame (get_selected_frame (NULL), 1, SRC_LINE);
1066 }
1067}
1068
1069struct current_thread_cleanup
1070{
1071 ptid_t inferior_ptid;
1072 struct frame_id selected_frame_id;
1073 int selected_frame_level;
1074 int was_stopped;
cf7f2e2d 1075 int inf_id;
ef5ccd6c 1076 int was_removable;
5796c8dc
SS
1077};
1078
1079static void
1080do_restore_current_thread_cleanup (void *arg)
1081{
1082 struct thread_info *tp;
1083 struct current_thread_cleanup *old = arg;
1084
1085 tp = find_thread_ptid (old->inferior_ptid);
1086
1087 /* If the previously selected thread belonged to a process that has
1088 in the mean time been deleted (due to normal exit, detach, etc.),
1089 then don't revert back to it, but instead simply drop back to no
1090 thread selected. */
1091 if (tp
1092 && find_inferior_pid (ptid_get_pid (tp->ptid)) != NULL)
1093 restore_current_thread (old->inferior_ptid);
1094 else
cf7f2e2d
JM
1095 {
1096 restore_current_thread (null_ptid);
1097 set_current_inferior (find_inferior_id (old->inf_id));
1098 }
5796c8dc
SS
1099
1100 /* The running state of the originally selected thread may have
1101 changed, so we have to recheck it here. */
1102 if (!ptid_equal (inferior_ptid, null_ptid)
1103 && old->was_stopped
1104 && is_stopped (inferior_ptid)
1105 && target_has_registers
1106 && target_has_stack
1107 && target_has_memory)
1108 restore_selected_frame (old->selected_frame_id,
1109 old->selected_frame_level);
1110}
1111
1112static void
1113restore_current_thread_cleanup_dtor (void *arg)
1114{
1115 struct current_thread_cleanup *old = arg;
1116 struct thread_info *tp;
ef5ccd6c 1117 struct inferior *inf;
cf7f2e2d 1118
5796c8dc
SS
1119 tp = find_thread_ptid (old->inferior_ptid);
1120 if (tp)
1121 tp->refcount--;
ef5ccd6c
JM
1122 inf = find_inferior_id (old->inf_id);
1123 if (inf != NULL)
1124 inf->removable = old->was_removable;
5796c8dc
SS
1125 xfree (old);
1126}
1127
1128struct cleanup *
1129make_cleanup_restore_current_thread (void)
1130{
1131 struct thread_info *tp;
1132 struct frame_info *frame;
1133 struct current_thread_cleanup *old;
1134
1135 old = xmalloc (sizeof (struct current_thread_cleanup));
1136 old->inferior_ptid = inferior_ptid;
cf7f2e2d 1137 old->inf_id = current_inferior ()->num;
ef5ccd6c 1138 old->was_removable = current_inferior ()->removable;
5796c8dc
SS
1139
1140 if (!ptid_equal (inferior_ptid, null_ptid))
1141 {
1142 old->was_stopped = is_stopped (inferior_ptid);
1143 if (old->was_stopped
1144 && target_has_registers
1145 && target_has_stack
1146 && target_has_memory)
c50c785c
JM
1147 {
1148 /* When processing internal events, there might not be a
1149 selected frame. If we naively call get_selected_frame
1150 here, then we can end up reading debuginfo for the
1151 current frame, but we don't generally need the debuginfo
1152 at this point. */
1153 frame = get_selected_frame_if_set ();
1154 }
5796c8dc
SS
1155 else
1156 frame = NULL;
1157
1158 old->selected_frame_id = get_frame_id (frame);
1159 old->selected_frame_level = frame_relative_level (frame);
1160
1161 tp = find_thread_ptid (inferior_ptid);
1162 if (tp)
1163 tp->refcount++;
1164 }
1165
ef5ccd6c
JM
1166 current_inferior ()->removable = 0;
1167
5796c8dc
SS
1168 return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
1169 restore_current_thread_cleanup_dtor);
1170}
1171
1172/* Apply a GDB command to a list of threads. List syntax is a whitespace
1173 seperated list of numbers, or ranges, or the keyword `all'. Ranges consist
1174 of two numbers seperated by a hyphen. Examples:
1175
1176 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4
1177 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9
c50c785c 1178 thread apply all p x/i $pc Apply x/i $pc cmd to all threads. */
5796c8dc
SS
1179
1180static void
1181thread_apply_all_command (char *cmd, int from_tty)
1182{
1183 struct thread_info *tp;
1184 struct cleanup *old_chain;
1185 char *saved_cmd;
1186
1187 if (cmd == NULL || *cmd == '\000')
1188 error (_("Please specify a command following the thread ID list"));
1189
cf7f2e2d 1190 update_thread_list ();
5796c8dc
SS
1191
1192 old_chain = make_cleanup_restore_current_thread ();
1193
1194 /* Save a copy of the command in case it is clobbered by
c50c785c 1195 execute_command. */
5796c8dc
SS
1196 saved_cmd = xstrdup (cmd);
1197 make_cleanup (xfree, saved_cmd);
1198 for (tp = thread_list; tp; tp = tp->next)
1199 if (thread_alive (tp))
1200 {
1201 switch_to_thread (tp->ptid);
1202
1203 printf_filtered (_("\nThread %d (%s):\n"),
1204 tp->num, target_pid_to_str (inferior_ptid));
1205 execute_command (cmd, from_tty);
c50c785c
JM
1206 strcpy (cmd, saved_cmd); /* Restore exact command used
1207 previously. */
5796c8dc
SS
1208 }
1209
1210 do_cleanups (old_chain);
1211}
1212
1213static void
1214thread_apply_command (char *tidlist, int from_tty)
1215{
1216 char *cmd;
5796c8dc
SS
1217 struct cleanup *old_chain;
1218 char *saved_cmd;
c50c785c 1219 struct get_number_or_range_state state;
5796c8dc
SS
1220
1221 if (tidlist == NULL || *tidlist == '\000')
1222 error (_("Please specify a thread ID list"));
1223
1224 for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
1225
1226 if (*cmd == '\000')
1227 error (_("Please specify a command following the thread ID list"));
1228
1229 /* Save a copy of the command in case it is clobbered by
c50c785c 1230 execute_command. */
5796c8dc
SS
1231 saved_cmd = xstrdup (cmd);
1232 old_chain = make_cleanup (xfree, saved_cmd);
c50c785c
JM
1233
1234 init_number_or_range (&state, tidlist);
1235 while (!state.finished && state.string < cmd)
5796c8dc
SS
1236 {
1237 struct thread_info *tp;
c50c785c 1238 int start;
5796c8dc 1239
c50c785c 1240 start = get_number_or_range (&state);
5796c8dc
SS
1241
1242 make_cleanup_restore_current_thread ();
1243
c50c785c 1244 tp = find_thread_id (start);
5796c8dc 1245
c50c785c
JM
1246 if (!tp)
1247 warning (_("Unknown thread %d."), start);
1248 else if (!thread_alive (tp))
1249 warning (_("Thread %d has terminated."), start);
1250 else
1251 {
1252 switch_to_thread (tp->ptid);
5796c8dc 1253
c50c785c
JM
1254 printf_filtered (_("\nThread %d (%s):\n"), tp->num,
1255 target_pid_to_str (inferior_ptid));
1256 execute_command (cmd, from_tty);
5796c8dc 1257
c50c785c
JM
1258 /* Restore exact command used previously. */
1259 strcpy (cmd, saved_cmd);
5796c8dc
SS
1260 }
1261 }
1262
1263 do_cleanups (old_chain);
1264}
1265
1266/* Switch to the specified thread. Will dispatch off to thread_apply_command
1267 if prefix of arg is `apply'. */
1268
1269static void
1270thread_command (char *tidstr, int from_tty)
1271{
1272 if (!tidstr)
1273 {
1274 if (ptid_equal (inferior_ptid, null_ptid))
1275 error (_("No thread selected"));
1276
1277 if (target_has_stack)
1278 {
1279 if (is_exited (inferior_ptid))
1280 printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
1281 pid_to_thread_id (inferior_ptid),
1282 target_pid_to_str (inferior_ptid));
1283 else
1284 printf_filtered (_("[Current thread is %d (%s)]\n"),
1285 pid_to_thread_id (inferior_ptid),
1286 target_pid_to_str (inferior_ptid));
1287 }
1288 else
1289 error (_("No stack."));
1290 return;
1291 }
1292
a45ae5f8 1293 gdb_thread_select (current_uiout, tidstr, NULL);
5796c8dc
SS
1294}
1295
c50c785c
JM
1296/* Implementation of `thread name'. */
1297
1298static void
1299thread_name_command (char *arg, int from_tty)
1300{
1301 struct thread_info *info;
1302
1303 if (ptid_equal (inferior_ptid, null_ptid))
1304 error (_("No thread selected"));
1305
ef5ccd6c 1306 arg = skip_spaces (arg);
c50c785c
JM
1307
1308 info = inferior_thread ();
1309 xfree (info->name);
1310 info->name = arg ? xstrdup (arg) : NULL;
1311}
1312
1313/* Find thread ids with a name, target pid, or extra info matching ARG. */
1314
1315static void
1316thread_find_command (char *arg, int from_tty)
1317{
1318 struct thread_info *tp;
1319 char *tmp;
1320 unsigned long match = 0;
1321
1322 if (arg == NULL || *arg == '\0')
1323 error (_("Command requires an argument."));
1324
1325 tmp = re_comp (arg);
1326 if (tmp != 0)
1327 error (_("Invalid regexp (%s): %s"), tmp, arg);
1328
1329 update_thread_list ();
1330 for (tp = thread_list; tp; tp = tp->next)
1331 {
1332 if (tp->name != NULL && re_exec (tp->name))
1333 {
1334 printf_filtered (_("Thread %d has name '%s'\n"),
1335 tp->num, tp->name);
1336 match++;
1337 }
1338
1339 tmp = target_thread_name (tp);
1340 if (tmp != NULL && re_exec (tmp))
1341 {
1342 printf_filtered (_("Thread %d has target name '%s'\n"),
1343 tp->num, tmp);
1344 match++;
1345 }
1346
1347 tmp = target_pid_to_str (tp->ptid);
1348 if (tmp != NULL && re_exec (tmp))
1349 {
1350 printf_filtered (_("Thread %d has target id '%s'\n"),
1351 tp->num, tmp);
1352 match++;
1353 }
1354
1355 tmp = target_extra_thread_info (tp);
1356 if (tmp != NULL && re_exec (tmp))
1357 {
1358 printf_filtered (_("Thread %d has extra info '%s'\n"),
1359 tp->num, tmp);
1360 match++;
1361 }
1362 }
1363 if (!match)
1364 printf_filtered (_("No threads match '%s'\n"), arg);
1365}
1366
5796c8dc
SS
1367/* Print notices when new threads are attached and detached. */
1368int print_thread_events = 1;
1369static void
1370show_print_thread_events (struct ui_file *file, int from_tty,
1371 struct cmd_list_element *c, const char *value)
1372{
c50c785c
JM
1373 fprintf_filtered (file,
1374 _("Printing of thread events is %s.\n"),
5796c8dc
SS
1375 value);
1376}
1377
1378static int
1379do_captured_thread_select (struct ui_out *uiout, void *tidstr)
1380{
1381 int num;
1382 struct thread_info *tp;
1383
1384 num = value_as_long (parse_and_eval (tidstr));
1385
1386 tp = find_thread_id (num);
1387
1388 if (!tp)
1389 error (_("Thread ID %d not known."), num);
1390
1391 if (!thread_alive (tp))
1392 error (_("Thread ID %d has terminated."), num);
1393
1394 switch_to_thread (tp->ptid);
1395
1396 annotate_thread_changed ();
1397
1398 ui_out_text (uiout, "[Switching to thread ");
1399 ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
1400 ui_out_text (uiout, " (");
1401 ui_out_text (uiout, target_pid_to_str (inferior_ptid));
1402 ui_out_text (uiout, ")]");
1403
1404 /* Note that we can't reach this with an exited thread, due to the
1405 thread_alive check above. */
a45ae5f8 1406 if (tp->state == THREAD_RUNNING)
5796c8dc
SS
1407 ui_out_text (uiout, "(running)\n");
1408 else
c50c785c
JM
1409 {
1410 ui_out_text (uiout, "\n");
1411 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1412 }
5796c8dc
SS
1413
1414 /* Since the current thread may have changed, see if there is any
1415 exited thread we can now delete. */
1416 prune_threads ();
1417
1418 return GDB_RC_OK;
1419}
1420
1421enum gdb_rc
1422gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
1423{
1424 if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
1425 error_message, RETURN_MASK_ALL) < 0)
1426 return GDB_RC_FAIL;
1427 return GDB_RC_OK;
1428}
1429
cf7f2e2d
JM
1430void
1431update_thread_list (void)
1432{
1433 prune_threads ();
1434 target_find_new_threads ();
1435}
1436
1437/* Return a new value for the selected thread's id. Return a value of 0 if
1438 no thread is selected, or no threads exist. */
1439
1440static struct value *
ef5ccd6c
JM
1441thread_id_make_value (struct gdbarch *gdbarch, struct internalvar *var,
1442 void *ignore)
cf7f2e2d
JM
1443{
1444 struct thread_info *tp = find_thread_ptid (inferior_ptid);
1445
1446 return value_from_longest (builtin_type (gdbarch)->builtin_int,
1447 (tp ? tp->num : 0));
1448}
1449
5796c8dc
SS
1450/* Commands with a prefix of `thread'. */
1451struct cmd_list_element *thread_cmd_list = NULL;
1452
ef5ccd6c
JM
1453/* Implementation of `thread' variable. */
1454
1455static const struct internalvar_funcs thread_funcs =
1456{
1457 thread_id_make_value,
1458 NULL,
1459 NULL
1460};
1461
5796c8dc
SS
1462void
1463_initialize_thread (void)
1464{
1465 static struct cmd_list_element *thread_apply_list = NULL;
1466
c50c785c
JM
1467 add_info ("threads", info_threads_command,
1468 _("Display currently known threads.\n\
1469Usage: info threads [ID]...\n\
1470Optional arguments are thread IDs with spaces between.\n\
1471If no arguments, all threads are displayed."));
5796c8dc
SS
1472
1473 add_prefix_cmd ("thread", class_run, thread_command, _("\
1474Use this command to switch between threads.\n\
1475The new thread ID must be currently known."),
1476 &thread_cmd_list, "thread ", 1, &cmdlist);
1477
1478 add_prefix_cmd ("apply", class_run, thread_apply_command,
1479 _("Apply a command to a list of threads."),
1480 &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
1481
1482 add_cmd ("all", class_run, thread_apply_all_command,
1483 _("Apply a command to all threads."), &thread_apply_list);
1484
c50c785c
JM
1485 add_cmd ("name", class_run, thread_name_command,
1486 _("Set the current thread's name.\n\
1487Usage: thread name [NAME]\n\
1488If NAME is not given, then any existing name is removed."), &thread_cmd_list);
1489
1490 add_cmd ("find", class_run, thread_find_command, _("\
1491Find threads that match a regular expression.\n\
1492Usage: thread find REGEXP\n\
1493Will display thread ids whose name, target ID, or extra info matches REGEXP."),
1494 &thread_cmd_list);
1495
5796c8dc
SS
1496 if (!xdb_commands)
1497 add_com_alias ("t", "thread", class_run, 1);
1498
1499 add_setshow_boolean_cmd ("thread-events", no_class,
1500 &print_thread_events, _("\
1501Set printing of thread events (such as thread start and exit)."), _("\
1502Show printing of thread events (such as thread start and exit)."), NULL,
1503 NULL,
1504 show_print_thread_events,
1505 &setprintlist, &showprintlist);
cf7f2e2d 1506
ef5ccd6c 1507 create_internalvar_type_lazy ("_thread", &thread_funcs, NULL);
5796c8dc 1508}