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 extern struct thread_info*
  75 inferior_thread (void)
  76 {
  77   struct thread_info *tp = find_thread_pid (inferior_ptid);
  78   gdb_assert (tp);
  79   return tp;
  80 }
  81
  82 void
  83 delete_step_resume_breakpoint (struct thread_info *tp)
  84 {
  85   if (tp && tp->step_resume_breakpoint)
  86     {
  87       delete_breakpoint (tp->step_resume_breakpoint);
  88       tp->step_resume_breakpoint = NULL;
  89     }
  90 }
  91
  92 static void
  93 clear_thread_inferior_resources (struct thread_info *tp)
  94 {
  95   /* NOTE: this will take care of any left-over step_resume breakpoints,
  96      but not any user-specified thread-specific breakpoints.  We can not
  97      delete the breakpoint straight-off, because the inferior might not
  98      be stopped at the moment.  */
  99   if (tp->step_resume_breakpoint)
 100     {
 101       tp->step_resume_breakpoint->disposition = disp_del_at_next_stop;
 102       tp->step_resume_breakpoint = NULL;
 103     }
 104
 105   bpstat_clear (&tp->stop_bpstat);
 106
 107   discard_all_intermediate_continuations_thread (tp);
 108   discard_all_continuations_thread (tp);
 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
 131   if (!thread_list)
 132     return;
 133
 134   for (tp = thread_list; tp; tp = tpnext)
 135     {
 136       tpnext = tp->next;
 137       free_thread (tp);
 138     }
 139
 140   thread_list = NULL;
 141 }
 142
 143 struct thread_info *
 144 add_thread_silent (ptid_t ptid)
 145 {
 146   struct thread_info *tp;
 147
 148   tp = find_thread_pid (ptid);
 149   if (tp)
 150     /* Found an old thread with the same id.  It has to be dead,
 151        otherwise we wouldn't be adding a new thread with the same id.
 152        The OS is reusing this id --- delete it, and recreate a new
 153        one.  */
 154     {
 155       /* In addition to deleting the thread, if this is the current
 156          thread, then we need to take care that delete_thread doesn't
 157          really delete the thread if it is inferior_ptid.  Create a
 158          new template thread in the list with an invalid ptid, switch
 159          to it, delete the original thread, reset the new thread's
 160          ptid, and switch to it.  */
 161
 162       if (ptid_equal (inferior_ptid, ptid))
 163         {
 164           tp = xmalloc (sizeof (*tp));
 165           memset (tp, 0, sizeof (*tp));
 166           tp->ptid = minus_one_ptid;
 167           tp->num = ++highest_thread_num;
 168           tp->next = thread_list;
 169           thread_list = tp;
 170
 171           /* Make switch_to_thread not read from the thread.  */
 172           tp->state_ = THREAD_EXITED;
 173           switch_to_thread (minus_one_ptid);
 174
 175           /* Now we can delete it.  */
 176           delete_thread (ptid);
 177
 178           /* Now reset its ptid, and reswitch inferior_ptid to it.  */
 179           tp->ptid = ptid;
 180           tp->state_ = THREAD_STOPPED;
 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 /* Return true if TP is an active thread. */
 443 static int
 444 thread_alive (struct thread_info *tp)
 445 {
 446   if (tp->state_ == THREAD_EXITED)
 447     return 0;
 448   if (!target_thread_alive (tp->ptid))
 449     return 0;
 450   return 1;
 451 }
 452
 453 static void
 454 prune_threads (void)
 455 {
 456   struct thread_info *tp, *next;
 457
 458   for (tp = thread_list; tp; tp = next)
 459     {
 460       next = tp->next;
 461       if (!thread_alive (tp))
 462         delete_thread (tp->ptid);
 463     }
 464 }
 465
 466 void
 467 thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
 468 {
 469   struct thread_info * tp = find_thread_pid (old_ptid);
 470   tp->ptid = new_ptid;
 471
 472   observer_notify_thread_ptid_changed (old_ptid, new_ptid);
 473 }
 474
 475 void
 476 set_running (ptid_t ptid, int running)
 477 {
 478   struct thread_info *tp;
 479
 480   /* We try not to notify the observer if no thread has actually changed
 481      the running state -- merely to reduce the number of messages to
 482      frontend.  Frontend is supposed to handle multiple *running just fine.  */
 483   if (PIDGET (ptid) == -1)
 484     {
 485       int any_started = 0;
 486       for (tp = thread_list; tp; tp = tp->next)
 487         {
 488           if (tp->state_ == THREAD_EXITED)
 489             continue;
 490           if (running && tp->state_ == THREAD_STOPPED)
 491             any_started = 1;
 492           tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 493         }
 494       if (any_started && !suppress_resume_observer)
 495         observer_notify_target_resumed (ptid);
 496     }
 497   else
 498     {
 499       int started = 0;
 500       tp = find_thread_pid (ptid);
 501       gdb_assert (tp);
 502       gdb_assert (tp->state_ != THREAD_EXITED);
 503       if (running && tp->state_ == THREAD_STOPPED)
 504         started = 1;
 505       tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 506       if (started && !suppress_resume_observer)
 507         observer_notify_target_resumed (ptid);
 508     }
 509 }
 510
 511 static int
 512 is_thread_state (ptid_t ptid, enum thread_state state)
 513 {
 514   struct thread_info *tp;
 515
 516   if (!target_has_execution)
 517     return 0;
 518
 519   tp = find_thread_pid (ptid);
 520   gdb_assert (tp);
 521   return tp->state_ == state;
 522 }
 523
 524 int
 525 is_stopped (ptid_t ptid)
 526 {
 527   /* Without execution, this property is always true.  */
 528   if (!target_has_execution)
 529     return 1;
 530
 531   return is_thread_state (ptid, THREAD_STOPPED);
 532 }
 533
 534 int
 535 is_exited (ptid_t ptid)
 536 {
 537   /* Without execution, this property is always false.  */
 538   if (!target_has_execution)
 539     return 0;
 540
 541   return is_thread_state (ptid, THREAD_EXITED);
 542 }
 543
 544 int
 545 is_running (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_RUNNING);
 552 }
 553
 554 int
 555 any_running (void)
 556 {
 557   struct thread_info *tp;
 558
 559   if (!target_has_execution)
 560     return 0;
 561
 562   for (tp = thread_list; tp; tp = tp->next)
 563     if (tp->state_ == THREAD_RUNNING)
 564       return 1;
 565
 566   return 0;
 567 }
 568
 569 int
 570 is_executing (ptid_t ptid)
 571 {
 572   struct thread_info *tp;
 573
 574   if (!target_has_execution)
 575     return 0;
 576
 577   tp = find_thread_pid (ptid);
 578   gdb_assert (tp);
 579   return tp->executing_;
 580 }
 581
 582 void
 583 set_executing (ptid_t ptid, int executing)
 584 {
 585   struct thread_info *tp;
 586
 587   if (PIDGET (ptid) == -1)
 588     {
 589       for (tp = thread_list; tp; tp = tp->next)
 590         tp->executing_ = executing;
 591     }
 592   else
 593     {
 594       tp = find_thread_pid (ptid);
 595       gdb_assert (tp);
 596       tp->executing_ = executing;
 597     }
 598 }
 599
 600 /* Prints the list of threads and their details on UIOUT.
 601    This is a version of 'info_thread_command' suitable for
 602    use from MI.
 603    If REQUESTED_THREAD is not -1, it's the GDB id of the thread
 604    that should be printed.  Otherwise, all threads are
 605    printed.  */
 606 void
 607 print_thread_info (struct ui_out *uiout, int requested_thread)
 608 {
 609   struct thread_info *tp;
 610   ptid_t current_ptid;
 611   struct cleanup *old_chain;
 612   char *extra_info;
 613   int current_thread = -1;
 614
 615   prune_threads ();
 616   target_find_new_threads ();
 617   current_ptid = inferior_ptid;
 618
 619   /* We'll be switching threads temporarily.  */
 620   old_chain = make_cleanup_restore_current_thread ();
 621
 622   make_cleanup_ui_out_list_begin_end (uiout, "threads");
 623   for (tp = thread_list; tp; tp = tp->next)
 624     {
 625       struct cleanup *chain2;
 626
 627       if (requested_thread != -1 && tp->num != requested_thread)
 628         continue;
 629
 630       if (ptid_equal (tp->ptid, current_ptid))
 631         current_thread = tp->num;
 632
 633       if (tp->state_ == THREAD_EXITED)
 634         continue;
 635
 636       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 637
 638       if (ptid_equal (tp->ptid, current_ptid))
 639         ui_out_text (uiout, "* ");
 640       else
 641         ui_out_text (uiout, "  ");
 642
 643       ui_out_field_int (uiout, "id", tp->num);
 644       ui_out_text (uiout, " ");
 645       ui_out_field_string (uiout, "target-id", target_tid_to_str (tp->ptid));
 646
 647       if (tp->state_ != THREAD_EXITED)
 648         {
 649           extra_info = target_extra_thread_info (tp);
 650           if (extra_info)
 651             {
 652               ui_out_text (uiout, " (");
 653               ui_out_field_string (uiout, "details", extra_info);
 654               ui_out_text (uiout, ")");
 655             }
 656           ui_out_text (uiout, "  ");
 657         }
 658
 659       if (tp->state_ == THREAD_RUNNING)
 660         ui_out_text (uiout, "(running)\n");
 661       else
 662         {
 663           /* The switch below puts us at the top of the stack (leaf
 664              frame).  */
 665           switch_to_thread (tp->ptid);
 666           print_stack_frame (get_selected_frame (NULL),
 667                              /* For MI output, print frame level.  */
 668                              ui_out_is_mi_like_p (uiout),
 669                              LOCATION);
 670         }
 671
 672       if (ui_out_is_mi_like_p (uiout))
 673         {
 674           char *state = "stopped";
 675           if (tp->state_ == THREAD_EXITED)
 676             state = "exited";
 677           else if (tp->state_ == THREAD_RUNNING)
 678             state = "running";
 679           ui_out_field_string (uiout, "state", state);
 680         }
 681
 682       do_cleanups (chain2);
 683     }
 684
 685   /* Restores the current thread and the frame selected before
 686      the "info threads" command.  */
 687   do_cleanups (old_chain);
 688
 689   if (requested_thread == -1)
 690     {
 691       gdb_assert (current_thread != -1
 692                   || !thread_list);
 693       if (current_thread != -1 && ui_out_is_mi_like_p (uiout))
 694         ui_out_field_int (uiout, "current-thread-id", current_thread);
 695
 696       if (current_thread != -1 && is_exited (current_ptid))
 697         ui_out_message (uiout, 0, "\n\
 698 The current thread <Thread ID %d> has terminated.  See `help thread'.\n",
 699                         current_thread);
 700     }
 701 }
 702
 703
 704 /* Print information about currently known threads
 705
 706  * Note: this has the drawback that it _really_ switches
 707  *       threads, which frees the frame cache.  A no-side
 708  *       effects info-threads command would be nicer.
 709  */
 710
 711 static void
 712 info_threads_command (char *arg, int from_tty)
 713 {
 714   print_thread_info (uiout, -1);
 715 }
 716
 717 /* Switch from one thread to another. */
 718
 719 void
 720 switch_to_thread (ptid_t ptid)
 721 {
 722   if (ptid_equal (ptid, inferior_ptid))
 723     return;
 724
 725   inferior_ptid = ptid;
 726   reinit_frame_cache ();
 727   registers_changed ();
 728
 729   /* We don't check for is_stopped, because we're called at times
 730      while in the TARGET_RUNNING state, e.g., while handling an
 731      internal event.  */
 732   if (!is_exited (ptid) && !is_executing (ptid))
 733     stop_pc = read_pc ();
 734   else
 735     stop_pc = ~(CORE_ADDR) 0;
 736 }
 737
 738 static void
 739 restore_current_thread (ptid_t ptid)
 740 {
 741   switch_to_thread (ptid);
 742 }
 743
 744 static void
 745 restore_selected_frame (struct frame_id a_frame_id, int frame_level)
 746 {
 747   struct frame_info *frame = NULL;
 748   int count;
 749
 750   gdb_assert (frame_level >= 0);
 751
 752   /* Restore by level first, check if the frame id is the same as
 753      expected.  If that fails, try restoring by frame id.  If that
 754      fails, nothing to do, just warn the user.  */
 755
 756   count = frame_level;
 757   frame = find_relative_frame (get_current_frame (), &count);
 758   if (count == 0
 759       && frame != NULL
 760       /* Either the frame ids match, of they're both invalid.  The
 761          latter case is not failsafe, but since it's highly unlikely
 762          the search by level finds the wrong frame, it's 99.9(9)% of
 763          the time (for all practical purposes) safe.  */
 764       && (frame_id_eq (get_frame_id (frame), a_frame_id)
 765           /* Note: could be better to check every frame_id
 766              member for equality here.  */
 767           || (!frame_id_p (get_frame_id (frame))
 768               && !frame_id_p (a_frame_id))))
 769     {
 770       /* Cool, all is fine.  */
 771       select_frame (frame);
 772       return;
 773     }
 774
 775   frame = frame_find_by_id (a_frame_id);
 776   if (frame != NULL)
 777     {
 778       /* Cool, refound it.  */
 779       select_frame (frame);
 780       return;
 781     }
 782
 783   /* Nothing else to do, the frame layout really changed.  Select the
 784      innermost stack frame.  */
 785   select_frame (get_current_frame ());
 786
 787   /* Warn the user.  */
 788   if (!ui_out_is_mi_like_p (uiout))
 789     {
 790       warning (_("\
 791 Couldn't restore frame #%d in current thread, at reparsed frame #0\n"),
 792                frame_level);
 793       /* For MI, we should probably have a notification about
 794          current frame change.  But this error is not very
 795          likely, so don't bother for now.  */
 796       print_stack_frame (get_selected_frame (NULL), 1, SRC_LINE);
 797     }
 798 }
 799
 800 struct current_thread_cleanup
 801 {
 802   ptid_t inferior_ptid;
 803   struct frame_id selected_frame_id;
 804   int selected_frame_level;
 805   int was_stopped;
 806 };
 807
 808 static void
 809 do_restore_current_thread_cleanup (void *arg)
 810 {
 811   struct thread_info *tp;
 812   struct current_thread_cleanup *old = arg;
 813   restore_current_thread (old->inferior_ptid);
 814
 815   /* The running state of the originally selected thread may have
 816      changed, so we have to recheck it here.  */
 817   if (old->was_stopped
 818       && is_stopped (inferior_ptid)
 819       && target_has_registers
 820       && target_has_stack
 821       && target_has_memory)
 822     restore_selected_frame (old->selected_frame_id,
 823                             old->selected_frame_level);
 824 }
 825
 826 static void
 827 restore_current_thread_cleanup_dtor (void *arg)
 828 {
 829   struct current_thread_cleanup *old = arg;
 830   struct thread_info *tp;
 831   tp = find_thread_pid (old->inferior_ptid);
 832   if (tp)
 833     tp->refcount--;
 834   xfree (old);
 835 }
 836
 837 struct cleanup *
 838 make_cleanup_restore_current_thread (void)
 839 {
 840   struct thread_info *tp;
 841   struct frame_info *frame;
 842   struct current_thread_cleanup *old;
 843
 844   old = xmalloc (sizeof (struct current_thread_cleanup));
 845   old->inferior_ptid = inferior_ptid;
 846   old->was_stopped = is_stopped (inferior_ptid);
 847   if (old->was_stopped
 848       && target_has_registers
 849       && target_has_stack
 850       && target_has_memory)
 851     frame = get_selected_frame (NULL);
 852   else
 853     frame = NULL;
 854
 855   old->selected_frame_id = get_frame_id (frame);
 856   old->selected_frame_level = frame_relative_level (frame);
 857
 858   tp = find_thread_pid (inferior_ptid);
 859   if (tp)
 860     tp->refcount++;
 861
 862   return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
 863                             restore_current_thread_cleanup_dtor);
 864 }
 865
 866 /* Apply a GDB command to a list of threads.  List syntax is a whitespace
 867    seperated list of numbers, or ranges, or the keyword `all'.  Ranges consist
 868    of two numbers seperated by a hyphen.  Examples:
 869
 870    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
 871    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
 872    thread apply all p x/i $pc   Apply x/i $pc cmd to all threads
 873  */
 874
 875 static void
 876 thread_apply_all_command (char *cmd, int from_tty)
 877 {
 878   struct thread_info *tp;
 879   struct cleanup *old_chain;
 880   char *saved_cmd;
 881
 882   if (cmd == NULL || *cmd == '\000')
 883     error (_("Please specify a command following the thread ID list"));
 884
 885   prune_threads ();
 886   target_find_new_threads ();
 887
 888   old_chain = make_cleanup_restore_current_thread ();
 889
 890   /* Save a copy of the command in case it is clobbered by
 891      execute_command */
 892   saved_cmd = xstrdup (cmd);
 893   make_cleanup (xfree, saved_cmd);
 894   for (tp = thread_list; tp; tp = tp->next)
 895     if (thread_alive (tp))
 896       {
 897         switch_to_thread (tp->ptid);
 898
 899         printf_filtered (_("\nThread %d (%s):\n"),
 900                          tp->num, target_tid_to_str (inferior_ptid));
 901         execute_command (cmd, from_tty);
 902         strcpy (cmd, saved_cmd);        /* Restore exact command used previously */
 903       }
 904
 905   do_cleanups (old_chain);
 906 }
 907
 908 static void
 909 thread_apply_command (char *tidlist, int from_tty)
 910 {
 911   char *cmd;
 912   char *p;
 913   struct cleanup *old_chain;
 914   char *saved_cmd;
 915
 916   if (tidlist == NULL || *tidlist == '\000')
 917     error (_("Please specify a thread ID list"));
 918
 919   for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
 920
 921   if (*cmd == '\000')
 922     error (_("Please specify a command following the thread ID list"));
 923
 924   /* Save a copy of the command in case it is clobbered by
 925      execute_command */
 926   saved_cmd = xstrdup (cmd);
 927   old_chain = make_cleanup (xfree, saved_cmd);
 928   while (tidlist < cmd)
 929     {
 930       struct thread_info *tp;
 931       int start, end;
 932
 933       start = strtol (tidlist, &p, 10);
 934       if (p == tidlist)
 935         error (_("Error parsing %s"), tidlist);
 936       tidlist = p;
 937
 938       while (*tidlist == ' ' || *tidlist == '\t')
 939         tidlist++;
 940
 941       if (*tidlist == '-')      /* Got a range of IDs? */
 942         {
 943           tidlist++;            /* Skip the - */
 944           end = strtol (tidlist, &p, 10);
 945           if (p == tidlist)
 946             error (_("Error parsing %s"), tidlist);
 947           tidlist = p;
 948
 949           while (*tidlist == ' ' || *tidlist == '\t')
 950             tidlist++;
 951         }
 952       else
 953         end = start;
 954
 955       make_cleanup_restore_current_thread ();
 956
 957       for (; start <= end; start++)
 958         {
 959           tp = find_thread_id (start);
 960
 961           if (!tp)
 962             warning (_("Unknown thread %d."), start);
 963           else if (!thread_alive (tp))
 964             warning (_("Thread %d has terminated."), start);
 965           else
 966             {
 967               switch_to_thread (tp->ptid);
 968
 969               printf_filtered (_("\nThread %d (%s):\n"), tp->num,
 970                                target_tid_to_str (inferior_ptid));
 971               execute_command (cmd, from_tty);
 972
 973               /* Restore exact command used previously.  */
 974               strcpy (cmd, saved_cmd);
 975             }
 976         }
 977     }
 978
 979   do_cleanups (old_chain);
 980 }
 981
 982 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
 983    if prefix of arg is `apply'.  */
 984
 985 static void
 986 thread_command (char *tidstr, int from_tty)
 987 {
 988   if (!tidstr)
 989     {
 990       if (target_has_stack)
 991         {
 992           if (is_exited (inferior_ptid))
 993             printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
 994                              pid_to_thread_id (inferior_ptid),
 995                              target_tid_to_str (inferior_ptid));
 996           else
 997             printf_filtered (_("[Current thread is %d (%s)]\n"),
 998                              pid_to_thread_id (inferior_ptid),
 999                              target_tid_to_str (inferior_ptid));
1000         }
1001       else
1002         error (_("No stack."));
1003       return;
1004     }
1005
1006   annotate_thread_changed ();
1007   gdb_thread_select (uiout, tidstr, NULL);
1008 }
1009
1010 /* Print notices when new threads are attached and detached.  */
1011 int print_thread_events = 1;
1012 static void
1013 show_print_thread_events (struct ui_file *file, int from_tty,
1014                           struct cmd_list_element *c, const char *value)
1015 {
1016   fprintf_filtered (file, _("\
1017 Printing of thread events is %s.\n"),
1018                     value);
1019 }
1020
1021 static int
1022 do_captured_thread_select (struct ui_out *uiout, void *tidstr)
1023 {
1024   int num;
1025   struct thread_info *tp;
1026
1027   num = value_as_long (parse_and_eval (tidstr));
1028
1029   tp = find_thread_id (num);
1030
1031   if (!tp)
1032     error (_("Thread ID %d not known."), num);
1033
1034   if (!thread_alive (tp))
1035     error (_("Thread ID %d has terminated."), num);
1036
1037   switch_to_thread (tp->ptid);
1038
1039   ui_out_text (uiout, "[Switching to thread ");
1040   ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
1041   ui_out_text (uiout, " (");
1042   ui_out_text (uiout, target_tid_to_str (inferior_ptid));
1043   ui_out_text (uiout, ")]");
1044
1045   /* Note that we can't reach this with an exited thread, due to the
1046      thread_alive check above.  */
1047   if (tp->state_ == THREAD_RUNNING)
1048     ui_out_text (uiout, "(running)\n");
1049   else
1050     print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1051
1052   /* Since the current thread may have changed, see if there is any
1053      exited thread we can now delete.  */
1054   prune_threads ();
1055
1056   return GDB_RC_OK;
1057 }
1058
1059 enum gdb_rc
1060 gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
1061 {
1062   if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
1063                                  error_message, RETURN_MASK_ALL) < 0)
1064     return GDB_RC_FAIL;
1065   return GDB_RC_OK;
1066 }
1067
1068 /* Commands with a prefix of `thread'.  */
1069 struct cmd_list_element *thread_cmd_list = NULL;
1070
1071 void
1072 _initialize_thread (void)
1073 {
1074   static struct cmd_list_element *thread_apply_list = NULL;
1075   struct cmd_list_element *c;
1076
1077   c = add_info ("threads", info_threads_command,
1078                 _("IDs of currently known threads."));
1079   set_cmd_no_selected_thread_ok (c);
1080
1081   c = add_prefix_cmd ("thread", class_run, thread_command, _("\
1082 Use this command to switch between threads.\n\
1083 The new thread ID must be currently known."),
1084                       &thread_cmd_list, "thread ", 1, &cmdlist);
1085   set_cmd_no_selected_thread_ok (c);
1086
1087   c = add_prefix_cmd ("apply", class_run, thread_apply_command,
1088                       _("Apply a command to a list of threads."),
1089                       &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
1090   set_cmd_no_selected_thread_ok (c);
1091
1092   c = add_cmd ("all", class_run, thread_apply_all_command,
1093                _("Apply a command to all threads."), &thread_apply_list);
1094   set_cmd_no_selected_thread_ok (c);
1095
1096   if (!xdb_commands)
1097     add_com_alias ("t", "thread", class_run, 1);
1098
1099   add_setshow_boolean_cmd ("thread-events", no_class,
1100          &print_thread_events, _("\
1101 Set printing of thread events (such as thread start and exit)."), _("\
1102 Show printing of thread events (such as thread start and exit)."), NULL,
1103          NULL,
1104          show_print_thread_events,
1105          &setprintlist, &showprintlist);
1106 }