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