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, 2009
   5    Free Software Foundation, Inc.
   6
   7    Contributed by Lynx Real-Time Systems, Inc.  Los Gatos, CA.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 #include "defs.h"
  25 #include "symtab.h"
  26 #include "frame.h"
  27 #include "inferior.h"
  28 #include "environ.h"
  29 #include "value.h"
  30 #include "target.h"
  31 #include "gdbthread.h"
  32 #include "exceptions.h"
  33 #include "command.h"
  34 #include "gdbcmd.h"
  35 #include "regcache.h"
  36 #include "gdb.h"
  37 #include "gdb_string.h"
  38
  39 #include <ctype.h>
  40 #include <sys/types.h>
  41 #include <signal.h>
  42 #include "ui-out.h"
  43 #include "observer.h"
  44 #include "annotate.h"
  45 #include "cli/cli-decode.h"
  46
  47 /* Definition of struct thread_info exported to gdbthread.h */
  48
  49 /* Prototypes for exported functions. */
  50
  51 void _initialize_thread (void);
  52
  53 /* Prototypes for local functions. */
  54
  55 static struct thread_info *thread_list = NULL;
  56 static int highest_thread_num;
  57
  58 static void thread_command (char *tidstr, int from_tty);
  59 static void thread_apply_all_command (char *, int);
  60 static int thread_alive (struct thread_info *);
  61 static void info_threads_command (char *, int);
  62 static void thread_apply_command (char *, int);
  63 static void restore_current_thread (ptid_t);
  64 static void prune_threads (void);
  65
  66 /* Frontend view of the thread state.  Possible extensions: stepping,
  67    finishing, until(ling),...  */
  68 enum thread_state
  69 {
  70   THREAD_STOPPED,
  71   THREAD_RUNNING,
  72   THREAD_EXITED,
  73 };
  74
  75 extern struct thread_info*
  76 inferior_thread (void)
  77 {
  78   struct thread_info *tp = find_thread_pid (inferior_ptid);
  79   gdb_assert (tp);
  80   return tp;
  81 }
  82
  83 void
  84 delete_step_resume_breakpoint (struct thread_info *tp)
  85 {
  86   if (tp && tp->step_resume_breakpoint)
  87     {
  88       delete_breakpoint (tp->step_resume_breakpoint);
  89       tp->step_resume_breakpoint = NULL;
  90     }
  91 }
  92
  93 static void
  94 clear_thread_inferior_resources (struct thread_info *tp)
  95 {
  96   /* NOTE: this will take care of any left-over step_resume breakpoints,
  97      but not any user-specified thread-specific breakpoints.  We can not
  98      delete the breakpoint straight-off, because the inferior might not
  99      be stopped at the moment.  */
 100   if (tp->step_resume_breakpoint)
 101     {
 102       tp->step_resume_breakpoint->disposition = disp_del_at_next_stop;
 103       tp->step_resume_breakpoint = NULL;
 104     }
 105
 106   bpstat_clear (&tp->stop_bpstat);
 107
 108   discard_all_intermediate_continuations_thread (tp);
 109   discard_all_continuations_thread (tp);
 110 }
 111
 112 static void
 113 free_thread (struct thread_info *tp)
 114 {
 115   clear_thread_inferior_resources (tp);
 116
 117   /* FIXME: do I ever need to call the back-end to give it a
 118      chance at this private data before deleting the thread?  */
 119   if (tp->private)
 120     xfree (tp->private);
 121
 122   xfree (tp);
 123 }
 124
 125 void
 126 init_thread_list (void)
 127 {
 128   struct thread_info *tp, *tpnext;
 129
 130   highest_thread_num = 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 take care that delete_thread doesn't
 158          really delete the thread if it is inferior_ptid.  Create a
 159          new template thread in the list with an invalid ptid, switch
 160          to it, delete the original thread, reset the new thread's
 161          ptid, and switch to it.  */
 162
 163       if (ptid_equal (inferior_ptid, ptid))
 164         {
 165           tp = xmalloc (sizeof (*tp));
 166           memset (tp, 0, sizeof (*tp));
 167           tp->ptid = minus_one_ptid;
 168           tp->num = ++highest_thread_num;
 169           tp->next = thread_list;
 170           thread_list = tp;
 171
 172           /* Make switch_to_thread not read from the thread.  */
 173           tp->state_ = THREAD_EXITED;
 174           switch_to_thread (minus_one_ptid);
 175
 176           /* Now we can delete it.  */
 177           delete_thread (ptid);
 178
 179           /* Now reset its ptid, and reswitch inferior_ptid to it.  */
 180           tp->ptid = ptid;
 181           tp->state_ = THREAD_STOPPED;
 182           switch_to_thread (ptid);
 183
 184           observer_notify_new_thread (tp);
 185
 186           /* All done.  */
 187           return tp;
 188         }
 189       else
 190         /* Just go ahead and delete it.  */
 191         delete_thread (ptid);
 192     }
 193
 194   tp = (struct thread_info *) xmalloc (sizeof (*tp));
 195   memset (tp, 0, sizeof (*tp));
 196   tp->ptid = ptid;
 197   tp->num = ++highest_thread_num;
 198   tp->next = thread_list;
 199   thread_list = tp;
 200
 201   observer_notify_new_thread (tp);
 202
 203   return tp;
 204 }
 205
 206 struct thread_info *
 207 add_thread_with_info (ptid_t ptid, struct private_thread_info *private)
 208 {
 209   struct thread_info *result = add_thread_silent (ptid);
 210
 211   result->private = private;
 212
 213   if (print_thread_events)
 214     printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
 215
 216   annotate_new_thread ();
 217   return result;
 218 }
 219
 220 struct thread_info *
 221 add_thread (ptid_t ptid)
 222 {
 223   return add_thread_with_info (ptid, NULL);
 224 }
 225
 226 /* Delete thread PTID.  If SILENT, don't notify the observer of this
 227    exit.  */
 228 static void
 229 delete_thread_1 (ptid_t ptid, int silent)
 230 {
 231   struct thread_info *tp, *tpprev;
 232
 233   tpprev = NULL;
 234
 235   for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
 236     if (ptid_equal (tp->ptid, ptid))
 237       break;
 238
 239   if (!tp)
 240     return;
 241
 242   /* If this is the current thread, or there's code out there that
 243      relies on it existing (refcount > 0) we can't delete yet.  Mark
 244      it as exited, and notify it.  */
 245   if (tp->refcount > 0
 246       || ptid_equal (tp->ptid, inferior_ptid))
 247     {
 248       if (tp->state_ != THREAD_EXITED)
 249         {
 250           observer_notify_thread_exit (tp, silent);
 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 (tp->state_ != THREAD_EXITED)
 270     observer_notify_thread_exit (tp, silent);
 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   int current_thread = -1;
 413
 414   prune_threads ();
 415   target_find_new_threads ();
 416
 417   cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids");
 418
 419   for (tp = thread_list; tp; tp = tp->next)
 420     {
 421       if (tp->state_ == THREAD_EXITED)
 422         continue;
 423
 424       if (ptid_equal (tp->ptid, inferior_ptid))
 425         current_thread = tp->num;
 426
 427       num++;
 428       ui_out_field_int (uiout, "thread-id", tp->num);
 429     }
 430
 431   do_cleanups (cleanup_chain);
 432
 433   if (current_thread != -1)
 434     ui_out_field_int (uiout, "current-thread-id", current_thread);
 435   ui_out_field_int (uiout, "number-of-threads", num);
 436   return GDB_RC_OK;
 437 }
 438
 439 /* Official gdblib interface function to get a list of thread ids and
 440    the total number. */
 441 enum gdb_rc
 442 gdb_list_thread_ids (struct ui_out *uiout, char **error_message)
 443 {
 444   if (catch_exceptions_with_msg (uiout, do_captured_list_thread_ids, NULL,
 445                                  error_message, RETURN_MASK_ALL) < 0)
 446     return GDB_RC_FAIL;
 447   return GDB_RC_OK;
 448 }
 449
 450 /* Return true if TP is an active thread. */
 451 static int
 452 thread_alive (struct thread_info *tp)
 453 {
 454   if (tp->state_ == THREAD_EXITED)
 455     return 0;
 456   if (!target_thread_alive (tp->ptid))
 457     return 0;
 458   return 1;
 459 }
 460
 461 static void
 462 prune_threads (void)
 463 {
 464   struct thread_info *tp, *next;
 465
 466   for (tp = thread_list; tp; tp = next)
 467     {
 468       next = tp->next;
 469       if (!thread_alive (tp))
 470         delete_thread (tp->ptid);
 471     }
 472 }
 473
 474 void
 475 thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
 476 {
 477   struct inferior *inf;
 478   struct thread_info *tp;
 479
 480   /* It can happen that what we knew as the target inferior id
 481      changes.  E.g, target remote may only discover the remote process
 482      pid after adding the inferior to GDB's list.  */
 483   inf = find_inferior_pid (ptid_get_pid (old_ptid));
 484   inf->pid = ptid_get_pid (new_ptid);
 485
 486   tp = find_thread_pid (old_ptid);
 487   tp->ptid = new_ptid;
 488
 489   observer_notify_thread_ptid_changed (old_ptid, new_ptid);
 490 }
 491
 492 void
 493 set_running (ptid_t ptid, int running)
 494 {
 495   struct thread_info *tp;
 496
 497   /* We try not to notify the observer if no thread has actually changed
 498      the running state -- merely to reduce the number of messages to
 499      frontend.  Frontend is supposed to handle multiple *running just fine.  */
 500   if (PIDGET (ptid) == -1)
 501     {
 502       int any_started = 0;
 503       for (tp = thread_list; tp; tp = tp->next)
 504         {
 505           if (tp->state_ == THREAD_EXITED)
 506             continue;
 507           if (running && tp->state_ == THREAD_STOPPED)
 508             any_started = 1;
 509           tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 510         }
 511       if (any_started)
 512         observer_notify_target_resumed (ptid);
 513     }
 514   else
 515     {
 516       int started = 0;
 517       tp = find_thread_pid (ptid);
 518       gdb_assert (tp);
 519       gdb_assert (tp->state_ != THREAD_EXITED);
 520       if (running && tp->state_ == THREAD_STOPPED)
 521         started = 1;
 522       tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 523       if (started)
 524         observer_notify_target_resumed (ptid);
 525     }
 526 }
 527
 528 static int
 529 is_thread_state (ptid_t ptid, enum thread_state state)
 530 {
 531   struct thread_info *tp;
 532
 533   if (!target_has_execution)
 534     return 0;
 535
 536   tp = find_thread_pid (ptid);
 537   gdb_assert (tp);
 538   return tp->state_ == state;
 539 }
 540
 541 int
 542 is_stopped (ptid_t ptid)
 543 {
 544   /* Without execution, this property is always true.  */
 545   if (!target_has_execution)
 546     return 1;
 547
 548   return is_thread_state (ptid, THREAD_STOPPED);
 549 }
 550
 551 int
 552 is_exited (ptid_t ptid)
 553 {
 554   /* Without execution, this property is always false.  */
 555   if (!target_has_execution)
 556     return 0;
 557
 558   return is_thread_state (ptid, THREAD_EXITED);
 559 }
 560
 561 int
 562 is_running (ptid_t ptid)
 563 {
 564    /* Without execution, this property is always false.  */
 565   if (!target_has_execution)
 566     return 0;
 567
 568   return is_thread_state (ptid, THREAD_RUNNING);
 569 }
 570
 571 int
 572 any_running (void)
 573 {
 574   struct thread_info *tp;
 575
 576   if (!target_has_execution)
 577     return 0;
 578
 579   for (tp = thread_list; tp; tp = tp->next)
 580     if (tp->state_ == THREAD_RUNNING)
 581       return 1;
 582
 583   return 0;
 584 }
 585
 586 int
 587 is_executing (ptid_t ptid)
 588 {
 589   struct thread_info *tp;
 590
 591   if (!target_has_execution)
 592     return 0;
 593
 594   tp = find_thread_pid (ptid);
 595   gdb_assert (tp);
 596   return tp->executing_;
 597 }
 598
 599 void
 600 set_executing (ptid_t ptid, int executing)
 601 {
 602   struct thread_info *tp;
 603
 604   if (PIDGET (ptid) == -1)
 605     {
 606       for (tp = thread_list; tp; tp = tp->next)
 607         tp->executing_ = executing;
 608     }
 609   else
 610     {
 611       tp = find_thread_pid (ptid);
 612       gdb_assert (tp);
 613       tp->executing_ = executing;
 614     }
 615 }
 616
 617 void
 618 set_stop_requested (ptid_t ptid, int stop)
 619 {
 620   struct thread_info *tp;
 621   int all = ptid_equal (ptid, minus_one_ptid);
 622
 623   if (all || ptid_is_pid (ptid))
 624     {
 625       for (tp = thread_list; tp; tp = tp->next)
 626         if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
 627           tp->stop_requested = stop;
 628     }
 629   else
 630     {
 631       tp = find_thread_pid (ptid);
 632       gdb_assert (tp);
 633       tp->stop_requested = stop;
 634     }
 635
 636   /* Call the stop requested observer so other components of GDB can
 637      react to this request.  */
 638   if (stop)
 639     observer_notify_thread_stop_requested (ptid);
 640 }
 641
 642 void
 643 finish_thread_state (ptid_t ptid)
 644 {
 645   struct thread_info *tp;
 646   int all;
 647   int any_started = 0;
 648
 649   all = ptid_equal (ptid, minus_one_ptid);
 650
 651   if (all || ptid_is_pid (ptid))
 652     {
 653       for (tp = thread_list; tp; tp = tp->next)
 654         {
 655           if (tp->state_ == THREAD_EXITED)
 656             continue;
 657           if (all || ptid_get_pid (ptid) == ptid_get_pid (tp->ptid))
 658             {
 659               if (tp->executing_ && tp->state_ == THREAD_STOPPED)
 660                 any_started = 1;
 661               tp->state_ = tp->executing_ ? THREAD_RUNNING : THREAD_STOPPED;
 662             }
 663         }
 664     }
 665   else
 666     {
 667       tp = find_thread_pid (ptid);
 668       gdb_assert (tp);
 669       if (tp->state_ != THREAD_EXITED)
 670         {
 671           if (tp->executing_ && tp->state_ == THREAD_STOPPED)
 672             any_started = 1;
 673           tp->state_ = tp->executing_ ? THREAD_RUNNING : THREAD_STOPPED;
 674         }
 675     }
 676
 677   if (any_started)
 678     observer_notify_target_resumed (ptid);
 679 }
 680
 681 void
 682 finish_thread_state_cleanup (void *arg)
 683 {
 684   ptid_t *ptid_p = arg;
 685
 686   gdb_assert (arg);
 687
 688   finish_thread_state (*ptid_p);
 689 }
 690
 691 /* Prints the list of threads and their details on UIOUT.
 692    This is a version of 'info_thread_command' suitable for
 693    use from MI.
 694    If REQUESTED_THREAD is not -1, it's the GDB id of the thread
 695    that should be printed.  Otherwise, all threads are
 696    printed.
 697    If PID is not -1, only print threads from the process PID.
 698    Otherwise, threads from all attached PIDs are printed.
 699    If both REQUESTED_THREAD and PID are not -1, then the thread
 700    is printed if it belongs to the specified process.  Otherwise,
 701    an error is raised.  */
 702 void
 703 print_thread_info (struct ui_out *uiout, int requested_thread, int pid)
 704 {
 705   struct thread_info *tp;
 706   ptid_t current_ptid;
 707   struct cleanup *old_chain;
 708   char *extra_info;
 709   int current_thread = -1;
 710
 711   prune_threads ();
 712   target_find_new_threads ();
 713   current_ptid = inferior_ptid;
 714
 715   /* We'll be switching threads temporarily.  */
 716   old_chain = make_cleanup_restore_current_thread ();
 717
 718   make_cleanup_ui_out_list_begin_end (uiout, "threads");
 719   for (tp = thread_list; tp; tp = tp->next)
 720     {
 721       struct cleanup *chain2;
 722
 723       if (requested_thread != -1 && tp->num != requested_thread)
 724         continue;
 725
 726       if (pid != -1 && PIDGET (tp->ptid) != pid)
 727         {
 728           if (requested_thread != -1)
 729             error (_("Requested thread not found in requested process"));
 730           continue;
 731         }
 732
 733       if (ptid_equal (tp->ptid, current_ptid))
 734         current_thread = tp->num;
 735
 736       if (tp->state_ == THREAD_EXITED)
 737         continue;
 738
 739       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 740
 741       if (ptid_equal (tp->ptid, current_ptid))
 742         ui_out_text (uiout, "* ");
 743       else
 744         ui_out_text (uiout, "  ");
 745
 746       ui_out_field_int (uiout, "id", tp->num);
 747       ui_out_text (uiout, " ");
 748       ui_out_field_string (uiout, "target-id", target_pid_to_str (tp->ptid));
 749
 750       extra_info = target_extra_thread_info (tp);
 751       if (extra_info)
 752         {
 753           ui_out_text (uiout, " (");
 754           ui_out_field_string (uiout, "details", extra_info);
 755           ui_out_text (uiout, ")");
 756         }
 757       ui_out_text (uiout, "  ");
 758
 759       if (tp->state_ == THREAD_RUNNING)
 760         ui_out_text (uiout, "(running)\n");
 761       else
 762         {
 763           /* The switch below puts us at the top of the stack (leaf
 764              frame).  */
 765           switch_to_thread (tp->ptid);
 766           print_stack_frame (get_selected_frame (NULL),
 767                              /* For MI output, print frame level.  */
 768                              ui_out_is_mi_like_p (uiout),
 769                              LOCATION);
 770         }
 771
 772       if (ui_out_is_mi_like_p (uiout))
 773         {
 774           char *state = "stopped";
 775           if (tp->state_ == THREAD_RUNNING)
 776             state = "running";
 777           ui_out_field_string (uiout, "state", state);
 778         }
 779
 780       do_cleanups (chain2);
 781     }
 782
 783   /* Restores the current thread and the frame selected before
 784      the "info threads" command.  */
 785   do_cleanups (old_chain);
 786
 787   if (pid == -1 && requested_thread == -1)
 788     {
 789       gdb_assert (current_thread != -1
 790                   || !thread_list
 791                   || ptid_equal (inferior_ptid, null_ptid));
 792       if (current_thread != -1 && ui_out_is_mi_like_p (uiout))
 793         ui_out_field_int (uiout, "current-thread-id", current_thread);
 794
 795       if (current_thread != -1 && is_exited (current_ptid))
 796         ui_out_message (uiout, 0, "\n\
 797 The current thread <Thread ID %d> has terminated.  See `help thread'.\n",
 798                         current_thread);
 799       else if (thread_list
 800                && current_thread == -1
 801                && ptid_equal (current_ptid, null_ptid))
 802         ui_out_message (uiout, 0, "\n\
 803 No selected thread.  See `help thread'.\n");
 804     }
 805 }
 806
 807
 808 /* Print information about currently known threads
 809
 810  * Note: this has the drawback that it _really_ switches
 811  *       threads, which frees the frame cache.  A no-side
 812  *       effects info-threads command would be nicer.
 813  */
 814
 815 static void
 816 info_threads_command (char *arg, int from_tty)
 817 {
 818   print_thread_info (uiout, -1, -1);
 819 }
 820
 821 /* Switch from one thread to another. */
 822
 823 void
 824 switch_to_thread (ptid_t ptid)
 825 {
 826   if (ptid_equal (ptid, inferior_ptid))
 827     return;
 828
 829   inferior_ptid = ptid;
 830   reinit_frame_cache ();
 831   registers_changed ();
 832
 833   /* We don't check for is_stopped, because we're called at times
 834      while in the TARGET_RUNNING state, e.g., while handling an
 835      internal event.  */
 836   if (!ptid_equal (inferior_ptid, null_ptid)
 837       && !is_exited (ptid)
 838       && !is_executing (ptid))
 839     stop_pc = read_pc ();
 840   else
 841     stop_pc = ~(CORE_ADDR) 0;
 842 }
 843
 844 static void
 845 restore_current_thread (ptid_t ptid)
 846 {
 847   switch_to_thread (ptid);
 848 }
 849
 850 static void
 851 restore_selected_frame (struct frame_id a_frame_id, int frame_level)
 852 {
 853   struct frame_info *frame = NULL;
 854   int count;
 855
 856   gdb_assert (frame_level >= 0);
 857
 858   /* Restore by level first, check if the frame id is the same as
 859      expected.  If that fails, try restoring by frame id.  If that
 860      fails, nothing to do, just warn the user.  */
 861
 862   count = frame_level;
 863   frame = find_relative_frame (get_current_frame (), &count);
 864   if (count == 0
 865       && frame != NULL
 866       /* Either the frame ids match, of they're both invalid.  The
 867          latter case is not failsafe, but since it's highly unlikely
 868          the search by level finds the wrong frame, it's 99.9(9)% of
 869          the time (for all practical purposes) safe.  */
 870       && (frame_id_eq (get_frame_id (frame), a_frame_id)
 871           /* Note: could be better to check every frame_id
 872              member for equality here.  */
 873           || (!frame_id_p (get_frame_id (frame))
 874               && !frame_id_p (a_frame_id))))
 875     {
 876       /* Cool, all is fine.  */
 877       select_frame (frame);
 878       return;
 879     }
 880
 881   frame = frame_find_by_id (a_frame_id);
 882   if (frame != NULL)
 883     {
 884       /* Cool, refound it.  */
 885       select_frame (frame);
 886       return;
 887     }
 888
 889   /* Nothing else to do, the frame layout really changed.  Select the
 890      innermost stack frame.  */
 891   select_frame (get_current_frame ());
 892
 893   /* Warn the user.  */
 894   if (!ui_out_is_mi_like_p (uiout))
 895     {
 896       warning (_("\
 897 Couldn't restore frame #%d in current thread, at reparsed frame #0\n"),
 898                frame_level);
 899       /* For MI, we should probably have a notification about
 900          current frame change.  But this error is not very
 901          likely, so don't bother for now.  */
 902       print_stack_frame (get_selected_frame (NULL), 1, SRC_LINE);
 903     }
 904 }
 905
 906 struct current_thread_cleanup
 907 {
 908   ptid_t inferior_ptid;
 909   struct frame_id selected_frame_id;
 910   int selected_frame_level;
 911   int was_stopped;
 912 };
 913
 914 static void
 915 do_restore_current_thread_cleanup (void *arg)
 916 {
 917   struct thread_info *tp;
 918   struct current_thread_cleanup *old = arg;
 919
 920   tp = find_thread_pid (old->inferior_ptid);
 921
 922   /* If the previously selected thread belonged to a process that has
 923      in the mean time been deleted (due to normal exit, detach, etc.),
 924      then don't revert back to it, but instead simply drop back to no
 925      thread selected.  */
 926   if (tp
 927       && is_exited (tp->ptid)
 928       && find_inferior_pid (ptid_get_pid (tp->ptid)) == NULL)
 929     restore_current_thread (null_ptid);
 930   else
 931     restore_current_thread (old->inferior_ptid);
 932
 933   /* The running state of the originally selected thread may have
 934      changed, so we have to recheck it here.  */
 935   if (!ptid_equal (inferior_ptid, null_ptid)
 936       && old->was_stopped
 937       && is_stopped (inferior_ptid)
 938       && target_has_registers
 939       && target_has_stack
 940       && target_has_memory)
 941     restore_selected_frame (old->selected_frame_id,
 942                             old->selected_frame_level);
 943 }
 944
 945 static void
 946 restore_current_thread_cleanup_dtor (void *arg)
 947 {
 948   struct current_thread_cleanup *old = arg;
 949   struct thread_info *tp;
 950   tp = find_thread_pid (old->inferior_ptid);
 951   if (tp)
 952     tp->refcount--;
 953   xfree (old);
 954 }
 955
 956 struct cleanup *
 957 make_cleanup_restore_current_thread (void)
 958 {
 959   struct thread_info *tp;
 960   struct frame_info *frame;
 961   struct current_thread_cleanup *old;
 962
 963   old = xmalloc (sizeof (struct current_thread_cleanup));
 964   old->inferior_ptid = inferior_ptid;
 965
 966   if (!ptid_equal (inferior_ptid, null_ptid))
 967     {
 968       old->was_stopped = is_stopped (inferior_ptid);
 969       if (old->was_stopped
 970           && target_has_registers
 971           && target_has_stack
 972           && target_has_memory)
 973         frame = get_selected_frame (NULL);
 974       else
 975         frame = NULL;
 976
 977       old->selected_frame_id = get_frame_id (frame);
 978       old->selected_frame_level = frame_relative_level (frame);
 979
 980       tp = find_thread_pid (inferior_ptid);
 981       if (tp)
 982         tp->refcount++;
 983     }
 984
 985   return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
 986                             restore_current_thread_cleanup_dtor);
 987 }
 988
 989 /* Apply a GDB command to a list of threads.  List syntax is a whitespace
 990    seperated list of numbers, or ranges, or the keyword `all'.  Ranges consist
 991    of two numbers seperated by a hyphen.  Examples:
 992
 993    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
 994    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
 995    thread apply all p x/i $pc   Apply x/i $pc cmd to all threads
 996  */
 997
 998 static void
 999 thread_apply_all_command (char *cmd, int from_tty)
1000 {
1001   struct thread_info *tp;
1002   struct cleanup *old_chain;
1003   char *saved_cmd;
1004
1005   if (cmd == NULL || *cmd == '\000')
1006     error (_("Please specify a command following the thread ID list"));
1007
1008   prune_threads ();
1009   target_find_new_threads ();
1010
1011   old_chain = make_cleanup_restore_current_thread ();
1012
1013   /* Save a copy of the command in case it is clobbered by
1014      execute_command */
1015   saved_cmd = xstrdup (cmd);
1016   make_cleanup (xfree, saved_cmd);
1017   for (tp = thread_list; tp; tp = tp->next)
1018     if (thread_alive (tp))
1019       {
1020         switch_to_thread (tp->ptid);
1021
1022         printf_filtered (_("\nThread %d (%s):\n"),
1023                          tp->num, target_pid_to_str (inferior_ptid));
1024         execute_command (cmd, from_tty);
1025         strcpy (cmd, saved_cmd);        /* Restore exact command used previously */
1026       }
1027
1028   do_cleanups (old_chain);
1029 }
1030
1031 static void
1032 thread_apply_command (char *tidlist, int from_tty)
1033 {
1034   char *cmd;
1035   char *p;
1036   struct cleanup *old_chain;
1037   char *saved_cmd;
1038
1039   if (tidlist == NULL || *tidlist == '\000')
1040     error (_("Please specify a thread ID list"));
1041
1042   for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
1043
1044   if (*cmd == '\000')
1045     error (_("Please specify a command following the thread ID list"));
1046
1047   /* Save a copy of the command in case it is clobbered by
1048      execute_command */
1049   saved_cmd = xstrdup (cmd);
1050   old_chain = make_cleanup (xfree, saved_cmd);
1051   while (tidlist < cmd)
1052     {
1053       struct thread_info *tp;
1054       int start, end;
1055
1056       start = strtol (tidlist, &p, 10);
1057       if (p == tidlist)
1058         error (_("Error parsing %s"), tidlist);
1059       tidlist = p;
1060
1061       while (*tidlist == ' ' || *tidlist == '\t')
1062         tidlist++;
1063
1064       if (*tidlist == '-')      /* Got a range of IDs? */
1065         {
1066           tidlist++;            /* Skip the - */
1067           end = strtol (tidlist, &p, 10);
1068           if (p == tidlist)
1069             error (_("Error parsing %s"), tidlist);
1070           tidlist = p;
1071
1072           while (*tidlist == ' ' || *tidlist == '\t')
1073             tidlist++;
1074         }
1075       else
1076         end = start;
1077
1078       make_cleanup_restore_current_thread ();
1079
1080       for (; start <= end; start++)
1081         {
1082           tp = find_thread_id (start);
1083
1084           if (!tp)
1085             warning (_("Unknown thread %d."), start);
1086           else if (!thread_alive (tp))
1087             warning (_("Thread %d has terminated."), start);
1088           else
1089             {
1090               switch_to_thread (tp->ptid);
1091
1092               printf_filtered (_("\nThread %d (%s):\n"), tp->num,
1093                                target_pid_to_str (inferior_ptid));
1094               execute_command (cmd, from_tty);
1095
1096               /* Restore exact command used previously.  */
1097               strcpy (cmd, saved_cmd);
1098             }
1099         }
1100     }
1101
1102   do_cleanups (old_chain);
1103 }
1104
1105 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
1106    if prefix of arg is `apply'.  */
1107
1108 static void
1109 thread_command (char *tidstr, int from_tty)
1110 {
1111   if (!tidstr)
1112     {
1113       if (ptid_equal (inferior_ptid, null_ptid))
1114         error (_("No thread selected"));
1115
1116       if (target_has_stack)
1117         {
1118           if (is_exited (inferior_ptid))
1119             printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
1120                              pid_to_thread_id (inferior_ptid),
1121                              target_pid_to_str (inferior_ptid));
1122           else
1123             printf_filtered (_("[Current thread is %d (%s)]\n"),
1124                              pid_to_thread_id (inferior_ptid),
1125                              target_pid_to_str (inferior_ptid));
1126         }
1127       else
1128         error (_("No stack."));
1129       return;
1130     }
1131
1132   gdb_thread_select (uiout, tidstr, NULL);
1133 }
1134
1135 /* Print notices when new threads are attached and detached.  */
1136 int print_thread_events = 1;
1137 static void
1138 show_print_thread_events (struct ui_file *file, int from_tty,
1139                           struct cmd_list_element *c, const char *value)
1140 {
1141   fprintf_filtered (file, _("\
1142 Printing of thread events is %s.\n"),
1143                     value);
1144 }
1145
1146 static int
1147 do_captured_thread_select (struct ui_out *uiout, void *tidstr)
1148 {
1149   int num;
1150   struct thread_info *tp;
1151
1152   num = value_as_long (parse_and_eval (tidstr));
1153
1154   tp = find_thread_id (num);
1155
1156   if (!tp)
1157     error (_("Thread ID %d not known."), num);
1158
1159   if (!thread_alive (tp))
1160     error (_("Thread ID %d has terminated."), num);
1161
1162   switch_to_thread (tp->ptid);
1163
1164   annotate_thread_changed ();
1165
1166   ui_out_text (uiout, "[Switching to thread ");
1167   ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
1168   ui_out_text (uiout, " (");
1169   ui_out_text (uiout, target_pid_to_str (inferior_ptid));
1170   ui_out_text (uiout, ")]");
1171
1172   /* Note that we can't reach this with an exited thread, due to the
1173      thread_alive check above.  */
1174   if (tp->state_ == THREAD_RUNNING)
1175     ui_out_text (uiout, "(running)\n");
1176   else
1177     print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1178
1179   /* Since the current thread may have changed, see if there is any
1180      exited thread we can now delete.  */
1181   prune_threads ();
1182
1183   return GDB_RC_OK;
1184 }
1185
1186 enum gdb_rc
1187 gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
1188 {
1189   if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
1190                                  error_message, RETURN_MASK_ALL) < 0)
1191     return GDB_RC_FAIL;
1192   return GDB_RC_OK;
1193 }
1194
1195 /* Commands with a prefix of `thread'.  */
1196 struct cmd_list_element *thread_cmd_list = NULL;
1197
1198 void
1199 _initialize_thread (void)
1200 {
1201   static struct cmd_list_element *thread_apply_list = NULL;
1202
1203   add_info ("threads", info_threads_command,
1204             _("IDs of currently known threads."));
1205
1206   add_prefix_cmd ("thread", class_run, thread_command, _("\
1207 Use this command to switch between threads.\n\
1208 The new thread ID must be currently known."),
1209                   &thread_cmd_list, "thread ", 1, &cmdlist);
1210
1211   add_prefix_cmd ("apply", class_run, thread_apply_command,
1212                   _("Apply a command to a list of threads."),
1213                   &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
1214
1215   add_cmd ("all", class_run, thread_apply_all_command,
1216            _("Apply a command to all threads."), &thread_apply_list);
1217
1218   if (!xdb_commands)
1219     add_com_alias ("t", "thread", class_run, 1);
1220
1221   add_setshow_boolean_cmd ("thread-events", no_class,
1222          &print_thread_events, _("\
1223 Set printing of thread events (such as thread start and exit)."), _("\
1224 Show printing of thread events (such as thread start and exit)."), NULL,
1225          NULL,
1226          show_print_thread_events,
1227          &setprintlist, &showprintlist);
1228 }