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