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, 2010, 2011
   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 #include "gdb_regex.h"
  47 #include "cli/cli-utils.h"
  48 #include "continuations.h"
  49
  50 /* Definition of struct thread_info exported to gdbthread.h.  */
  51
  52 /* Prototypes for exported functions.  */
  53
  54 void _initialize_thread (void);
  55
  56 /* Prototypes for local functions.  */
  57
  58 static struct thread_info *thread_list = NULL;
  59 static int highest_thread_num;
  60
  61 static void thread_command (char *tidstr, int from_tty);
  62 static void thread_apply_all_command (char *, int);
  63 static int thread_alive (struct thread_info *);
  64 static void info_threads_command (char *, int);
  65 static void thread_apply_command (char *, int);
  66 static void restore_current_thread (ptid_t);
  67 static void prune_threads (void);
  68
  69 /* Frontend view of the thread state.  Possible extensions: stepping,
  70    finishing, until(ling),...  */
  71 enum thread_state
  72 {
  73   THREAD_STOPPED,
  74   THREAD_RUNNING,
  75   THREAD_EXITED,
  76 };
  77
  78 struct thread_info*
  79 inferior_thread (void)
  80 {
  81   struct thread_info *tp = find_thread_ptid (inferior_ptid);
  82   gdb_assert (tp);
  83   return tp;
  84 }
  85
  86 void
  87 delete_step_resume_breakpoint (struct thread_info *tp)
  88 {
  89   if (tp && tp->control.step_resume_breakpoint)
  90     {
  91       delete_breakpoint (tp->control.step_resume_breakpoint);
  92       tp->control.step_resume_breakpoint = NULL;
  93     }
  94 }
  95
  96 void
  97 delete_exception_resume_breakpoint (struct thread_info *tp)
  98 {
  99   if (tp && tp->control.exception_resume_breakpoint)
 100     {
 101       delete_breakpoint (tp->control.exception_resume_breakpoint);
 102       tp->control.exception_resume_breakpoint = NULL;
 103     }
 104 }
 105
 106 static void
 107 clear_thread_inferior_resources (struct thread_info *tp)
 108 {
 109   /* NOTE: this will take care of any left-over step_resume breakpoints,
 110      but not any user-specified thread-specific breakpoints.  We can not
 111      delete the breakpoint straight-off, because the inferior might not
 112      be stopped at the moment.  */
 113   if (tp->control.step_resume_breakpoint)
 114     {
 115       tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop;
 116       tp->control.step_resume_breakpoint = NULL;
 117     }
 118
 119   if (tp->control.exception_resume_breakpoint)
 120     {
 121       tp->control.exception_resume_breakpoint->disposition
 122         = disp_del_at_next_stop;
 123       tp->control.exception_resume_breakpoint = NULL;
 124     }
 125
 126   bpstat_clear (&tp->control.stop_bpstat);
 127
 128   do_all_intermediate_continuations_thread (tp, 1);
 129   do_all_continuations_thread (tp, 1);
 130
 131   delete_longjmp_breakpoint (tp->num);
 132 }
 133
 134 static void
 135 free_thread (struct thread_info *tp)
 136 {
 137   if (tp->private)
 138     {
 139       if (tp->private_dtor)
 140         tp->private_dtor (tp->private);
 141       else
 142         xfree (tp->private);
 143     }
 144
 145   xfree (tp->name);
 146   xfree (tp);
 147 }
 148
 149 void
 150 init_thread_list (void)
 151 {
 152   struct thread_info *tp, *tpnext;
 153
 154   highest_thread_num = 0;
 155
 156   if (!thread_list)
 157     return;
 158
 159   for (tp = thread_list; tp; tp = tpnext)
 160     {
 161       tpnext = tp->next;
 162       free_thread (tp);
 163     }
 164
 165   thread_list = NULL;
 166 }
 167
 168 /* Allocate a new thread with target id PTID and add it to the thread
 169    list.  */
 170
 171 static struct thread_info *
 172 new_thread (ptid_t ptid)
 173 {
 174   struct thread_info *tp;
 175
 176   tp = xcalloc (1, sizeof (*tp));
 177
 178   tp->ptid = ptid;
 179   tp->num = ++highest_thread_num;
 180   tp->next = thread_list;
 181   thread_list = tp;
 182
 183   /* Nothing to follow yet.  */
 184   tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
 185   tp->state_ = THREAD_STOPPED;
 186
 187   return tp;
 188 }
 189
 190 struct thread_info *
 191 add_thread_silent (ptid_t ptid)
 192 {
 193   struct thread_info *tp;
 194
 195   tp = find_thread_ptid (ptid);
 196   if (tp)
 197     /* Found an old thread with the same id.  It has to be dead,
 198        otherwise we wouldn't be adding a new thread with the same id.
 199        The OS is reusing this id --- delete it, and recreate a new
 200        one.  */
 201     {
 202       /* In addition to deleting the thread, if this is the current
 203          thread, then we need to take care that delete_thread doesn't
 204          really delete the thread if it is inferior_ptid.  Create a
 205          new template thread in the list with an invalid ptid, switch
 206          to it, delete the original thread, reset the new thread's
 207          ptid, and switch to it.  */
 208
 209       if (ptid_equal (inferior_ptid, ptid))
 210         {
 211           tp = new_thread (null_ptid);
 212
 213           /* Make switch_to_thread not read from the thread.  */
 214           tp->state_ = THREAD_EXITED;
 215           switch_to_thread (null_ptid);
 216
 217           /* Now we can delete it.  */
 218           delete_thread (ptid);
 219
 220           /* Now reset its ptid, and reswitch inferior_ptid to it.  */
 221           tp->ptid = ptid;
 222           tp->state_ = THREAD_STOPPED;
 223           switch_to_thread (ptid);
 224
 225           observer_notify_new_thread (tp);
 226
 227           /* All done.  */
 228           return tp;
 229         }
 230       else
 231         /* Just go ahead and delete it.  */
 232         delete_thread (ptid);
 233     }
 234
 235   tp = new_thread (ptid);
 236   observer_notify_new_thread (tp);
 237
 238   return tp;
 239 }
 240
 241 struct thread_info *
 242 add_thread_with_info (ptid_t ptid, struct private_thread_info *private)
 243 {
 244   struct thread_info *result = add_thread_silent (ptid);
 245
 246   result->private = private;
 247
 248   if (print_thread_events)
 249     printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
 250
 251   annotate_new_thread ();
 252   return result;
 253 }
 254
 255 struct thread_info *
 256 add_thread (ptid_t ptid)
 257 {
 258   return add_thread_with_info (ptid, NULL);
 259 }
 260
 261 /* Delete thread PTID.  If SILENT, don't notify the observer of this
 262    exit.  */
 263 static void
 264 delete_thread_1 (ptid_t ptid, int silent)
 265 {
 266   struct thread_info *tp, *tpprev;
 267
 268   tpprev = NULL;
 269
 270   for (tp = thread_list; tp; tpprev = tp, tp = tp->next)
 271     if (ptid_equal (tp->ptid, ptid))
 272       break;
 273
 274   if (!tp)
 275     return;
 276
 277   /* If this is the current thread, or there's code out there that
 278      relies on it existing (refcount > 0) we can't delete yet.  Mark
 279      it as exited, and notify it.  */
 280   if (tp->refcount > 0
 281       || ptid_equal (tp->ptid, inferior_ptid))
 282     {
 283       if (tp->state_ != THREAD_EXITED)
 284         {
 285           observer_notify_thread_exit (tp, silent);
 286
 287           /* Tag it as exited.  */
 288           tp->state_ = THREAD_EXITED;
 289
 290           /* Clear breakpoints, etc. associated with this thread.  */
 291           clear_thread_inferior_resources (tp);
 292         }
 293
 294        /* Will be really deleted some other time.  */
 295        return;
 296      }
 297
 298   /* Notify thread exit, but only if we haven't already.  */
 299   if (tp->state_ != THREAD_EXITED)
 300     observer_notify_thread_exit (tp, silent);
 301
 302   /* Tag it as exited.  */
 303   tp->state_ = THREAD_EXITED;
 304   clear_thread_inferior_resources (tp);
 305
 306   if (tpprev)
 307     tpprev->next = tp->next;
 308   else
 309     thread_list = tp->next;
 310
 311   free_thread (tp);
 312 }
 313
 314 /* Delete thread PTID and notify of thread exit.  If this is
 315    inferior_ptid, don't actually delete it, but tag it as exited and
 316    do the notification.  If PTID is the user selected thread, clear
 317    it.  */
 318 void
 319 delete_thread (ptid_t ptid)
 320 {
 321   delete_thread_1 (ptid, 0 /* not silent */);
 322 }
 323
 324 void
 325 delete_thread_silent (ptid_t ptid)
 326 {
 327   delete_thread_1 (ptid, 1 /* silent */);
 328 }
 329
 330 struct thread_info *
 331 find_thread_id (int num)
 332 {
 333   struct thread_info *tp;
 334
 335   for (tp = thread_list; tp; tp = tp->next)
 336     if (tp->num == num)
 337       return tp;
 338
 339   return NULL;
 340 }
 341
 342 /* Find a thread_info by matching PTID.  */
 343 struct thread_info *
 344 find_thread_ptid (ptid_t ptid)
 345 {
 346   struct thread_info *tp;
 347
 348   for (tp = thread_list; tp; tp = tp->next)
 349     if (ptid_equal (tp->ptid, ptid))
 350       return tp;
 351
 352   return NULL;
 353 }
 354
 355 /*
 356  * Thread iterator function.
 357  *
 358  * Calls a callback function once for each thread, so long as
 359  * the callback function returns false.  If the callback function
 360  * returns true, the iteration will end and the current thread
 361  * will be returned.  This can be useful for implementing a
 362  * search for a thread with arbitrary attributes, or for applying
 363  * some operation to every thread.
 364  *
 365  * FIXME: some of the existing functionality, such as
 366  * "Thread apply all", might be rewritten using this functionality.
 367  */
 368
 369 struct thread_info *
 370 iterate_over_threads (int (*callback) (struct thread_info *, void *),
 371                       void *data)
 372 {
 373   struct thread_info *tp, *next;
 374
 375   for (tp = thread_list; tp; tp = next)
 376     {
 377       next = tp->next;
 378       if ((*callback) (tp, data))
 379         return tp;
 380     }
 381
 382   return NULL;
 383 }
 384
 385 int
 386 thread_count (void)
 387 {
 388   int result = 0;
 389   struct thread_info *tp;
 390
 391   for (tp = thread_list; tp; tp = tp->next)
 392     ++result;
 393
 394   return result;
 395 }
 396
 397 int
 398 valid_thread_id (int num)
 399 {
 400   struct thread_info *tp;
 401
 402   for (tp = thread_list; tp; tp = tp->next)
 403     if (tp->num == num)
 404       return 1;
 405
 406   return 0;
 407 }
 408
 409 int
 410 pid_to_thread_id (ptid_t ptid)
 411 {
 412   struct thread_info *tp;
 413
 414   for (tp = thread_list; tp; tp = tp->next)
 415     if (ptid_equal (tp->ptid, ptid))
 416       return tp->num;
 417
 418   return 0;
 419 }
 420
 421 ptid_t
 422 thread_id_to_pid (int num)
 423 {
 424   struct thread_info *thread = find_thread_id (num);
 425
 426   if (thread)
 427     return thread->ptid;
 428   else
 429     return pid_to_ptid (-1);
 430 }
 431
 432 int
 433 in_thread_list (ptid_t ptid)
 434 {
 435   struct thread_info *tp;
 436
 437   for (tp = thread_list; tp; tp = tp->next)
 438     if (ptid_equal (tp->ptid, ptid))
 439       return 1;
 440
 441   return 0;                     /* Never heard of 'im.  */
 442 }
 443
 444 /* Finds the first thread of the inferior given by PID.  If PID is -1,
 445    return the first thread in the list.  */
 446
 447 struct thread_info *
 448 first_thread_of_process (int pid)
 449 {
 450   struct thread_info *tp, *ret = NULL;
 451
 452   for (tp = thread_list; tp; tp = tp->next)
 453     if (pid == -1 || ptid_get_pid (tp->ptid) == pid)
 454       if (ret == NULL || tp->num < ret->num)
 455         ret = tp;
 456
 457   return ret;
 458 }
 459
 460 struct thread_info *
 461 any_thread_of_process (int pid)
 462 {
 463   struct thread_info *tp;
 464
 465   for (tp = thread_list; tp; tp = tp->next)
 466     if (ptid_get_pid (tp->ptid) == pid)
 467       return tp;
 468
 469   return NULL;
 470 }
 471
 472 struct thread_info *
 473 any_live_thread_of_process (int pid)
 474 {
 475   struct thread_info *tp;
 476   struct thread_info *tp_executing = NULL;
 477
 478   for (tp = thread_list; tp; tp = tp->next)
 479     if (tp->state_ != THREAD_EXITED && ptid_get_pid (tp->ptid) == pid)
 480       {
 481         if (tp->executing_)
 482           tp_executing = tp;
 483         else
 484           return tp;
 485       }
 486
 487   return tp_executing;
 488 }
 489
 490 /* Print a list of thread ids currently known, and the total number of
 491    threads.  To be used from within catch_errors.  */
 492 static int
 493 do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
 494 {
 495   struct thread_info *tp;
 496   int num = 0;
 497   struct cleanup *cleanup_chain;
 498   int current_thread = -1;
 499
 500   update_thread_list ();
 501
 502   cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids");
 503
 504   for (tp = thread_list; tp; tp = tp->next)
 505     {
 506       if (tp->state_ == THREAD_EXITED)
 507         continue;
 508
 509       if (ptid_equal (tp->ptid, inferior_ptid))
 510         current_thread = tp->num;
 511
 512       num++;
 513       ui_out_field_int (uiout, "thread-id", tp->num);
 514     }
 515
 516   do_cleanups (cleanup_chain);
 517
 518   if (current_thread != -1)
 519     ui_out_field_int (uiout, "current-thread-id", current_thread);
 520   ui_out_field_int (uiout, "number-of-threads", num);
 521   return GDB_RC_OK;
 522 }
 523
 524 /* Official gdblib interface function to get a list of thread ids and
 525    the total number.  */
 526 enum gdb_rc
 527 gdb_list_thread_ids (struct ui_out *uiout, char **error_message)
 528 {
 529   if (catch_exceptions_with_msg (uiout, do_captured_list_thread_ids, NULL,
 530                                  error_message, RETURN_MASK_ALL) < 0)
 531     return GDB_RC_FAIL;
 532   return GDB_RC_OK;
 533 }
 534
 535 /* Return true if TP is an active thread.  */
 536 static int
 537 thread_alive (struct thread_info *tp)
 538 {
 539   if (tp->state_ == THREAD_EXITED)
 540     return 0;
 541   if (!target_thread_alive (tp->ptid))
 542     return 0;
 543   return 1;
 544 }
 545
 546 static void
 547 prune_threads (void)
 548 {
 549   struct thread_info *tp, *next;
 550
 551   for (tp = thread_list; tp; tp = next)
 552     {
 553       next = tp->next;
 554       if (!thread_alive (tp))
 555         delete_thread (tp->ptid);
 556     }
 557 }
 558
 559 void
 560 thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid)
 561 {
 562   struct inferior *inf;
 563   struct thread_info *tp;
 564
 565   /* It can happen that what we knew as the target inferior id
 566      changes.  E.g, target remote may only discover the remote process
 567      pid after adding the inferior to GDB's list.  */
 568   inf = find_inferior_pid (ptid_get_pid (old_ptid));
 569   inf->pid = ptid_get_pid (new_ptid);
 570
 571   tp = find_thread_ptid (old_ptid);
 572   tp->ptid = new_ptid;
 573
 574   observer_notify_thread_ptid_changed (old_ptid, new_ptid);
 575 }
 576
 577 void
 578 set_running (ptid_t ptid, int running)
 579 {
 580   struct thread_info *tp;
 581   int all = ptid_equal (ptid, minus_one_ptid);
 582
 583   /* We try not to notify the observer if no thread has actually changed
 584      the running state -- merely to reduce the number of messages to
 585      frontend.  Frontend is supposed to handle multiple *running just fine.  */
 586   if (all || ptid_is_pid (ptid))
 587     {
 588       int any_started = 0;
 589
 590       for (tp = thread_list; tp; tp = tp->next)
 591         if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
 592           {
 593             if (tp->state_ == THREAD_EXITED)
 594               continue;
 595             if (running && tp->state_ == THREAD_STOPPED)
 596               any_started = 1;
 597             tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 598           }
 599       if (any_started)
 600         observer_notify_target_resumed (ptid);
 601     }
 602   else
 603     {
 604       int started = 0;
 605
 606       tp = find_thread_ptid (ptid);
 607       gdb_assert (tp);
 608       gdb_assert (tp->state_ != THREAD_EXITED);
 609       if (running && tp->state_ == THREAD_STOPPED)
 610         started = 1;
 611       tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
 612       if (started)
 613         observer_notify_target_resumed (ptid);
 614     }
 615 }
 616
 617 static int
 618 is_thread_state (ptid_t ptid, enum thread_state state)
 619 {
 620   struct thread_info *tp;
 621
 622   tp = find_thread_ptid (ptid);
 623   gdb_assert (tp);
 624   return tp->state_ == state;
 625 }
 626
 627 int
 628 is_stopped (ptid_t ptid)
 629 {
 630   return is_thread_state (ptid, THREAD_STOPPED);
 631 }
 632
 633 int
 634 is_exited (ptid_t ptid)
 635 {
 636   return is_thread_state (ptid, THREAD_EXITED);
 637 }
 638
 639 int
 640 is_running (ptid_t ptid)
 641 {
 642   return is_thread_state (ptid, THREAD_RUNNING);
 643 }
 644
 645 int
 646 any_running (void)
 647 {
 648   struct thread_info *tp;
 649
 650   for (tp = thread_list; tp; tp = tp->next)
 651     if (tp->state_ == THREAD_RUNNING)
 652       return 1;
 653
 654   return 0;
 655 }
 656
 657 int
 658 is_executing (ptid_t ptid)
 659 {
 660   struct thread_info *tp;
 661
 662   tp = find_thread_ptid (ptid);
 663   gdb_assert (tp);
 664   return tp->executing_;
 665 }
 666
 667 void
 668 set_executing (ptid_t ptid, int executing)
 669 {
 670   struct thread_info *tp;
 671   int all = ptid_equal (ptid, minus_one_ptid);
 672
 673   if (all || ptid_is_pid (ptid))
 674     {
 675       for (tp = thread_list; tp; tp = tp->next)
 676         if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
 677           tp->executing_ = executing;
 678     }
 679   else
 680     {
 681       tp = find_thread_ptid (ptid);
 682       gdb_assert (tp);
 683       tp->executing_ = executing;
 684     }
 685 }
 686
 687 void
 688 set_stop_requested (ptid_t ptid, int stop)
 689 {
 690   struct thread_info *tp;
 691   int all = ptid_equal (ptid, minus_one_ptid);
 692
 693   if (all || ptid_is_pid (ptid))
 694     {
 695       for (tp = thread_list; tp; tp = tp->next)
 696         if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid))
 697           tp->stop_requested = stop;
 698     }
 699   else
 700     {
 701       tp = find_thread_ptid (ptid);
 702       gdb_assert (tp);
 703       tp->stop_requested = stop;
 704     }
 705
 706   /* Call the stop requested observer so other components of GDB can
 707      react to this request.  */
 708   if (stop)
 709     observer_notify_thread_stop_requested (ptid);
 710 }
 711
 712 void
 713 finish_thread_state (ptid_t ptid)
 714 {
 715   struct thread_info *tp;
 716   int all;
 717   int any_started = 0;
 718
 719   all = ptid_equal (ptid, minus_one_ptid);
 720
 721   if (all || ptid_is_pid (ptid))
 722     {
 723       for (tp = thread_list; tp; tp = tp->next)
 724         {
 725           if (tp->state_ == THREAD_EXITED)
 726             continue;
 727           if (all || ptid_get_pid (ptid) == ptid_get_pid (tp->ptid))
 728             {
 729               if (tp->executing_ && tp->state_ == THREAD_STOPPED)
 730                 any_started = 1;
 731               tp->state_ = tp->executing_ ? THREAD_RUNNING : THREAD_STOPPED;
 732             }
 733         }
 734     }
 735   else
 736     {
 737       tp = find_thread_ptid (ptid);
 738       gdb_assert (tp);
 739       if (tp->state_ != THREAD_EXITED)
 740         {
 741           if (tp->executing_ && tp->state_ == THREAD_STOPPED)
 742             any_started = 1;
 743           tp->state_ = tp->executing_ ? THREAD_RUNNING : THREAD_STOPPED;
 744         }
 745     }
 746
 747   if (any_started)
 748     observer_notify_target_resumed (ptid);
 749 }
 750
 751 void
 752 finish_thread_state_cleanup (void *arg)
 753 {
 754   ptid_t *ptid_p = arg;
 755
 756   gdb_assert (arg);
 757
 758   finish_thread_state (*ptid_p);
 759 }
 760
 761 /* Prints the list of threads and their details on UIOUT.
 762    This is a version of 'info_threads_command' suitable for
 763    use from MI.
 764    If REQUESTED_THREAD is not -1, it's the GDB id of the thread
 765    that should be printed.  Otherwise, all threads are
 766    printed.
 767    If PID is not -1, only print threads from the process PID.
 768    Otherwise, threads from all attached PIDs are printed.
 769    If both REQUESTED_THREAD and PID are not -1, then the thread
 770    is printed if it belongs to the specified process.  Otherwise,
 771    an error is raised.  */
 772 void
 773 print_thread_info (struct ui_out *uiout, char *requested_threads, int pid)
 774 {
 775   struct thread_info *tp;
 776   ptid_t current_ptid;
 777   struct cleanup *old_chain;
 778   char *extra_info, *name, *target_id;
 779   int current_thread = -1;
 780
 781   update_thread_list ();
 782   current_ptid = inferior_ptid;
 783
 784   /* We'll be switching threads temporarily.  */
 785   old_chain = make_cleanup_restore_current_thread ();
 786
 787   /* For backward compatibility, we make a list for MI.  A table is
 788      preferable for the CLI, though, because it shows table
 789      headers.  */
 790   if (ui_out_is_mi_like_p (uiout))
 791     make_cleanup_ui_out_list_begin_end (uiout, "threads");
 792   else
 793     {
 794       int n_threads = 0;
 795
 796       for (tp = thread_list; tp; tp = tp->next)
 797         {
 798           if (!number_is_in_list (requested_threads, tp->num))
 799             continue;
 800
 801           if (pid != -1 && PIDGET (tp->ptid) != pid)
 802             continue;
 803
 804           if (tp->state_ == THREAD_EXITED)
 805             continue;
 806
 807           ++n_threads;
 808         }
 809
 810       if (n_threads == 0)
 811         {
 812           if (requested_threads == NULL || *requested_threads == '\0')
 813             ui_out_message (uiout, 0, _("No threads.\n"));
 814           else
 815             ui_out_message (uiout, 0, _("No threads match '%s'.\n"),
 816                             requested_threads);
 817           do_cleanups (old_chain);
 818           return;
 819         }
 820
 821       make_cleanup_ui_out_table_begin_end (uiout, 4, n_threads, "threads");
 822
 823       ui_out_table_header (uiout, 1, ui_left, "current", "");
 824       ui_out_table_header (uiout, 4, ui_left, "id", "Id");
 825       ui_out_table_header (uiout, 17, ui_left, "target-id", "Target Id");
 826       ui_out_table_header (uiout, 1, ui_left, "frame", "Frame");
 827       ui_out_table_body (uiout);
 828     }
 829
 830   for (tp = thread_list; tp; tp = tp->next)
 831     {
 832       struct cleanup *chain2;
 833       int core;
 834
 835       if (!number_is_in_list (requested_threads, tp->num))
 836         continue;
 837
 838       if (pid != -1 && PIDGET (tp->ptid) != pid)
 839         {
 840           if (requested_threads != NULL && *requested_threads != '\0')
 841             error (_("Requested thread not found in requested process"));
 842           continue;
 843         }
 844
 845       if (ptid_equal (tp->ptid, current_ptid))
 846         current_thread = tp->num;
 847
 848       if (tp->state_ == THREAD_EXITED)
 849         continue;
 850
 851       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 852
 853       if (ui_out_is_mi_like_p (uiout))
 854         {
 855           /* Compatibility.  */
 856           if (ptid_equal (tp->ptid, current_ptid))
 857             ui_out_text (uiout, "* ");
 858           else
 859             ui_out_text (uiout, "  ");
 860         }
 861       else
 862         {
 863           if (ptid_equal (tp->ptid, current_ptid))
 864             ui_out_field_string (uiout, "current", "*");
 865           else
 866             ui_out_field_skip (uiout, "current");
 867         }
 868
 869       ui_out_field_int (uiout, "id", tp->num);
 870
 871       /* For the CLI, we stuff everything into the target-id field.
 872          This is a gross hack to make the output come out looking
 873          correct.  The underlying problem here is that ui-out has no
 874          way to specify that a field's space allocation should be
 875          shared by several fields.  For MI, we do the right thing
 876          instead.  */
 877
 878       target_id = target_pid_to_str (tp->ptid);
 879       extra_info = target_extra_thread_info (tp);
 880       name = tp->name ? tp->name : target_thread_name (tp);
 881
 882       if (ui_out_is_mi_like_p (uiout))
 883         {
 884           ui_out_field_string (uiout, "target-id", target_id);
 885           if (extra_info)
 886             ui_out_field_string (uiout, "details", extra_info);
 887           if (name)
 888             ui_out_field_string (uiout, "name", name);
 889         }
 890       else
 891         {
 892           struct cleanup *str_cleanup;
 893           char *contents;
 894
 895           if (extra_info && name)
 896             contents = xstrprintf ("%s \"%s\" (%s)", target_id,
 897                                    name, extra_info);
 898           else if (extra_info)
 899             contents = xstrprintf ("%s (%s)", target_id, extra_info);
 900           else if (name)
 901             contents = xstrprintf ("%s \"%s\"", target_id, name);
 902           else
 903             contents = xstrdup (target_id);
 904           str_cleanup = make_cleanup (xfree, contents);
 905
 906           ui_out_field_string (uiout, "target-id", contents);
 907           do_cleanups (str_cleanup);
 908         }
 909
 910       if (tp->state_ == THREAD_RUNNING)
 911         ui_out_text (uiout, "(running)\n");
 912       else
 913         {
 914           /* The switch below puts us at the top of the stack (leaf
 915              frame).  */
 916           switch_to_thread (tp->ptid);
 917           print_stack_frame (get_selected_frame (NULL),
 918                              /* For MI output, print frame level.  */
 919                              ui_out_is_mi_like_p (uiout),
 920                              LOCATION);
 921         }
 922
 923       if (ui_out_is_mi_like_p (uiout))
 924         {
 925           char *state = "stopped";
 926
 927           if (tp->state_ == THREAD_RUNNING)
 928             state = "running";
 929           ui_out_field_string (uiout, "state", state);
 930         }
 931
 932       core = target_core_of_thread (tp->ptid);
 933       if (ui_out_is_mi_like_p (uiout) && core != -1)
 934         ui_out_field_int (uiout, "core", core);
 935
 936       do_cleanups (chain2);
 937     }
 938
 939   /* Restores the current thread and the frame selected before
 940      the "info threads" command.  */
 941   do_cleanups (old_chain);
 942
 943   if (pid == -1 && requested_threads == NULL)
 944     {
 945       gdb_assert (current_thread != -1
 946                   || !thread_list
 947                   || ptid_equal (inferior_ptid, null_ptid));
 948       if (current_thread != -1 && ui_out_is_mi_like_p (uiout))
 949         ui_out_field_int (uiout, "current-thread-id", current_thread);
 950
 951       if (current_thread != -1 && is_exited (current_ptid))
 952         ui_out_message (uiout, 0, "\n\
 953 The current thread <Thread ID %d> has terminated.  See `help thread'.\n",
 954                         current_thread);
 955       else if (thread_list
 956                && current_thread == -1
 957                && ptid_equal (current_ptid, null_ptid))
 958         ui_out_message (uiout, 0, "\n\
 959 No selected thread.  See `help thread'.\n");
 960     }
 961 }
 962
 963 /* Print information about currently known threads
 964
 965    Optional ARG is a thread id, or list of thread ids.
 966
 967    Note: this has the drawback that it _really_ switches
 968          threads, which frees the frame cache.  A no-side
 969          effects info-threads command would be nicer.  */
 970
 971 static void
 972 info_threads_command (char *arg, int from_tty)
 973 {
 974   print_thread_info (uiout, arg, -1);
 975 }
 976
 977 /* Switch from one thread to another.  */
 978
 979 void
 980 switch_to_thread (ptid_t ptid)
 981 {
 982   /* Switch the program space as well, if we can infer it from the now
 983      current thread.  Otherwise, it's up to the caller to select the
 984      space it wants.  */
 985   if (!ptid_equal (ptid, null_ptid))
 986     {
 987       struct inferior *inf;
 988
 989       inf = find_inferior_pid (ptid_get_pid (ptid));
 990       gdb_assert (inf != NULL);
 991       set_current_program_space (inf->pspace);
 992       set_current_inferior (inf);
 993     }
 994
 995   if (ptid_equal (ptid, inferior_ptid))
 996     return;
 997
 998   inferior_ptid = ptid;
 999   reinit_frame_cache ();
1000   registers_changed ();
1001
1002   /* We don't check for is_stopped, because we're called at times
1003      while in the TARGET_RUNNING state, e.g., while handling an
1004      internal event.  */
1005   if (!ptid_equal (inferior_ptid, null_ptid)
1006       && !is_exited (ptid)
1007       && !is_executing (ptid))
1008     stop_pc = regcache_read_pc (get_thread_regcache (ptid));
1009   else
1010     stop_pc = ~(CORE_ADDR) 0;
1011 }
1012
1013 static void
1014 restore_current_thread (ptid_t ptid)
1015 {
1016   switch_to_thread (ptid);
1017 }
1018
1019 static void
1020 restore_selected_frame (struct frame_id a_frame_id, int frame_level)
1021 {
1022   struct frame_info *frame = NULL;
1023   int count;
1024
1025   /* This means there was no selected frame.  */
1026   if (frame_level == -1)
1027     {
1028       select_frame (NULL);
1029       return;
1030     }
1031
1032   gdb_assert (frame_level >= 0);
1033
1034   /* Restore by level first, check if the frame id is the same as
1035      expected.  If that fails, try restoring by frame id.  If that
1036      fails, nothing to do, just warn the user.  */
1037
1038   count = frame_level;
1039   frame = find_relative_frame (get_current_frame (), &count);
1040   if (count == 0
1041       && frame != NULL
1042       /* The frame ids must match - either both valid or both outer_frame_id.
1043          The latter case is not failsafe, but since it's highly unlikely
1044          the search by level finds the wrong frame, it's 99.9(9)% of
1045          the time (for all practical purposes) safe.  */
1046       && frame_id_eq (get_frame_id (frame), a_frame_id))
1047     {
1048       /* Cool, all is fine.  */
1049       select_frame (frame);
1050       return;
1051     }
1052
1053   frame = frame_find_by_id (a_frame_id);
1054   if (frame != NULL)
1055     {
1056       /* Cool, refound it.  */
1057       select_frame (frame);
1058       return;
1059     }
1060
1061   /* Nothing else to do, the frame layout really changed.  Select the
1062      innermost stack frame.  */
1063   select_frame (get_current_frame ());
1064
1065   /* Warn the user.  */
1066   if (frame_level > 0 && !ui_out_is_mi_like_p (uiout))
1067     {
1068       warning (_("Couldn't restore frame #%d in "
1069                  "current thread, at reparsed frame #0\n"),
1070                frame_level);
1071       /* For MI, we should probably have a notification about
1072          current frame change.  But this error is not very
1073          likely, so don't bother for now.  */
1074       print_stack_frame (get_selected_frame (NULL), 1, SRC_LINE);
1075     }
1076 }
1077
1078 struct current_thread_cleanup
1079 {
1080   ptid_t inferior_ptid;
1081   struct frame_id selected_frame_id;
1082   int selected_frame_level;
1083   int was_stopped;
1084   int inf_id;
1085 };
1086
1087 static void
1088 do_restore_current_thread_cleanup (void *arg)
1089 {
1090   struct thread_info *tp;
1091   struct current_thread_cleanup *old = arg;
1092
1093   tp = find_thread_ptid (old->inferior_ptid);
1094
1095   /* If the previously selected thread belonged to a process that has
1096      in the mean time been deleted (due to normal exit, detach, etc.),
1097      then don't revert back to it, but instead simply drop back to no
1098      thread selected.  */
1099   if (tp
1100       && find_inferior_pid (ptid_get_pid (tp->ptid)) != NULL)
1101     restore_current_thread (old->inferior_ptid);
1102   else
1103     {
1104       restore_current_thread (null_ptid);
1105       set_current_inferior (find_inferior_id (old->inf_id));
1106     }
1107
1108   /* The running state of the originally selected thread may have
1109      changed, so we have to recheck it here.  */
1110   if (!ptid_equal (inferior_ptid, null_ptid)
1111       && old->was_stopped
1112       && is_stopped (inferior_ptid)
1113       && target_has_registers
1114       && target_has_stack
1115       && target_has_memory)
1116     restore_selected_frame (old->selected_frame_id,
1117                             old->selected_frame_level);
1118 }
1119
1120 static void
1121 restore_current_thread_cleanup_dtor (void *arg)
1122 {
1123   struct current_thread_cleanup *old = arg;
1124   struct thread_info *tp;
1125
1126   tp = find_thread_ptid (old->inferior_ptid);
1127   if (tp)
1128     tp->refcount--;
1129   xfree (old);
1130 }
1131
1132 struct cleanup *
1133 make_cleanup_restore_current_thread (void)
1134 {
1135   struct thread_info *tp;
1136   struct frame_info *frame;
1137   struct current_thread_cleanup *old;
1138
1139   old = xmalloc (sizeof (struct current_thread_cleanup));
1140   old->inferior_ptid = inferior_ptid;
1141   old->inf_id = current_inferior ()->num;
1142
1143   if (!ptid_equal (inferior_ptid, null_ptid))
1144     {
1145       old->was_stopped = is_stopped (inferior_ptid);
1146       if (old->was_stopped
1147           && target_has_registers
1148           && target_has_stack
1149           && target_has_memory)
1150         {
1151           /* When processing internal events, there might not be a
1152              selected frame.  If we naively call get_selected_frame
1153              here, then we can end up reading debuginfo for the
1154              current frame, but we don't generally need the debuginfo
1155              at this point.  */
1156           frame = get_selected_frame_if_set ();
1157         }
1158       else
1159         frame = NULL;
1160
1161       old->selected_frame_id = get_frame_id (frame);
1162       old->selected_frame_level = frame_relative_level (frame);
1163
1164       tp = find_thread_ptid (inferior_ptid);
1165       if (tp)
1166         tp->refcount++;
1167     }
1168
1169   return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
1170                             restore_current_thread_cleanup_dtor);
1171 }
1172
1173 /* Apply a GDB command to a list of threads.  List syntax is a whitespace
1174    seperated list of numbers, or ranges, or the keyword `all'.  Ranges consist
1175    of two numbers seperated by a hyphen.  Examples:
1176
1177    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
1178    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
1179    thread apply all p x/i $pc   Apply x/i $pc cmd to all threads.  */
1180
1181 static void
1182 thread_apply_all_command (char *cmd, int from_tty)
1183 {
1184   struct thread_info *tp;
1185   struct cleanup *old_chain;
1186   char *saved_cmd;
1187
1188   if (cmd == NULL || *cmd == '\000')
1189     error (_("Please specify a command following the thread ID list"));
1190
1191   update_thread_list ();
1192
1193   old_chain = make_cleanup_restore_current_thread ();
1194
1195   /* Save a copy of the command in case it is clobbered by
1196      execute_command.  */
1197   saved_cmd = xstrdup (cmd);
1198   make_cleanup (xfree, saved_cmd);
1199   for (tp = thread_list; tp; tp = tp->next)
1200     if (thread_alive (tp))
1201       {
1202         switch_to_thread (tp->ptid);
1203
1204         printf_filtered (_("\nThread %d (%s):\n"),
1205                          tp->num, target_pid_to_str (inferior_ptid));
1206         execute_command (cmd, from_tty);
1207         strcpy (cmd, saved_cmd);        /* Restore exact command used
1208                                            previously.  */
1209       }
1210
1211   do_cleanups (old_chain);
1212 }
1213
1214 static void
1215 thread_apply_command (char *tidlist, int from_tty)
1216 {
1217   char *cmd;
1218   struct cleanup *old_chain;
1219   char *saved_cmd;
1220   struct get_number_or_range_state state;
1221
1222   if (tidlist == NULL || *tidlist == '\000')
1223     error (_("Please specify a thread ID list"));
1224
1225   for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++);
1226
1227   if (*cmd == '\000')
1228     error (_("Please specify a command following the thread ID list"));
1229
1230   /* Save a copy of the command in case it is clobbered by
1231      execute_command.  */
1232   saved_cmd = xstrdup (cmd);
1233   old_chain = make_cleanup (xfree, saved_cmd);
1234
1235   init_number_or_range (&state, tidlist);
1236   while (!state.finished && state.string < cmd)
1237     {
1238       struct thread_info *tp;
1239       int start;
1240       char *p = tidlist;
1241
1242       start = get_number_or_range (&state);
1243
1244       make_cleanup_restore_current_thread ();
1245
1246       tp = find_thread_id (start);
1247
1248       if (!tp)
1249         warning (_("Unknown thread %d."), start);
1250       else if (!thread_alive (tp))
1251         warning (_("Thread %d has terminated."), start);
1252       else
1253         {
1254           switch_to_thread (tp->ptid);
1255
1256           printf_filtered (_("\nThread %d (%s):\n"), tp->num,
1257                            target_pid_to_str (inferior_ptid));
1258           execute_command (cmd, from_tty);
1259
1260           /* Restore exact command used previously.  */
1261           strcpy (cmd, saved_cmd);
1262         }
1263     }
1264
1265   do_cleanups (old_chain);
1266 }
1267
1268 /* Switch to the specified thread.  Will dispatch off to thread_apply_command
1269    if prefix of arg is `apply'.  */
1270
1271 static void
1272 thread_command (char *tidstr, int from_tty)
1273 {
1274   if (!tidstr)
1275     {
1276       if (ptid_equal (inferior_ptid, null_ptid))
1277         error (_("No thread selected"));
1278
1279       if (target_has_stack)
1280         {
1281           if (is_exited (inferior_ptid))
1282             printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
1283                              pid_to_thread_id (inferior_ptid),
1284                              target_pid_to_str (inferior_ptid));
1285           else
1286             printf_filtered (_("[Current thread is %d (%s)]\n"),
1287                              pid_to_thread_id (inferior_ptid),
1288                              target_pid_to_str (inferior_ptid));
1289         }
1290       else
1291         error (_("No stack."));
1292       return;
1293     }
1294
1295   gdb_thread_select (uiout, tidstr, NULL);
1296 }
1297
1298 /* Implementation of `thread name'.  */
1299
1300 static void
1301 thread_name_command (char *arg, int from_tty)
1302 {
1303   struct thread_info *info;
1304
1305   if (ptid_equal (inferior_ptid, null_ptid))
1306     error (_("No thread selected"));
1307
1308   while (arg && isspace (*arg))
1309     ++arg;
1310
1311   info = inferior_thread ();
1312   xfree (info->name);
1313   info->name = arg ? xstrdup (arg) : NULL;
1314 }
1315
1316 /* Find thread ids with a name, target pid, or extra info matching ARG.  */
1317
1318 static void
1319 thread_find_command (char *arg, int from_tty)
1320 {
1321   struct thread_info *tp;
1322   char *tmp;
1323   unsigned long match = 0;
1324
1325   if (arg == NULL || *arg == '\0')
1326     error (_("Command requires an argument."));
1327
1328   tmp = re_comp (arg);
1329   if (tmp != 0)
1330     error (_("Invalid regexp (%s): %s"), tmp, arg);
1331
1332   update_thread_list ();
1333   for (tp = thread_list; tp; tp = tp->next)
1334     {
1335       if (tp->name != NULL && re_exec (tp->name))
1336         {
1337           printf_filtered (_("Thread %d has name '%s'\n"),
1338                            tp->num, tp->name);
1339           match++;
1340         }
1341
1342       tmp = target_thread_name (tp);
1343       if (tmp != NULL && re_exec (tmp))
1344         {
1345           printf_filtered (_("Thread %d has target name '%s'\n"),
1346                            tp->num, tmp);
1347           match++;
1348         }
1349
1350       tmp = target_pid_to_str (tp->ptid);
1351       if (tmp != NULL && re_exec (tmp))
1352         {
1353           printf_filtered (_("Thread %d has target id '%s'\n"),
1354                            tp->num, tmp);
1355           match++;
1356         }
1357
1358       tmp = target_extra_thread_info (tp);
1359       if (tmp != NULL && re_exec (tmp))
1360         {
1361           printf_filtered (_("Thread %d has extra info '%s'\n"),
1362                            tp->num, tmp);
1363           match++;
1364         }
1365     }
1366   if (!match)
1367     printf_filtered (_("No threads match '%s'\n"), arg);
1368 }
1369
1370 /* Print notices when new threads are attached and detached.  */
1371 int print_thread_events = 1;
1372 static void
1373 show_print_thread_events (struct ui_file *file, int from_tty,
1374                           struct cmd_list_element *c, const char *value)
1375 {
1376   fprintf_filtered (file,
1377                     _("Printing of thread events is %s.\n"),
1378                     value);
1379 }
1380
1381 static int
1382 do_captured_thread_select (struct ui_out *uiout, void *tidstr)
1383 {
1384   int num;
1385   struct thread_info *tp;
1386
1387   num = value_as_long (parse_and_eval (tidstr));
1388
1389   tp = find_thread_id (num);
1390
1391   if (!tp)
1392     error (_("Thread ID %d not known."), num);
1393
1394   if (!thread_alive (tp))
1395     error (_("Thread ID %d has terminated."), num);
1396
1397   switch_to_thread (tp->ptid);
1398
1399   annotate_thread_changed ();
1400
1401   ui_out_text (uiout, "[Switching to thread ");
1402   ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
1403   ui_out_text (uiout, " (");
1404   ui_out_text (uiout, target_pid_to_str (inferior_ptid));
1405   ui_out_text (uiout, ")]");
1406
1407   /* Note that we can't reach this with an exited thread, due to the
1408      thread_alive check above.  */
1409   if (tp->state_ == THREAD_RUNNING)
1410     ui_out_text (uiout, "(running)\n");
1411   else
1412     {
1413       ui_out_text (uiout, "\n");
1414       print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1415     }
1416
1417   /* Since the current thread may have changed, see if there is any
1418      exited thread we can now delete.  */
1419   prune_threads ();
1420
1421   return GDB_RC_OK;
1422 }
1423
1424 enum gdb_rc
1425 gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
1426 {
1427   if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
1428                                  error_message, RETURN_MASK_ALL) < 0)
1429     return GDB_RC_FAIL;
1430   return GDB_RC_OK;
1431 }
1432
1433 void
1434 update_thread_list (void)
1435 {
1436   prune_threads ();
1437   target_find_new_threads ();
1438 }
1439
1440 /* Return a new value for the selected thread's id.  Return a value of 0 if
1441    no thread is selected, or no threads exist.  */
1442
1443 static struct value *
1444 thread_id_make_value (struct gdbarch *gdbarch, struct internalvar *var)
1445 {
1446   struct thread_info *tp = find_thread_ptid (inferior_ptid);
1447
1448   return value_from_longest (builtin_type (gdbarch)->builtin_int,
1449                              (tp ? tp->num : 0));
1450 }
1451
1452 /* Commands with a prefix of `thread'.  */
1453 struct cmd_list_element *thread_cmd_list = NULL;
1454
1455 void
1456 _initialize_thread (void)
1457 {
1458   static struct cmd_list_element *thread_apply_list = NULL;
1459
1460   add_info ("threads", info_threads_command,
1461             _("Display currently known threads.\n\
1462 Usage: info threads [ID]...\n\
1463 Optional arguments are thread IDs with spaces between.\n\
1464 If no arguments, all threads are displayed."));
1465
1466   add_prefix_cmd ("thread", class_run, thread_command, _("\
1467 Use this command to switch between threads.\n\
1468 The new thread ID must be currently known."),
1469                   &thread_cmd_list, "thread ", 1, &cmdlist);
1470
1471   add_prefix_cmd ("apply", class_run, thread_apply_command,
1472                   _("Apply a command to a list of threads."),
1473                   &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
1474
1475   add_cmd ("all", class_run, thread_apply_all_command,
1476            _("Apply a command to all threads."), &thread_apply_list);
1477
1478   add_cmd ("name", class_run, thread_name_command,
1479            _("Set the current thread's name.\n\
1480 Usage: thread name [NAME]\n\
1481 If NAME is not given, then any existing name is removed."), &thread_cmd_list);
1482
1483   add_cmd ("find", class_run, thread_find_command, _("\
1484 Find threads that match a regular expression.\n\
1485 Usage: thread find REGEXP\n\
1486 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
1487            &thread_cmd_list);
1488
1489   if (!xdb_commands)
1490     add_com_alias ("t", "thread", class_run, 1);
1491
1492   add_setshow_boolean_cmd ("thread-events", no_class,
1493          &print_thread_events, _("\
1494 Set printing of thread events (such as thread start and exit)."), _("\
1495 Show printing of thread events (such as thread start and exit)."), NULL,
1496          NULL,
1497          show_print_thread_events,
1498          &setprintlist, &showprintlist);
1499
1500   create_internalvar_type_lazy ("_thread", thread_id_make_value);
1501 }