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 /* Print information about currently known threads
 411
 412  * Note: this has the drawback that it _really_ switches
 413  *       threads, which frees the frame cache.  A no-side
 414  *       effects info-threads command would be nicer.
 415  */
 416
 417 static void
 418 info_threads_command (char *arg, int from_tty)
 419 {
 420   struct thread_info *tp;
 421   ptid_t current_ptid;
 422   struct frame_info *cur_frame;
 423   struct cleanup *old_chain;
 424   struct frame_id saved_frame_id;
 425   char *extra_info;
 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   prune_threads ();
 432   target_find_new_threads ();
 433   current_ptid = inferior_ptid;
 434   for (tp = thread_list; tp; tp = tp->next)
 435     {
 436       if (ptid_equal (tp->ptid, current_ptid))
 437         printf_filtered ("* ");
 438       else
 439         printf_filtered ("  ");
 440
 441       printf_filtered ("%d %s", tp->num, target_tid_to_str (tp->ptid));
 442
 443       extra_info = target_extra_thread_info (tp);
 444       if (extra_info)
 445         printf_filtered (" (%s)", extra_info);
 446       puts_filtered ("  ");
 447       /* That switch put us at the top of the stack (leaf frame).  */
 448       switch_to_thread (tp->ptid);
 449       print_stack_frame (get_selected_frame (NULL), 0, LOCATION);
 450     }
 451
 452   /* Restores the current thread and the frame selected before
 453      the "info threads" command.  */
 454   do_cleanups (old_chain);
 455
 456   /*  If case we were not able to find the original frame, print the
 457       new selected frame.  */
 458   if (frame_find_by_id (saved_frame_id) == NULL)
 459     {
 460       warning (_("Couldn't restore frame in current thread, at frame 0"));
 461       print_stack_frame (get_selected_frame (NULL), 0, LOCATION);
 462     }
 463 }
 464
 465 /* Switch from one thread to another. */
 466
 467 void
 468 switch_to_thread (ptid_t ptid)
 469 {
 470   if (ptid_equal (ptid, inferior_ptid))
 471     return;
 472
 473   inferior_ptid = ptid;
 474   reinit_frame_cache ();
 475   registers_changed ();
 476   stop_pc = read_pc ();
 477 }
 478
 479 static void
 480 restore_current_thread (ptid_t ptid)
 481 {
 482   if (!ptid_equal (ptid, inferior_ptid))
 483     {
 484       switch_to_thread (ptid);
 485     }
 486 }
 487
 488 static void
 489 restore_selected_frame (struct frame_id a_frame_id)
 490 {
 491   struct frame_info *selected_frame_info = NULL;
 492
 493   if (frame_id_eq (a_frame_id, null_frame_id))
 494     return;
 495
 496   if ((selected_frame_info = frame_find_by_id (a_frame_id)) != NULL)
 497     {
 498       select_frame (selected_frame_info);
 499     }
 500 }
 501
 502 struct current_thread_cleanup
 503 {
 504   ptid_t inferior_ptid;
 505   struct frame_id selected_frame_id;
 506 };
 507
 508 static void
 509 do_restore_current_thread_cleanup (void *arg)
 510 {
 511   struct current_thread_cleanup *old = arg;
 512   restore_current_thread (old->inferior_ptid);
 513   restore_selected_frame (old->selected_frame_id);
 514   xfree (old);
 515 }
 516
 517 static struct cleanup *
 518 make_cleanup_restore_current_thread (ptid_t inferior_ptid,
 519                                      struct frame_id a_frame_id)
 520 {
 521   struct current_thread_cleanup *old
 522     = xmalloc (sizeof (struct current_thread_cleanup));
 523   old->inferior_ptid = inferior_ptid;
 524   old->selected_frame_id = a_frame_id;
 525   return make_cleanup (do_restore_current_thread_cleanup, old);
 526 }
 527
 528 /* Apply a GDB command to a list of threads.  List syntax is a whitespace
 529    seperated list of numbers, or ranges, or the keyword `all'.  Ranges consist
 530    of two numbers seperated by a hyphen.  Examples:
 531
 532    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
 533    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
 534    thread apply all p x/i $pc   Apply x/i $pc cmd to all threads
 535  */
 536
 537 static void
 538 thread_apply_all_command (char *cmd, int from_tty)
 539 {
 540   struct thread_info *tp;
 541   struct cleanup *old_chain;
 542   struct cleanup *saved_cmd_cleanup_chain;
 543   char *saved_cmd;
 544   struct frame_id saved_frame_id;
 545   ptid_t current_ptid;
 546   int thread_has_changed = 0;
 547
 548   if (cmd == NULL || *cmd == '\000')
 549     error (_("Please specify a command following the thread ID list"));
 550
 551   current_ptid = inferior_ptid;
 552   saved_frame_id = get_frame_id (get_selected_frame (NULL));
 553   old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
 554
 555   /* It is safe to update the thread list now, before
 556      traversing it for "thread apply all".  MVS */
 557   target_find_new_threads ();
 558
 559   /* Save a copy of the command in case it is clobbered by
 560      execute_command */
 561   saved_cmd = xstrdup (cmd);
 562   saved_cmd_cleanup_chain = make_cleanup (xfree, (void *) saved_cmd);
 563   for (tp = thread_list; tp; tp = tp->next)
 564     if (thread_alive (tp))
 565       {
 566         switch_to_thread (tp->ptid);
 567         printf_filtered (_("\nThread %d (%s):\n"),
 568                          tp->num, target_tid_to_str (inferior_ptid));
 569         execute_command (cmd, from_tty);
 570         strcpy (cmd, saved_cmd);        /* Restore exact command used previously */
 571       }
 572
 573   if (!ptid_equal (current_ptid, inferior_ptid))
 574     thread_has_changed = 1;
 575
 576   do_cleanups (saved_cmd_cleanup_chain);
 577   do_cleanups (old_chain);
 578   /* Print stack frame only if we changed thread.  */
 579   if (thread_has_changed)
 580     print_stack_frame (get_current_frame (), 1, SRC_LINE);
 581
 582 }
 583
 584 static void
 585 thread_apply_command (char *tidlist, int from_tty)
 586 {
 587   char *cmd;
 588   char *p;
 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 (tidlist == NULL || *tidlist == '\000')
 597     error (_("Please specify a thread ID list"));
 598
 599   for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
 600
 601   if (*cmd == '\000')
 602     error (_("Please specify a command following the thread ID list"));
 603
 604   current_ptid = inferior_ptid;
 605   saved_frame_id = get_frame_id (get_selected_frame (NULL));
 606   old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
 607
 608   /* Save a copy of the command in case it is clobbered by
 609      execute_command */
 610   saved_cmd = xstrdup (cmd);
 611   saved_cmd_cleanup_chain = make_cleanup (xfree, (void *) saved_cmd);
 612   while (tidlist < cmd)
 613     {
 614       struct thread_info *tp;
 615       int start, end;
 616
 617       start = strtol (tidlist, &p, 10);
 618       if (p == tidlist)
 619         error (_("Error parsing %s"), tidlist);
 620       tidlist = p;
 621
 622       while (*tidlist == ' ' || *tidlist == '\t')
 623         tidlist++;
 624
 625       if (*tidlist == '-')      /* Got a range of IDs? */
 626         {
 627           tidlist++;            /* Skip the - */
 628           end = strtol (tidlist, &p, 10);
 629           if (p == tidlist)
 630             error (_("Error parsing %s"), tidlist);
 631           tidlist = p;
 632
 633           while (*tidlist == ' ' || *tidlist == '\t')
 634             tidlist++;
 635         }
 636       else
 637         end = start;
 638
 639       for (; start <= end; start++)
 640         {
 641           tp = find_thread_id (start);
 642
 643           if (!tp)
 644             warning (_("Unknown thread %d."), start);
 645           else if (!thread_alive (tp))
 646             warning (_("Thread %d has terminated."), start);
 647           else
 648             {
 649               switch_to_thread (tp->ptid);
 650               printf_filtered (_("\nThread %d (%s):\n"), tp->num,
 651                                target_tid_to_str (inferior_ptid));
 652               execute_command (cmd, from_tty);
 653               strcpy (cmd, saved_cmd);  /* Restore exact command used previously */
 654             }
 655         }
 656     }
 657
 658   if (!ptid_equal (current_ptid, inferior_ptid))
 659     thread_has_changed = 1;
 660
 661   do_cleanups (saved_cmd_cleanup_chain);
 662   do_cleanups (old_chain);
 663   /* Print stack frame only if we changed thread.  */
 664   if (thread_has_changed)
 665     print_stack_frame (get_current_frame (), 1, SRC_LINE);
 666 }
 667
 668 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
 669    if prefix of arg is `apply'.  */
 670
 671 static void
 672 thread_command (char *tidstr, int from_tty)
 673 {
 674   if (!tidstr)
 675     {
 676       /* Don't generate an error, just say which thread is current. */
 677       if (target_has_stack)
 678         printf_filtered (_("[Current thread is %d (%s)]\n"),
 679                          pid_to_thread_id (inferior_ptid),
 680                          target_tid_to_str (inferior_ptid));
 681       else
 682         error (_("No stack."));
 683       return;
 684     }
 685
 686   gdb_thread_select (uiout, tidstr, NULL);
 687 }
 688
 689 /* Print notices when new threads are attached and detached.  */
 690 int print_thread_events = 1;
 691 static void
 692 show_print_thread_events (struct ui_file *file, int from_tty,
 693                           struct cmd_list_element *c, const char *value)
 694 {
 695   fprintf_filtered (file, _("\
 696 Printing of thread events is %s.\n"),
 697                     value);
 698 }
 699
 700 static int
 701 do_captured_thread_select (struct ui_out *uiout, void *tidstr)
 702 {
 703   int num;
 704   struct thread_info *tp;
 705
 706   num = value_as_long (parse_and_eval (tidstr));
 707
 708   tp = find_thread_id (num);
 709
 710   if (!tp)
 711     error (_("Thread ID %d not known."), num);
 712
 713   if (!thread_alive (tp))
 714     error (_("Thread ID %d has terminated."), num);
 715
 716   switch_to_thread (tp->ptid);
 717
 718   ui_out_text (uiout, "[Switching to thread ");
 719   ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
 720   ui_out_text (uiout, " (");
 721   ui_out_text (uiout, target_tid_to_str (inferior_ptid));
 722   ui_out_text (uiout, ")]");
 723
 724   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 725   return GDB_RC_OK;
 726 }
 727
 728 enum gdb_rc
 729 gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
 730 {
 731   if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
 732                                  error_message, RETURN_MASK_ALL) < 0)
 733     return GDB_RC_FAIL;
 734   return GDB_RC_OK;
 735 }
 736
 737 /* Commands with a prefix of `thread'.  */
 738 struct cmd_list_element *thread_cmd_list = NULL;
 739
 740 void
 741 _initialize_thread (void)
 742 {
 743   static struct cmd_list_element *thread_apply_list = NULL;
 744
 745   add_info ("threads", info_threads_command,
 746             _("IDs of currently known threads."));
 747
 748   add_prefix_cmd ("thread", class_run, thread_command, _("\
 749 Use this command to switch between threads.\n\
 750 The new thread ID must be currently known."),
 751                   &thread_cmd_list, "thread ", 1, &cmdlist);
 752
 753   add_prefix_cmd ("apply", class_run, thread_apply_command,
 754                   _("Apply a command to a list of threads."),
 755                   &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
 756
 757   add_cmd ("all", class_run, thread_apply_all_command,
 758            _("Apply a command to all threads."), &thread_apply_list);
 759
 760   if (!xdb_commands)
 761     add_com_alias ("t", "thread", class_run, 1);
 762
 763   add_setshow_boolean_cmd ("thread-events", no_class,
 764          &print_thread_events, _("\
 765 Set printing of thread events (e.g., thread start and exit)."), _("\
 766 Show printing of thread events (e.g., thread start and exit)."), NULL,
 767          NULL,
 768          show_print_thread_events,
 769          &setprintlist, &showprintlist);
 770 }