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