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