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