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