gdb/thread.c

   1 /* Multi-process/thread control for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2020 Free Software Foundation, Inc.
   4
   5    Contributed by Lynx Real-Time Systems, Inc.  Los Gatos, CA.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "frame.h"
  25 #include "inferior.h"
  26 #include "gdbsupport/environ.h"
  27 #include "value.h"
  28 #include "target.h"
  29 #include "gdbthread.h"
  30 #include "command.h"
  31 #include "gdbcmd.h"
  32 #include "regcache.h"
  33 #include "btrace.h"
  34
  35 #include <ctype.h>
  36 #include <sys/types.h>
  37 #include <signal.h>
  38 #include "ui-out.h"
  39 #include "observable.h"
  40 #include "annotate.h"
  41 #include "cli/cli-decode.h"
  42 #include "cli/cli-option.h"
  43 #include "gdb_regex.h"
  44 #include "cli/cli-utils.h"
  45 #include "thread-fsm.h"
  46 #include "tid-parse.h"
  47 #include <algorithm>
  48 #include "gdbsupport/gdb_optional.h"
  49 #include "inline-frame.h"
  50 #include "stack.h"
  51
  52 /* Definition of struct thread_info exported to gdbthread.h.  */
  53
  54 /* Prototypes for local functions.  */
  55
  56 static int highest_thread_num;
  57
  58 /* The current/selected thread.  */
  59 static thread_info *current_thread_;
  60
  61 /* RAII type used to increase / decrease the refcount of each thread
  62    in a given list of threads.  */
  63
  64 class scoped_inc_dec_ref
  65 {
  66 public:
  67   explicit scoped_inc_dec_ref (const std::vector<thread_info *> &thrds)
  68     : m_thrds (thrds)
  69   {
  70     for (thread_info *thr : m_thrds)
  71       thr->incref ();
  72   }
  73
  74   ~scoped_inc_dec_ref ()
  75   {
  76     for (thread_info *thr : m_thrds)
  77       thr->decref ();
  78   }
  79
  80 private:
  81   const std::vector<thread_info *> &m_thrds;
  82 };
  83
  84 /* Returns true if THR is the current thread.  */
  85
  86 static bool
  87 is_current_thread (const thread_info *thr)
  88 {
  89   return thr == current_thread_;
  90 }
  91
  92 struct thread_info*
  93 inferior_thread (void)
  94 {
  95   gdb_assert (current_thread_ != nullptr);
  96   return current_thread_;
  97 }
  98
  99 /* Delete the breakpoint pointed at by BP_P, if there's one.  */
 100
 101 static void
 102 delete_thread_breakpoint (struct breakpoint **bp_p)
 103 {
 104   if (*bp_p != NULL)
 105     {
 106       delete_breakpoint (*bp_p);
 107       *bp_p = NULL;
 108     }
 109 }
 110
 111 void
 112 delete_step_resume_breakpoint (struct thread_info *tp)
 113 {
 114   if (tp != NULL)
 115     delete_thread_breakpoint (&tp->control.step_resume_breakpoint);
 116 }
 117
 118 void
 119 delete_exception_resume_breakpoint (struct thread_info *tp)
 120 {
 121   if (tp != NULL)
 122     delete_thread_breakpoint (&tp->control.exception_resume_breakpoint);
 123 }
 124
 125 /* See gdbthread.h.  */
 126
 127 void
 128 delete_single_step_breakpoints (struct thread_info *tp)
 129 {
 130   if (tp != NULL)
 131     delete_thread_breakpoint (&tp->control.single_step_breakpoints);
 132 }
 133
 134 /* Delete the breakpoint pointed at by BP_P at the next stop, if
 135    there's one.  */
 136
 137 static void
 138 delete_at_next_stop (struct breakpoint **bp)
 139 {
 140   if (*bp != NULL)
 141     {
 142       (*bp)->disposition = disp_del_at_next_stop;
 143       *bp = NULL;
 144     }
 145 }
 146
 147 /* See gdbthread.h.  */
 148
 149 int
 150 thread_has_single_step_breakpoints_set (struct thread_info *tp)
 151 {
 152   return tp->control.single_step_breakpoints != NULL;
 153 }
 154
 155 /* See gdbthread.h.  */
 156
 157 int
 158 thread_has_single_step_breakpoint_here (struct thread_info *tp,
 159                                         const address_space *aspace,
 160                                         CORE_ADDR addr)
 161 {
 162   struct breakpoint *ss_bps = tp->control.single_step_breakpoints;
 163
 164   return (ss_bps != NULL
 165           && breakpoint_has_location_inserted_here (ss_bps, aspace, addr));
 166 }
 167
 168 /* See gdbthread.h.  */
 169
 170 void
 171 thread_cancel_execution_command (struct thread_info *thr)
 172 {
 173   if (thr->thread_fsm != NULL)
 174     {
 175       thr->thread_fsm->clean_up (thr);
 176       delete thr->thread_fsm;
 177       thr->thread_fsm = NULL;
 178     }
 179 }
 180
 181 static void
 182 clear_thread_inferior_resources (struct thread_info *tp)
 183 {
 184   /* NOTE: this will take care of any left-over step_resume breakpoints,
 185      but not any user-specified thread-specific breakpoints.  We can not
 186      delete the breakpoint straight-off, because the inferior might not
 187      be stopped at the moment.  */
 188   delete_at_next_stop (&tp->control.step_resume_breakpoint);
 189   delete_at_next_stop (&tp->control.exception_resume_breakpoint);
 190   delete_at_next_stop (&tp->control.single_step_breakpoints);
 191
 192   delete_longjmp_breakpoint_at_next_stop (tp->global_num);
 193
 194   bpstat_clear (&tp->control.stop_bpstat);
 195
 196   btrace_teardown (tp);
 197
 198   thread_cancel_execution_command (tp);
 199
 200   clear_inline_frame_state (tp);
 201 }
 202
 203 /* Set the TP's state as exited.  */
 204
 205 static void
 206 set_thread_exited (thread_info *tp, bool silent)
 207 {
 208   /* Dead threads don't need to step-over.  Remove from queue.  */
 209   if (tp->step_over_next != NULL)
 210     thread_step_over_chain_remove (tp);
 211
 212   if (tp->state != THREAD_EXITED)
 213     {
 214       gdb::observers::thread_exit.notify (tp, silent);
 215
 216       /* Tag it as exited.  */
 217       tp->state = THREAD_EXITED;
 218
 219       /* Clear breakpoints, etc. associated with this thread.  */
 220       clear_thread_inferior_resources (tp);
 221     }
 222 }
 223
 224 void
 225 init_thread_list (void)
 226 {
 227   highest_thread_num = 0;
 228
 229   for (thread_info *tp : all_threads_safe ())
 230     {
 231       inferior *inf = tp->inf;
 232
 233       if (tp->deletable ())
 234         delete tp;
 235       else
 236         set_thread_exited (tp, 1);
 237
 238       inf->thread_list = NULL;
 239     }
 240 }
 241
 242 /* Allocate a new thread of inferior INF with target id PTID and add
 243    it to the thread list.  */
 244
 245 static struct thread_info *
 246 new_thread (struct inferior *inf, ptid_t ptid)
 247 {
 248   thread_info *tp = new thread_info (inf, ptid);
 249
 250   if (inf->thread_list == NULL)
 251     inf->thread_list = tp;
 252   else
 253     {
 254       struct thread_info *last;
 255
 256       for (last = inf->thread_list; last->next != NULL; last = last->next)
 257         gdb_assert (ptid != last->ptid
 258                     || last->state == THREAD_EXITED);
 259
 260       gdb_assert (ptid != last->ptid
 261                   || last->state == THREAD_EXITED);
 262
 263       last->next = tp;
 264     }
 265
 266   return tp;
 267 }
 268
 269 struct thread_info *
 270 add_thread_silent (process_stratum_target *targ, ptid_t ptid)
 271 {
 272   inferior *inf = find_inferior_ptid (targ, ptid);
 273
 274   /* We may have an old thread with the same id in the thread list.
 275      If we do, it must be dead, otherwise we wouldn't be adding a new
 276      thread with the same id.  The OS is reusing this id --- delete
 277      the old thread, and create a new one.  */
 278   thread_info *tp = find_thread_ptid (inf, ptid);
 279   if (tp != nullptr)
 280     delete_thread (tp);
 281
 282   tp = new_thread (inf, ptid);
 283   gdb::observers::new_thread.notify (tp);
 284
 285   return tp;
 286 }
 287
 288 struct thread_info *
 289 add_thread_with_info (process_stratum_target *targ, ptid_t ptid,
 290                       private_thread_info *priv)
 291 {
 292   thread_info *result = add_thread_silent (targ, ptid);
 293
 294   result->priv.reset (priv);
 295
 296   if (print_thread_events)
 297     printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid).c_str ());
 298
 299   annotate_new_thread ();
 300   return result;
 301 }
 302
 303 struct thread_info *
 304 add_thread (process_stratum_target *targ, ptid_t ptid)
 305 {
 306   return add_thread_with_info (targ, ptid, NULL);
 307 }
 308
 309 private_thread_info::~private_thread_info () = default;
 310
 311 thread_info::thread_info (struct inferior *inf_, ptid_t ptid_)
 312   : ptid (ptid_), inf (inf_)
 313 {
 314   gdb_assert (inf_ != NULL);
 315
 316   this->global_num = ++highest_thread_num;
 317   this->per_inf_num = ++inf_->highest_thread_num;
 318
 319   /* Nothing to follow yet.  */
 320   memset (&this->pending_follow, 0, sizeof (this->pending_follow));
 321   this->pending_follow.kind = TARGET_WAITKIND_SPURIOUS;
 322   this->suspend.waitstatus.kind = TARGET_WAITKIND_IGNORE;
 323 }
 324
 325 thread_info::~thread_info ()
 326 {
 327   xfree (this->name);
 328 }
 329
 330 /* See gdbthread.h.  */
 331
 332 bool
 333 thread_info::deletable () const
 334 {
 335   /* If this is the current thread, or there's code out there that
 336      relies on it existing (refcount > 0) we can't delete yet.  */
 337   return refcount () == 0 && !is_current_thread (this);
 338 }
 339
 340 /* Add TP to the end of the step-over chain LIST_P.  */
 341
 342 static void
 343 step_over_chain_enqueue (struct thread_info **list_p, struct thread_info *tp)
 344 {
 345   gdb_assert (tp->step_over_next == NULL);
 346   gdb_assert (tp->step_over_prev == NULL);
 347
 348   if (*list_p == NULL)
 349     {
 350       *list_p = tp;
 351       tp->step_over_prev = tp->step_over_next = tp;
 352     }
 353   else
 354     {
 355       struct thread_info *head = *list_p;
 356       struct thread_info *tail = head->step_over_prev;
 357
 358       tp->step_over_prev = tail;
 359       tp->step_over_next = head;
 360       head->step_over_prev = tp;
 361       tail->step_over_next = tp;
 362     }
 363 }
 364
 365 /* Remove TP from step-over chain LIST_P.  */
 366
 367 static void
 368 step_over_chain_remove (struct thread_info **list_p, struct thread_info *tp)
 369 {
 370   gdb_assert (tp->step_over_next != NULL);
 371   gdb_assert (tp->step_over_prev != NULL);
 372
 373   if (*list_p == tp)
 374     {
 375       if (tp == tp->step_over_next)
 376         *list_p = NULL;
 377       else
 378         *list_p = tp->step_over_next;
 379     }
 380
 381   tp->step_over_prev->step_over_next = tp->step_over_next;
 382   tp->step_over_next->step_over_prev = tp->step_over_prev;
 383   tp->step_over_prev = tp->step_over_next = NULL;
 384 }
 385
 386 /* See gdbthread.h.  */
 387
 388 struct thread_info *
 389 thread_step_over_chain_next (struct thread_info *tp)
 390 {
 391   struct thread_info *next = tp->step_over_next;
 392
 393   return (next == step_over_queue_head ? NULL : next);
 394 }
 395
 396 /* See gdbthread.h.  */
 397
 398 int
 399 thread_is_in_step_over_chain (struct thread_info *tp)
 400 {
 401   return (tp->step_over_next != NULL);
 402 }
 403
 404 /* See gdbthread.h.  */
 405
 406 void
 407 thread_step_over_chain_enqueue (struct thread_info *tp)
 408 {
 409   step_over_chain_enqueue (&step_over_queue_head, tp);
 410 }
 411
 412 /* See gdbthread.h.  */
 413
 414 void
 415 thread_step_over_chain_remove (struct thread_info *tp)
 416 {
 417   step_over_chain_remove (&step_over_queue_head, tp);
 418 }
 419
 420 /* Delete the thread referenced by THR.  If SILENT, don't notify
 421    the observer of this exit.
 422
 423    THR must not be NULL or a failed assertion will be raised.  */
 424
 425 static void
 426 delete_thread_1 (thread_info *thr, bool silent)
 427 {
 428   gdb_assert (thr != nullptr);
 429
 430   struct thread_info *tp, *tpprev = NULL;
 431
 432   for (tp = thr->inf->thread_list; tp; tpprev = tp, tp = tp->next)
 433     if (tp == thr)
 434       break;
 435
 436   if (!tp)
 437     return;
 438
 439   set_thread_exited (tp, silent);
 440
 441   if (!tp->deletable ())
 442     {
 443        /* Will be really deleted some other time.  */
 444        return;
 445      }
 446
 447   if (tpprev)
 448     tpprev->next = tp->next;
 449   else
 450     tp->inf->thread_list = tp->next;
 451
 452   delete tp;
 453 }
 454
 455 /* See gdbthread.h.  */
 456
 457 void
 458 delete_thread (thread_info *thread)
 459 {
 460   delete_thread_1 (thread, false /* not silent */);
 461 }
 462
 463 void
 464 delete_thread_silent (thread_info *thread)
 465 {
 466   delete_thread_1 (thread, true /* silent */);
 467 }
 468
 469 struct thread_info *
 470 find_thread_global_id (int global_id)
 471 {
 472   for (thread_info *tp : all_threads ())
 473     if (tp->global_num == global_id)
 474       return tp;
 475
 476   return NULL;
 477 }
 478
 479 static struct thread_info *
 480 find_thread_id (struct inferior *inf, int thr_num)
 481 {
 482   for (thread_info *tp : inf->threads ())
 483     if (tp->per_inf_num == thr_num)
 484       return tp;
 485
 486   return NULL;
 487 }
 488
 489 /* See gdbthread.h.  */
 490
 491 struct thread_info *
 492 find_thread_ptid (process_stratum_target *targ, ptid_t ptid)
 493 {
 494   inferior *inf = find_inferior_ptid (targ, ptid);
 495   if (inf == NULL)
 496     return NULL;
 497   return find_thread_ptid (inf, ptid);
 498 }
 499
 500 /* See gdbthread.h.  */
 501
 502 struct thread_info *
 503 find_thread_ptid (inferior *inf, ptid_t ptid)
 504 {
 505   for (thread_info *tp : inf->non_exited_threads ())
 506     if (tp->ptid == ptid)
 507       return tp;
 508
 509   return NULL;
 510 }
 511
 512 /* See gdbthread.h.  */
 513
 514 struct thread_info *
 515 find_thread_by_handle (gdb::array_view<const gdb_byte> handle,
 516                        struct inferior *inf)
 517 {
 518   return target_thread_handle_to_thread_info (handle.data (),
 519                                               handle.size (),
 520                                               inf);
 521 }
 522
 523 /*
 524  * Thread iterator function.
 525  *
 526  * Calls a callback function once for each thread, so long as
 527  * the callback function returns false.  If the callback function
 528  * returns true, the iteration will end and the current thread
 529  * will be returned.  This can be useful for implementing a
 530  * search for a thread with arbitrary attributes, or for applying
 531  * some operation to every thread.
 532  *
 533  * FIXME: some of the existing functionality, such as
 534  * "Thread apply all", might be rewritten using this functionality.
 535  */
 536
 537 struct thread_info *
 538 iterate_over_threads (int (*callback) (struct thread_info *, void *),
 539                       void *data)
 540 {
 541   for (thread_info *tp : all_threads_safe ())
 542     if ((*callback) (tp, data))
 543       return tp;
 544
 545   return NULL;
 546 }
 547
 548 /* See gdbthread.h.  */
 549
 550 bool
 551 any_thread_p ()
 552 {
 553   for (thread_info *tp ATTRIBUTE_UNUSED : all_threads ())
 554     return true;
 555   return false;
 556 }
 557
 558 int
 559 thread_count (process_stratum_target *proc_target)
 560 {
 561   auto rng = all_threads (proc_target);
 562   return std::distance (rng.begin (), rng.end ());
 563 }
 564
 565 /* Return the number of non-exited threads in the thread list.  */
 566
 567 static int
 568 live_threads_count (void)
 569 {
 570   auto rng = all_non_exited_threads ();
 571   return std::distance (rng.begin (), rng.end ());
 572 }
 573
 574 int
 575 valid_global_thread_id (int global_id)
 576 {
 577   for (thread_info *tp : all_threads ())
 578     if (tp->global_num == global_id)
 579       return 1;
 580
 581   return 0;
 582 }
 583
 584 bool
 585 in_thread_list (process_stratum_target *targ, ptid_t ptid)
 586 {
 587   return find_thread_ptid (targ, ptid) != nullptr;
 588 }
 589
 590 /* Finds the first thread of the inferior.  */
 591
 592 thread_info *
 593 first_thread_of_inferior (inferior *inf)
 594 {
 595   return inf->thread_list;
 596 }
 597
 598 thread_info *
 599 any_thread_of_inferior (inferior *inf)
 600 {
 601   gdb_assert (inf->pid != 0);
 602
 603   /* Prefer the current thread.  */
 604   if (inf == current_inferior ())
 605     return inferior_thread ();
 606
 607   for (thread_info *tp : inf->non_exited_threads ())
 608     return tp;
 609
 610   return NULL;
 611 }
 612
 613 thread_info *
 614 any_live_thread_of_inferior (inferior *inf)
 615 {
 616   struct thread_info *curr_tp = NULL;
 617   struct thread_info *tp_executing = NULL;
 618
 619   gdb_assert (inf != NULL && inf->pid != 0);
 620
 621   /* Prefer the current thread if it's not executing.  */
 622   if (inferior_ptid != null_ptid && current_inferior () == inf)
 623     {
 624       /* If the current thread is dead, forget it.  If it's not
 625          executing, use it.  Otherwise, still choose it (below), but
 626          only if no other non-executing thread is found.  */
 627       curr_tp = inferior_thread ();
 628       if (curr_tp->state == THREAD_EXITED)
 629         curr_tp = NULL;
 630       else if (!curr_tp->executing)
 631         return curr_tp;
 632     }
 633
 634   for (thread_info *tp : inf->non_exited_threads ())
 635     {
 636       if (!tp->executing)
 637         return tp;
 638
 639       tp_executing = tp;
 640     }
 641
 642   /* If both the current thread and all live threads are executing,
 643      prefer the current thread.  */
 644   if (curr_tp != NULL)
 645     return curr_tp;
 646
 647   /* Otherwise, just return an executing thread, if any.  */
 648   return tp_executing;
 649 }
 650
 651 /* Return true if TP is an active thread.  */
 652 static bool
 653 thread_alive (thread_info *tp)
 654 {
 655   if (tp->state == THREAD_EXITED)
 656     return false;
 657
 658   /* Ensure we're looking at the right target stack.  */
 659   gdb_assert (tp->inf == current_inferior ());
 660
 661   return target_thread_alive (tp->ptid);
 662 }
 663
 664 /* Switch to thread TP if it is alive.  Returns true if successfully
 665    switched, false otherwise.  */
 666
 667 static bool
 668 switch_to_thread_if_alive (thread_info *thr)
 669 {
 670   scoped_restore_current_thread restore_thread;
 671
 672   /* Switch inferior first, so that we're looking at the right target
 673      stack.  */
 674   switch_to_inferior_no_thread (thr->inf);
 675
 676   if (thread_alive (thr))
 677     {
 678       switch_to_thread (thr);
 679       restore_thread.dont_restore ();
 680       return true;
 681     }
 682
 683   return false;
 684 }
 685
 686 /* See gdbthreads.h.  */
 687
 688 void
 689 prune_threads (void)
 690 {
 691   scoped_restore_current_thread restore_thread;
 692
 693   for (thread_info *tp : all_threads_safe ())
 694     {
 695       switch_to_inferior_no_thread (tp->inf);
 696
 697       if (!thread_alive (tp))
 698         delete_thread (tp);
 699     }
 700 }
 701
 702 /* See gdbthreads.h.  */
 703
 704 void
 705 delete_exited_threads (void)
 706 {
 707   for (thread_info *tp : all_threads_safe ())
 708     if (tp->state == THREAD_EXITED)
 709       delete_thread (tp);
 710 }
 711
 712 /* Return true value if stack temporaries are enabled for the thread
 713    TP.  */
 714
 715 bool
 716 thread_stack_temporaries_enabled_p (thread_info *tp)
 717 {
 718   if (tp == NULL)
 719     return false;
 720   else
 721     return tp->stack_temporaries_enabled;
 722 }
 723
 724 /* Push V on to the stack temporaries of the thread with id PTID.  */
 725
 726 void
 727 push_thread_stack_temporary (thread_info *tp, struct value *v)
 728 {
 729   gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
 730   tp->stack_temporaries.push_back (v);
 731 }
 732
 733 /* Return true if VAL is among the stack temporaries of the thread
 734    TP.  Return false otherwise.  */
 735
 736 bool
 737 value_in_thread_stack_temporaries (struct value *val, thread_info *tp)
 738 {
 739   gdb_assert (tp != NULL && tp->stack_temporaries_enabled);
 740   for (value *v : tp->stack_temporaries)
 741     if (v == val)
 742       return true;
 743
 744   return false;
 745 }
 746
 747 /* Return the last of the stack temporaries for thread with id PTID.
 748    Return NULL if there are no stack temporaries for the thread.  */
 749
 750 value *
 751 get_last_thread_stack_temporary (thread_info *tp)
 752 {
 753   struct value *lastval = NULL;
 754
 755   gdb_assert (tp != NULL);
 756   if (!tp->stack_temporaries.empty ())
 757     lastval = tp->stack_temporaries.back ();
 758
 759   return lastval;
 760 }
 761
 762 void
 763 thread_change_ptid (process_stratum_target *targ,
 764                     ptid_t old_ptid, ptid_t new_ptid)
 765 {
 766   struct inferior *inf;
 767   struct thread_info *tp;
 768
 769   /* It can happen that what we knew as the target inferior id
 770      changes.  E.g, target remote may only discover the remote process
 771      pid after adding the inferior to GDB's list.  */
 772   inf = find_inferior_ptid (targ, old_ptid);
 773   inf->pid = new_ptid.pid ();
 774
 775   tp = find_thread_ptid (inf, old_ptid);
 776   tp->ptid = new_ptid;
 777
 778   gdb::observers::thread_ptid_changed.notify (old_ptid, new_ptid);
 779 }
 780
 781 /* See gdbthread.h.  */
 782
 783 void
 784 set_resumed (process_stratum_target *targ, ptid_t ptid, bool resumed)
 785 {
 786   for (thread_info *tp : all_non_exited_threads (targ, ptid))
 787     tp->resumed = resumed;
 788 }
 789
 790 /* Helper for set_running, that marks one thread either running or
 791    stopped.  */
 792
 793 static bool
 794 set_running_thread (struct thread_info *tp, bool running)
 795 {
 796   bool started = false;
 797
 798   if (running && tp->state == THREAD_STOPPED)
 799     started = true;
 800   tp->state = running ? THREAD_RUNNING : THREAD_STOPPED;
 801
 802   if (!running)
 803     {
 804       /* If the thread is now marked stopped, remove it from
 805          the step-over queue, so that we don't try to resume
 806          it until the user wants it to.  */
 807       if (tp->step_over_next != NULL)
 808         thread_step_over_chain_remove (tp);
 809     }
 810
 811   return started;
 812 }
 813
 814 /* See gdbthread.h.  */
 815
 816 void
 817 thread_info::set_running (bool running)
 818 {
 819   if (set_running_thread (this, running))
 820     gdb::observers::target_resumed.notify (this->ptid);
 821 }
 822
 823 void
 824 set_running (process_stratum_target *targ, ptid_t ptid, bool running)
 825 {
 826   /* We try not to notify the observer if no thread has actually
 827      changed the running state -- merely to reduce the number of
 828      messages to the MI frontend.  A frontend is supposed to handle
 829      multiple *running notifications just fine.  */
 830   bool any_started = false;
 831
 832   for (thread_info *tp : all_non_exited_threads (targ, ptid))
 833     if (set_running_thread (tp, running))
 834       any_started = true;
 835
 836   if (any_started)
 837     gdb::observers::target_resumed.notify (ptid);
 838 }
 839
 840
 841 /* Helper for set_executing.  Set's the thread's 'executing' field
 842    from EXECUTING, and if EXECUTING is true also clears the thread's
 843    stop_pc.  */
 844
 845 static void
 846 set_executing_thread (thread_info *thr, bool executing)
 847 {
 848   thr->executing = executing;
 849   if (executing)
 850     thr->suspend.stop_pc = ~(CORE_ADDR) 0;
 851 }
 852
 853 void
 854 set_executing (process_stratum_target *targ, ptid_t ptid, bool executing)
 855 {
 856   for (thread_info *tp : all_non_exited_threads (targ, ptid))
 857     set_executing_thread (tp, executing);
 858
 859   /* It only takes one running thread to spawn more threads.  */
 860   if (executing)
 861     targ->threads_executing = true;
 862   /* Only clear the flag if the caller is telling us everything is
 863      stopped.  */
 864   else if (minus_one_ptid == ptid)
 865     targ->threads_executing = false;
 866 }
 867
 868 /* See gdbthread.h.  */
 869
 870 bool
 871 threads_are_executing (process_stratum_target *target)
 872 {
 873   return target->threads_executing;
 874 }
 875
 876 void
 877 set_stop_requested (process_stratum_target *targ, ptid_t ptid, bool stop)
 878 {
 879   for (thread_info *tp : all_non_exited_threads (targ, ptid))
 880     tp->stop_requested = stop;
 881
 882   /* Call the stop requested observer so other components of GDB can
 883      react to this request.  */
 884   if (stop)
 885     gdb::observers::thread_stop_requested.notify (ptid);
 886 }
 887
 888 void
 889 finish_thread_state (process_stratum_target *targ, ptid_t ptid)
 890 {
 891   bool any_started = false;
 892
 893   for (thread_info *tp : all_non_exited_threads (targ, ptid))
 894     if (set_running_thread (tp, tp->executing))
 895       any_started = true;
 896
 897   if (any_started)
 898     gdb::observers::target_resumed.notify (ptid);
 899 }
 900
 901 /* See gdbthread.h.  */
 902
 903 void
 904 validate_registers_access (void)
 905 {
 906   /* No selected thread, no registers.  */
 907   if (inferior_ptid == null_ptid)
 908     error (_("No thread selected."));
 909
 910   thread_info *tp = inferior_thread ();
 911
 912   /* Don't try to read from a dead thread.  */
 913   if (tp->state == THREAD_EXITED)
 914     error (_("The current thread has terminated"));
 915
 916   /* ... or from a spinning thread.  FIXME: This isn't actually fully
 917      correct.  It'll allow an user-requested access (e.g., "print $pc"
 918      at the prompt) when a thread is not executing for some internal
 919      reason, but is marked running from the user's perspective.  E.g.,
 920      the thread is waiting for its turn in the step-over queue.  */
 921   if (tp->executing)
 922     error (_("Selected thread is running."));
 923 }
 924
 925 /* See gdbthread.h.  */
 926
 927 bool
 928 can_access_registers_thread (thread_info *thread)
 929 {
 930   /* No thread, no registers.  */
 931   if (thread == NULL)
 932     return false;
 933
 934   /* Don't try to read from a dead thread.  */
 935   if (thread->state == THREAD_EXITED)
 936     return false;
 937
 938   /* ... or from a spinning thread.  FIXME: see validate_registers_access.  */
 939   if (thread->executing)
 940     return false;
 941
 942   return true;
 943 }
 944
 945 int
 946 pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread)
 947 {
 948   return (pc >= thread->control.step_range_start
 949           && pc < thread->control.step_range_end);
 950 }
 951
 952 /* Helper for print_thread_info.  Returns true if THR should be
 953    printed.  If REQUESTED_THREADS, a list of GDB ids/ranges, is not
 954    NULL, only print THR if its ID is included in the list.  GLOBAL_IDS
 955    is true if REQUESTED_THREADS is list of global IDs, false if a list
 956    of per-inferior thread ids.  If PID is not -1, only print THR if it
 957    is a thread from the process PID.  Otherwise, threads from all
 958    attached PIDs are printed.  If both REQUESTED_THREADS is not NULL
 959    and PID is not -1, then the thread is printed if it belongs to the
 960    specified process.  Otherwise, an error is raised.  */
 961
 962 static int
 963 should_print_thread (const char *requested_threads, int default_inf_num,
 964                      int global_ids, int pid, struct thread_info *thr)
 965 {
 966   if (requested_threads != NULL && *requested_threads != '\0')
 967     {
 968       int in_list;
 969
 970       if (global_ids)
 971         in_list = number_is_in_list (requested_threads, thr->global_num);
 972       else
 973         in_list = tid_is_in_list (requested_threads, default_inf_num,
 974                                   thr->inf->num, thr->per_inf_num);
 975       if (!in_list)
 976         return 0;
 977     }
 978
 979   if (pid != -1 && thr->ptid.pid () != pid)
 980     {
 981       if (requested_threads != NULL && *requested_threads != '\0')
 982         error (_("Requested thread not found in requested process"));
 983       return 0;
 984     }
 985
 986   if (thr->state == THREAD_EXITED)
 987     return 0;
 988
 989   return 1;
 990 }
 991
 992 /* Return the string to display in "info threads"'s "Target Id"
 993    column, for TP.  */
 994
 995 static std::string
 996 thread_target_id_str (thread_info *tp)
 997 {
 998   std::string target_id = target_pid_to_str (tp->ptid);
 999   const char *extra_info = target_extra_thread_info (tp);
1000   const char *name = tp->name != nullptr ? tp->name : target_thread_name (tp);
1001
1002   if (extra_info != nullptr && name != nullptr)
1003     return string_printf ("%s \"%s\" (%s)", target_id.c_str (), name,
1004                           extra_info);
1005   else if (extra_info != nullptr)
1006     return string_printf ("%s (%s)", target_id.c_str (), extra_info);
1007   else if (name != nullptr)
1008     return string_printf ("%s \"%s\"", target_id.c_str (), name);
1009   else
1010     return target_id;
1011 }
1012
1013 /* Like print_thread_info, but in addition, GLOBAL_IDS indicates
1014    whether REQUESTED_THREADS is a list of global or per-inferior
1015    thread ids.  */
1016
1017 static void
1018 print_thread_info_1 (struct ui_out *uiout, const char *requested_threads,
1019                      int global_ids, int pid,
1020                      int show_global_ids)
1021 {
1022   int default_inf_num = current_inferior ()->num;
1023
1024   update_thread_list ();
1025
1026   /* Whether we saw any thread.  */
1027   bool any_thread = false;
1028   /* Whether the current thread is exited.  */
1029   bool current_exited = false;
1030
1031   thread_info *current_thread = (inferior_ptid != null_ptid
1032                                  ? inferior_thread () : NULL);
1033
1034   {
1035     /* For backward compatibility, we make a list for MI.  A table is
1036        preferable for the CLI, though, because it shows table
1037        headers.  */
1038     gdb::optional<ui_out_emit_list> list_emitter;
1039     gdb::optional<ui_out_emit_table> table_emitter;
1040
1041     /* We'll be switching threads temporarily below.  */
1042     scoped_restore_current_thread restore_thread;
1043
1044     if (uiout->is_mi_like_p ())
1045       list_emitter.emplace (uiout, "threads");
1046     else
1047       {
1048         int n_threads = 0;
1049         /* The width of the "Target Id" column.  Grown below to
1050            accommodate the largest entry.  */
1051         size_t target_id_col_width = 17;
1052
1053         for (thread_info *tp : all_threads ())
1054           {
1055             if (!should_print_thread (requested_threads, default_inf_num,
1056                                       global_ids, pid, tp))
1057               continue;
1058
1059             if (!uiout->is_mi_like_p ())
1060               {
1061                 /* Switch inferiors so we're looking at the right
1062                    target stack.  */
1063                 switch_to_inferior_no_thread (tp->inf);
1064
1065                 target_id_col_width
1066                   = std::max (target_id_col_width,
1067                               thread_target_id_str (tp).size ());
1068               }
1069
1070             ++n_threads;
1071           }
1072
1073         if (n_threads == 0)
1074           {
1075             if (requested_threads == NULL || *requested_threads == '\0')
1076               uiout->message (_("No threads.\n"));
1077             else
1078               uiout->message (_("No threads match '%s'.\n"),
1079                               requested_threads);
1080             return;
1081           }
1082
1083         table_emitter.emplace (uiout, show_global_ids ? 5 : 4,
1084                                n_threads, "threads");
1085
1086         uiout->table_header (1, ui_left, "current", "");
1087         uiout->table_header (4, ui_left, "id-in-tg", "Id");
1088         if (show_global_ids)
1089           uiout->table_header (4, ui_left, "id", "GId");
1090         uiout->table_header (target_id_col_width, ui_left,
1091                              "target-id", "Target Id");
1092         uiout->table_header (1, ui_left, "frame", "Frame");
1093         uiout->table_body ();
1094       }
1095
1096     for (inferior *inf : all_inferiors ())
1097       for (thread_info *tp : inf->threads ())
1098         {
1099           int core;
1100
1101           any_thread = true;
1102           if (tp == current_thread && tp->state == THREAD_EXITED)
1103             current_exited = true;
1104
1105           if (!should_print_thread (requested_threads, default_inf_num,
1106                                     global_ids, pid, tp))
1107             continue;
1108
1109           ui_out_emit_tuple tuple_emitter (uiout, NULL);
1110
1111           if (!uiout->is_mi_like_p ())
1112             {
1113               if (tp == current_thread)
1114                 uiout->field_string ("current", "*");
1115               else
1116                 uiout->field_skip ("current");
1117
1118               uiout->field_string ("id-in-tg", print_thread_id (tp));
1119             }
1120
1121           if (show_global_ids || uiout->is_mi_like_p ())
1122             uiout->field_signed ("id", tp->global_num);
1123
1124           /* Switch to the thread (and inferior / target).  */
1125           switch_to_thread (tp);
1126
1127           /* For the CLI, we stuff everything into the target-id field.
1128              This is a gross hack to make the output come out looking
1129              correct.  The underlying problem here is that ui-out has no
1130              way to specify that a field's space allocation should be
1131              shared by several fields.  For MI, we do the right thing
1132              instead.  */
1133
1134           if (uiout->is_mi_like_p ())
1135             {
1136               uiout->field_string ("target-id", target_pid_to_str (tp->ptid));
1137
1138               const char *extra_info = target_extra_thread_info (tp);
1139               if (extra_info != nullptr)
1140                 uiout->field_string ("details", extra_info);
1141
1142               const char *name = (tp->name != nullptr
1143                                   ? tp->name
1144                                   : target_thread_name (tp));
1145               if (name != NULL)
1146                 uiout->field_string ("name", name);
1147             }
1148           else
1149             {
1150               uiout->field_string ("target-id",
1151                                    thread_target_id_str (tp).c_str ());
1152             }
1153
1154           if (tp->state == THREAD_RUNNING)
1155             uiout->text ("(running)\n");
1156           else
1157             {
1158               /* The switch above put us at the top of the stack (leaf
1159                  frame).  */
1160               print_stack_frame (get_selected_frame (NULL),
1161                                  /* For MI output, print frame level.  */
1162                                  uiout->is_mi_like_p (),
1163                                  LOCATION, 0);
1164             }
1165
1166           if (uiout->is_mi_like_p ())
1167             {
1168               const char *state = "stopped";
1169
1170               if (tp->state == THREAD_RUNNING)
1171                 state = "running";
1172               uiout->field_string ("state", state);
1173             }
1174
1175           core = target_core_of_thread (tp->ptid);
1176           if (uiout->is_mi_like_p () && core != -1)
1177             uiout->field_signed ("core", core);
1178         }
1179
1180     /* This end scope restores the current thread and the frame
1181        selected before the "info threads" command, and it finishes the
1182        ui-out list or table.  */
1183   }
1184
1185   if (pid == -1 && requested_threads == NULL)
1186     {
1187       if (uiout->is_mi_like_p () && inferior_ptid != null_ptid)
1188         uiout->field_signed ("current-thread-id", current_thread->global_num);
1189
1190       if (inferior_ptid != null_ptid && current_exited)
1191         uiout->message ("\n\
1192 The current thread <Thread ID %s> has terminated.  See `help thread'.\n",
1193                         print_thread_id (inferior_thread ()));
1194       else if (any_thread && inferior_ptid == null_ptid)
1195         uiout->message ("\n\
1196 No selected thread.  See `help thread'.\n");
1197     }
1198 }
1199
1200 /* See gdbthread.h.  */
1201
1202 void
1203 print_thread_info (struct ui_out *uiout, const char *requested_threads,
1204                    int pid)
1205 {
1206   print_thread_info_1 (uiout, requested_threads, 1, pid, 0);
1207 }
1208
1209 /* The options for the "info threads" command.  */
1210
1211 struct info_threads_opts
1212 {
1213   /* For "-gid".  */
1214   bool show_global_ids = false;
1215 };
1216
1217 static const gdb::option::option_def info_threads_option_defs[] = {
1218
1219   gdb::option::flag_option_def<info_threads_opts> {
1220     "gid",
1221     [] (info_threads_opts *opts) { return &opts->show_global_ids; },
1222     N_("Show global thread IDs."),
1223   },
1224
1225 };
1226
1227 /* Create an option_def_group for the "info threads" options, with
1228    IT_OPTS as context.  */
1229
1230 static inline gdb::option::option_def_group
1231 make_info_threads_options_def_group (info_threads_opts *it_opts)
1232 {
1233   return {{info_threads_option_defs}, it_opts};
1234 }
1235
1236 /* Implementation of the "info threads" command.
1237
1238    Note: this has the drawback that it _really_ switches
1239          threads, which frees the frame cache.  A no-side
1240          effects info-threads command would be nicer.  */
1241
1242 static void
1243 info_threads_command (const char *arg, int from_tty)
1244 {
1245   info_threads_opts it_opts;
1246
1247   auto grp = make_info_threads_options_def_group (&it_opts);
1248   gdb::option::process_options
1249     (&arg, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, grp);
1250
1251   print_thread_info_1 (current_uiout, arg, 0, -1, it_opts.show_global_ids);
1252 }
1253
1254 /* Completer for the "info threads" command.  */
1255
1256 static void
1257 info_threads_command_completer (struct cmd_list_element *ignore,
1258                                 completion_tracker &tracker,
1259                                 const char *text, const char *word_ignored)
1260 {
1261   const auto grp = make_info_threads_options_def_group (nullptr);
1262
1263   if (gdb::option::complete_options
1264       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR, grp))
1265     return;
1266
1267   /* Convenience to let the user know what the option can accept.  */
1268   if (*text == '\0')
1269     {
1270       gdb::option::complete_on_all_options (tracker, grp);
1271       /* Keep this "ID" in sync with what "help info threads"
1272          says.  */
1273       tracker.add_completion (make_unique_xstrdup ("ID"));
1274     }
1275 }
1276
1277 /* See gdbthread.h.  */
1278
1279 void
1280 switch_to_thread_no_regs (struct thread_info *thread)
1281 {
1282   struct inferior *inf = thread->inf;
1283
1284   set_current_program_space (inf->pspace);
1285   set_current_inferior (inf);
1286
1287   current_thread_ = thread;
1288   inferior_ptid = current_thread_->ptid;
1289 }
1290
1291 /* See gdbthread.h.  */
1292
1293 void
1294 switch_to_no_thread ()
1295 {
1296   if (current_thread_ == nullptr)
1297     return;
1298
1299   current_thread_ = nullptr;
1300   inferior_ptid = null_ptid;
1301   reinit_frame_cache ();
1302 }
1303
1304 /* See gdbthread.h.  */
1305
1306 void
1307 switch_to_thread (thread_info *thr)
1308 {
1309   gdb_assert (thr != NULL);
1310
1311   if (is_current_thread (thr))
1312     return;
1313
1314   switch_to_thread_no_regs (thr);
1315
1316   reinit_frame_cache ();
1317 }
1318
1319 /* See gdbsupport/common-gdbthread.h.  */
1320
1321 void
1322 switch_to_thread (process_stratum_target *proc_target, ptid_t ptid)
1323 {
1324   thread_info *thr = find_thread_ptid (proc_target, ptid);
1325   switch_to_thread (thr);
1326 }
1327
1328 static void
1329 restore_selected_frame (struct frame_id a_frame_id, int frame_level)
1330 {
1331   struct frame_info *frame = NULL;
1332   int count;
1333
1334   /* This means there was no selected frame.  */
1335   if (frame_level == -1)
1336     {
1337       select_frame (NULL);
1338       return;
1339     }
1340
1341   gdb_assert (frame_level >= 0);
1342
1343   /* Restore by level first, check if the frame id is the same as
1344      expected.  If that fails, try restoring by frame id.  If that
1345      fails, nothing to do, just warn the user.  */
1346
1347   count = frame_level;
1348   frame = find_relative_frame (get_current_frame (), &count);
1349   if (count == 0
1350       && frame != NULL
1351       /* The frame ids must match - either both valid or both outer_frame_id.
1352          The latter case is not failsafe, but since it's highly unlikely
1353          the search by level finds the wrong frame, it's 99.9(9)% of
1354          the time (for all practical purposes) safe.  */
1355       && frame_id_eq (get_frame_id (frame), a_frame_id))
1356     {
1357       /* Cool, all is fine.  */
1358       select_frame (frame);
1359       return;
1360     }
1361
1362   frame = frame_find_by_id (a_frame_id);
1363   if (frame != NULL)
1364     {
1365       /* Cool, refound it.  */
1366       select_frame (frame);
1367       return;
1368     }
1369
1370   /* Nothing else to do, the frame layout really changed.  Select the
1371      innermost stack frame.  */
1372   select_frame (get_current_frame ());
1373
1374   /* Warn the user.  */
1375   if (frame_level > 0 && !current_uiout->is_mi_like_p ())
1376     {
1377       warning (_("Couldn't restore frame #%d in "
1378                  "current thread.  Bottom (innermost) frame selected:"),
1379                frame_level);
1380       /* For MI, we should probably have a notification about
1381          current frame change.  But this error is not very
1382          likely, so don't bother for now.  */
1383       print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
1384     }
1385 }
1386
1387 void
1388 scoped_restore_current_thread::restore ()
1389 {
1390   /* If an entry of thread_info was previously selected, it won't be
1391      deleted because we've increased its refcount.  The thread represented
1392      by this thread_info entry may have already exited (due to normal exit,
1393      detach, etc), so the thread_info.state is THREAD_EXITED.  */
1394   if (m_thread != NULL
1395       /* If the previously selected thread belonged to a process that has
1396          in the mean time exited (or killed, detached, etc.), then don't revert
1397          back to it, but instead simply drop back to no thread selected.  */
1398       && m_inf->pid != 0)
1399     switch_to_thread (m_thread);
1400   else
1401     switch_to_inferior_no_thread (m_inf);
1402
1403   /* The running state of the originally selected thread may have
1404      changed, so we have to recheck it here.  */
1405   if (inferior_ptid != null_ptid
1406       && m_was_stopped
1407       && m_thread->state == THREAD_STOPPED
1408       && target_has_registers
1409       && target_has_stack
1410       && target_has_memory)
1411     restore_selected_frame (m_selected_frame_id, m_selected_frame_level);
1412 }
1413
1414 scoped_restore_current_thread::~scoped_restore_current_thread ()
1415 {
1416   if (!m_dont_restore)
1417     {
1418       try
1419         {
1420           restore ();
1421         }
1422       catch (const gdb_exception &ex)
1423         {
1424           /* We're in a dtor, there's really nothing else we can do
1425              but swallow the exception.  */
1426         }
1427     }
1428
1429   if (m_thread != NULL)
1430     m_thread->decref ();
1431   m_inf->decref ();
1432 }
1433
1434 scoped_restore_current_thread::scoped_restore_current_thread ()
1435 {
1436   m_thread = NULL;
1437   m_inf = current_inferior ();
1438
1439   if (inferior_ptid != null_ptid)
1440     {
1441       thread_info *tp = inferior_thread ();
1442       struct frame_info *frame;
1443
1444       m_was_stopped = tp->state == THREAD_STOPPED;
1445       if (m_was_stopped
1446           && target_has_registers
1447           && target_has_stack
1448           && target_has_memory)
1449         {
1450           /* When processing internal events, there might not be a
1451              selected frame.  If we naively call get_selected_frame
1452              here, then we can end up reading debuginfo for the
1453              current frame, but we don't generally need the debuginfo
1454              at this point.  */
1455           frame = get_selected_frame_if_set ();
1456         }
1457       else
1458         frame = NULL;
1459
1460       try
1461         {
1462           m_selected_frame_id = get_frame_id (frame);
1463           m_selected_frame_level = frame_relative_level (frame);
1464         }
1465       catch (const gdb_exception_error &ex)
1466         {
1467           m_selected_frame_id = null_frame_id;
1468           m_selected_frame_level = -1;
1469         }
1470
1471       tp->incref ();
1472       m_thread = tp;
1473     }
1474
1475   m_inf->incref ();
1476 }
1477
1478 /* See gdbthread.h.  */
1479
1480 int
1481 show_thread_that_caused_stop (void)
1482 {
1483   return highest_thread_num > 1;
1484 }
1485
1486 /* See gdbthread.h.  */
1487
1488 int
1489 show_inferior_qualified_tids (void)
1490 {
1491   return (inferior_list->next != NULL || inferior_list->num != 1);
1492 }
1493
1494 /* See gdbthread.h.  */
1495
1496 const char *
1497 print_thread_id (struct thread_info *thr)
1498 {
1499   char *s = get_print_cell ();
1500
1501   if (show_inferior_qualified_tids ())
1502     xsnprintf (s, PRINT_CELL_SIZE, "%d.%d", thr->inf->num, thr->per_inf_num);
1503   else
1504     xsnprintf (s, PRINT_CELL_SIZE, "%d", thr->per_inf_num);
1505   return s;
1506 }
1507
1508 /* Sort an array of struct thread_info pointers by thread ID (first by
1509    inferior number, and then by per-inferior thread number).  Sorts in
1510    ascending order.  */
1511
1512 static bool
1513 tp_array_compar_ascending (const thread_info *a, const thread_info *b)
1514 {
1515   if (a->inf->num != b->inf->num)
1516     return a->inf->num < b->inf->num;
1517
1518   return (a->per_inf_num < b->per_inf_num);
1519 }
1520
1521 /* Sort an array of struct thread_info pointers by thread ID (first by
1522    inferior number, and then by per-inferior thread number).  Sorts in
1523    descending order.  */
1524
1525 static bool
1526 tp_array_compar_descending (const thread_info *a, const thread_info *b)
1527 {
1528   if (a->inf->num != b->inf->num)
1529     return a->inf->num > b->inf->num;
1530
1531   return (a->per_inf_num > b->per_inf_num);
1532 }
1533
1534 /* Switch to thread THR and execute CMD.
1535    FLAGS.QUIET controls the printing of the thread information.
1536    FLAGS.CONT and FLAGS.SILENT control how to handle errors.  */
1537
1538 static void
1539 thr_try_catch_cmd (thread_info *thr, const char *cmd, int from_tty,
1540                    const qcs_flags &flags)
1541 {
1542   switch_to_thread (thr);
1543
1544   /* The thread header is computed before running the command since
1545      the command can change the inferior, which is not permitted
1546      by thread_target_id_str.  */
1547   std::string thr_header =
1548     string_printf (_("\nThread %s (%s):\n"), print_thread_id (thr),
1549                    thread_target_id_str (thr).c_str ());
1550
1551   try
1552     {
1553       std::string cmd_result = execute_command_to_string
1554         (cmd, from_tty, gdb_stdout->term_out ());
1555       if (!flags.silent || cmd_result.length () > 0)
1556         {
1557           if (!flags.quiet)
1558             printf_filtered ("%s", thr_header.c_str ());
1559           printf_filtered ("%s", cmd_result.c_str ());
1560         }
1561     }
1562   catch (const gdb_exception_error &ex)
1563     {
1564       if (!flags.silent)
1565         {
1566           if (!flags.quiet)
1567             printf_filtered ("%s", thr_header.c_str ());
1568           if (flags.cont)
1569             printf_filtered ("%s\n", ex.what ());
1570           else
1571             throw;
1572         }
1573     }
1574 }
1575
1576 /* Option definition of "thread apply"'s "-ascending" option.  */
1577
1578 static const gdb::option::flag_option_def<> ascending_option_def = {
1579   "ascending",
1580   N_("\
1581 Call COMMAND for all threads in ascending order.\n\
1582 The default is descending order."),
1583 };
1584
1585 /* The qcs command line flags for the "thread apply" commands.  Keep
1586    this in sync with the "frame apply" commands.  */
1587
1588 using qcs_flag_option_def
1589   = gdb::option::flag_option_def<qcs_flags>;
1590
1591 static const gdb::option::option_def thr_qcs_flags_option_defs[] = {
1592   qcs_flag_option_def {
1593     "q", [] (qcs_flags *opt) { return &opt->quiet; },
1594     N_("Disables printing the thread information."),
1595   },
1596
1597   qcs_flag_option_def {
1598     "c", [] (qcs_flags *opt) { return &opt->cont; },
1599     N_("Print any error raised by COMMAND and continue."),
1600   },
1601
1602   qcs_flag_option_def {
1603     "s", [] (qcs_flags *opt) { return &opt->silent; },
1604     N_("Silently ignore any errors or empty output produced by COMMAND."),
1605   },
1606 };
1607
1608 /* Create an option_def_group for the "thread apply all" options, with
1609    ASCENDING and FLAGS as context.  */
1610
1611 static inline std::array<gdb::option::option_def_group, 2>
1612 make_thread_apply_all_options_def_group (bool *ascending,
1613                                          qcs_flags *flags)
1614 {
1615   return {{
1616     { {ascending_option_def.def ()}, ascending},
1617     { {thr_qcs_flags_option_defs}, flags },
1618   }};
1619 }
1620
1621 /* Create an option_def_group for the "thread apply" options, with
1622    FLAGS as context.  */
1623
1624 static inline gdb::option::option_def_group
1625 make_thread_apply_options_def_group (qcs_flags *flags)
1626 {
1627   return {{thr_qcs_flags_option_defs}, flags};
1628 }
1629
1630 /* Apply a GDB command to a list of threads.  List syntax is a whitespace
1631    separated list of numbers, or ranges, or the keyword `all'.  Ranges consist
1632    of two numbers separated by a hyphen.  Examples:
1633
1634    thread apply 1 2 7 4 backtrace       Apply backtrace cmd to threads 1,2,7,4
1635    thread apply 2-7 9 p foo(1)  Apply p foo(1) cmd to threads 2->7 & 9
1636    thread apply all x/i $pc   Apply x/i $pc cmd to all threads.  */
1637
1638 static void
1639 thread_apply_all_command (const char *cmd, int from_tty)
1640 {
1641   bool ascending = false;
1642   qcs_flags flags;
1643
1644   auto group = make_thread_apply_all_options_def_group (&ascending,
1645                                                         &flags);
1646   gdb::option::process_options
1647     (&cmd, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group);
1648
1649   validate_flags_qcs ("thread apply all", &flags);
1650
1651   if (cmd == NULL || *cmd == '\000')
1652     error (_("Please specify a command at the end of 'thread apply all'"));
1653
1654   update_thread_list ();
1655
1656   int tc = live_threads_count ();
1657   if (tc != 0)
1658     {
1659       /* Save a copy of the thread list and increment each thread's
1660          refcount while executing the command in the context of each
1661          thread, in case the command is one that wipes threads.  E.g.,
1662          detach, kill, disconnect, etc., or even normally continuing
1663          over an inferior or thread exit.  */
1664       std::vector<thread_info *> thr_list_cpy;
1665       thr_list_cpy.reserve (tc);
1666
1667       for (thread_info *tp : all_non_exited_threads ())
1668         thr_list_cpy.push_back (tp);
1669       gdb_assert (thr_list_cpy.size () == tc);
1670
1671       /* Increment the refcounts, and restore them back on scope
1672          exit.  */
1673       scoped_inc_dec_ref inc_dec_ref (thr_list_cpy);
1674
1675       auto *sorter = (ascending
1676                       ? tp_array_compar_ascending
1677                       : tp_array_compar_descending);
1678       std::sort (thr_list_cpy.begin (), thr_list_cpy.end (), sorter);
1679
1680       scoped_restore_current_thread restore_thread;
1681
1682       for (thread_info *thr : thr_list_cpy)
1683         if (switch_to_thread_if_alive (thr))
1684           thr_try_catch_cmd (thr, cmd, from_tty, flags);
1685     }
1686 }
1687
1688 /* Completer for "thread apply [ID list]".  */
1689
1690 static void
1691 thread_apply_command_completer (cmd_list_element *ignore,
1692                                 completion_tracker &tracker,
1693                                 const char *text, const char * /*word*/)
1694 {
1695   /* Don't leave this to complete_options because there's an early
1696      return below.  */
1697   tracker.set_use_custom_word_point (true);
1698
1699   tid_range_parser parser;
1700   parser.init (text, current_inferior ()->num);
1701
1702   try
1703     {
1704       while (!parser.finished ())
1705         {
1706           int inf_num, thr_start, thr_end;
1707
1708           if (!parser.get_tid_range (&inf_num, &thr_start, &thr_end))
1709             break;
1710
1711           if (parser.in_star_range () || parser.in_thread_range ())
1712             parser.skip_range ();
1713         }
1714     }
1715   catch (const gdb_exception_error &ex)
1716     {
1717       /* get_tid_range throws if it parses a negative number, for
1718          example.  But a seemingly negative number may be the start of
1719          an option instead.  */
1720     }
1721
1722   const char *cmd = parser.cur_tok ();
1723
1724   if (cmd == text)
1725     {
1726       /* No thread ID list yet.  */
1727       return;
1728     }
1729
1730   /* Check if we're past a valid thread ID list already.  */
1731   if (parser.finished ()
1732       && cmd > text && !isspace (cmd[-1]))
1733     return;
1734
1735   /* We're past the thread ID list, advance word point.  */
1736   tracker.advance_custom_word_point_by (cmd - text);
1737   text = cmd;
1738
1739   const auto group = make_thread_apply_options_def_group (nullptr);
1740   if (gdb::option::complete_options
1741       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
1742     return;
1743
1744   complete_nested_command_line (tracker, text);
1745 }
1746
1747 /* Completer for "thread apply all".  */
1748
1749 static void
1750 thread_apply_all_command_completer (cmd_list_element *ignore,
1751                                     completion_tracker &tracker,
1752                                     const char *text, const char *word)
1753 {
1754   const auto group = make_thread_apply_all_options_def_group (nullptr,
1755                                                               nullptr);
1756   if (gdb::option::complete_options
1757       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
1758     return;
1759
1760   complete_nested_command_line (tracker, text);
1761 }
1762
1763 /* Implementation of the "thread apply" command.  */
1764
1765 static void
1766 thread_apply_command (const char *tidlist, int from_tty)
1767 {
1768   qcs_flags flags;
1769   const char *cmd = NULL;
1770   tid_range_parser parser;
1771
1772   if (tidlist == NULL || *tidlist == '\000')
1773     error (_("Please specify a thread ID list"));
1774
1775   parser.init (tidlist, current_inferior ()->num);
1776   while (!parser.finished ())
1777     {
1778       int inf_num, thr_start, thr_end;
1779
1780       if (!parser.get_tid_range (&inf_num, &thr_start, &thr_end))
1781         break;
1782     }
1783
1784   cmd = parser.cur_tok ();
1785
1786   auto group = make_thread_apply_options_def_group (&flags);
1787   gdb::option::process_options
1788     (&cmd, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group);
1789
1790   validate_flags_qcs ("thread apply", &flags);
1791
1792   if (*cmd == '\0')
1793     error (_("Please specify a command following the thread ID list"));
1794
1795   if (tidlist == cmd || isdigit (cmd[0]))
1796     invalid_thread_id_error (cmd);
1797
1798   scoped_restore_current_thread restore_thread;
1799
1800   parser.init (tidlist, current_inferior ()->num);
1801   while (!parser.finished ())
1802     {
1803       struct thread_info *tp = NULL;
1804       struct inferior *inf;
1805       int inf_num, thr_num;
1806
1807       parser.get_tid (&inf_num, &thr_num);
1808       inf = find_inferior_id (inf_num);
1809       if (inf != NULL)
1810         tp = find_thread_id (inf, thr_num);
1811
1812       if (parser.in_star_range ())
1813         {
1814           if (inf == NULL)
1815             {
1816               warning (_("Unknown inferior %d"), inf_num);
1817               parser.skip_range ();
1818               continue;
1819             }
1820
1821           /* No use looking for threads past the highest thread number
1822              the inferior ever had.  */
1823           if (thr_num >= inf->highest_thread_num)
1824             parser.skip_range ();
1825
1826           /* Be quiet about unknown threads numbers.  */
1827           if (tp == NULL)
1828             continue;
1829         }
1830
1831       if (tp == NULL)
1832         {
1833           if (show_inferior_qualified_tids () || parser.tid_is_qualified ())
1834             warning (_("Unknown thread %d.%d"), inf_num, thr_num);
1835           else
1836             warning (_("Unknown thread %d"), thr_num);
1837           continue;
1838         }
1839
1840       if (!switch_to_thread_if_alive (tp))
1841         {
1842           warning (_("Thread %s has terminated."), print_thread_id (tp));
1843           continue;
1844         }
1845
1846       thr_try_catch_cmd (tp, cmd, from_tty, flags);
1847     }
1848 }
1849
1850
1851 /* Implementation of the "taas" command.  */
1852
1853 static void
1854 taas_command (const char *cmd, int from_tty)
1855 {
1856   if (cmd == NULL || *cmd == '\0')
1857     error (_("Please specify a command to apply on all threads"));
1858   std::string expanded = std::string ("thread apply all -s ") + cmd;
1859   execute_command (expanded.c_str (), from_tty);
1860 }
1861
1862 /* Implementation of the "tfaas" command.  */
1863
1864 static void
1865 tfaas_command (const char *cmd, int from_tty)
1866 {
1867   if (cmd == NULL || *cmd == '\0')
1868     error (_("Please specify a command to apply on all frames of all threads"));
1869   std::string expanded
1870     = std::string ("thread apply all -s -- frame apply all -s ") + cmd;
1871   execute_command (expanded.c_str (), from_tty);
1872 }
1873
1874 /* Switch to the specified thread, or print the current thread.  */
1875
1876 void
1877 thread_command (const char *tidstr, int from_tty)
1878 {
1879   if (tidstr == NULL)
1880     {
1881       if (inferior_ptid == null_ptid)
1882         error (_("No thread selected"));
1883
1884       if (target_has_stack)
1885         {
1886           struct thread_info *tp = inferior_thread ();
1887
1888           if (tp->state == THREAD_EXITED)
1889             printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
1890                              print_thread_id (tp),
1891                              target_pid_to_str (inferior_ptid).c_str ());
1892           else
1893             printf_filtered (_("[Current thread is %s (%s)]\n"),
1894                              print_thread_id (tp),
1895                              target_pid_to_str (inferior_ptid).c_str ());
1896         }
1897       else
1898         error (_("No stack."));
1899     }
1900   else
1901     {
1902       ptid_t previous_ptid = inferior_ptid;
1903
1904       thread_select (tidstr, parse_thread_id (tidstr, NULL));
1905
1906       /* Print if the thread has not changed, otherwise an event will
1907          be sent.  */
1908       if (inferior_ptid == previous_ptid)
1909         {
1910           print_selected_thread_frame (current_uiout,
1911                                        USER_SELECTED_THREAD
1912                                        | USER_SELECTED_FRAME);
1913         }
1914       else
1915         {
1916           gdb::observers::user_selected_context_changed.notify
1917             (USER_SELECTED_THREAD | USER_SELECTED_FRAME);
1918         }
1919     }
1920 }
1921
1922 /* Implementation of `thread name'.  */
1923
1924 static void
1925 thread_name_command (const char *arg, int from_tty)
1926 {
1927   struct thread_info *info;
1928
1929   if (inferior_ptid == null_ptid)
1930     error (_("No thread selected"));
1931
1932   arg = skip_spaces (arg);
1933
1934   info = inferior_thread ();
1935   xfree (info->name);
1936   info->name = arg ? xstrdup (arg) : NULL;
1937 }
1938
1939 /* Find thread ids with a name, target pid, or extra info matching ARG.  */
1940
1941 static void
1942 thread_find_command (const char *arg, int from_tty)
1943 {
1944   const char *tmp;
1945   unsigned long match = 0;
1946
1947   if (arg == NULL || *arg == '\0')
1948     error (_("Command requires an argument."));
1949
1950   tmp = re_comp (arg);
1951   if (tmp != 0)
1952     error (_("Invalid regexp (%s): %s"), tmp, arg);
1953
1954   update_thread_list ();
1955   for (thread_info *tp : all_threads ())
1956     {
1957       if (tp->name != NULL && re_exec (tp->name))
1958         {
1959           printf_filtered (_("Thread %s has name '%s'\n"),
1960                            print_thread_id (tp), tp->name);
1961           match++;
1962         }
1963
1964       tmp = target_thread_name (tp);
1965       if (tmp != NULL && re_exec (tmp))
1966         {
1967           printf_filtered (_("Thread %s has target name '%s'\n"),
1968                            print_thread_id (tp), tmp);
1969           match++;
1970         }
1971
1972       std::string name = target_pid_to_str (tp->ptid);
1973       if (!name.empty () && re_exec (name.c_str ()))
1974         {
1975           printf_filtered (_("Thread %s has target id '%s'\n"),
1976                            print_thread_id (tp), name.c_str ());
1977           match++;
1978         }
1979
1980       tmp = target_extra_thread_info (tp);
1981       if (tmp != NULL && re_exec (tmp))
1982         {
1983           printf_filtered (_("Thread %s has extra info '%s'\n"),
1984                            print_thread_id (tp), tmp);
1985           match++;
1986         }
1987     }
1988   if (!match)
1989     printf_filtered (_("No threads match '%s'\n"), arg);
1990 }
1991
1992 /* Print notices when new threads are attached and detached.  */
1993 bool print_thread_events = true;
1994 static void
1995 show_print_thread_events (struct ui_file *file, int from_tty,
1996                           struct cmd_list_element *c, const char *value)
1997 {
1998   fprintf_filtered (file,
1999                     _("Printing of thread events is %s.\n"),
2000                     value);
2001 }
2002
2003 /* See gdbthread.h.  */
2004
2005 void
2006 thread_select (const char *tidstr, thread_info *tp)
2007 {
2008   if (!switch_to_thread_if_alive (tp))
2009     error (_("Thread ID %s has terminated."), tidstr);
2010
2011   annotate_thread_changed ();
2012
2013   /* Since the current thread may have changed, see if there is any
2014      exited thread we can now delete.  */
2015   delete_exited_threads ();
2016 }
2017
2018 /* Print thread and frame switch command response.  */
2019
2020 void
2021 print_selected_thread_frame (struct ui_out *uiout,
2022                              user_selected_what selection)
2023 {
2024   struct thread_info *tp = inferior_thread ();
2025
2026   if (selection & USER_SELECTED_THREAD)
2027     {
2028       if (uiout->is_mi_like_p ())
2029         {
2030           uiout->field_signed ("new-thread-id",
2031                                inferior_thread ()->global_num);
2032         }
2033       else
2034         {
2035           uiout->text ("[Switching to thread ");
2036           uiout->field_string ("new-thread-id", print_thread_id (tp));
2037           uiout->text (" (");
2038           uiout->text (target_pid_to_str (inferior_ptid).c_str ());
2039           uiout->text (")]");
2040         }
2041     }
2042
2043   if (tp->state == THREAD_RUNNING)
2044     {
2045       if (selection & USER_SELECTED_THREAD)
2046         uiout->text ("(running)\n");
2047     }
2048   else if (selection & USER_SELECTED_FRAME)
2049     {
2050       if (selection & USER_SELECTED_THREAD)
2051         uiout->text ("\n");
2052
2053       if (has_stack_frames ())
2054         print_stack_frame_to_uiout (uiout, get_selected_frame (NULL),
2055                                     1, SRC_AND_LOC, 1);
2056     }
2057 }
2058
2059 /* Update the 'threads_executing' global based on the threads we know
2060    about right now.  This is used by infrun to tell whether we should
2061    pull events out of the current target.  */
2062
2063 static void
2064 update_threads_executing (void)
2065 {
2066   process_stratum_target *targ = current_inferior ()->process_target ();
2067
2068   if (targ == NULL)
2069     return;
2070
2071   targ->threads_executing = false;
2072
2073   for (inferior *inf : all_non_exited_inferiors (targ))
2074     {
2075       if (!inf->has_execution ())
2076         continue;
2077
2078       /* If the process has no threads, then it must be we have a
2079          process-exit event pending.  */
2080       if (inf->thread_list == NULL)
2081         {
2082           targ->threads_executing = true;
2083           return;
2084         }
2085
2086       for (thread_info *tp : inf->non_exited_threads ())
2087         {
2088           if (tp->executing)
2089             {
2090               targ->threads_executing = true;
2091               return;
2092             }
2093         }
2094     }
2095 }
2096
2097 void
2098 update_thread_list (void)
2099 {
2100   target_update_thread_list ();
2101   update_threads_executing ();
2102 }
2103
2104 /* Return a new value for the selected thread's id.  Return a value of
2105    0 if no thread is selected.  If GLOBAL is true, return the thread's
2106    global number.  Otherwise return the per-inferior number.  */
2107
2108 static struct value *
2109 thread_num_make_value_helper (struct gdbarch *gdbarch, int global)
2110 {
2111   int int_val;
2112
2113   if (inferior_ptid == null_ptid)
2114     int_val = 0;
2115   else
2116     {
2117       thread_info *tp = inferior_thread ();
2118       if (global)
2119         int_val = tp->global_num;
2120       else
2121         int_val = tp->per_inf_num;
2122     }
2123
2124   return value_from_longest (builtin_type (gdbarch)->builtin_int, int_val);
2125 }
2126
2127 /* Return a new value for the selected thread's per-inferior thread
2128    number.  Return a value of 0 if no thread is selected, or no
2129    threads exist.  */
2130
2131 static struct value *
2132 thread_id_per_inf_num_make_value (struct gdbarch *gdbarch,
2133                                   struct internalvar *var,
2134                                   void *ignore)
2135 {
2136   return thread_num_make_value_helper (gdbarch, 0);
2137 }
2138
2139 /* Return a new value for the selected thread's global id.  Return a
2140    value of 0 if no thread is selected, or no threads exist.  */
2141
2142 static struct value *
2143 global_thread_id_make_value (struct gdbarch *gdbarch, struct internalvar *var,
2144                              void *ignore)
2145 {
2146   return thread_num_make_value_helper (gdbarch, 1);
2147 }
2148
2149 /* Commands with a prefix of `thread'.  */
2150 struct cmd_list_element *thread_cmd_list = NULL;
2151
2152 /* Implementation of `thread' variable.  */
2153
2154 static const struct internalvar_funcs thread_funcs =
2155 {
2156   thread_id_per_inf_num_make_value,
2157   NULL,
2158   NULL
2159 };
2160
2161 /* Implementation of `gthread' variable.  */
2162
2163 static const struct internalvar_funcs gthread_funcs =
2164 {
2165   global_thread_id_make_value,
2166   NULL,
2167   NULL
2168 };
2169
2170 void _initialize_thread ();
2171 void
2172 _initialize_thread ()
2173 {
2174   static struct cmd_list_element *thread_apply_list = NULL;
2175   cmd_list_element *c;
2176
2177   const auto info_threads_opts = make_info_threads_options_def_group (nullptr);
2178
2179   /* Note: keep this "ID" in sync with what "info threads [TAB]"
2180      suggests.  */
2181   static std::string info_threads_help
2182     = gdb::option::build_help (_("\
2183 Display currently known threads.\n\
2184 Usage: info threads [OPTION]... [ID]...\n\
2185 \n\
2186 Options:\n\
2187 %OPTIONS%\
2188 If ID is given, it is a space-separated list of IDs of threads to display.\n\
2189 Otherwise, all threads are displayed."),
2190                                info_threads_opts);
2191
2192   c = add_info ("threads", info_threads_command, info_threads_help.c_str ());
2193   set_cmd_completer_handle_brkchars (c, info_threads_command_completer);
2194
2195   add_prefix_cmd ("thread", class_run, thread_command, _("\
2196 Use this command to switch between threads.\n\
2197 The new thread ID must be currently known."),
2198                   &thread_cmd_list, "thread ", 1, &cmdlist);
2199
2200 #define THREAD_APPLY_OPTION_HELP "\
2201 Prints per-inferior thread number and target system's thread id\n\
2202 followed by COMMAND output.\n\
2203 \n\
2204 By default, an error raised during the execution of COMMAND\n\
2205 aborts \"thread apply\".\n\
2206 \n\
2207 Options:\n\
2208 %OPTIONS%"
2209
2210   const auto thread_apply_opts = make_thread_apply_options_def_group (nullptr);
2211
2212   static std::string thread_apply_help = gdb::option::build_help (_("\
2213 Apply a command to a list of threads.\n\
2214 Usage: thread apply ID... [OPTION]... COMMAND\n\
2215 ID is a space-separated list of IDs of threads to apply COMMAND on.\n"
2216 THREAD_APPLY_OPTION_HELP),
2217                                thread_apply_opts);
2218
2219   c = add_prefix_cmd ("apply", class_run, thread_apply_command,
2220                       thread_apply_help.c_str (),
2221                       &thread_apply_list, "thread apply ", 1,
2222                       &thread_cmd_list);
2223   set_cmd_completer_handle_brkchars (c, thread_apply_command_completer);
2224
2225   const auto thread_apply_all_opts
2226     = make_thread_apply_all_options_def_group (nullptr, nullptr);
2227
2228   static std::string thread_apply_all_help = gdb::option::build_help (_("\
2229 Apply a command to all threads.\n\
2230 \n\
2231 Usage: thread apply all [OPTION]... COMMAND\n"
2232 THREAD_APPLY_OPTION_HELP),
2233                                thread_apply_all_opts);
2234
2235   c = add_cmd ("all", class_run, thread_apply_all_command,
2236                thread_apply_all_help.c_str (),
2237                &thread_apply_list);
2238   set_cmd_completer_handle_brkchars (c, thread_apply_all_command_completer);
2239
2240   c = add_com ("taas", class_run, taas_command, _("\
2241 Apply a command to all threads (ignoring errors and empty output).\n\
2242 Usage: taas [OPTION]... COMMAND\n\
2243 shortcut for 'thread apply all -s [OPTION]... COMMAND'\n\
2244 See \"help thread apply all\" for available options."));
2245   set_cmd_completer_handle_brkchars (c, thread_apply_all_command_completer);
2246
2247   c = add_com ("tfaas", class_run, tfaas_command, _("\
2248 Apply a command to all frames of all threads (ignoring errors and empty output).\n\
2249 Usage: tfaas [OPTION]... COMMAND\n\
2250 shortcut for 'thread apply all -s -- frame apply all -s [OPTION]... COMMAND'\n\
2251 See \"help frame apply all\" for available options."));
2252   set_cmd_completer_handle_brkchars (c, frame_apply_all_cmd_completer);
2253
2254   add_cmd ("name", class_run, thread_name_command,
2255            _("Set the current thread's name.\n\
2256 Usage: thread name [NAME]\n\
2257 If NAME is not given, then any existing name is removed."), &thread_cmd_list);
2258
2259   add_cmd ("find", class_run, thread_find_command, _("\
2260 Find threads that match a regular expression.\n\
2261 Usage: thread find REGEXP\n\
2262 Will display thread ids whose name, target ID, or extra info matches REGEXP."),
2263            &thread_cmd_list);
2264
2265   add_com_alias ("t", "thread", class_run, 1);
2266
2267   add_setshow_boolean_cmd ("thread-events", no_class,
2268                            &print_thread_events, _("\
2269 Set printing of thread events (such as thread start and exit)."), _("\
2270 Show printing of thread events (such as thread start and exit)."), NULL,
2271                            NULL,
2272                            show_print_thread_events,
2273                            &setprintlist, &showprintlist);
2274
2275   create_internalvar_type_lazy ("_thread", &thread_funcs, NULL);
2276   create_internalvar_type_lazy ("_gthread", &gthread_funcs, NULL);
2277 }