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