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
  45 /* Definition of struct thread_info exported to gdbthread.h */
  46
  47 /* Prototypes for exported functions. */
  48
  49 void _initialize_thread (void);
  50
  51 /* Prototypes for local functions. */
  52
  53 static struct thread_info *thread_list = NULL;
  54 static int highest_thread_num;
  55
  56 static struct thread_info *find_thread_id (int 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 void
  67 delete_step_resume_breakpoint (void *arg)
  68 {
  69   struct breakpoint **breakpointp = (struct breakpoint **) arg;
  70   struct thread_info *tp;
  71
  72   if (*breakpointp != NULL)
  73     {
  74       delete_breakpoint (*breakpointp);
  75       for (tp = thread_list; tp; tp = tp->next)
  76         if (tp->step_resume_breakpoint == *breakpointp)
  77           tp->step_resume_breakpoint = NULL;
  78
  79       *breakpointp = NULL;
  80     }
  81 }
  82
  83 static void
  84 free_thread (struct thread_info *tp)
  85 {
  86   /* NOTE: this will take care of any left-over step_resume breakpoints,
  87      but not any user-specified thread-specific breakpoints.  We can not
  88      delete the breakpoint straight-off, because the inferior might not
  89      be stopped at the moment.  */
  90   if (tp->step_resume_breakpoint)
  91     tp->step_resume_breakpoint->disposition = disp_del_at_next_stop;
  92
  93   /* FIXME: do I ever need to call the back-end to give it a
  94      chance at this private data before deleting the thread?  */
  95   if (tp->private)
  96     xfree (tp->private);
  97
  98   xfree (tp);
  99 }
 100
 101 void
 102 init_thread_list (void)
 103 {
 104   struct thread_info *tp, *tpnext;
 105
 106   highest_thread_num = 0;
 107   if (!thread_list)
 108     return;
 109
 110   for (tp = thread_list; tp; tp = tpnext)
 111     {
 112       tpnext = tp->next;
 113       free_thread (tp);
 114     }
 115
 116   thread_list = NULL;
 117 }
 118
 119 struct thread_info *
 120 add_thread_silent (ptid_t ptid)
 121 {
 122   struct thread_info *tp;
 123
 124   tp = (struct thread_info *) xmalloc (sizeof (*tp));
 125   memset (tp, 0, sizeof (*tp));
 126   tp->ptid = ptid;
 127   tp->num = ++highest_thread_num;
 128   tp->next = thread_list;
 129   thread_list = tp;
 130
 131   observer_notify_new_thread (tp);
 132
 133   return tp;
 134 }
 135
 136 struct thread_info *
 137 add_thread_with_info (ptid_t ptid, struct private_thread_info *private)
 138 {
 139   struct thread_info *result = add_thread_silent (ptid);
 140
 141   result->private = private;
 142
 143   if (print_thread_events)
 144     printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
 145
 146   annotate_new_thread ();
 147   return result;
 148 }
 149
 150 struct thread_info *
 151 add_thread (ptid_t ptid)
 152 {
 153   return add_thread_with_info (ptid, NULL);
 154 }
 155
 156 void
 157 delete_thread (ptid_t ptid)
 158 {
 159   struct thread_info *tp, *tpprev;
 160
 161   tpprev = NULL;
 162
 163   for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
 164     if (ptid_equal (tp->ptid, ptid))
 165       break;
 166
 167   if (!tp)
 168     return;
 169
 170   if (tpprev)
 171     tpprev->next = tp->next;
 172   else
 173     thread_list = tp->next;
 174
 175   observer_notify_thread_exit (tp);
 176
 177   free_thread (tp);
 178 }
 179
 180 static struct thread_info *
 181 find_thread_id (int num)
 182 {
 183   struct thread_info *tp;
 184
 185   for (tp = thread_list; tp; tp = tp->next)
 186     if (tp->num == num)
 187       return tp;
 188
 189   return NULL;
 190 }
 191
 192 /* Find a thread_info by matching PTID.  */
 193 struct thread_info *
 194 find_thread_pid (ptid_t ptid)
 195 {
 196   struct thread_info *tp;
 197
 198   for (tp = thread_list; tp; tp = tp->next)
 199     if (ptid_equal (tp->ptid, ptid))
 200       return tp;
 201
 202   return NULL;
 203 }
 204
 205 /*
 206  * Thread iterator function.
 207  *
 208  * Calls a callback function once for each thread, so long as
 209  * the callback function returns false.  If the callback function
 210  * returns true, the iteration will end and the current thread
 211  * will be returned.  This can be useful for implementing a
 212  * search for a thread with arbitrary attributes, or for applying
 213  * some operation to every thread.
 214  *
 215  * FIXME: some of the existing functionality, such as
 216  * "Thread apply all", might be rewritten using this functionality.
 217  */
 218
 219 struct thread_info *
 220 iterate_over_threads (int (*callback) (struct thread_info *, void *),
 221                       void *data)
 222 {
 223   struct thread_info *tp;
 224
 225   for (tp = thread_list; tp; tp = tp->next)
 226     if ((*callback) (tp, data))
 227       return tp;
 228
 229   return NULL;
 230 }
 231
 232 int
 233 valid_thread_id (int num)
 234 {
 235   struct thread_info *tp;
 236
 237   for (tp = thread_list; tp; tp = tp->next)
 238     if (tp->num == num)
 239       return 1;
 240
 241   return 0;
 242 }
 243
 244 int
 245 pid_to_thread_id (ptid_t ptid)
 246 {
 247   struct thread_info *tp;
 248
 249   for (tp = thread_list; tp; tp = tp->next)
 250     if (ptid_equal (tp->ptid, ptid))
 251       return tp->num;
 252
 253   return 0;
 254 }
 255
 256 ptid_t
 257 thread_id_to_pid (int num)
 258 {
 259   struct thread_info *thread = find_thread_id (num);
 260   if (thread)
 261     return thread->ptid;
 262   else
 263     return pid_to_ptid (-1);
 264 }
 265
 266 int
 267 in_thread_list (ptid_t ptid)
 268 {
 269   struct thread_info *tp;
 270
 271   for (tp = thread_list; tp; tp = tp->next)
 272     if (ptid_equal (tp->ptid, ptid))
 273       return 1;
 274
 275   return 0;                     /* Never heard of 'im */
 276 }
 277
 278 /* Print a list of thread ids currently known, and the total number of
 279    threads. To be used from within catch_errors. */
 280 static int
 281 do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
 282 {
 283   struct thread_info *tp;
 284   int num = 0;
 285   struct cleanup *cleanup_chain;
 286
 287   prune_threads ();
 288   target_find_new_threads ();
 289
 290   cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids");
 291
 292   for (tp = thread_list; tp; tp = tp->next)
 293     {
 294       num++;
 295       ui_out_field_int (uiout, "thread-id", tp->num);
 296     }
 297
 298   do_cleanups (cleanup_chain);
 299   ui_out_field_int (uiout, "number-of-threads", num);
 300   return GDB_RC_OK;
 301 }
 302
 303 /* Official gdblib interface function to get a list of thread ids and
 304    the total number. */
 305 enum gdb_rc
 306 gdb_list_thread_ids (struct ui_out *uiout, char **error_message)
 307 {
 308   if (catch_exceptions_with_msg (uiout, do_captured_list_thread_ids, NULL,
 309                                  error_message, RETURN_MASK_ALL) < 0)
 310     return GDB_RC_FAIL;
 311   return GDB_RC_OK;
 312 }
 313
 314 /* Load infrun state for the thread PID.  */
 315
 316 void
 317 load_infrun_state (ptid_t ptid,
 318                    CORE_ADDR *prev_pc,
 319                    int *trap_expected,
 320                    struct breakpoint **step_resume_breakpoint,
 321                    CORE_ADDR *step_range_start,
 322                    CORE_ADDR *step_range_end,
 323                    struct frame_id *step_frame_id,
 324                    int *stepping_over_breakpoint,
 325                    int *stepping_through_solib_after_catch,
 326                    bpstat *stepping_through_solib_catchpoints,
 327                    int *current_line,
 328                    struct symtab **current_symtab)
 329 {
 330   struct thread_info *tp;
 331
 332   /* If we can't find the thread, then we're debugging a single threaded
 333      process.  No need to do anything in that case.  */
 334   tp = find_thread_id (pid_to_thread_id (ptid));
 335   if (tp == NULL)
 336     return;
 337
 338   *prev_pc = tp->prev_pc;
 339   *trap_expected = tp->trap_expected;
 340   *step_resume_breakpoint = tp->step_resume_breakpoint;
 341   *step_range_start = tp->step_range_start;
 342   *step_range_end = tp->step_range_end;
 343   *step_frame_id = tp->step_frame_id;
 344   *stepping_over_breakpoint = tp->stepping_over_breakpoint;
 345   *stepping_through_solib_after_catch =
 346     tp->stepping_through_solib_after_catch;
 347   *stepping_through_solib_catchpoints =
 348     tp->stepping_through_solib_catchpoints;
 349   *current_line = tp->current_line;
 350   *current_symtab = tp->current_symtab;
 351 }
 352
 353 /* Save infrun state for the thread PID.  */
 354
 355 void
 356 save_infrun_state (ptid_t ptid,
 357                    CORE_ADDR prev_pc,
 358                    int trap_expected,
 359                    struct breakpoint *step_resume_breakpoint,
 360                    CORE_ADDR step_range_start,
 361                    CORE_ADDR step_range_end,
 362                    const struct frame_id *step_frame_id,
 363                    int stepping_over_breakpoint,
 364                    int stepping_through_solib_after_catch,
 365                    bpstat stepping_through_solib_catchpoints,
 366                    int current_line,
 367                    struct symtab *current_symtab)
 368 {
 369   struct thread_info *tp;
 370
 371   /* If we can't find the thread, then we're debugging a single-threaded
 372      process.  Nothing to do in that case.  */
 373   tp = find_thread_id (pid_to_thread_id (ptid));
 374   if (tp == NULL)
 375     return;
 376
 377   tp->prev_pc = prev_pc;
 378   tp->trap_expected = trap_expected;
 379   tp->step_resume_breakpoint = step_resume_breakpoint;
 380   tp->step_range_start = step_range_start;
 381   tp->step_range_end = step_range_end;
 382   tp->step_frame_id = (*step_frame_id);
 383   tp->stepping_over_breakpoint = stepping_over_breakpoint;
 384   tp->stepping_through_solib_after_catch = stepping_through_solib_after_catch;
 385   tp->stepping_through_solib_catchpoints = stepping_through_solib_catchpoints;
 386   tp->current_line = current_line;
 387   tp->current_symtab = current_symtab;
 388 }
 389
 390 /* Return true if TP is an active thread. */
 391 static int
 392 thread_alive (struct thread_info *tp)
 393 {
 394   if (PIDGET (tp->ptid) == -1)
 395     return 0;
 396   if (!target_thread_alive (tp->ptid))
 397     {
 398       tp->ptid = pid_to_ptid (-1);      /* Mark it as dead */
 399       return 0;
 400     }
 401   return 1;
 402 }
 403
 404 static void
 405 prune_threads (void)
 406 {
 407   struct thread_info *tp, *next;
 408
 409   for (tp = thread_list; tp; tp = next)
 410     {
 411       next = tp->next;
 412       if (!thread_alive (tp))
 413         delete_thread (tp->ptid);
 414     }
 415 }
 416
 417 static int main_thread_running = 0;
 418
 419 void
 420 set_running (ptid_t ptid, int running)
 421 {
 422   struct thread_info *tp;
 423
 424   if (!thread_list)
 425     {
 426       /* This is one of the targets that does not add main
 427          thread to the thread list.  Just use a single
 428          global flag to indicate that a thread is running.
 429
 430          This problem is unique to ST programs.  For MT programs,
 431          the main thread is always present in the thread list.  If it's
 432          not, the first call to context_switch will mess up GDB internal
 433          state.  */
 434       if (running && !main_thread_running && !suppress_resume_observer)
 435         observer_notify_target_resumed (ptid);
 436       main_thread_running = running;
 437       return;
 438     }
 439
 440   /* We try not to notify the observer if no thread has actually changed
 441      the running state -- merely to reduce the number of messages to
 442      frontend.  Frontend is supposed to handle multiple *running just fine.  */
 443   if (PIDGET (ptid) == -1)
 444     {
 445       int any_started = 0;
 446       for (tp = thread_list; tp; tp = tp->next)
 447         {
 448           if (running && !tp->running_)
 449             any_started = 1;
 450           tp->running_ = running;
 451         }
 452       if (any_started && !suppress_resume_observer)
 453         observer_notify_target_resumed (ptid);
 454     }
 455   else
 456     {
 457       tp = find_thread_pid (ptid);
 458       gdb_assert (tp);
 459       if (running && !tp->running_ && !suppress_resume_observer)
 460         observer_notify_target_resumed (ptid);
 461       tp->running_ = running;
 462     }
 463 }
 464
 465 int
 466 is_running (ptid_t ptid)
 467 {
 468   struct thread_info *tp;
 469
 470   if (!thread_list)
 471     return main_thread_running;
 472
 473   tp = find_thread_pid (ptid);
 474   gdb_assert (tp);
 475   return tp->running_;
 476 }
 477
 478 /* Prints the list of threads and their details on UIOUT.
 479    This is a version of 'info_thread_command' suitable for
 480    use from MI.
 481    If REQESTED_THREAD is not -1, it's the GDB id of the thread
 482    that should be printed.  Otherwise, all threads are
 483    printed.  */
 484 void
 485 print_thread_info (struct ui_out *uiout, int requested_thread)
 486 {
 487   struct thread_info *tp;
 488   ptid_t current_ptid;
 489   struct frame_info *cur_frame;
 490   struct cleanup *old_chain;
 491   struct frame_id saved_frame_id;
 492   char *extra_info;
 493   int current_thread = -1;
 494
 495   /* Backup current thread and selected frame.  */
 496   saved_frame_id = get_frame_id (get_selected_frame (NULL));
 497   old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
 498
 499   make_cleanup_ui_out_list_begin_end (uiout, "threads");
 500
 501   prune_threads ();
 502   target_find_new_threads ();
 503   current_ptid = inferior_ptid;
 504   for (tp = thread_list; tp; tp = tp->next)
 505     {
 506       struct cleanup *chain2;
 507
 508       if (requested_thread != -1 && tp->num != requested_thread)
 509         continue;
 510
 511       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 512
 513       if (ptid_equal (tp->ptid, current_ptid))
 514         {
 515           current_thread = tp->num;
 516           ui_out_text (uiout, "* ");
 517         }
 518       else
 519         ui_out_text (uiout, "  ");
 520
 521       ui_out_field_int (uiout, "id", tp->num);
 522       ui_out_text (uiout, " ");
 523       ui_out_field_string (uiout, "target-id", target_tid_to_str (tp->ptid));
 524
 525       extra_info = target_extra_thread_info (tp);
 526       if (extra_info)
 527         {
 528           ui_out_text (uiout, " (");
 529           ui_out_field_string (uiout, "details", extra_info);
 530           ui_out_text (uiout, ")");
 531         }
 532       ui_out_text (uiout, "  ");
 533       /* That switch put us at the top of the stack (leaf frame).  */
 534       switch_to_thread (tp->ptid);
 535       print_stack_frame (get_selected_frame (NULL),
 536                          /* For MI output, print frame level.  */
 537                          ui_out_is_mi_like_p (uiout),
 538                          LOCATION);
 539
 540       do_cleanups (chain2);
 541     }
 542
 543   /* Restores the current thread and the frame selected before
 544      the "info threads" command.  */
 545   do_cleanups (old_chain);
 546
 547   if (requested_thread == -1)
 548     {
 549       gdb_assert (current_thread != -1 || !thread_list);
 550       if (current_thread != -1 && ui_out_is_mi_like_p (uiout))
 551         ui_out_field_int (uiout, "current-thread-id", current_thread);
 552     }
 553
 554   /*  If case we were not able to find the original frame, print the
 555       new selected frame.  */
 556   if (frame_find_by_id (saved_frame_id) == NULL)
 557     {
 558       warning (_("Couldn't restore frame in current thread, at frame 0"));
 559       /* For MI, we should probably have a notification about
 560          current frame change.  But this error is not very likely, so
 561          don't bother for now.  */
 562       if (!ui_out_is_mi_like_p (uiout))
 563         print_stack_frame (get_selected_frame (NULL), 0, LOCATION);
 564     }
 565 }
 566
 567
 568 /* Print information about currently known threads
 569
 570  * Note: this has the drawback that it _really_ switches
 571  *       threads, which frees the frame cache.  A no-side
 572  *       effects info-threads command would be nicer.
 573  */
 574
 575 static void
 576 info_threads_command (char *arg, int from_tty)
 577 {
 578   print_thread_info (uiout, -1);
 579 }
 580
 581 /* Switch from one thread to another. */
 582
 583 void
 584 switch_to_thread (ptid_t ptid)
 585 {
 586   if (ptid_equal (ptid, inferior_ptid))
 587     return;
 588
 589   inferior_ptid = ptid;
 590   reinit_frame_cache ();
 591   registers_changed ();
 592   stop_pc = read_pc ();
 593 }
 594
 595 static void
 596 restore_current_thread (ptid_t ptid)
 597 {
 598   if (!ptid_equal (ptid, inferior_ptid))
 599     {
 600       switch_to_thread (ptid);
 601     }
 602 }
 603
 604 static void
 605 restore_selected_frame (struct frame_id a_frame_id)
 606 {
 607   struct frame_info *selected_frame_info = NULL;
 608
 609   if (frame_id_eq (a_frame_id, null_frame_id))
 610     return;
 611
 612   if ((selected_frame_info = frame_find_by_id (a_frame_id)) != NULL)
 613     {
 614       select_frame (selected_frame_info);
 615     }
 616 }
 617
 618 struct current_thread_cleanup
 619 {
 620   ptid_t inferior_ptid;
 621   struct frame_id selected_frame_id;
 622 };
 623
 624 static void
 625 do_restore_current_thread_cleanup (void *arg)
 626 {
 627   struct current_thread_cleanup *old = arg;
 628   restore_current_thread (old->inferior_ptid);
 629   restore_selected_frame (old->selected_frame_id);
 630   xfree (old);
 631 }
 632
 633 struct cleanup *
 634 make_cleanup_restore_current_thread (ptid_t inferior_ptid,
 635                                      struct frame_id a_frame_id)
 636 {
 637   struct current_thread_cleanup *old
 638     = xmalloc (sizeof (struct current_thread_cleanup));
 639   old->inferior_ptid = inferior_ptid;
 640   old->selected_frame_id = a_frame_id;
 641   return make_cleanup (do_restore_current_thread_cleanup, old);
 642 }
 643
 644 /* Apply a GDB command to a list of threads.  List syntax is a whitespace
 645    seperated list of numbers, or ranges, or the keyword `all'.  Ranges consist
 646    of two numbers seperated by a hyphen.  Examples:
 647
 648    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
 649    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
 650    thread apply all p x/i $pc   Apply x/i $pc cmd to all threads
 651  */
 652
 653 static void
 654 thread_apply_all_command (char *cmd, int from_tty)
 655 {
 656   struct thread_info *tp;
 657   struct cleanup *old_chain;
 658   struct cleanup *saved_cmd_cleanup_chain;
 659   char *saved_cmd;
 660   struct frame_id saved_frame_id;
 661   ptid_t current_ptid;
 662   int thread_has_changed = 0;
 663
 664   if (cmd == NULL || *cmd == '\000')
 665     error (_("Please specify a command following the thread ID list"));
 666
 667   current_ptid = inferior_ptid;
 668   saved_frame_id = get_frame_id (get_selected_frame (NULL));
 669   old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
 670
 671   /* It is safe to update the thread list now, before
 672      traversing it for "thread apply all".  MVS */
 673   target_find_new_threads ();
 674
 675   /* Save a copy of the command in case it is clobbered by
 676      execute_command */
 677   saved_cmd = xstrdup (cmd);
 678   saved_cmd_cleanup_chain = make_cleanup (xfree, (void *) saved_cmd);
 679   for (tp = thread_list; tp; tp = tp->next)
 680     if (thread_alive (tp))
 681       {
 682         switch_to_thread (tp->ptid);
 683         printf_filtered (_("\nThread %d (%s):\n"),
 684                          tp->num, target_tid_to_str (inferior_ptid));
 685         execute_command (cmd, from_tty);
 686         strcpy (cmd, saved_cmd);        /* Restore exact command used previously */
 687       }
 688
 689   if (!ptid_equal (current_ptid, inferior_ptid))
 690     thread_has_changed = 1;
 691
 692   do_cleanups (saved_cmd_cleanup_chain);
 693   do_cleanups (old_chain);
 694   /* Print stack frame only if we changed thread.  */
 695   if (thread_has_changed)
 696     print_stack_frame (get_current_frame (), 1, SRC_LINE);
 697
 698 }
 699
 700 static void
 701 thread_apply_command (char *tidlist, int from_tty)
 702 {
 703   char *cmd;
 704   char *p;
 705   struct cleanup *old_chain;
 706   struct cleanup *saved_cmd_cleanup_chain;
 707   char *saved_cmd;
 708   struct frame_id saved_frame_id;
 709   ptid_t current_ptid;
 710   int thread_has_changed = 0;
 711
 712   if (tidlist == NULL || *tidlist == '\000')
 713     error (_("Please specify a thread ID list"));
 714
 715   for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
 716
 717   if (*cmd == '\000')
 718     error (_("Please specify a command following the thread ID list"));
 719
 720   current_ptid = inferior_ptid;
 721   saved_frame_id = get_frame_id (get_selected_frame (NULL));
 722   old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
 723
 724   /* Save a copy of the command in case it is clobbered by
 725      execute_command */
 726   saved_cmd = xstrdup (cmd);
 727   saved_cmd_cleanup_chain = make_cleanup (xfree, (void *) saved_cmd);
 728   while (tidlist < cmd)
 729     {
 730       struct thread_info *tp;
 731       int start, end;
 732
 733       start = strtol (tidlist, &p, 10);
 734       if (p == tidlist)
 735         error (_("Error parsing %s"), tidlist);
 736       tidlist = p;
 737
 738       while (*tidlist == ' ' || *tidlist == '\t')
 739         tidlist++;
 740
 741       if (*tidlist == '-')      /* Got a range of IDs? */
 742         {
 743           tidlist++;            /* Skip the - */
 744           end = strtol (tidlist, &p, 10);
 745           if (p == tidlist)
 746             error (_("Error parsing %s"), tidlist);
 747           tidlist = p;
 748
 749           while (*tidlist == ' ' || *tidlist == '\t')
 750             tidlist++;
 751         }
 752       else
 753         end = start;
 754
 755       for (; start <= end; start++)
 756         {
 757           tp = find_thread_id (start);
 758
 759           if (!tp)
 760             warning (_("Unknown thread %d."), start);
 761           else if (!thread_alive (tp))
 762             warning (_("Thread %d has terminated."), start);
 763           else
 764             {
 765               switch_to_thread (tp->ptid);
 766               printf_filtered (_("\nThread %d (%s):\n"), tp->num,
 767                                target_tid_to_str (inferior_ptid));
 768               execute_command (cmd, from_tty);
 769               strcpy (cmd, saved_cmd);  /* Restore exact command used previously */
 770             }
 771         }
 772     }
 773
 774   if (!ptid_equal (current_ptid, inferior_ptid))
 775     thread_has_changed = 1;
 776
 777   do_cleanups (saved_cmd_cleanup_chain);
 778   do_cleanups (old_chain);
 779   /* Print stack frame only if we changed thread.  */
 780   if (thread_has_changed)
 781     print_stack_frame (get_current_frame (), 1, SRC_LINE);
 782 }
 783
 784 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
 785    if prefix of arg is `apply'.  */
 786
 787 static void
 788 thread_command (char *tidstr, int from_tty)
 789 {
 790   if (!tidstr)
 791     {
 792       /* Don't generate an error, just say which thread is current. */
 793       if (target_has_stack)
 794         printf_filtered (_("[Current thread is %d (%s)]\n"),
 795                          pid_to_thread_id (inferior_ptid),
 796                          target_tid_to_str (inferior_ptid));
 797       else
 798         error (_("No stack."));
 799       return;
 800     }
 801
 802   annotate_thread_changed ();
 803   gdb_thread_select (uiout, tidstr, NULL);
 804 }
 805
 806 /* Print notices when new threads are attached and detached.  */
 807 int print_thread_events = 1;
 808 static void
 809 show_print_thread_events (struct ui_file *file, int from_tty,
 810                           struct cmd_list_element *c, const char *value)
 811 {
 812   fprintf_filtered (file, _("\
 813 Printing of thread events is %s.\n"),
 814                     value);
 815 }
 816
 817 static int
 818 do_captured_thread_select (struct ui_out *uiout, void *tidstr)
 819 {
 820   int num;
 821   struct thread_info *tp;
 822
 823   num = value_as_long (parse_and_eval (tidstr));
 824
 825   tp = find_thread_id (num);
 826
 827   if (!tp)
 828     error (_("Thread ID %d not known."), num);
 829
 830   if (!thread_alive (tp))
 831     error (_("Thread ID %d has terminated."), num);
 832
 833   switch_to_thread (tp->ptid);
 834
 835   ui_out_text (uiout, "[Switching to thread ");
 836   ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
 837   ui_out_text (uiout, " (");
 838   ui_out_text (uiout, target_tid_to_str (inferior_ptid));
 839   ui_out_text (uiout, ")]");
 840
 841   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 842   return GDB_RC_OK;
 843 }
 844
 845 enum gdb_rc
 846 gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
 847 {
 848   if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
 849                                  error_message, RETURN_MASK_ALL) < 0)
 850     return GDB_RC_FAIL;
 851   return GDB_RC_OK;
 852 }
 853
 854 /* Commands with a prefix of `thread'.  */
 855 struct cmd_list_element *thread_cmd_list = NULL;
 856
 857 void
 858 _initialize_thread (void)
 859 {
 860   static struct cmd_list_element *thread_apply_list = NULL;
 861
 862   add_info ("threads", info_threads_command,
 863             _("IDs of currently known threads."));
 864
 865   add_prefix_cmd ("thread", class_run, thread_command, _("\
 866 Use this command to switch between threads.\n\
 867 The new thread ID must be currently known."),
 868                   &thread_cmd_list, "thread ", 1, &cmdlist);
 869
 870   add_prefix_cmd ("apply", class_run, thread_apply_command,
 871                   _("Apply a command to a list of threads."),
 872                   &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
 873
 874   add_cmd ("all", class_run, thread_apply_all_command,
 875            _("Apply a command to all threads."), &thread_apply_list);
 876
 877   if (!xdb_commands)
 878     add_com_alias ("t", "thread", class_run, 1);
 879
 880   add_setshow_boolean_cmd ("thread-events", no_class,
 881          &print_thread_events, _("\
 882 Set printing of thread events (such as thread start and exit)."), _("\
 883 Show printing of thread events (such as thread start and exit)."), NULL,
 884          NULL,
 885          show_print_thread_events,
 886          &setprintlist, &showprintlist);
 887 }