gdb/thread.c

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