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