gdb/thread.c

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