gdb/thread.c

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