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