gdb/gdbthread.h

   1 /* Multi-process/thread control defs for GDB, the GNU debugger.
   2    Copyright (C) 1987-2021 Free Software Foundation, Inc.
   3    Contributed by Lynx Real-Time Systems, Inc.  Los Gatos, CA.
   4
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GDBTHREAD_H
  22 #define GDBTHREAD_H
  23
  24 struct symtab;
  25
  26 #include "breakpoint.h"
  27 #include "frame.h"
  28 #include "ui-out.h"
  29 #include "btrace.h"
  30 #include "target/waitstatus.h"
  31 #include "cli/cli-utils.h"
  32 #include "gdbsupport/refcounted-object.h"
  33 #include "gdbsupport/common-gdbthread.h"
  34 #include "gdbsupport/forward-scope-exit.h"
  35 #include "displaced-stepping.h"
  36 #include "gdbsupport/intrusive_list.h"
  37
  38 struct inferior;
  39 struct process_stratum_target;
  40
  41 /* Frontend view of the thread state.  Possible extensions: stepping,
  42    finishing, until(ling),...
  43
  44    NOTE: Since the thread state is not a boolean, most times, you do
  45    not want to check it with negation.  If you really want to check if
  46    the thread is stopped,
  47
  48     use (good):
  49
  50      if (tp->state == THREAD_STOPPED)
  51
  52     instead of (bad):
  53
  54      if (tp->state != THREAD_RUNNING)
  55
  56    The latter is also true for exited threads, most likely not what
  57    you want.  */
  58 enum thread_state
  59 {
  60   /* In the frontend's perpective, the thread is stopped.  */
  61   THREAD_STOPPED,
  62
  63   /* In the frontend's perpective, the thread is running.  */
  64   THREAD_RUNNING,
  65
  66   /* The thread is listed, but known to have exited.  We keep it
  67      listed (but not visible) until it's safe to delete it.  */
  68   THREAD_EXITED,
  69 };
  70
  71 /* STEP_OVER_ALL means step over all subroutine calls.
  72    STEP_OVER_UNDEBUGGABLE means step over calls to undebuggable functions.
  73    STEP_OVER_NONE means don't step over any subroutine calls.  */
  74
  75 enum step_over_calls_kind
  76   {
  77     STEP_OVER_NONE,
  78     STEP_OVER_ALL,
  79     STEP_OVER_UNDEBUGGABLE
  80   };
  81
  82 /* Inferior thread specific part of `struct infcall_control_state'.
  83
  84    Inferior process counterpart is `struct inferior_control_state'.  */
  85
  86 struct thread_control_state
  87 {
  88   /* User/external stepping state.  */
  89
  90   /* Step-resume or longjmp-resume breakpoint.  */
  91   struct breakpoint *step_resume_breakpoint = nullptr;
  92
  93   /* Exception-resume breakpoint.  */
  94   struct breakpoint *exception_resume_breakpoint = nullptr;
  95
  96   /* Breakpoints used for software single stepping.  Plural, because
  97      it may have multiple locations.  E.g., if stepping over a
  98      conditional branch instruction we can't decode the condition for,
  99      we'll need to put a breakpoint at the branch destination, and
 100      another at the instruction after the branch.  */
 101   struct breakpoint *single_step_breakpoints = nullptr;
 102
 103   /* Range to single step within.
 104
 105      If this is nonzero, respond to a single-step signal by continuing
 106      to step if the pc is in this range.
 107
 108      If step_range_start and step_range_end are both 1, it means to
 109      step for a single instruction (FIXME: it might clean up
 110      wait_for_inferior in a minor way if this were changed to the
 111      address of the instruction and that address plus one.  But maybe
 112      not).  */
 113   CORE_ADDR step_range_start = 0;       /* Inclusive */
 114   CORE_ADDR step_range_end = 0;         /* Exclusive */
 115
 116   /* Function the thread was in as of last it started stepping.  */
 117   struct symbol *step_start_function = nullptr;
 118
 119   /* If GDB issues a target step request, and this is nonzero, the
 120      target should single-step this thread once, and then continue
 121      single-stepping it without GDB core involvement as long as the
 122      thread stops in the step range above.  If this is zero, the
 123      target should ignore the step range, and only issue one single
 124      step.  */
 125   int may_range_step = 0;
 126
 127   /* Stack frame address as of when stepping command was issued.
 128      This is how we know when we step into a subroutine call, and how
 129      to set the frame for the breakpoint used to step out.  */
 130   struct frame_id step_frame_id {};
 131
 132   /* Similarly, the frame ID of the underlying stack frame (skipping
 133      any inlined frames).  */
 134   struct frame_id step_stack_frame_id {};
 135
 136   /* True if the the thread is presently stepping over a breakpoint or
 137      a watchpoint, either with an inline step over or a displaced (out
 138      of line) step, and we're now expecting it to report a trap for
 139      the finished single step.  */
 140   int trap_expected = 0;
 141
 142   /* Nonzero if the thread is being proceeded for a "finish" command
 143      or a similar situation when return value should be printed.  */
 144   int proceed_to_finish = 0;
 145
 146   /* Nonzero if the thread is being proceeded for an inferior function
 147      call.  */
 148   int in_infcall = 0;
 149
 150   enum step_over_calls_kind step_over_calls = STEP_OVER_NONE;
 151
 152   /* Nonzero if stopped due to a step command.  */
 153   int stop_step = 0;
 154
 155   /* Chain containing status of breakpoint(s) the thread stopped
 156      at.  */
 157   bpstat stop_bpstat = nullptr;
 158
 159   /* Whether the command that started the thread was a stepping
 160      command.  This is used to decide whether "set scheduler-locking
 161      step" behaves like "on" or "off".  */
 162   int stepping_command = 0;
 163 };
 164
 165 /* Inferior thread specific part of `struct infcall_suspend_state'.  */
 166
 167 struct thread_suspend_state
 168 {
 169   /* Last signal that the inferior received (why it stopped).  When
 170      the thread is resumed, this signal is delivered.  Note: the
 171      target should not check whether the signal is in pass state,
 172      because the signal may have been explicitly passed with the
 173      "signal" command, which overrides "handle nopass".  If the signal
 174      should be suppressed, the core will take care of clearing this
 175      before the target is resumed.  */
 176   enum gdb_signal stop_signal = GDB_SIGNAL_0;
 177
 178   /* The reason the thread last stopped, if we need to track it
 179      (breakpoint, watchpoint, etc.)  */
 180   enum target_stop_reason stop_reason = TARGET_STOPPED_BY_NO_REASON;
 181
 182   /* The waitstatus for this thread's last event.  */
 183   struct target_waitstatus waitstatus {};
 184   /* If true WAITSTATUS hasn't been handled yet.  */
 185   int waitstatus_pending_p = 0;
 186
 187   /* Record the pc of the thread the last time it stopped.  (This is
 188      not the current thread's PC as that may have changed since the
 189      last stop, e.g., "return" command, or "p $pc = 0xf000").
 190
 191      - If the thread's PC has not changed since the thread last
 192        stopped, then proceed skips a breakpoint at the current PC,
 193        otherwise we let the thread run into the breakpoint.
 194
 195      - If the thread has an unprocessed event pending, as indicated by
 196        waitstatus_pending_p, this is used in coordination with
 197        stop_reason: if the thread's PC has changed since the thread
 198        last stopped, a pending breakpoint waitstatus is discarded.
 199
 200      - If the thread is running, this is set to -1, to avoid leaving
 201        it with a stale value, to make it easier to catch bugs.  */
 202   CORE_ADDR stop_pc = 0;
 203 };
 204
 205 /* Base class for target-specific thread data.  */
 206 struct private_thread_info
 207 {
 208   virtual ~private_thread_info () = 0;
 209 };
 210
 211 /* Threads are intrusively refcounted objects.  Being the
 212    user-selected thread is normally considered an implicit strong
 213    reference and is thus not accounted in the refcount, unlike
 214    inferior objects.  This is necessary, because there's no "current
 215    thread" pointer.  Instead the current thread is inferred from the
 216    inferior_ptid global.  However, when GDB needs to remember the
 217    selected thread to later restore it, GDB bumps the thread object's
 218    refcount, to prevent something deleting the thread object before
 219    reverting back (e.g., due to a "kill" command).  If the thread
 220    meanwhile exits before being re-selected, then the thread object is
 221    left listed in the thread list, but marked with state
 222    THREAD_EXITED.  (See scoped_restore_current_thread and
 223    delete_thread).  All other thread references are considered weak
 224    references.  Placing a thread in the thread list is an implicit
 225    strong reference, and is thus not accounted for in the thread's
 226    refcount.
 227
 228    The intrusive_list_node base links threads in a per-inferior list.  */
 229
 230 class thread_info : public refcounted_object,
 231                     public intrusive_list_node<thread_info>
 232 {
 233 public:
 234   explicit thread_info (inferior *inf, ptid_t ptid);
 235   ~thread_info ();
 236
 237   bool deletable () const;
 238
 239   /* Mark this thread as running and notify observers.  */
 240   void set_running (bool running);
 241
 242   ptid_t ptid;                  /* "Actual process id";
 243                                     In fact, this may be overloaded with
 244                                     kernel thread id, etc.  */
 245
 246   /* Each thread has two GDB IDs.
 247
 248      a) The thread ID (Id).  This consists of the pair of:
 249
 250         - the number of the thread's inferior and,
 251
 252         - the thread's thread number in its inferior, aka, the
 253           per-inferior thread number.  This number is unique in the
 254           inferior but not unique between inferiors.
 255
 256      b) The global ID (GId).  This is a a single integer unique
 257         between all inferiors.
 258
 259      E.g.:
 260
 261       (gdb) info threads -gid
 262         Id    GId   Target Id   Frame
 263       * 1.1   1     Thread A    0x16a09237 in foo () at foo.c:10
 264         1.2   3     Thread B    0x15ebc6ed in bar () at foo.c:20
 265         1.3   5     Thread C    0x15ebc6ed in bar () at foo.c:20
 266         2.1   2     Thread A    0x16a09237 in foo () at foo.c:10
 267         2.2   4     Thread B    0x15ebc6ed in bar () at foo.c:20
 268         2.3   6     Thread C    0x15ebc6ed in bar () at foo.c:20
 269
 270      Above, both inferiors 1 and 2 have threads numbered 1-3, but each
 271      thread has its own unique global ID.  */
 272
 273   /* The thread's global GDB thread number.  This is exposed to MI,
 274      Python/Scheme, visible with "info threads -gid", and is also what
 275      the $_gthread convenience variable is bound to.  */
 276   int global_num;
 277
 278   /* The per-inferior thread number.  This is unique in the inferior
 279      the thread belongs to, but not unique between inferiors.  This is
 280      what the $_thread convenience variable is bound to.  */
 281   int per_inf_num;
 282
 283   /* The inferior this thread belongs to.  */
 284   struct inferior *inf;
 285
 286   /* The name of the thread, as specified by the user.  This is NULL
 287      if the thread does not have a user-given name.  */
 288   char *name = NULL;
 289
 290   /* True means the thread is executing.  Note: this is different
 291      from saying that there is an active target and we are stopped at
 292      a breakpoint, for instance.  This is a real indicator whether the
 293      thread is off and running.  */
 294   bool executing = false;
 295
 296   /* True if this thread is resumed from infrun's perspective.
 297      Note that a thread can be marked both as not-executing and
 298      resumed at the same time.  This happens if we try to resume a
 299      thread that has a wait status pending.  We shouldn't let the
 300      thread really run until that wait status has been processed, but
 301      we should not process that wait status if we didn't try to let
 302      the thread run.  */
 303   bool resumed = false;
 304
 305   /* Frontend view of the thread state.  Note that the THREAD_RUNNING/
 306      THREAD_STOPPED states are different from EXECUTING.  When the
 307      thread is stopped internally while handling an internal event,
 308      like a software single-step breakpoint, EXECUTING will be false,
 309      but STATE will still be THREAD_RUNNING.  */
 310   enum thread_state state = THREAD_STOPPED;
 311
 312   /* State of GDB control of inferior thread execution.
 313      See `struct thread_control_state'.  */
 314   thread_control_state control;
 315
 316   /* State of inferior thread to restore after GDB is done with an inferior
 317      call.  See `struct thread_suspend_state'.  */
 318   thread_suspend_state suspend;
 319
 320   int current_line = 0;
 321   struct symtab *current_symtab = NULL;
 322
 323   /* Internal stepping state.  */
 324
 325   /* Record the pc of the thread the last time it was resumed.  (It
 326      can't be done on stop as the PC may change since the last stop,
 327      e.g., "return" command, or "p $pc = 0xf000").  This is maintained
 328      by proceed and keep_going, and among other things, it's used in
 329      adjust_pc_after_break to distinguish a hardware single-step
 330      SIGTRAP from a breakpoint SIGTRAP.  */
 331   CORE_ADDR prev_pc = 0;
 332
 333   /* Did we set the thread stepping a breakpoint instruction?  This is
 334      used in conjunction with PREV_PC to decide whether to adjust the
 335      PC.  */
 336   int stepped_breakpoint = 0;
 337
 338   /* Should we step over breakpoint next time keep_going is called?  */
 339   int stepping_over_breakpoint = 0;
 340
 341   /* Should we step over a watchpoint next time keep_going is called?
 342      This is needed on targets with non-continuable, non-steppable
 343      watchpoints.  */
 344   int stepping_over_watchpoint = 0;
 345
 346   /* Set to TRUE if we should finish single-stepping over a breakpoint
 347      after hitting the current step-resume breakpoint.  The context here
 348      is that GDB is to do `next' or `step' while signal arrives.
 349      When stepping over a breakpoint and signal arrives, GDB will attempt
 350      to skip signal handler, so it inserts a step_resume_breakpoint at the
 351      signal return address, and resume inferior.
 352      step_after_step_resume_breakpoint is set to TRUE at this moment in
 353      order to keep GDB in mind that there is still a breakpoint to step over
 354      when GDB gets back SIGTRAP from step_resume_breakpoint.  */
 355   int step_after_step_resume_breakpoint = 0;
 356
 357   /* Pointer to the state machine manager object that handles what is
 358      left to do for the thread's execution command after the target
 359      stops.  Several execution commands use it.  */
 360   struct thread_fsm *thread_fsm = NULL;
 361
 362   /* This is used to remember when a fork or vfork event was caught by
 363      a catchpoint, and thus the event is to be followed at the next
 364      resume of the thread, and not immediately.  */
 365   struct target_waitstatus pending_follow;
 366
 367   /* True if this thread has been explicitly requested to stop.  */
 368   int stop_requested = 0;
 369
 370   /* The initiating frame of a nexting operation, used for deciding
 371      which exceptions to intercept.  If it is null_frame_id no
 372      bp_longjmp or bp_exception but longjmp has been caught just for
 373      bp_longjmp_call_dummy.  */
 374   struct frame_id initiating_frame = null_frame_id;
 375
 376   /* Private data used by the target vector implementation.  */
 377   std::unique_ptr<private_thread_info> priv;
 378
 379   /* Branch trace information for this thread.  */
 380   struct btrace_thread_info btrace {};
 381
 382   /* Flag which indicates that the stack temporaries should be stored while
 383      evaluating expressions.  */
 384   bool stack_temporaries_enabled = false;
 385
 386   /* Values that are stored as temporaries on stack while evaluating
 387      expressions.  */
 388   std::vector<struct value *> stack_temporaries;
 389
 390   /* Step-over chain.  A thread is in the step-over queue if these are
 391      non-NULL.  If only a single thread is in the chain, then these
 392      fields point to self.  */
 393   struct thread_info *step_over_prev = NULL;
 394   struct thread_info *step_over_next = NULL;
 395
 396   /* Displaced-step state for this thread.  */
 397   displaced_step_thread_state displaced_step_state;
 398 };
 399
 400 /* A gdb::ref_ptr pointer to a thread_info.  */
 401
 402 using thread_info_ref
 403   = gdb::ref_ptr<struct thread_info, refcounted_object_ref_policy>;
 404
 405 /* A gdb::ref_ptr pointer to an inferior.  This would ideally be in
 406    inferior.h, but it can't due to header dependencies (inferior.h
 407    includes gdbthread.h).  */
 408
 409 using inferior_ref
 410   = gdb::ref_ptr<struct inferior, refcounted_object_ref_policy>;
 411
 412 /* Create an empty thread list, or empty the existing one.  */
 413 extern void init_thread_list (void);
 414
 415 /* Add a thread to the thread list, print a message
 416    that a new thread is found, and return the pointer to
 417    the new thread.  Caller my use this pointer to
 418    initialize the private thread data.  */
 419 extern struct thread_info *add_thread (process_stratum_target *targ,
 420                                        ptid_t ptid);
 421
 422 /* Same as add_thread, but does not print a message about new
 423    thread.  */
 424 extern struct thread_info *add_thread_silent (process_stratum_target *targ,
 425                                               ptid_t ptid);
 426
 427 /* Same as add_thread, and sets the private info.  */
 428 extern struct thread_info *add_thread_with_info (process_stratum_target *targ,
 429                                                  ptid_t ptid,
 430                                                  private_thread_info *);
 431
 432 /* Delete thread THREAD and notify of thread exit.  If the thread is
 433    currently not deletable, don't actually delete it but still tag it
 434    as exited and do the notification.  */
 435 extern void delete_thread (struct thread_info *thread);
 436
 437 /* Like delete_thread, but be quiet about it.  Used when the process
 438    this thread belonged to has already exited, for example.  */
 439 extern void delete_thread_silent (struct thread_info *thread);
 440
 441 /* Mark the thread exited, but don't delete it or remove it from the
 442    inferior thread list.  */
 443 extern void set_thread_exited (thread_info *tp, bool silent);
 444
 445 /* Delete a step_resume_breakpoint from the thread database.  */
 446 extern void delete_step_resume_breakpoint (struct thread_info *);
 447
 448 /* Delete an exception_resume_breakpoint from the thread database.  */
 449 extern void delete_exception_resume_breakpoint (struct thread_info *);
 450
 451 /* Delete the single-step breakpoints of thread TP, if any.  */
 452 extern void delete_single_step_breakpoints (struct thread_info *tp);
 453
 454 /* Check if the thread has software single stepping breakpoints
 455    set.  */
 456 extern int thread_has_single_step_breakpoints_set (struct thread_info *tp);
 457
 458 /* Check whether the thread has software single stepping breakpoints
 459    set at PC.  */
 460 extern int thread_has_single_step_breakpoint_here (struct thread_info *tp,
 461                                                    const address_space *aspace,
 462                                                    CORE_ADDR addr);
 463
 464 /* Returns whether to show inferior-qualified thread IDs, or plain
 465    thread numbers.  Inferior-qualified IDs are shown whenever we have
 466    multiple inferiors, or the only inferior left has number > 1.  */
 467 extern int show_inferior_qualified_tids (void);
 468
 469 /* Return a string version of THR's thread ID.  If there are multiple
 470    inferiors, then this prints the inferior-qualifier form, otherwise
 471    it only prints the thread number.  The result is stored in a
 472    circular static buffer, NUMCELLS deep.  */
 473 const char *print_thread_id (struct thread_info *thr);
 474
 475 /* Boolean test for an already-known ptid.  */
 476 extern bool in_thread_list (process_stratum_target *targ, ptid_t ptid);
 477
 478 /* Boolean test for an already-known global thread id (GDB's homegrown
 479    global id, not the system's).  */
 480 extern int valid_global_thread_id (int global_id);
 481
 482 /* Find (non-exited) thread PTID of inferior INF.  */
 483 extern thread_info *find_thread_ptid (inferior *inf, ptid_t ptid);
 484
 485 /* Search function to lookup a (non-exited) thread by 'ptid'.  */
 486 extern struct thread_info *find_thread_ptid (process_stratum_target *targ,
 487                                              ptid_t ptid);
 488
 489 /* Find thread by GDB global thread ID.  */
 490 struct thread_info *find_thread_global_id (int global_id);
 491
 492 /* Find thread by thread library specific handle in inferior INF.  */
 493 struct thread_info *find_thread_by_handle
 494   (gdb::array_view<const gdb_byte> handle, struct inferior *inf);
 495
 496 /* Finds the first thread of the specified inferior.  */
 497 extern struct thread_info *first_thread_of_inferior (inferior *inf);
 498
 499 /* Returns any thread of inferior INF, giving preference to the
 500    current thread.  */
 501 extern struct thread_info *any_thread_of_inferior (inferior *inf);
 502
 503 /* Returns any non-exited thread of inferior INF, giving preference to
 504    the current thread, and to not executing threads.  */
 505 extern struct thread_info *any_live_thread_of_inferior (inferior *inf);
 506
 507 /* Change the ptid of thread OLD_PTID to NEW_PTID.  */
 508 void thread_change_ptid (process_stratum_target *targ,
 509                          ptid_t old_ptid, ptid_t new_ptid);
 510
 511 /* Iterator function to call a user-provided callback function
 512    once for each known thread.  */
 513 typedef int (*thread_callback_func) (struct thread_info *, void *);
 514 extern struct thread_info *iterate_over_threads (thread_callback_func, void *);
 515
 516 /* Pull in the internals of the inferiors/threads ranges and
 517    iterators.  Must be done after struct thread_info is defined.  */
 518 #include "thread-iter.h"
 519
 520 /* Return a range that can be used to walk over threads, with
 521    range-for.
 522
 523    Used like this, it walks over all threads of all inferiors of all
 524    targets:
 525
 526        for (thread_info *thr : all_threads ())
 527          { .... }
 528
 529    FILTER_PTID can be used to filter out threads that don't match.
 530    FILTER_PTID can be:
 531
 532    - minus_one_ptid, meaning walk all threads of all inferiors of
 533      PROC_TARGET.  If PROC_TARGET is NULL, then of all targets.
 534
 535    - A process ptid, in which case walk all threads of the specified
 536      process.  PROC_TARGET must be non-NULL in this case.
 537
 538    - A thread ptid, in which case walk that thread only.  PROC_TARGET
 539      must be non-NULL in this case.
 540 */
 541
 542 inline all_matching_threads_range
 543 all_threads (process_stratum_target *proc_target = nullptr,
 544              ptid_t filter_ptid = minus_one_ptid)
 545 {
 546   return all_matching_threads_range (proc_target, filter_ptid);
 547 }
 548
 549 /* Return a range that can be used to walk over all non-exited threads
 550    of all inferiors, with range-for.  Arguments are like all_threads
 551    above.  */
 552
 553 inline all_non_exited_threads_range
 554 all_non_exited_threads (process_stratum_target *proc_target = nullptr,
 555                         ptid_t filter_ptid = minus_one_ptid)
 556 {
 557   return all_non_exited_threads_range (proc_target, filter_ptid);
 558 }
 559
 560 /* Return a range that can be used to walk over all threads of all
 561    inferiors, with range-for, safely.  I.e., it is safe to delete the
 562    currently-iterated thread.  When combined with range-for, this
 563    allow convenient patterns like this:
 564
 565      for (thread_info *t : all_threads_safe ())
 566        if (some_condition ())
 567          delete f;
 568 */
 569
 570 inline all_threads_safe_range
 571 all_threads_safe ()
 572 {
 573   return all_threads_safe_range (all_threads_iterator::begin_t {});
 574 }
 575
 576 extern int thread_count (process_stratum_target *proc_target);
 577
 578 /* Return true if we have any thread in any inferior.  */
 579 extern bool any_thread_p ();
 580
 581 /* Switch context to thread THR.  Also sets the STOP_PC global.  */
 582 extern void switch_to_thread (struct thread_info *thr);
 583
 584 /* Switch context to no thread selected.  */
 585 extern void switch_to_no_thread ();
 586
 587 /* Switch from one thread to another.  Does not read registers.  */
 588 extern void switch_to_thread_no_regs (struct thread_info *thread);
 589
 590 /* Marks or clears thread(s) PTID of TARG as resumed.  If PTID is
 591    MINUS_ONE_PTID, applies to all threads of TARG.  If
 592    ptid_is_pid(PTID) is true, applies to all threads of the process
 593    pointed at by {TARG,PTID}.  */
 594 extern void set_resumed (process_stratum_target *targ,
 595                          ptid_t ptid, bool resumed);
 596
 597 /* Marks thread PTID of TARG as running, or as stopped.  If PTID is
 598    minus_one_ptid, marks all threads of TARG.  */
 599 extern void set_running (process_stratum_target *targ,
 600                          ptid_t ptid, bool running);
 601
 602 /* Marks or clears thread(s) PTID of TARG as having been requested to
 603    stop.  If PTID is MINUS_ONE_PTID, applies to all threads of TARG.
 604    If ptid_is_pid(PTID) is true, applies to all threads of the process
 605    pointed at by {TARG, PTID}.  If STOP, then the
 606    THREAD_STOP_REQUESTED observer is called with PTID as argument.  */
 607 extern void set_stop_requested (process_stratum_target *targ,
 608                                 ptid_t ptid, bool stop);
 609
 610 /* Marks thread PTID of TARG as executing, or not.  If PTID is
 611    minus_one_ptid, marks all threads of TARG.
 612
 613    Note that this is different from the running state.  See the
 614    description of state and executing fields of struct
 615    thread_info.  */
 616 extern void set_executing (process_stratum_target *targ,
 617                            ptid_t ptid, bool executing);
 618
 619 /* True if any (known or unknown) thread of TARG is or may be
 620    executing.  */
 621 extern bool threads_are_executing (process_stratum_target *targ);
 622
 623 /* Merge the executing property of thread PTID of TARG over to its
 624    thread state property (frontend running/stopped view).
 625
 626    "not executing" -> "stopped"
 627    "executing"     -> "running"
 628    "exited"        -> "exited"
 629
 630    If PTID is minus_one_ptid, go over all threads of TARG.
 631
 632    Notifications are only emitted if the thread state did change.  */
 633 extern void finish_thread_state (process_stratum_target *targ, ptid_t ptid);
 634
 635 /* Calls finish_thread_state on scope exit, unless release() is called
 636    to disengage.  */
 637 using scoped_finish_thread_state
 638   = FORWARD_SCOPE_EXIT (finish_thread_state);
 639
 640 /* Commands with a prefix of `thread'.  */
 641 extern struct cmd_list_element *thread_cmd_list;
 642
 643 extern void thread_command (const char *tidstr, int from_tty);
 644
 645 /* Print notices on thread events (attach, detach, etc.), set with
 646    `set print thread-events'.  */
 647 extern bool print_thread_events;
 648
 649 /* Prints the list of threads and their details on UIOUT.  If
 650    REQUESTED_THREADS, a list of GDB ids/ranges, is not NULL, only
 651    print threads whose ID is included in the list.  If PID is not -1,
 652    only print threads from the process PID.  Otherwise, threads from
 653    all attached PIDs are printed.  If both REQUESTED_THREADS is not
 654    NULL and PID is not -1, then the thread is printed if it belongs to
 655    the specified process.  Otherwise, an error is raised.  */
 656 extern void print_thread_info (struct ui_out *uiout,
 657                                const char *requested_threads,
 658                                int pid);
 659
 660 /* Save/restore current inferior/thread/frame.  */
 661
 662 class scoped_restore_current_thread
 663 {
 664 public:
 665   scoped_restore_current_thread ();
 666   ~scoped_restore_current_thread ();
 667
 668   DISABLE_COPY_AND_ASSIGN (scoped_restore_current_thread);
 669
 670   /* Cancel restoring on scope exit.  */
 671   void dont_restore () { m_dont_restore = true; }
 672
 673 private:
 674   void restore ();
 675
 676   bool m_dont_restore = false;
 677   thread_info_ref m_thread;
 678   inferior_ref m_inf;
 679
 680   frame_id m_selected_frame_id;
 681   int m_selected_frame_level;
 682   bool m_was_stopped;
 683   /* Save/restore the language as well, because selecting a frame
 684      changes the current language to the frame's language if "set
 685      language auto".  */
 686   enum language m_lang;
 687 };
 688
 689 /* Returns a pointer into the thread_info corresponding to
 690    INFERIOR_PTID.  INFERIOR_PTID *must* be in the thread list.  */
 691 extern struct thread_info* inferior_thread (void);
 692
 693 extern void update_thread_list (void);
 694
 695 /* Delete any thread the target says is no longer alive.  */
 696
 697 extern void prune_threads (void);
 698
 699 /* Delete threads marked THREAD_EXITED.  Unlike prune_threads, this
 700    does not consult the target about whether the thread is alive right
 701    now.  */
 702 extern void delete_exited_threads (void);
 703
 704 /* Return true if PC is in the stepping range of THREAD.  */
 705
 706 int pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread);
 707
 708 /* Enable storing stack temporaries for thread THR and disable and
 709    clear the stack temporaries on destruction.  Holds a strong
 710    reference to THR.  */
 711
 712 class enable_thread_stack_temporaries
 713 {
 714 public:
 715
 716   explicit enable_thread_stack_temporaries (struct thread_info *thr)
 717     : m_thr (thread_info_ref::new_reference (thr))
 718   {
 719     m_thr->stack_temporaries_enabled = true;
 720     m_thr->stack_temporaries.clear ();
 721   }
 722
 723   ~enable_thread_stack_temporaries ()
 724   {
 725     m_thr->stack_temporaries_enabled = false;
 726     m_thr->stack_temporaries.clear ();
 727   }
 728
 729   DISABLE_COPY_AND_ASSIGN (enable_thread_stack_temporaries);
 730
 731 private:
 732
 733   thread_info_ref m_thr;
 734 };
 735
 736 extern bool thread_stack_temporaries_enabled_p (struct thread_info *tp);
 737
 738 extern void push_thread_stack_temporary (struct thread_info *tp, struct value *v);
 739
 740 extern value *get_last_thread_stack_temporary (struct thread_info *tp);
 741
 742 extern bool value_in_thread_stack_temporaries (struct value *,
 743                                                struct thread_info *thr);
 744
 745 /* Add TP to the end of the global pending step-over chain.  */
 746
 747 extern void global_thread_step_over_chain_enqueue (thread_info *tp);
 748
 749 /* Append the thread step over chain CHAIN_HEAD to the global thread step over
 750    chain. */
 751
 752 extern void global_thread_step_over_chain_enqueue_chain
 753   (thread_info *chain_head);
 754
 755 /* Remove TP from step-over chain LIST_P.  */
 756
 757 extern void thread_step_over_chain_remove (thread_info **list_p,
 758                                            thread_info *tp);
 759
 760 /* Remove TP from the global pending step-over chain.  */
 761
 762 extern void global_thread_step_over_chain_remove (thread_info *tp);
 763
 764 /* Return the thread following TP in the step-over chain whose head is
 765    CHAIN_HEAD.  Return NULL if TP is the last entry in the chain.  */
 766
 767 extern thread_info *thread_step_over_chain_next (thread_info *chain_head,
 768                                                  thread_info *tp);
 769
 770 /* Return the thread following TP in the global step-over chain, or NULL if TP
 771    is the last entry in the chain.  */
 772
 773 extern thread_info *global_thread_step_over_chain_next (thread_info *tp);
 774
 775 /* Return true if TP is in any step-over chain.  */
 776
 777 extern int thread_is_in_step_over_chain (struct thread_info *tp);
 778
 779 /* Return the length of the the step over chain TP is in.
 780
 781    If TP is non-nullptr, the thread must be in a step over chain.
 782    TP may be nullptr, in which case it denotes an empty list, so a length of
 783    0.  */
 784
 785 extern int thread_step_over_chain_length (thread_info *tp);
 786
 787 /* Cancel any ongoing execution command.  */
 788
 789 extern void thread_cancel_execution_command (struct thread_info *thr);
 790
 791 /* Check whether it makes sense to access a register of the current
 792    thread at this point.  If not, throw an error (e.g., the thread is
 793    executing).  */
 794 extern void validate_registers_access (void);
 795
 796 /* Check whether it makes sense to access a register of THREAD at this point.
 797    Returns true if registers may be accessed; false otherwise.  */
 798 extern bool can_access_registers_thread (struct thread_info *thread);
 799
 800 /* Returns whether to show which thread hit the breakpoint, received a
 801    signal, etc. and ended up causing a user-visible stop.  This is
 802    true iff we ever detected multiple threads.  */
 803 extern int show_thread_that_caused_stop (void);
 804
 805 /* Print the message for a thread or/and frame selected.  */
 806 extern void print_selected_thread_frame (struct ui_out *uiout,
 807                                          user_selected_what selection);
 808
 809 /* Helper for the CLI's "thread" command and for MI's -thread-select.
 810    Selects thread THR.  TIDSTR is the original string the thread ID
 811    was parsed from.  This is used in the error message if THR is not
 812    alive anymore.  */
 813 extern void thread_select (const char *tidstr, class thread_info *thr);
 814
 815 #endif /* GDBTHREAD_H */