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.  Select the
 942      innermost stack frame.  */
 943   select_frame (get_current_frame ());
 944
 945   /* Warn the user.  */
 946   if (!ui_out_is_mi_like_p (uiout))
 947     {
 948       warning (_("\
 949 Couldn't restore frame #%d in current thread, at reparsed frame #0\n"),
 950                frame_level);
 951       /* For MI, we should probably have a notification about
 952          current frame change.  But this error is not very
 953          likely, so don't bother for now.  */
 954       print_stack_frame (get_selected_frame (NULL), 1, SRC_LINE);
 955     }
 956 }
 957
 958 struct current_thread_cleanup
 959 {
 960   ptid_t inferior_ptid;
 961   struct frame_id selected_frame_id;
 962   int selected_frame_level;
 963   int was_stopped;
 964 };
 965
 966 static void
 967 do_restore_current_thread_cleanup (void *arg)
 968 {
 969   struct thread_info *tp;
 970   struct current_thread_cleanup *old = arg;
 971   restore_current_thread (old->inferior_ptid);
 972
 973   /* The running state of the originally selected thread may have
 974      changed, so we have to recheck it here.  */
 975   if (old->was_stopped
 976       && is_stopped (inferior_ptid)
 977       && target_has_registers
 978       && target_has_stack
 979       && target_has_memory)
 980     restore_selected_frame (old->selected_frame_id,
 981                             old->selected_frame_level);
 982 }
 983
 984 static void
 985 restore_current_thread_cleanup_dtor (void *arg)
 986 {
 987   struct current_thread_cleanup *old = arg;
 988   struct thread_info *tp;
 989   tp = find_thread_pid (old->inferior_ptid);
 990   if (tp)
 991     tp->refcount--;
 992   xfree (old);
 993 }
 994
 995 struct cleanup *
 996 make_cleanup_restore_current_thread (void)
 997 {
 998   struct thread_info *tp;
 999   struct frame_info *frame;
1000   struct current_thread_cleanup *old;
1001
1002   old = xmalloc (sizeof (struct current_thread_cleanup));
1003   old->inferior_ptid = inferior_ptid;
1004   old->was_stopped = is_stopped (inferior_ptid);
1005   if (old->was_stopped
1006       && target_has_registers
1007       && target_has_stack
1008       && target_has_memory)
1009     frame = get_selected_frame (NULL);
1010   else
1011     frame = NULL;
1012
1013   old->selected_frame_id = get_frame_id (frame);
1014   old->selected_frame_level = frame_relative_level (frame);
1015
1016   tp = find_thread_pid (inferior_ptid);
1017   if (tp)
1018     tp->refcount++;
1019
1020   return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
1021                             restore_current_thread_cleanup_dtor);
1022 }
1023
1024 /* Apply a GDB command to a list of threads.  List syntax is a whitespace
1025    seperated list of numbers, or ranges, or the keyword `all'.  Ranges consist
1026    of two numbers seperated by a hyphen.  Examples:
1027
1028    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
1029    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
1030    thread apply all p x/i $pc   Apply x/i $pc cmd to all threads
1031  */
1032
1033 static void
1034 thread_apply_all_command (char *cmd, int from_tty)
1035 {
1036   struct thread_info *tp;
1037   struct cleanup *old_chain;
1038   char *saved_cmd;
1039
1040   if (cmd == NULL || *cmd == '\000')
1041     error (_("Please specify a command following the thread ID list"));
1042
1043   prune_threads ();
1044   target_find_new_threads ();
1045
1046   old_chain = make_cleanup_restore_current_thread ();
1047
1048   /* Save a copy of the command in case it is clobbered by
1049      execute_command */
1050   saved_cmd = xstrdup (cmd);
1051   make_cleanup (xfree, saved_cmd);
1052   for (tp = thread_list; tp; tp = tp->next)
1053     if (thread_alive (tp))
1054       {
1055         if (non_stop)
1056           context_switch_to (tp->ptid);
1057         else
1058           switch_to_thread (tp->ptid);
1059
1060         printf_filtered (_("\nThread %d (%s):\n"),
1061                          tp->num, target_tid_to_str (inferior_ptid));
1062         execute_command (cmd, from_tty);
1063         strcpy (cmd, saved_cmd);        /* Restore exact command used previously */
1064       }
1065
1066   do_cleanups (old_chain);
1067 }
1068
1069 static void
1070 thread_apply_command (char *tidlist, int from_tty)
1071 {
1072   char *cmd;
1073   char *p;
1074   struct cleanup *old_chain;
1075   char *saved_cmd;
1076
1077   if (tidlist == NULL || *tidlist == '\000')
1078     error (_("Please specify a thread ID list"));
1079
1080   for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
1081
1082   if (*cmd == '\000')
1083     error (_("Please specify a command following the thread ID list"));
1084
1085   /* Save a copy of the command in case it is clobbered by
1086      execute_command */
1087   saved_cmd = xstrdup (cmd);
1088   old_chain = make_cleanup (xfree, saved_cmd);
1089   while (tidlist < cmd)
1090     {
1091       struct thread_info *tp;
1092       int start, end;
1093
1094       start = strtol (tidlist, &p, 10);
1095       if (p == tidlist)
1096         error (_("Error parsing %s"), tidlist);
1097       tidlist = p;
1098
1099       while (*tidlist == ' ' || *tidlist == '\t')
1100         tidlist++;
1101
1102       if (*tidlist == '-')      /* Got a range of IDs? */
1103         {
1104           tidlist++;            /* Skip the - */
1105           end = strtol (tidlist, &p, 10);
1106           if (p == tidlist)
1107             error (_("Error parsing %s"), tidlist);
1108           tidlist = p;
1109
1110           while (*tidlist == ' ' || *tidlist == '\t')
1111             tidlist++;
1112         }
1113       else
1114         end = start;
1115
1116       make_cleanup_restore_current_thread ();
1117
1118       for (; start <= end; start++)
1119         {
1120           tp = find_thread_id (start);
1121
1122           if (!tp)
1123             warning (_("Unknown thread %d."), start);
1124           else if (!thread_alive (tp))
1125             warning (_("Thread %d has terminated."), start);
1126           else
1127             {
1128               if (non_stop)
1129                 context_switch_to (tp->ptid);
1130               else
1131                 switch_to_thread (tp->ptid);
1132
1133               printf_filtered (_("\nThread %d (%s):\n"), tp->num,
1134                                target_tid_to_str (inferior_ptid));
1135               execute_command (cmd, from_tty);
1136
1137               /* Restore exact command used previously.  */
1138               strcpy (cmd, saved_cmd);
1139             }
1140         }
1141     }
1142
1143   do_cleanups (old_chain);
1144 }
1145
1146 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
1147    if prefix of arg is `apply'.  */
1148
1149 static void
1150 thread_command (char *tidstr, int from_tty)
1151 {
1152   if (!tidstr)
1153     {
1154       if (target_has_stack)
1155         {
1156           if (is_exited (inferior_ptid))
1157             printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
1158                              pid_to_thread_id (inferior_ptid),
1159                              target_tid_to_str (inferior_ptid));
1160           else
1161             printf_filtered (_("[Current thread is %d (%s)]\n"),
1162                              pid_to_thread_id (inferior_ptid),
1163                              target_tid_to_str (inferior_ptid));
1164         }
1165       else
1166         error (_("No stack."));
1167       return;
1168     }
1169
1170   annotate_thread_changed ();
1171   gdb_thread_select (uiout, tidstr, NULL);
1172 }
1173
1174 /* Print notices when new threads are attached and detached.  */
1175 int print_thread_events = 1;
1176 static void
1177 show_print_thread_events (struct ui_file *file, int from_tty,
1178                           struct cmd_list_element *c, const char *value)
1179 {
1180   fprintf_filtered (file, _("\
1181 Printing of thread events is %s.\n"),
1182                     value);
1183 }
1184
1185 static int
1186 do_captured_thread_select (struct ui_out *uiout, void *tidstr)
1187 {
1188   int num;
1189   struct thread_info *tp;
1190
1191   num = value_as_long (parse_and_eval (tidstr));
1192
1193   tp = find_thread_id (num);
1194
1195   if (!tp)
1196     error (_("Thread ID %d not known."), num);
1197
1198   if (!thread_alive (tp))
1199     error (_("Thread ID %d has terminated."), num);
1200
1201   if (non_stop)
1202     context_switch_to (tp->ptid);
1203   else
1204     switch_to_thread (tp->ptid);
1205
1206   ui_out_text (uiout, "[Switching to thread ");
1207   ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
1208   ui_out_text (uiout, " (");
1209   ui_out_text (uiout, target_tid_to_str (inferior_ptid));
1210   ui_out_text (uiout, ")]");
1211
1212   /* Note that we can't reach this with an exited thread, due to the
1213      thread_alive check above.  */
1214   if (tp->state_ == THREAD_RUNNING)
1215     ui_out_text (uiout, "(running)\n");
1216   else
1217     print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1218
1219   /* Since the current thread may have changed, see if there is any
1220      exited thread we can now delete.  */
1221   prune_threads ();
1222
1223   return GDB_RC_OK;
1224 }
1225
1226 enum gdb_rc
1227 gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
1228 {
1229   if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
1230                                  error_message, RETURN_MASK_ALL) < 0)
1231     return GDB_RC_FAIL;
1232   return GDB_RC_OK;
1233 }
1234
1235 /* Commands with a prefix of `thread'.  */
1236 struct cmd_list_element *thread_cmd_list = NULL;
1237
1238 void
1239 _initialize_thread (void)
1240 {
1241   static struct cmd_list_element *thread_apply_list = NULL;
1242   struct cmd_list_element *c;
1243
1244   c = add_info ("threads", info_threads_command,
1245                 _("IDs of currently known threads."));
1246   set_cmd_async_ok (c);
1247   set_cmd_no_selected_thread_ok (c);
1248
1249   c = add_prefix_cmd ("thread", class_run, thread_command, _("\
1250 Use this command to switch between threads.\n\
1251 The new thread ID must be currently known."),
1252                       &thread_cmd_list, "thread ", 1, &cmdlist);
1253   set_cmd_async_ok (c);
1254   set_cmd_no_selected_thread_ok (c);
1255
1256   c = add_prefix_cmd ("apply", class_run, thread_apply_command,
1257                       _("Apply a command to a list of threads."),
1258                       &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
1259   set_cmd_async_ok (c);
1260   set_cmd_no_selected_thread_ok (c);
1261
1262   c = add_cmd ("all", class_run, thread_apply_all_command,
1263                _("Apply a command to all threads."), &thread_apply_list);
1264   set_cmd_async_ok (c);
1265   set_cmd_no_selected_thread_ok (c);
1266
1267   if (!xdb_commands)
1268     add_com_alias ("t", "thread", class_run, 1);
1269
1270   add_setshow_boolean_cmd ("thread-events", no_class,
1271          &print_thread_events, _("\
1272 Set printing of thread events (such as thread start and exit)."), _("\
1273 Show printing of thread events (such as thread start and exit)."), NULL,
1274          NULL,
1275          show_print_thread_events,
1276          &setprintlist, &showprintlist);
1277 }