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