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