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 Free Software Foundation, Inc.
   5
   6    Contributed by Lynx Real-Time Systems, Inc.  Los Gatos, CA.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "symtab.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "environ.h"
  28 #include "value.h"
  29 #include "target.h"
  30 #include "gdbthread.h"
  31 #include "exceptions.h"
  32 #include "command.h"
  33 #include "gdbcmd.h"
  34 #include "regcache.h"
  35 #include "gdb.h"
  36 #include "gdb_string.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
  46 /* Definition of struct thread_info exported to gdbthread.h */
  47
  48 /* Prototypes for exported functions. */
  49
  50 void _initialize_thread (void);
  51
  52 /* Prototypes for local functions. */
  53
  54 static struct thread_info *thread_list = NULL;
  55 static int highest_thread_num;
  56
  57 static void thread_command (char *tidstr, int from_tty);
  58 static void thread_apply_all_command (char *, int);
  59 static int thread_alive (struct thread_info *);
  60 static void info_threads_command (char *, int);
  61 static void thread_apply_command (char *, int);
  62 static void restore_current_thread (ptid_t);
  63 static void prune_threads (void);
  64
  65 /* Frontend view of the thread state.  Possible extensions: stepping,
  66    finishing, until(ling),...  */
  67 enum thread_state
  68 {
  69   THREAD_STOPPED,
  70   THREAD_RUNNING,
  71   THREAD_EXITED,
  72 };
  73
  74 static enum thread_state main_thread_state = THREAD_STOPPED;
  75 static int main_thread_executing = 0;
  76
  77 extern struct thread_info*
  78 inferior_thread (void)
  79 {
  80   struct thread_info *tp = find_thread_pid (inferior_ptid);
  81   gdb_assert (tp);
  82   return tp;
  83 }
  84
  85 void
  86 delete_step_resume_breakpoint (struct thread_info *tp)
  87 {
  88   if (tp && tp->step_resume_breakpoint)
  89     {
  90       delete_breakpoint (tp->step_resume_breakpoint);
  91       tp->step_resume_breakpoint = NULL;
  92     }
  93 }
  94
  95 static void
  96 clear_thread_inferior_resources (struct thread_info *tp)
  97 {
  98   /* NOTE: this will take care of any left-over step_resume breakpoints,
  99      but not any user-specified thread-specific breakpoints.  We can not
 100      delete the breakpoint straight-off, because the inferior might not
 101      be stopped at the moment.  */
 102   if (tp->step_resume_breakpoint)
 103     {
 104       tp->step_resume_breakpoint->disposition = disp_del_at_next_stop;
 105       tp->step_resume_breakpoint = NULL;
 106     }
 107
 108   bpstat_clear (&tp->stop_bpstat);
 109 }
 110
 111 static void
 112 free_thread (struct thread_info *tp)
 113 {
 114   clear_thread_inferior_resources (tp);
 115
 116   /* FIXME: do I ever need to call the back-end to give it a
 117      chance at this private data before deleting the thread?  */
 118   if (tp->private)
 119     xfree (tp->private);
 120
 121   xfree (tp);
 122 }
 123
 124 void
 125 init_thread_list (void)
 126 {
 127   struct thread_info *tp, *tpnext;
 128
 129   highest_thread_num = 0;
 130   main_thread_state = THREAD_STOPPED;
 131   main_thread_executing = 0;
 132
 133   if (!thread_list)
 134     return;
 135
 136   for (tp = thread_list; tp; tp = tpnext)
 137     {
 138       tpnext = tp->next;
 139       free_thread (tp);
 140     }
 141
 142   thread_list = NULL;
 143 }
 144
 145 struct thread_info *
 146 add_thread_silent (ptid_t ptid)
 147 {
 148   struct thread_info *tp;
 149
 150   tp = find_thread_pid (ptid);
 151   if (tp)
 152     /* Found an old thread with the same id.  It has to be dead,
 153        otherwise we wouldn't be adding a new thread with the same id.
 154        The OS is reusing this id --- delete it, and recreate a new
 155        one.  */
 156     {
 157       /* In addition to deleting the thread, if this is the current
 158          thread, then we need to also get rid of the current infrun
 159          context, and take care that delete_thread doesn't really
 160          delete the thread if it is inferior_ptid.  Create a new
 161          template thread in the list with an invalid ptid, context
 162          switch to it, delete the original thread, reset the new
 163          thread's ptid, and switch to it.  */
 164
 165       if (ptid_equal (inferior_ptid, ptid))
 166         {
 167           tp = xmalloc (sizeof (*tp));
 168           memset (tp, 0, sizeof (*tp));
 169           tp->ptid = minus_one_ptid;
 170           tp->num = ++highest_thread_num;
 171           tp->next = thread_list;
 172           thread_list = tp;
 173           context_switch_to (minus_one_ptid);
 174
 175           /* Now we can delete it.  */
 176           delete_thread (ptid);
 177
 178           /* Since the context is already set to this new thread,
 179              reset its ptid, and reswitch inferior_ptid to it.  */
 180           tp->ptid = ptid;
 181           switch_to_thread (ptid);
 182
 183           observer_notify_new_thread (tp);
 184
 185           /* All done.  */
 186           return tp;
 187         }
 188       else
 189         /* Just go ahead and delete it.  */
 190         delete_thread (ptid);
 191     }
 192
 193   tp = (struct thread_info *) xmalloc (sizeof (*tp));
 194   memset (tp, 0, sizeof (*tp));
 195   tp->ptid = ptid;
 196   tp->num = ++highest_thread_num;
 197   tp->next = thread_list;
 198   thread_list = tp;
 199
 200   observer_notify_new_thread (tp);
 201
 202   return tp;
 203 }
 204
 205 struct thread_info *
 206 add_thread_with_info (ptid_t ptid, struct private_thread_info *private)
 207 {
 208   struct thread_info *result = add_thread_silent (ptid);
 209
 210   result->private = private;
 211
 212   if (print_thread_events)
 213     printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
 214
 215   annotate_new_thread ();
 216   return result;
 217 }
 218
 219 struct thread_info *
 220 add_thread (ptid_t ptid)
 221 {
 222   return add_thread_with_info (ptid, NULL);
 223 }
 224
 225 /* Delete thread PTID.  If SILENT, don't notify the observer of this
 226    exit.  */
 227 static void
 228 delete_thread_1 (ptid_t ptid, int silent)
 229 {
 230   struct thread_info *tp, *tpprev;
 231
 232   tpprev = NULL;
 233
 234   for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
 235     if (ptid_equal (tp->ptid, ptid))
 236       break;
 237
 238   if (!tp)
 239     return;
 240
 241   /* If this is the current thread, or there's code out there that
 242      relies on it existing (refcount > 0) we can't delete yet.  Mark
 243      it as exited, and notify it.  */
 244   if (tp->refcount > 0
 245       || ptid_equal (tp->ptid, inferior_ptid))
 246     {
 247       if (tp->state_ != THREAD_EXITED)
 248         {
 249           if (!silent)
 250             observer_notify_thread_exit (tp);
 251
 252           /* Tag it as exited.  */
 253           tp->state_ = THREAD_EXITED;
 254
 255           /* Clear breakpoints, etc. associated with this thread.  */
 256           clear_thread_inferior_resources (tp);
 257         }
 258
 259        /* Will be really deleted some other time.  */
 260        return;
 261      }
 262
 263   if (tpprev)
 264     tpprev->next = tp->next;
 265   else
 266     thread_list = tp->next;
 267
 268   /* Notify thread exit, but only if we haven't already.  */
 269   if (!silent && tp->state_ != THREAD_EXITED)
 270     observer_notify_thread_exit (tp);
 271
 272   free_thread (tp);
 273 }
 274
 275 /* Delete thread PTID and notify of thread exit.  If this is
 276    inferior_ptid, don't actually delete it, but tag it as exited and
 277    do the notification.  If PTID is the user selected thread, clear
 278    it.  */
 279 void
 280 delete_thread (ptid_t ptid)
 281 {
 282   delete_thread_1 (ptid, 0 /* not silent */);
 283 }
 284
 285 void
 286 delete_thread_silent (ptid_t ptid)
 287 {
 288   delete_thread_1 (ptid, 1 /* silent */);
 289 }
 290
 291 struct thread_info *
 292 find_thread_id (int num)
 293 {
 294   struct thread_info *tp;
 295
 296   for (tp = thread_list; tp; tp = tp->next)
 297     if (tp->num == num)
 298       return tp;
 299
 300   return NULL;
 301 }
 302
 303 /* Find a thread_info by matching PTID.  */
 304 struct thread_info *
 305 find_thread_pid (ptid_t ptid)
 306 {
 307   struct thread_info *tp;
 308
 309   for (tp = thread_list; tp; tp = tp->next)
 310     if (ptid_equal (tp->ptid, ptid))
 311       return tp;
 312
 313   return NULL;
 314 }
 315
 316 /*
 317  * Thread iterator function.
 318  *
 319  * Calls a callback function once for each thread, so long as
 320  * the callback function returns false.  If the callback function
 321  * returns true, the iteration will end and the current thread
 322  * will be returned.  This can be useful for implementing a
 323  * search for a thread with arbitrary attributes, or for applying
 324  * some operation to every thread.
 325  *
 326  * FIXME: some of the existing functionality, such as
 327  * "Thread apply all", might be rewritten using this functionality.
 328  */
 329
 330 struct thread_info *
 331 iterate_over_threads (int (*callback) (struct thread_info *, void *),
 332                       void *data)
 333 {
 334   struct thread_info *tp, *next;
 335
 336   for (tp = thread_list; tp; tp = next)
 337     {
 338       next = tp->next;
 339       if ((*callback) (tp, data))
 340         return tp;
 341     }
 342
 343   return NULL;
 344 }
 345
 346 int
 347 thread_count (void)
 348 {
 349   int result = 0;
 350   struct thread_info *tp;
 351
 352   for (tp = thread_list; tp; tp = tp->next)
 353     ++result;
 354
 355   return result;
 356 }
 357
 358 int
 359 valid_thread_id (int num)
 360 {
 361   struct thread_info *tp;
 362
 363   for (tp = thread_list; tp; tp = tp->next)
 364     if (tp->num == num)
 365       return 1;
 366
 367   return 0;
 368 }
 369
 370 int
 371 pid_to_thread_id (ptid_t ptid)
 372 {
 373   struct thread_info *tp;
 374
 375   for (tp = thread_list; tp; tp = tp->next)
 376     if (ptid_equal (tp->ptid, ptid))
 377       return tp->num;
 378
 379   return 0;
 380 }
 381
 382 ptid_t
 383 thread_id_to_pid (int num)
 384 {
 385   struct thread_info *thread = find_thread_id (num);
 386   if (thread)
 387     return thread->ptid;
 388   else
 389     return pid_to_ptid (-1);
 390 }
 391
 392 int
 393 in_thread_list (ptid_t ptid)
 394 {
 395   struct thread_info *tp;
 396
 397   for (tp = thread_list; tp; tp = tp->next)
 398     if (ptid_equal (tp->ptid, ptid))
 399       return 1;
 400
 401   return 0;                     /* Never heard of 'im */
 402 }
 403
 404 /* Print a list of thread ids currently known, and the total number of
 405    threads. To be used from within catch_errors. */
 406 static int
 407 do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
 408 {
 409   struct thread_info *tp;
 410   int num = 0;
 411   struct cleanup *cleanup_chain;
 412
 413   prune_threads ();
 414   target_find_new_threads ();
 415
 416   cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids");
 417
 418   for (tp = thread_list; tp; tp = tp->next)
 419     {
 420       if (tp->state_ == THREAD_EXITED)
 421         continue;
 422       num++;
 423       ui_out_field_int (uiout, "thread-id", tp->num);
 424     }
 425
 426   do_cleanups (cleanup_chain);
 427   ui_out_field_int (uiout, "number-of-threads", num);
 428   return GDB_RC_OK;
 429 }
 430
 431 /* Official gdblib interface function to get a list of thread ids and
 432    the total number. */
 433 enum gdb_rc
 434 gdb_list_thread_ids (struct ui_out *uiout, char **error_message)
 435 {
 436   if (catch_exceptions_with_msg (uiout, do_captured_list_thread_ids, NULL,
 437                                  error_message, RETURN_MASK_ALL) < 0)
 438     return GDB_RC_FAIL;
 439   return GDB_RC_OK;
 440 }
 441
 442 /* Load infrun state for the thread PID.  */
 443
 444 void
 445 load_infrun_state (ptid_t ptid,
 446                    struct continuation **continuations,
 447                    struct continuation **intermediate_continuations,
 448                    int *proceed_to_finish,
 449                    enum step_over_calls_kind *step_over_calls,
 450                    int *stop_step,
 451                    int *step_multi,
 452                    enum target_signal *stop_signal,
 453                    bpstat *stop_bpstat)
 454 {
 455   struct thread_info *tp;
 456
 457   /* If we can't find the thread, then we're debugging a single threaded
 458      process.  No need to do anything in that case.  */
 459   tp = find_thread_id (pid_to_thread_id (ptid));
 460   if (tp == NULL)
 461     return;
 462
 463   /* In all-stop mode, these are global state, while in non-stop mode,
 464      they are per thread.  */
 465   if (non_stop)
 466     {
 467       *continuations = tp->continuations;
 468       tp->continuations = NULL;
 469       *intermediate_continuations = tp->intermediate_continuations;
 470       tp->intermediate_continuations = NULL;
 471       *proceed_to_finish = tp->proceed_to_finish;
 472       *step_over_calls = tp->step_over_calls;
 473       *stop_step = tp->stop_step;
 474       *step_multi = tp->step_multi;
 475       *stop_signal = tp->stop_signal;
 476
 477       /* Swap instead of copy, so we only have to update one of
 478          them.  */
 479       *stop_bpstat = tp->stop_bpstat;
 480       tp->stop_bpstat = 0;
 481     }
 482 }
 483
 484 /* Save infrun state for the thread PID.  */
 485
 486 void
 487 save_infrun_state (ptid_t ptid,
 488                    struct continuation *continuations,
 489                    struct continuation *intermediate_continuations,
 490                    int proceed_to_finish,
 491                    enum step_over_calls_kind step_over_calls,
 492                    int stop_step,
 493                    int step_multi,
 494                    enum target_signal stop_signal,
 495                    bpstat stop_bpstat)
 496 {
 497   struct thread_info *tp;
 498
 499   /* If we can't find the thread, then we're debugging a single-threaded
 500      process.  Nothing to do in that case.  */
 501   tp = find_thread_id (pid_to_thread_id (ptid));
 502   if (tp == NULL)
 503     return;
 504
 505   /* In all-stop mode, these are global state, while in non-stop mode,
 506      they are per thread.  */
 507   if (non_stop)
 508     {
 509       tp->continuations = continuations;
 510       tp->intermediate_continuations = intermediate_continuations;
 511       tp->proceed_to_finish = proceed_to_finish;
 512       tp->step_over_calls = step_over_calls;
 513       tp->stop_step = stop_step;
 514       tp->step_multi = step_multi;
 515       tp->stop_signal = stop_signal;
 516       tp->stop_bpstat = stop_bpstat;
 517     }
 518 }
 519
 520 /* Return true if TP is an active thread. */
 521 static int
 522 thread_alive (struct thread_info *tp)
 523 {
 524   if (tp->state_ == THREAD_EXITED)
 525     return 0;
 526   if (!target_thread_alive (tp->ptid))
 527     return 0;
 528   return 1;
 529 }
 530
 531 static void
 532 prune_threads (void)
 533 {
 534   struct thread_info *tp, *next;
 535
 536   for (tp = thread_list; tp; tp = next)
 537     {
 538       next = tp->next;
 539       if (!thread_alive (tp))
 540         delete_thread (tp->ptid);
 541     }
 542 }
 543
 544 void
 545 thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
 546 {
 547   struct thread_info * tp = find_thread_pid (old_ptid);
 548   tp->ptid = new_ptid;
 549
 550   observer_notify_thread_ptid_changed (old_ptid, new_ptid);
 551 }
 552
 553 void
 554 set_running (ptid_t ptid, int running)
 555 {
 556   struct thread_info *tp;
 557
 558   if (!thread_list)
 559     {
 560       /* This is one of the targets that does not add main
 561          thread to the thread list.  Just use a single
 562          global flag to indicate that a thread is running.
 563
 564          This problem is unique to ST programs.  For MT programs,
 565          the main thread is always present in the thread list.  If it's
 566          not, the first call to context_switch will mess up GDB internal
 567          state.  */
 568       if (running
 569           && main_thread_state != THREAD_RUNNING
 570           && !suppress_resume_observer)
 571         observer_notify_target_resumed (ptid);
 572       main_thread_state = running ? THREAD_RUNNING : THREAD_STOPPED;
 573       return;
 574     }
 575
 576   /* We try not to notify the observer if no thread has actually changed
 577      the running state -- merely to reduce the number of messages to
 578      frontend.  Frontend is supposed to handle multiple *running just fine.  */
 579   if (PIDGET (ptid) == -1)
 580     {
 581       int any_started = 0;
 582       for (tp = thread_list; tp; tp = tp->next)
 583         {
 584           if (tp->state_ == THREAD_EXITED)
 585             continue;
 586           if (running && tp->state_ == THREAD_STOPPED)
 587             any_started = 1;
 588           tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 589         }
 590       if (any_started && !suppress_resume_observer)
 591         observer_notify_target_resumed (ptid);
 592     }
 593   else
 594     {
 595       int started = 0;
 596       tp = find_thread_pid (ptid);
 597       gdb_assert (tp);
 598       gdb_assert (tp->state_ != THREAD_EXITED);
 599       if (running && tp->state_ == THREAD_STOPPED)
 600         started = 1;
 601       tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 602       if (started && !suppress_resume_observer)
 603         observer_notify_target_resumed (ptid);
 604     }
 605 }
 606
 607 static int
 608 is_thread_state (ptid_t ptid, enum thread_state state)
 609 {
 610   struct thread_info *tp;
 611
 612   if (!target_has_execution)
 613     return 0;
 614
 615   if (!thread_list)
 616     return main_thread_state == state;
 617
 618   tp = find_thread_pid (ptid);
 619   gdb_assert (tp);
 620   return tp->state_ == state;
 621 }
 622
 623 int
 624 is_stopped (ptid_t ptid)
 625 {
 626   /* Without execution, this property is always true.  */
 627   if (!target_has_execution)
 628     return 1;
 629
 630   return is_thread_state (ptid, THREAD_STOPPED);
 631 }
 632
 633 int
 634 is_exited (ptid_t ptid)
 635 {
 636   /* Without execution, this property is always false.  */
 637   if (!target_has_execution)
 638     return 0;
 639
 640   return is_thread_state (ptid, THREAD_EXITED);
 641 }
 642
 643 int
 644 is_running (ptid_t ptid)
 645 {
 646    /* Without execution, this property is always false.  */
 647   if (!target_has_execution)
 648     return 0;
 649
 650   return is_thread_state (ptid, THREAD_RUNNING);
 651 }
 652
 653 int
 654 any_running (void)
 655 {
 656   struct thread_info *tp;
 657
 658   if (!target_has_execution)
 659     return 0;
 660
 661   if (!thread_list)
 662     return main_thread_state == THREAD_RUNNING;
 663
 664   for (tp = thread_list; tp; tp = tp->next)
 665     if (tp->state_ == THREAD_RUNNING)
 666       return 1;
 667
 668   return 0;
 669 }
 670
 671 int
 672 is_executing (ptid_t ptid)
 673 {
 674   struct thread_info *tp;
 675
 676   if (!target_has_execution)
 677     return 0;
 678
 679   if (!thread_list)
 680     return main_thread_executing;
 681
 682   tp = find_thread_pid (ptid);
 683   gdb_assert (tp);
 684   return tp->executing_;
 685 }
 686
 687 void
 688 set_executing (ptid_t ptid, int executing)
 689 {
 690   struct thread_info *tp;
 691
 692   if (!thread_list)
 693     {
 694       /* This target does not add the main thread to the thread list.
 695          Use a global flag to indicate that the thread is
 696          executing.  */
 697       main_thread_executing = executing;
 698       return;
 699     }
 700
 701   if (PIDGET (ptid) == -1)
 702     {
 703       for (tp = thread_list; tp; tp = tp->next)
 704         tp->executing_ = executing;
 705     }
 706   else
 707     {
 708       tp = find_thread_pid (ptid);
 709       gdb_assert (tp);
 710       tp->executing_ = executing;
 711     }
 712 }
 713
 714 /* Prints the list of threads and their details on UIOUT.
 715    This is a version of 'info_thread_command' suitable for
 716    use from MI.
 717    If REQUESTED_THREAD is not -1, it's the GDB id of the thread
 718    that should be printed.  Otherwise, all threads are
 719    printed.  */
 720 void
 721 print_thread_info (struct ui_out *uiout, int requested_thread)
 722 {
 723   struct thread_info *tp;
 724   ptid_t current_ptid;
 725   struct cleanup *old_chain;
 726   char *extra_info;
 727   int current_thread = -1;
 728
 729   prune_threads ();
 730   target_find_new_threads ();
 731   current_ptid = inferior_ptid;
 732
 733   /* We'll be switching threads temporarily.  */
 734   old_chain = make_cleanup_restore_current_thread ();
 735
 736   make_cleanup_ui_out_list_begin_end (uiout, "threads");
 737   for (tp = thread_list; tp; tp = tp->next)
 738     {
 739       struct cleanup *chain2;
 740
 741       if (requested_thread != -1 && tp->num != requested_thread)
 742         continue;
 743
 744       if (ptid_equal (tp->ptid, current_ptid))
 745         current_thread = tp->num;
 746
 747       if (tp->state_ == THREAD_EXITED)
 748         continue;
 749
 750       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 751
 752       if (ptid_equal (tp->ptid, current_ptid))
 753         ui_out_text (uiout, "* ");
 754       else
 755         ui_out_text (uiout, "  ");
 756
 757       ui_out_field_int (uiout, "id", tp->num);
 758       ui_out_text (uiout, " ");
 759       ui_out_field_string (uiout, "target-id", target_tid_to_str (tp->ptid));
 760
 761       if (tp->state_ != THREAD_EXITED)
 762         {
 763           extra_info = target_extra_thread_info (tp);
 764           if (extra_info)
 765             {
 766               ui_out_text (uiout, " (");
 767               ui_out_field_string (uiout, "details", extra_info);
 768               ui_out_text (uiout, ")");
 769             }
 770           ui_out_text (uiout, "  ");
 771         }
 772
 773       if (tp->state_ == THREAD_RUNNING)
 774         ui_out_text (uiout, "(running)\n");
 775       else
 776         {
 777           /* The switch below puts us at the top of the stack (leaf
 778              frame).  */
 779           switch_to_thread (tp->ptid);
 780           print_stack_frame (get_selected_frame (NULL),
 781                              /* For MI output, print frame level.  */
 782                              ui_out_is_mi_like_p (uiout),
 783                              LOCATION);
 784         }
 785
 786       if (ui_out_is_mi_like_p (uiout))
 787         {
 788           char *state = "stopped";
 789           if (tp->state_ == THREAD_EXITED)
 790             state = "exited";
 791           else if (tp->state_ == THREAD_RUNNING)
 792             state = "running";
 793           ui_out_field_string (uiout, "state", state);
 794         }
 795
 796       do_cleanups (chain2);
 797     }
 798
 799   /* Restores the current thread and the frame selected before
 800      the "info threads" command.  */
 801   do_cleanups (old_chain);
 802
 803   if (requested_thread == -1)
 804     {
 805       gdb_assert (current_thread != -1
 806                   || !thread_list);
 807       if (current_thread != -1 && ui_out_is_mi_like_p (uiout))
 808         ui_out_field_int (uiout, "current-thread-id", current_thread);
 809
 810       if (current_thread != -1 && is_exited (current_ptid))
 811         ui_out_message (uiout, 0, "\n\
 812 The current thread <Thread ID %d> has terminated.  See `help thread'.\n",
 813                         current_thread);
 814     }
 815 }
 816
 817
 818 /* Print information about currently known threads
 819
 820  * Note: this has the drawback that it _really_ switches
 821  *       threads, which frees the frame cache.  A no-side
 822  *       effects info-threads command would be nicer.
 823  */
 824
 825 static void
 826 info_threads_command (char *arg, int from_tty)
 827 {
 828   print_thread_info (uiout, -1);
 829 }
 830
 831 /* Switch from one thread to another. */
 832
 833 void
 834 switch_to_thread (ptid_t ptid)
 835 {
 836   if (ptid_equal (ptid, inferior_ptid))
 837     return;
 838
 839   inferior_ptid = ptid;
 840   reinit_frame_cache ();
 841   registers_changed ();
 842
 843   /* We don't check for is_stopped, because we're called at times
 844      while in the TARGET_RUNNING state, e.g., while handling an
 845      internal event.  */
 846   if (!is_exited (ptid) && !is_executing (ptid))
 847     stop_pc = read_pc ();
 848   else
 849     stop_pc = ~(CORE_ADDR) 0;
 850 }
 851
 852 static void
 853 restore_current_thread (ptid_t ptid)
 854 {
 855   if (!ptid_equal (ptid, inferior_ptid))
 856     {
 857       if (non_stop)
 858         context_switch_to (ptid);
 859       else
 860         switch_to_thread (ptid);
 861     }
 862 }
 863
 864 static void
 865 restore_selected_frame (struct frame_id a_frame_id, int frame_level)
 866 {
 867   struct frame_info *frame = NULL;
 868   int count;
 869
 870   gdb_assert (frame_level >= 0);
 871
 872   /* Restore by level first, check if the frame id is the same as
 873      expected.  If that fails, try restoring by frame id.  If that
 874      fails, nothing to do, just warn the user.  */
 875
 876   count = frame_level;
 877   frame = find_relative_frame (get_current_frame (), &count);
 878   if (count == 0
 879       && frame != NULL
 880       /* Either the frame ids match, of they're both invalid.  The
 881          latter case is not failsafe, but since it's highly unlikely
 882          the search by level finds the wrong frame, it's 99.9(9)% of
 883          the time (for all practical purposes) safe.  */
 884       && (frame_id_eq (get_frame_id (frame), a_frame_id)
 885           /* Note: could be better to check every frame_id
 886              member for equality here.  */
 887           || (!frame_id_p (get_frame_id (frame))
 888               && !frame_id_p (a_frame_id))))
 889     {
 890       /* Cool, all is fine.  */
 891       select_frame (frame);
 892       return;
 893     }
 894
 895   frame = frame_find_by_id (a_frame_id);
 896   if (frame != NULL)
 897     {
 898       /* Cool, refound it.  */
 899       select_frame (frame);
 900       return;
 901     }
 902
 903   /* Nothing else to do, the frame layout really changed.  Select the
 904      innermost stack frame.  */
 905   select_frame (get_current_frame ());
 906
 907   /* Warn the user.  */
 908   if (!ui_out_is_mi_like_p (uiout))
 909     {
 910       warning (_("\
 911 Couldn't restore frame #%d in current thread, at reparsed frame #0\n"),
 912                frame_level);
 913       /* For MI, we should probably have a notification about
 914          current frame change.  But this error is not very
 915          likely, so don't bother for now.  */
 916       print_stack_frame (get_selected_frame (NULL), 1, SRC_LINE);
 917     }
 918 }
 919
 920 struct current_thread_cleanup
 921 {
 922   ptid_t inferior_ptid;
 923   struct frame_id selected_frame_id;
 924   int selected_frame_level;
 925   int was_stopped;
 926 };
 927
 928 static void
 929 do_restore_current_thread_cleanup (void *arg)
 930 {
 931   struct thread_info *tp;
 932   struct current_thread_cleanup *old = arg;
 933   restore_current_thread (old->inferior_ptid);
 934
 935   /* The running state of the originally selected thread may have
 936      changed, so we have to recheck it here.  */
 937   if (old->was_stopped
 938       && is_stopped (inferior_ptid)
 939       && target_has_registers
 940       && target_has_stack
 941       && target_has_memory)
 942     restore_selected_frame (old->selected_frame_id,
 943                             old->selected_frame_level);
 944 }
 945
 946 static void
 947 restore_current_thread_cleanup_dtor (void *arg)
 948 {
 949   struct current_thread_cleanup *old = arg;
 950   struct thread_info *tp;
 951   tp = find_thread_pid (old->inferior_ptid);
 952   if (tp)
 953     tp->refcount--;
 954   xfree (old);
 955 }
 956
 957 struct cleanup *
 958 make_cleanup_restore_current_thread (void)
 959 {
 960   struct thread_info *tp;
 961   struct frame_info *frame;
 962   struct current_thread_cleanup *old;
 963
 964   old = xmalloc (sizeof (struct current_thread_cleanup));
 965   old->inferior_ptid = inferior_ptid;
 966   old->was_stopped = is_stopped (inferior_ptid);
 967   if (old->was_stopped
 968       && target_has_registers
 969       && target_has_stack
 970       && target_has_memory)
 971     frame = get_selected_frame (NULL);
 972   else
 973     frame = NULL;
 974
 975   old->selected_frame_id = get_frame_id (frame);
 976   old->selected_frame_level = frame_relative_level (frame);
 977
 978   tp = find_thread_pid (inferior_ptid);
 979   if (tp)
 980     tp->refcount++;
 981
 982   return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
 983                             restore_current_thread_cleanup_dtor);
 984 }
 985
 986 /* Apply a GDB command to a list of threads.  List syntax is a whitespace
 987    seperated list of numbers, or ranges, or the keyword `all'.  Ranges consist
 988    of two numbers seperated by a hyphen.  Examples:
 989
 990    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
 991    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
 992    thread apply all p x/i $pc   Apply x/i $pc cmd to all threads
 993  */
 994
 995 static void
 996 thread_apply_all_command (char *cmd, int from_tty)
 997 {
 998   struct thread_info *tp;
 999   struct cleanup *old_chain;
1000   char *saved_cmd;
1001
1002   if (cmd == NULL || *cmd == '\000')
1003     error (_("Please specify a command following the thread ID list"));
1004
1005   prune_threads ();
1006   target_find_new_threads ();
1007
1008   old_chain = make_cleanup_restore_current_thread ();
1009
1010   /* Save a copy of the command in case it is clobbered by
1011      execute_command */
1012   saved_cmd = xstrdup (cmd);
1013   make_cleanup (xfree, saved_cmd);
1014   for (tp = thread_list; tp; tp = tp->next)
1015     if (thread_alive (tp))
1016       {
1017         if (non_stop)
1018           context_switch_to (tp->ptid);
1019         else
1020           switch_to_thread (tp->ptid);
1021
1022         printf_filtered (_("\nThread %d (%s):\n"),
1023                          tp->num, target_tid_to_str (inferior_ptid));
1024         execute_command (cmd, from_tty);
1025         strcpy (cmd, saved_cmd);        /* Restore exact command used previously */
1026       }
1027
1028   do_cleanups (old_chain);
1029 }
1030
1031 static void
1032 thread_apply_command (char *tidlist, int from_tty)
1033 {
1034   char *cmd;
1035   char *p;
1036   struct cleanup *old_chain;
1037   char *saved_cmd;
1038
1039   if (tidlist == NULL || *tidlist == '\000')
1040     error (_("Please specify a thread ID list"));
1041
1042   for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
1043
1044   if (*cmd == '\000')
1045     error (_("Please specify a command following the thread ID list"));
1046
1047   /* Save a copy of the command in case it is clobbered by
1048      execute_command */
1049   saved_cmd = xstrdup (cmd);
1050   old_chain = make_cleanup (xfree, saved_cmd);
1051   while (tidlist < cmd)
1052     {
1053       struct thread_info *tp;
1054       int start, end;
1055
1056       start = strtol (tidlist, &p, 10);
1057       if (p == tidlist)
1058         error (_("Error parsing %s"), tidlist);
1059       tidlist = p;
1060
1061       while (*tidlist == ' ' || *tidlist == '\t')
1062         tidlist++;
1063
1064       if (*tidlist == '-')      /* Got a range of IDs? */
1065         {
1066           tidlist++;            /* Skip the - */
1067           end = strtol (tidlist, &p, 10);
1068           if (p == tidlist)
1069             error (_("Error parsing %s"), tidlist);
1070           tidlist = p;
1071
1072           while (*tidlist == ' ' || *tidlist == '\t')
1073             tidlist++;
1074         }
1075       else
1076         end = start;
1077
1078       make_cleanup_restore_current_thread ();
1079
1080       for (; start <= end; start++)
1081         {
1082           tp = find_thread_id (start);
1083
1084           if (!tp)
1085             warning (_("Unknown thread %d."), start);
1086           else if (!thread_alive (tp))
1087             warning (_("Thread %d has terminated."), start);
1088           else
1089             {
1090               if (non_stop)
1091                 context_switch_to (tp->ptid);
1092               else
1093                 switch_to_thread (tp->ptid);
1094
1095               printf_filtered (_("\nThread %d (%s):\n"), tp->num,
1096                                target_tid_to_str (inferior_ptid));
1097               execute_command (cmd, from_tty);
1098
1099               /* Restore exact command used previously.  */
1100               strcpy (cmd, saved_cmd);
1101             }
1102         }
1103     }
1104
1105   do_cleanups (old_chain);
1106 }
1107
1108 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
1109    if prefix of arg is `apply'.  */
1110
1111 static void
1112 thread_command (char *tidstr, int from_tty)
1113 {
1114   if (!tidstr)
1115     {
1116       if (target_has_stack)
1117         {
1118           if (is_exited (inferior_ptid))
1119             printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
1120                              pid_to_thread_id (inferior_ptid),
1121                              target_tid_to_str (inferior_ptid));
1122           else
1123             printf_filtered (_("[Current thread is %d (%s)]\n"),
1124                              pid_to_thread_id (inferior_ptid),
1125                              target_tid_to_str (inferior_ptid));
1126         }
1127       else
1128         error (_("No stack."));
1129       return;
1130     }
1131
1132   annotate_thread_changed ();
1133   gdb_thread_select (uiout, tidstr, NULL);
1134 }
1135
1136 /* Print notices when new threads are attached and detached.  */
1137 int print_thread_events = 1;
1138 static void
1139 show_print_thread_events (struct ui_file *file, int from_tty,
1140                           struct cmd_list_element *c, const char *value)
1141 {
1142   fprintf_filtered (file, _("\
1143 Printing of thread events is %s.\n"),
1144                     value);
1145 }
1146
1147 static int
1148 do_captured_thread_select (struct ui_out *uiout, void *tidstr)
1149 {
1150   int num;
1151   struct thread_info *tp;
1152
1153   num = value_as_long (parse_and_eval (tidstr));
1154
1155   tp = find_thread_id (num);
1156
1157   if (!tp)
1158     error (_("Thread ID %d not known."), num);
1159
1160   if (!thread_alive (tp))
1161     error (_("Thread ID %d has terminated."), num);
1162
1163   if (non_stop)
1164     context_switch_to (tp->ptid);
1165   else
1166     switch_to_thread (tp->ptid);
1167
1168   ui_out_text (uiout, "[Switching to thread ");
1169   ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
1170   ui_out_text (uiout, " (");
1171   ui_out_text (uiout, target_tid_to_str (inferior_ptid));
1172   ui_out_text (uiout, ")]");
1173
1174   /* Note that we can't reach this with an exited thread, due to the
1175      thread_alive check above.  */
1176   if (tp->state_ == THREAD_RUNNING)
1177     ui_out_text (uiout, "(running)\n");
1178   else
1179     print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1180
1181   /* Since the current thread may have changed, see if there is any
1182      exited thread we can now delete.  */
1183   prune_threads ();
1184
1185   return GDB_RC_OK;
1186 }
1187
1188 enum gdb_rc
1189 gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
1190 {
1191   if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
1192                                  error_message, RETURN_MASK_ALL) < 0)
1193     return GDB_RC_FAIL;
1194   return GDB_RC_OK;
1195 }
1196
1197 /* Commands with a prefix of `thread'.  */
1198 struct cmd_list_element *thread_cmd_list = NULL;
1199
1200 void
1201 _initialize_thread (void)
1202 {
1203   static struct cmd_list_element *thread_apply_list = NULL;
1204   struct cmd_list_element *c;
1205
1206   c = add_info ("threads", info_threads_command,
1207                 _("IDs of currently known threads."));
1208   set_cmd_no_selected_thread_ok (c);
1209
1210   c = add_prefix_cmd ("thread", class_run, thread_command, _("\
1211 Use this command to switch between threads.\n\
1212 The new thread ID must be currently known."),
1213                       &thread_cmd_list, "thread ", 1, &cmdlist);
1214   set_cmd_no_selected_thread_ok (c);
1215
1216   c = add_prefix_cmd ("apply", class_run, thread_apply_command,
1217                       _("Apply a command to a list of threads."),
1218                       &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
1219   set_cmd_no_selected_thread_ok (c);
1220
1221   c = add_cmd ("all", class_run, thread_apply_all_command,
1222                _("Apply a command to all threads."), &thread_apply_list);
1223   set_cmd_no_selected_thread_ok (c);
1224
1225   if (!xdb_commands)
1226     add_com_alias ("t", "thread", class_run, 1);
1227
1228   add_setshow_boolean_cmd ("thread-events", no_class,
1229          &print_thread_events, _("\
1230 Set printing of thread events (such as thread start and exit)."), _("\
1231 Show printing of thread events (such as thread start and exit)."), NULL,
1232          NULL,
1233          show_print_thread_events,
1234          &setprintlist, &showprintlist);
1235 }