gdb/thread.c

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