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