gdb/thread.c

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