gdb/thread.c

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