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 *stop_step,
 449                    int *step_multi,
 450                    enum target_signal *stop_signal)
 451 {
 452   struct thread_info *tp;
 453
 454   /* If we can't find the thread, then we're debugging a single threaded
 455      process.  No need to do anything in that case.  */
 456   tp = find_thread_id (pid_to_thread_id (ptid));
 457   if (tp == NULL)
 458     return;
 459
 460   /* In all-stop mode, these are global state, while in non-stop mode,
 461      they are per thread.  */
 462   if (non_stop)
 463     {
 464       *continuations = tp->continuations;
 465       tp->continuations = NULL;
 466       *intermediate_continuations = tp->intermediate_continuations;
 467       tp->intermediate_continuations = NULL;
 468       *stop_step = tp->stop_step;
 469       *step_multi = tp->step_multi;
 470       *stop_signal = tp->stop_signal;
 471     }
 472 }
 473
 474 /* Save infrun state for the thread PID.  */
 475
 476 void
 477 save_infrun_state (ptid_t ptid,
 478                    struct continuation *continuations,
 479                    struct continuation *intermediate_continuations,
 480                    int stop_step,
 481                    int step_multi,
 482                    enum target_signal stop_signal)
 483 {
 484   struct thread_info *tp;
 485
 486   /* If we can't find the thread, then we're debugging a single-threaded
 487      process.  Nothing to do in that case.  */
 488   tp = find_thread_id (pid_to_thread_id (ptid));
 489   if (tp == NULL)
 490     return;
 491
 492   /* In all-stop mode, these are global state, while in non-stop mode,
 493      they are per thread.  */
 494   if (non_stop)
 495     {
 496       tp->continuations = continuations;
 497       tp->intermediate_continuations = intermediate_continuations;
 498       tp->stop_step = stop_step;
 499       tp->step_multi = step_multi;
 500       tp->stop_signal = stop_signal;
 501     }
 502 }
 503
 504 /* Return true if TP is an active thread. */
 505 static int
 506 thread_alive (struct thread_info *tp)
 507 {
 508   if (tp->state_ == THREAD_EXITED)
 509     return 0;
 510   if (!target_thread_alive (tp->ptid))
 511     return 0;
 512   return 1;
 513 }
 514
 515 static void
 516 prune_threads (void)
 517 {
 518   struct thread_info *tp, *next;
 519
 520   for (tp = thread_list; tp; tp = next)
 521     {
 522       next = tp->next;
 523       if (!thread_alive (tp))
 524         delete_thread (tp->ptid);
 525     }
 526 }
 527
 528 void
 529 thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
 530 {
 531   struct thread_info * tp = find_thread_pid (old_ptid);
 532   tp->ptid = new_ptid;
 533
 534   observer_notify_thread_ptid_changed (old_ptid, new_ptid);
 535 }
 536
 537 void
 538 set_running (ptid_t ptid, int running)
 539 {
 540   struct thread_info *tp;
 541
 542   if (!thread_list)
 543     {
 544       /* This is one of the targets that does not add main
 545          thread to the thread list.  Just use a single
 546          global flag to indicate that a thread is running.
 547
 548          This problem is unique to ST programs.  For MT programs,
 549          the main thread is always present in the thread list.  If it's
 550          not, the first call to context_switch will mess up GDB internal
 551          state.  */
 552       if (running
 553           && main_thread_state != THREAD_RUNNING
 554           && !suppress_resume_observer)
 555         observer_notify_target_resumed (ptid);
 556       main_thread_state = running ? THREAD_RUNNING : THREAD_STOPPED;
 557       return;
 558     }
 559
 560   /* We try not to notify the observer if no thread has actually changed
 561      the running state -- merely to reduce the number of messages to
 562      frontend.  Frontend is supposed to handle multiple *running just fine.  */
 563   if (PIDGET (ptid) == -1)
 564     {
 565       int any_started = 0;
 566       for (tp = thread_list; tp; tp = tp->next)
 567         {
 568           if (tp->state_ == THREAD_EXITED)
 569             continue;
 570           if (running && tp->state_ == THREAD_STOPPED)
 571             any_started = 1;
 572           tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 573         }
 574       if (any_started && !suppress_resume_observer)
 575         observer_notify_target_resumed (ptid);
 576     }
 577   else
 578     {
 579       int started = 0;
 580       tp = find_thread_pid (ptid);
 581       gdb_assert (tp);
 582       gdb_assert (tp->state_ != THREAD_EXITED);
 583       if (running && tp->state_ == THREAD_STOPPED)
 584         started = 1;
 585       tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 586       if (started && !suppress_resume_observer)
 587         observer_notify_target_resumed (ptid);
 588     }
 589 }
 590
 591 static int
 592 is_thread_state (ptid_t ptid, enum thread_state state)
 593 {
 594   struct thread_info *tp;
 595
 596   if (!target_has_execution)
 597     return 0;
 598
 599   if (!thread_list)
 600     return main_thread_state == state;
 601
 602   tp = find_thread_pid (ptid);
 603   gdb_assert (tp);
 604   return tp->state_ == state;
 605 }
 606
 607 int
 608 is_stopped (ptid_t ptid)
 609 {
 610   /* Without execution, this property is always true.  */
 611   if (!target_has_execution)
 612     return 1;
 613
 614   return is_thread_state (ptid, THREAD_STOPPED);
 615 }
 616
 617 int
 618 is_exited (ptid_t ptid)
 619 {
 620   /* Without execution, this property is always false.  */
 621   if (!target_has_execution)
 622     return 0;
 623
 624   return is_thread_state (ptid, THREAD_EXITED);
 625 }
 626
 627 int
 628 is_running (ptid_t ptid)
 629 {
 630    /* Without execution, this property is always false.  */
 631   if (!target_has_execution)
 632     return 0;
 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   if (!target_has_execution)
 643     return 0;
 644
 645   if (!thread_list)
 646     return main_thread_state == THREAD_RUNNING;
 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   if (!target_has_execution)
 661     return 0;
 662
 663   if (!thread_list)
 664     return main_thread_executing;
 665
 666   tp = find_thread_pid (ptid);
 667   gdb_assert (tp);
 668   return tp->executing_;
 669 }
 670
 671 void
 672 set_executing (ptid_t ptid, int executing)
 673 {
 674   struct thread_info *tp;
 675
 676   if (!thread_list)
 677     {
 678       /* This target does not add the main thread to the thread list.
 679          Use a global flag to indicate that the thread is
 680          executing.  */
 681       main_thread_executing = executing;
 682       return;
 683     }
 684
 685   if (PIDGET (ptid) == -1)
 686     {
 687       for (tp = thread_list; tp; tp = tp->next)
 688         tp->executing_ = executing;
 689     }
 690   else
 691     {
 692       tp = find_thread_pid (ptid);
 693       gdb_assert (tp);
 694       tp->executing_ = executing;
 695     }
 696 }
 697
 698 /* Prints the list of threads and their details on UIOUT.
 699    This is a version of 'info_thread_command' suitable for
 700    use from MI.
 701    If REQUESTED_THREAD is not -1, it's the GDB id of the thread
 702    that should be printed.  Otherwise, all threads are
 703    printed.  */
 704 void
 705 print_thread_info (struct ui_out *uiout, int requested_thread)
 706 {
 707   struct thread_info *tp;
 708   ptid_t current_ptid;
 709   struct cleanup *old_chain;
 710   char *extra_info;
 711   int current_thread = -1;
 712
 713   prune_threads ();
 714   target_find_new_threads ();
 715   current_ptid = inferior_ptid;
 716
 717   /* We'll be switching threads temporarily.  */
 718   old_chain = make_cleanup_restore_current_thread ();
 719
 720   make_cleanup_ui_out_list_begin_end (uiout, "threads");
 721   for (tp = thread_list; tp; tp = tp->next)
 722     {
 723       struct cleanup *chain2;
 724
 725       if (requested_thread != -1 && tp->num != requested_thread)
 726         continue;
 727
 728       if (ptid_equal (tp->ptid, current_ptid))
 729         current_thread = tp->num;
 730
 731       if (tp->state_ == THREAD_EXITED)
 732         continue;
 733
 734       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 735
 736       if (ptid_equal (tp->ptid, current_ptid))
 737         ui_out_text (uiout, "* ");
 738       else
 739         ui_out_text (uiout, "  ");
 740
 741       ui_out_field_int (uiout, "id", tp->num);
 742       ui_out_text (uiout, " ");
 743       ui_out_field_string (uiout, "target-id", target_tid_to_str (tp->ptid));
 744
 745       if (tp->state_ != THREAD_EXITED)
 746         {
 747           extra_info = target_extra_thread_info (tp);
 748           if (extra_info)
 749             {
 750               ui_out_text (uiout, " (");
 751               ui_out_field_string (uiout, "details", extra_info);
 752               ui_out_text (uiout, ")");
 753             }
 754           ui_out_text (uiout, "  ");
 755         }
 756
 757       if (tp->state_ == THREAD_RUNNING)
 758         ui_out_text (uiout, "(running)\n");
 759       else
 760         {
 761           /* The switch below puts us at the top of the stack (leaf
 762              frame).  */
 763           switch_to_thread (tp->ptid);
 764           print_stack_frame (get_selected_frame (NULL),
 765                              /* For MI output, print frame level.  */
 766                              ui_out_is_mi_like_p (uiout),
 767                              LOCATION);
 768         }
 769
 770       if (ui_out_is_mi_like_p (uiout))
 771         {
 772           char *state = "stopped";
 773           if (tp->state_ == THREAD_EXITED)
 774             state = "exited";
 775           else if (tp->state_ == THREAD_RUNNING)
 776             state = "running";
 777           ui_out_field_string (uiout, "state", state);
 778         }
 779
 780       do_cleanups (chain2);
 781     }
 782
 783   /* Restores the current thread and the frame selected before
 784      the "info threads" command.  */
 785   do_cleanups (old_chain);
 786
 787   if (requested_thread == -1)
 788     {
 789       gdb_assert (current_thread != -1
 790                   || !thread_list);
 791       if (current_thread != -1 && ui_out_is_mi_like_p (uiout))
 792         ui_out_field_int (uiout, "current-thread-id", current_thread);
 793
 794       if (current_thread != -1 && is_exited (current_ptid))
 795         ui_out_message (uiout, 0, "\n\
 796 The current thread <Thread ID %d> has terminated.  See `help thread'.\n",
 797                         current_thread);
 798     }
 799 }
 800
 801
 802 /* Print information about currently known threads
 803
 804  * Note: this has the drawback that it _really_ switches
 805  *       threads, which frees the frame cache.  A no-side
 806  *       effects info-threads command would be nicer.
 807  */
 808
 809 static void
 810 info_threads_command (char *arg, int from_tty)
 811 {
 812   print_thread_info (uiout, -1);
 813 }
 814
 815 /* Switch from one thread to another. */
 816
 817 void
 818 switch_to_thread (ptid_t ptid)
 819 {
 820   if (ptid_equal (ptid, inferior_ptid))
 821     return;
 822
 823   inferior_ptid = ptid;
 824   reinit_frame_cache ();
 825   registers_changed ();
 826
 827   /* We don't check for is_stopped, because we're called at times
 828      while in the TARGET_RUNNING state, e.g., while handling an
 829      internal event.  */
 830   if (!is_exited (ptid) && !is_executing (ptid))
 831     stop_pc = read_pc ();
 832   else
 833     stop_pc = ~(CORE_ADDR) 0;
 834 }
 835
 836 static void
 837 restore_current_thread (ptid_t ptid)
 838 {
 839   if (!ptid_equal (ptid, inferior_ptid))
 840     {
 841       if (non_stop)
 842         context_switch_to (ptid);
 843       else
 844         switch_to_thread (ptid);
 845     }
 846 }
 847
 848 static void
 849 restore_selected_frame (struct frame_id a_frame_id, int frame_level)
 850 {
 851   struct frame_info *frame = NULL;
 852   int count;
 853
 854   gdb_assert (frame_level >= 0);
 855
 856   /* Restore by level first, check if the frame id is the same as
 857      expected.  If that fails, try restoring by frame id.  If that
 858      fails, nothing to do, just warn the user.  */
 859
 860   count = frame_level;
 861   frame = find_relative_frame (get_current_frame (), &count);
 862   if (count == 0
 863       && frame != NULL
 864       /* Either the frame ids match, of they're both invalid.  The
 865          latter case is not failsafe, but since it's highly unlikely
 866          the search by level finds the wrong frame, it's 99.9(9)% of
 867          the time (for all practical purposes) safe.  */
 868       && (frame_id_eq (get_frame_id (frame), a_frame_id)
 869           /* Note: could be better to check every frame_id
 870              member for equality here.  */
 871           || (!frame_id_p (get_frame_id (frame))
 872               && !frame_id_p (a_frame_id))))
 873     {
 874       /* Cool, all is fine.  */
 875       select_frame (frame);
 876       return;
 877     }
 878
 879   frame = frame_find_by_id (a_frame_id);
 880   if (frame != NULL)
 881     {
 882       /* Cool, refound it.  */
 883       select_frame (frame);
 884       return;
 885     }
 886
 887   /* Nothing else to do, the frame layout really changed.  Select the
 888      innermost stack frame.  */
 889   select_frame (get_current_frame ());
 890
 891   /* Warn the user.  */
 892   if (!ui_out_is_mi_like_p (uiout))
 893     {
 894       warning (_("\
 895 Couldn't restore frame #%d in current thread, at reparsed frame #0\n"),
 896                frame_level);
 897       /* For MI, we should probably have a notification about
 898          current frame change.  But this error is not very
 899          likely, so don't bother for now.  */
 900       print_stack_frame (get_selected_frame (NULL), 1, SRC_LINE);
 901     }
 902 }
 903
 904 struct current_thread_cleanup
 905 {
 906   ptid_t inferior_ptid;
 907   struct frame_id selected_frame_id;
 908   int selected_frame_level;
 909   int was_stopped;
 910 };
 911
 912 static void
 913 do_restore_current_thread_cleanup (void *arg)
 914 {
 915   struct thread_info *tp;
 916   struct current_thread_cleanup *old = arg;
 917   restore_current_thread (old->inferior_ptid);
 918
 919   /* The running state of the originally selected thread may have
 920      changed, so we have to recheck it here.  */
 921   if (old->was_stopped
 922       && is_stopped (inferior_ptid)
 923       && target_has_registers
 924       && target_has_stack
 925       && target_has_memory)
 926     restore_selected_frame (old->selected_frame_id,
 927                             old->selected_frame_level);
 928 }
 929
 930 static void
 931 restore_current_thread_cleanup_dtor (void *arg)
 932 {
 933   struct current_thread_cleanup *old = arg;
 934   struct thread_info *tp;
 935   tp = find_thread_pid (old->inferior_ptid);
 936   if (tp)
 937     tp->refcount--;
 938   xfree (old);
 939 }
 940
 941 struct cleanup *
 942 make_cleanup_restore_current_thread (void)
 943 {
 944   struct thread_info *tp;
 945   struct frame_info *frame;
 946   struct current_thread_cleanup *old;
 947
 948   old = xmalloc (sizeof (struct current_thread_cleanup));
 949   old->inferior_ptid = inferior_ptid;
 950   old->was_stopped = is_stopped (inferior_ptid);
 951   if (old->was_stopped
 952       && target_has_registers
 953       && target_has_stack
 954       && target_has_memory)
 955     frame = get_selected_frame (NULL);
 956   else
 957     frame = NULL;
 958
 959   old->selected_frame_id = get_frame_id (frame);
 960   old->selected_frame_level = frame_relative_level (frame);
 961
 962   tp = find_thread_pid (inferior_ptid);
 963   if (tp)
 964     tp->refcount++;
 965
 966   return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
 967                             restore_current_thread_cleanup_dtor);
 968 }
 969
 970 /* Apply a GDB command to a list of threads.  List syntax is a whitespace
 971    seperated list of numbers, or ranges, or the keyword `all'.  Ranges consist
 972    of two numbers seperated by a hyphen.  Examples:
 973
 974    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
 975    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
 976    thread apply all p x/i $pc   Apply x/i $pc cmd to all threads
 977  */
 978
 979 static void
 980 thread_apply_all_command (char *cmd, int from_tty)
 981 {
 982   struct thread_info *tp;
 983   struct cleanup *old_chain;
 984   char *saved_cmd;
 985
 986   if (cmd == NULL || *cmd == '\000')
 987     error (_("Please specify a command following the thread ID list"));
 988
 989   prune_threads ();
 990   target_find_new_threads ();
 991
 992   old_chain = make_cleanup_restore_current_thread ();
 993
 994   /* Save a copy of the command in case it is clobbered by
 995      execute_command */
 996   saved_cmd = xstrdup (cmd);
 997   make_cleanup (xfree, saved_cmd);
 998   for (tp = thread_list; tp; tp = tp->next)
 999     if (thread_alive (tp))
1000       {
1001         if (non_stop)
1002           context_switch_to (tp->ptid);
1003         else
1004           switch_to_thread (tp->ptid);
1005
1006         printf_filtered (_("\nThread %d (%s):\n"),
1007                          tp->num, target_tid_to_str (inferior_ptid));
1008         execute_command (cmd, from_tty);
1009         strcpy (cmd, saved_cmd);        /* Restore exact command used previously */
1010       }
1011
1012   do_cleanups (old_chain);
1013 }
1014
1015 static void
1016 thread_apply_command (char *tidlist, int from_tty)
1017 {
1018   char *cmd;
1019   char *p;
1020   struct cleanup *old_chain;
1021   char *saved_cmd;
1022
1023   if (tidlist == NULL || *tidlist == '\000')
1024     error (_("Please specify a thread ID list"));
1025
1026   for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
1027
1028   if (*cmd == '\000')
1029     error (_("Please specify a command following the thread ID list"));
1030
1031   /* Save a copy of the command in case it is clobbered by
1032      execute_command */
1033   saved_cmd = xstrdup (cmd);
1034   old_chain = make_cleanup (xfree, saved_cmd);
1035   while (tidlist < cmd)
1036     {
1037       struct thread_info *tp;
1038       int start, end;
1039
1040       start = strtol (tidlist, &p, 10);
1041       if (p == tidlist)
1042         error (_("Error parsing %s"), tidlist);
1043       tidlist = p;
1044
1045       while (*tidlist == ' ' || *tidlist == '\t')
1046         tidlist++;
1047
1048       if (*tidlist == '-')      /* Got a range of IDs? */
1049         {
1050           tidlist++;            /* Skip the - */
1051           end = strtol (tidlist, &p, 10);
1052           if (p == tidlist)
1053             error (_("Error parsing %s"), tidlist);
1054           tidlist = p;
1055
1056           while (*tidlist == ' ' || *tidlist == '\t')
1057             tidlist++;
1058         }
1059       else
1060         end = start;
1061
1062       make_cleanup_restore_current_thread ();
1063
1064       for (; start <= end; start++)
1065         {
1066           tp = find_thread_id (start);
1067
1068           if (!tp)
1069             warning (_("Unknown thread %d."), start);
1070           else if (!thread_alive (tp))
1071             warning (_("Thread %d has terminated."), start);
1072           else
1073             {
1074               if (non_stop)
1075                 context_switch_to (tp->ptid);
1076               else
1077                 switch_to_thread (tp->ptid);
1078
1079               printf_filtered (_("\nThread %d (%s):\n"), tp->num,
1080                                target_tid_to_str (inferior_ptid));
1081               execute_command (cmd, from_tty);
1082
1083               /* Restore exact command used previously.  */
1084               strcpy (cmd, saved_cmd);
1085             }
1086         }
1087     }
1088
1089   do_cleanups (old_chain);
1090 }
1091
1092 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
1093    if prefix of arg is `apply'.  */
1094
1095 static void
1096 thread_command (char *tidstr, int from_tty)
1097 {
1098   if (!tidstr)
1099     {
1100       if (target_has_stack)
1101         {
1102           if (is_exited (inferior_ptid))
1103             printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
1104                              pid_to_thread_id (inferior_ptid),
1105                              target_tid_to_str (inferior_ptid));
1106           else
1107             printf_filtered (_("[Current thread is %d (%s)]\n"),
1108                              pid_to_thread_id (inferior_ptid),
1109                              target_tid_to_str (inferior_ptid));
1110         }
1111       else
1112         error (_("No stack."));
1113       return;
1114     }
1115
1116   annotate_thread_changed ();
1117   gdb_thread_select (uiout, tidstr, NULL);
1118 }
1119
1120 /* Print notices when new threads are attached and detached.  */
1121 int print_thread_events = 1;
1122 static void
1123 show_print_thread_events (struct ui_file *file, int from_tty,
1124                           struct cmd_list_element *c, const char *value)
1125 {
1126   fprintf_filtered (file, _("\
1127 Printing of thread events is %s.\n"),
1128                     value);
1129 }
1130
1131 static int
1132 do_captured_thread_select (struct ui_out *uiout, void *tidstr)
1133 {
1134   int num;
1135   struct thread_info *tp;
1136
1137   num = value_as_long (parse_and_eval (tidstr));
1138
1139   tp = find_thread_id (num);
1140
1141   if (!tp)
1142     error (_("Thread ID %d not known."), num);
1143
1144   if (!thread_alive (tp))
1145     error (_("Thread ID %d has terminated."), num);
1146
1147   if (non_stop)
1148     context_switch_to (tp->ptid);
1149   else
1150     switch_to_thread (tp->ptid);
1151
1152   ui_out_text (uiout, "[Switching to thread ");
1153   ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
1154   ui_out_text (uiout, " (");
1155   ui_out_text (uiout, target_tid_to_str (inferior_ptid));
1156   ui_out_text (uiout, ")]");
1157
1158   /* Note that we can't reach this with an exited thread, due to the
1159      thread_alive check above.  */
1160   if (tp->state_ == THREAD_RUNNING)
1161     ui_out_text (uiout, "(running)\n");
1162   else
1163     print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1164
1165   /* Since the current thread may have changed, see if there is any
1166      exited thread we can now delete.  */
1167   prune_threads ();
1168
1169   return GDB_RC_OK;
1170 }
1171
1172 enum gdb_rc
1173 gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
1174 {
1175   if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
1176                                  error_message, RETURN_MASK_ALL) < 0)
1177     return GDB_RC_FAIL;
1178   return GDB_RC_OK;
1179 }
1180
1181 /* Commands with a prefix of `thread'.  */
1182 struct cmd_list_element *thread_cmd_list = NULL;
1183
1184 void
1185 _initialize_thread (void)
1186 {
1187   static struct cmd_list_element *thread_apply_list = NULL;
1188   struct cmd_list_element *c;
1189
1190   c = add_info ("threads", info_threads_command,
1191                 _("IDs of currently known threads."));
1192   set_cmd_no_selected_thread_ok (c);
1193
1194   c = add_prefix_cmd ("thread", class_run, thread_command, _("\
1195 Use this command to switch between threads.\n\
1196 The new thread ID must be currently known."),
1197                       &thread_cmd_list, "thread ", 1, &cmdlist);
1198   set_cmd_no_selected_thread_ok (c);
1199
1200   c = add_prefix_cmd ("apply", class_run, thread_apply_command,
1201                       _("Apply a command to a list of threads."),
1202                       &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
1203   set_cmd_no_selected_thread_ok (c);
1204
1205   c = add_cmd ("all", class_run, thread_apply_all_command,
1206                _("Apply a command to all threads."), &thread_apply_list);
1207   set_cmd_no_selected_thread_ok (c);
1208
1209   if (!xdb_commands)
1210     add_com_alias ("t", "thread", class_run, 1);
1211
1212   add_setshow_boolean_cmd ("thread-events", no_class,
1213          &print_thread_events, _("\
1214 Set printing of thread events (such as thread start and exit)."), _("\
1215 Show printing of thread events (such as thread start and exit)."), NULL,
1216          NULL,
1217          show_print_thread_events,
1218          &setprintlist, &showprintlist);
1219 }