]>
Commit | Line | Data |
---|---|---|
c906108c | 1 | /* Multi-process/thread control defs for GDB, the GNU debugger. |
213516ef | 2 | Copyright (C) 1987-2023 Free Software Foundation, Inc. |
b6ba6518 KB |
3 | Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA. |
4 | ||
c906108c | 5 | |
c5aa993b | 6 | This file is part of GDB. |
c906108c | 7 | |
c5aa993b JM |
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 | |
a9762ec7 | 10 | the Free Software Foundation; either version 3 of the License, or |
c5aa993b | 11 | (at your option) any later version. |
c906108c | 12 | |
c5aa993b JM |
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. | |
c906108c | 17 | |
c5aa993b | 18 | You should have received a copy of the GNU General Public License |
a9762ec7 | 19 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
c906108c SS |
20 | |
21 | #ifndef GDBTHREAD_H | |
22 | #define GDBTHREAD_H | |
23 | ||
da3331ec AC |
24 | struct symtab; |
25 | ||
c906108c | 26 | #include "breakpoint.h" |
aa0cd9c1 | 27 | #include "frame.h" |
8e8901c5 | 28 | #include "ui-out.h" |
02d27625 | 29 | #include "btrace.h" |
372316f1 | 30 | #include "target/waitstatus.h" |
65c459ab | 31 | #include "target/target.h" |
5d5658a1 | 32 | #include "cli/cli-utils.h" |
268a13a5 TT |
33 | #include "gdbsupport/refcounted-object.h" |
34 | #include "gdbsupport/common-gdbthread.h" | |
35 | #include "gdbsupport/forward-scope-exit.h" | |
187b041e | 36 | #include "displaced-stepping.h" |
bf809310 | 37 | #include "gdbsupport/intrusive_list.h" |
573269a8 | 38 | #include "thread-fsm.h" |
0a008773 | 39 | #include "language.h" |
8e8901c5 | 40 | |
08036331 | 41 | struct inferior; |
5b6d1e4f | 42 | struct process_stratum_target; |
08036331 | 43 | |
5b0a3d62 AB |
44 | /* When true, print debug messages related to GDB thread creation and |
45 | deletion. */ | |
46 | ||
47 | extern bool debug_threads; | |
48 | ||
49 | /* Print a "threads" debug statement. */ | |
50 | ||
51 | #define threads_debug_printf(fmt, ...) \ | |
52 | debug_prefixed_printf_cond (debug_threads, "threads", fmt, ##__VA_ARGS__) | |
53 | ||
30596231 | 54 | /* Frontend view of the thread state. Possible extensions: stepping, |
6af05e64 PA |
55 | finishing, until(ling),... |
56 | ||
57 | NOTE: Since the thread state is not a boolean, most times, you do | |
58 | not want to check it with negation. If you really want to check if | |
59 | the thread is stopped, | |
60 | ||
61 | use (good): | |
62 | ||
63 | if (tp->state == THREAD_STOPPED) | |
64 | ||
65 | instead of (bad): | |
66 | ||
67 | if (tp->state != THREAD_RUNNING) | |
68 | ||
69 | The latter is also true for exited threads, most likely not what | |
70 | you want. */ | |
30596231 PA |
71 | enum thread_state |
72 | { | |
6af05e64 | 73 | /* In the frontend's perpective, the thread is stopped. */ |
30596231 | 74 | THREAD_STOPPED, |
6af05e64 PA |
75 | |
76 | /* In the frontend's perpective, the thread is running. */ | |
30596231 | 77 | THREAD_RUNNING, |
6af05e64 PA |
78 | |
79 | /* The thread is listed, but known to have exited. We keep it | |
80 | listed (but not visible) until it's safe to delete it. */ | |
30596231 PA |
81 | THREAD_EXITED, |
82 | }; | |
83 | ||
08036331 PA |
84 | /* STEP_OVER_ALL means step over all subroutine calls. |
85 | STEP_OVER_UNDEBUGGABLE means step over calls to undebuggable functions. | |
86 | STEP_OVER_NONE means don't step over any subroutine calls. */ | |
87 | ||
88 | enum step_over_calls_kind | |
89 | { | |
90 | STEP_OVER_NONE, | |
91 | STEP_OVER_ALL, | |
92 | STEP_OVER_UNDEBUGGABLE | |
93 | }; | |
94 | ||
16c381f0 | 95 | /* Inferior thread specific part of `struct infcall_control_state'. |
8ea051c5 | 96 | |
16c381f0 | 97 | Inferior process counterpart is `struct inferior_control_state'. */ |
8ea051c5 | 98 | |
16c381f0 JK |
99 | struct thread_control_state |
100 | { | |
4e1c45ea PA |
101 | /* User/external stepping state. */ |
102 | ||
8358c15c | 103 | /* Step-resume or longjmp-resume breakpoint. */ |
ee841dd8 | 104 | struct breakpoint *step_resume_breakpoint = nullptr; |
8358c15c | 105 | |
186c406b | 106 | /* Exception-resume breakpoint. */ |
ee841dd8 | 107 | struct breakpoint *exception_resume_breakpoint = nullptr; |
186c406b | 108 | |
34b7e8a6 PA |
109 | /* Breakpoints used for software single stepping. Plural, because |
110 | it may have multiple locations. E.g., if stepping over a | |
111 | conditional branch instruction we can't decode the condition for, | |
112 | we'll need to put a breakpoint at the branch destination, and | |
113 | another at the instruction after the branch. */ | |
ee841dd8 | 114 | struct breakpoint *single_step_breakpoints = nullptr; |
34b7e8a6 | 115 | |
4e1c45ea PA |
116 | /* Range to single step within. |
117 | ||
118 | If this is nonzero, respond to a single-step signal by continuing | |
119 | to step if the pc is in this range. | |
120 | ||
121 | If step_range_start and step_range_end are both 1, it means to | |
122 | step for a single instruction (FIXME: it might clean up | |
123 | wait_for_inferior in a minor way if this were changed to the | |
124 | address of the instruction and that address plus one. But maybe | |
0963b4bd | 125 | not). */ |
ee841dd8 TT |
126 | CORE_ADDR step_range_start = 0; /* Inclusive */ |
127 | CORE_ADDR step_range_end = 0; /* Exclusive */ | |
4e1c45ea | 128 | |
885eeb5b | 129 | /* Function the thread was in as of last it started stepping. */ |
ee841dd8 | 130 | struct symbol *step_start_function = nullptr; |
885eeb5b | 131 | |
c1e36e3e PA |
132 | /* If GDB issues a target step request, and this is nonzero, the |
133 | target should single-step this thread once, and then continue | |
134 | single-stepping it without GDB core involvement as long as the | |
135 | thread stops in the step range above. If this is zero, the | |
136 | target should ignore the step range, and only issue one single | |
137 | step. */ | |
ee841dd8 | 138 | int may_range_step = 0; |
c1e36e3e | 139 | |
4e1c45ea PA |
140 | /* Stack frame address as of when stepping command was issued. |
141 | This is how we know when we step into a subroutine call, and how | |
142 | to set the frame for the breakpoint used to step out. */ | |
ee841dd8 | 143 | struct frame_id step_frame_id {}; |
edb3359d DJ |
144 | |
145 | /* Similarly, the frame ID of the underlying stack frame (skipping | |
146 | any inlined frames). */ | |
ee841dd8 | 147 | struct frame_id step_stack_frame_id {}; |
edb3359d | 148 | |
b25e22fd PA |
149 | /* True if the the thread is presently stepping over a breakpoint or |
150 | a watchpoint, either with an inline step over or a displaced (out | |
151 | of line) step, and we're now expecting it to report a trap for | |
152 | the finished single step. */ | |
ee841dd8 | 153 | int trap_expected = 0; |
4e1c45ea | 154 | |
b986eec5 CL |
155 | /* Nonzero if the thread is being proceeded for a "finish" command |
156 | or a similar situation when return value should be printed. */ | |
157 | int proceed_to_finish = 0; | |
158 | ||
16c381f0 JK |
159 | /* Nonzero if the thread is being proceeded for an inferior function |
160 | call. */ | |
ee841dd8 | 161 | int in_infcall = 0; |
16c381f0 | 162 | |
ee841dd8 | 163 | enum step_over_calls_kind step_over_calls = STEP_OVER_NONE; |
16c381f0 JK |
164 | |
165 | /* Nonzero if stopped due to a step command. */ | |
ee841dd8 | 166 | int stop_step = 0; |
16c381f0 JK |
167 | |
168 | /* Chain containing status of breakpoint(s) the thread stopped | |
169 | at. */ | |
313f3b21 | 170 | bpstat *stop_bpstat = nullptr; |
17b2616c | 171 | |
856e7dd6 PA |
172 | /* Whether the command that started the thread was a stepping |
173 | command. This is used to decide whether "set scheduler-locking | |
174 | step" behaves like "on" or "off". */ | |
ee841dd8 | 175 | int stepping_command = 0; |
16c381f0 JK |
176 | }; |
177 | ||
a38fe4fe | 178 | /* Inferior thread specific part of `struct infcall_suspend_state'. */ |
16c381f0 JK |
179 | |
180 | struct thread_suspend_state | |
181 | { | |
70509625 PA |
182 | /* Last signal that the inferior received (why it stopped). When |
183 | the thread is resumed, this signal is delivered. Note: the | |
184 | target should not check whether the signal is in pass state, | |
185 | because the signal may have been explicitly passed with the | |
186 | "signal" command, which overrides "handle nopass". If the signal | |
187 | should be suppressed, the core will take care of clearing this | |
188 | before the target is resumed. */ | |
dd848631 | 189 | enum gdb_signal stop_signal = GDB_SIGNAL_0; |
372316f1 PA |
190 | |
191 | /* The reason the thread last stopped, if we need to track it | |
192 | (breakpoint, watchpoint, etc.) */ | |
dd848631 | 193 | enum target_stop_reason stop_reason = TARGET_STOPPED_BY_NO_REASON; |
372316f1 PA |
194 | |
195 | /* The waitstatus for this thread's last event. */ | |
183be222 | 196 | struct target_waitstatus waitstatus; |
372316f1 | 197 | /* If true WAITSTATUS hasn't been handled yet. */ |
dd848631 | 198 | int waitstatus_pending_p = 0; |
372316f1 PA |
199 | |
200 | /* Record the pc of the thread the last time it stopped. (This is | |
201 | not the current thread's PC as that may have changed since the | |
f2ffa92b PA |
202 | last stop, e.g., "return" command, or "p $pc = 0xf000"). |
203 | ||
204 | - If the thread's PC has not changed since the thread last | |
205 | stopped, then proceed skips a breakpoint at the current PC, | |
206 | otherwise we let the thread run into the breakpoint. | |
207 | ||
208 | - If the thread has an unprocessed event pending, as indicated by | |
209 | waitstatus_pending_p, this is used in coordination with | |
210 | stop_reason: if the thread's PC has changed since the thread | |
211 | last stopped, a pending breakpoint waitstatus is discarded. | |
212 | ||
351031f2 AB |
213 | - If the thread is running, then this field has its value removed by |
214 | calling stop_pc.reset() (see thread_info::set_executing()). | |
6b09f134 | 215 | Attempting to read a std::optional with no value is undefined |
351031f2 AB |
216 | behaviour and will trigger an assertion error when _GLIBCXX_DEBUG is |
217 | defined, which should make error easier to track down. */ | |
6b09f134 | 218 | std::optional<CORE_ADDR> stop_pc; |
16c381f0 JK |
219 | }; |
220 | ||
7aabaf9d SM |
221 | /* Base class for target-specific thread data. */ |
222 | struct private_thread_info | |
223 | { | |
224 | virtual ~private_thread_info () = 0; | |
225 | }; | |
226 | ||
d0ffdf64 TT |
227 | /* Unique pointer wrapper for private_thread_info. */ |
228 | using private_thread_info_up = std::unique_ptr<private_thread_info>; | |
229 | ||
3a3fd0fd PA |
230 | /* Threads are intrusively refcounted objects. Being the |
231 | user-selected thread is normally considered an implicit strong | |
232 | reference and is thus not accounted in the refcount, unlike | |
233 | inferior objects. This is necessary, because there's no "current | |
234 | thread" pointer. Instead the current thread is inferred from the | |
235 | inferior_ptid global. However, when GDB needs to remember the | |
236 | selected thread to later restore it, GDB bumps the thread object's | |
237 | refcount, to prevent something deleting the thread object before | |
a6c21d4a | 238 | reverting back (e.g., due to a "kill" command). If the thread |
3a3fd0fd PA |
239 | meanwhile exits before being re-selected, then the thread object is |
240 | left listed in the thread list, but marked with state | |
09e3c4ca | 241 | THREAD_EXITED. (See scoped_restore_current_thread and |
3a3fd0fd PA |
242 | delete_thread). All other thread references are considered weak |
243 | references. Placing a thread in the thread list is an implicit | |
244 | strong reference, and is thus not accounted for in the thread's | |
bf809310 | 245 | refcount. |
3a3fd0fd | 246 | |
bf809310 PA |
247 | The intrusive_list_node base links threads in a per-inferior list. */ |
248 | ||
249 | class thread_info : public refcounted_object, | |
250 | public intrusive_list_node<thread_info> | |
16c381f0 | 251 | { |
12316564 YQ |
252 | public: |
253 | explicit thread_info (inferior *inf, ptid_t ptid); | |
5b0a3d62 | 254 | ~thread_info (); |
12316564 | 255 | |
08036331 | 256 | bool deletable () const; |
803bdfe4 | 257 | |
00431a78 PA |
258 | /* Mark this thread as running and notify observers. */ |
259 | void set_running (bool running); | |
260 | ||
16c381f0 JK |
261 | ptid_t ptid; /* "Actual process id"; |
262 | In fact, this may be overloaded with | |
263 | kernel thread id, etc. */ | |
5d5658a1 PA |
264 | |
265 | /* Each thread has two GDB IDs. | |
266 | ||
267 | a) The thread ID (Id). This consists of the pair of: | |
268 | ||
dda83cd7 | 269 | - the number of the thread's inferior and, |
5d5658a1 | 270 | |
dda83cd7 SM |
271 | - the thread's thread number in its inferior, aka, the |
272 | per-inferior thread number. This number is unique in the | |
273 | inferior but not unique between inferiors. | |
5d5658a1 PA |
274 | |
275 | b) The global ID (GId). This is a a single integer unique | |
dda83cd7 | 276 | between all inferiors. |
5d5658a1 PA |
277 | |
278 | E.g.: | |
279 | ||
280 | (gdb) info threads -gid | |
281 | Id GId Target Id Frame | |
282 | * 1.1 1 Thread A 0x16a09237 in foo () at foo.c:10 | |
283 | 1.2 3 Thread B 0x15ebc6ed in bar () at foo.c:20 | |
284 | 1.3 5 Thread C 0x15ebc6ed in bar () at foo.c:20 | |
285 | 2.1 2 Thread A 0x16a09237 in foo () at foo.c:10 | |
286 | 2.2 4 Thread B 0x15ebc6ed in bar () at foo.c:20 | |
287 | 2.3 6 Thread C 0x15ebc6ed in bar () at foo.c:20 | |
288 | ||
289 | Above, both inferiors 1 and 2 have threads numbered 1-3, but each | |
290 | thread has its own unique global ID. */ | |
291 | ||
c84f6bbf | 292 | /* The thread's global GDB thread number. This is exposed to MI, |
663f6d42 PA |
293 | Python/Scheme, visible with "info threads -gid", and is also what |
294 | the $_gthread convenience variable is bound to. */ | |
5d5658a1 PA |
295 | int global_num; |
296 | ||
297 | /* The per-inferior thread number. This is unique in the inferior | |
298 | the thread belongs to, but not unique between inferiors. This is | |
299 | what the $_thread convenience variable is bound to. */ | |
300 | int per_inf_num; | |
301 | ||
302 | /* The inferior this thread belongs to. */ | |
303 | struct inferior *inf; | |
16c381f0 | 304 | |
25558938 SM |
305 | /* The user-given name of the thread. |
306 | ||
307 | Returns nullptr if the thread does not have a user-given name. */ | |
308 | const char *name () const | |
309 | { | |
310 | return m_name.get (); | |
311 | } | |
312 | ||
313 | /* Set the user-given name of the thread. | |
314 | ||
315 | Pass nullptr to clear the name. */ | |
316 | void set_name (gdb::unique_xmalloc_ptr<char> name) | |
317 | { | |
318 | m_name = std::move (name); | |
319 | } | |
4694da01 | 320 | |
611841bb AB |
321 | bool executing () const |
322 | { return m_executing; } | |
323 | ||
324 | /* Set the thread's 'm_executing' field from EXECUTING, and if EXECUTING | |
325 | is true also clears the thread's stop_pc. */ | |
326 | void set_executing (bool executing); | |
16c381f0 | 327 | |
7846f3aa SM |
328 | bool resumed () const |
329 | { return m_resumed; } | |
330 | ||
611841bb AB |
331 | /* Set the thread's 'm_resumed' field from RESUMED. The thread may also |
332 | be added to (when RESUMED is true), or removed from (when RESUMED is | |
333 | false), the list of threads with a pending wait status. */ | |
a66f7298 | 334 | void set_resumed (bool resumed); |
372316f1 | 335 | |
f6e29b6e YQ |
336 | /* Frontend view of the thread state. Note that the THREAD_RUNNING/ |
337 | THREAD_STOPPED states are different from EXECUTING. When the | |
338 | thread is stopped internally while handling an internal event, | |
339 | like a software single-step breakpoint, EXECUTING will be false, | |
340 | but STATE will still be THREAD_RUNNING. */ | |
12316564 | 341 | enum thread_state state = THREAD_STOPPED; |
16c381f0 | 342 | |
16c381f0 JK |
343 | /* State of GDB control of inferior thread execution. |
344 | See `struct thread_control_state'. */ | |
ee841dd8 | 345 | thread_control_state control; |
16c381f0 | 346 | |
1edb66d8 SM |
347 | /* Save M_SUSPEND to SUSPEND. */ |
348 | ||
349 | void save_suspend_to (thread_suspend_state &suspend) const | |
350 | { | |
351 | suspend = m_suspend; | |
352 | } | |
353 | ||
354 | /* Restore M_SUSPEND from SUSPEND. */ | |
355 | ||
356 | void restore_suspend_from (const thread_suspend_state &suspend) | |
357 | { | |
358 | m_suspend = suspend; | |
359 | } | |
360 | ||
351031f2 AB |
361 | /* Return this thread's stop PC. This should only be called when it is |
362 | known that stop_pc has a value. If this function is being used in a | |
363 | situation where a thread may not have had a stop_pc assigned, then | |
364 | stop_pc_p() can be used to check if the stop_pc is defined. */ | |
1edb66d8 SM |
365 | |
366 | CORE_ADDR stop_pc () const | |
367 | { | |
351031f2 AB |
368 | gdb_assert (m_suspend.stop_pc.has_value ()); |
369 | return *m_suspend.stop_pc; | |
1edb66d8 SM |
370 | } |
371 | ||
372 | /* Set this thread's stop PC. */ | |
373 | ||
374 | void set_stop_pc (CORE_ADDR stop_pc) | |
375 | { | |
376 | m_suspend.stop_pc = stop_pc; | |
377 | } | |
378 | ||
351031f2 AB |
379 | /* Remove the stop_pc stored on this thread. */ |
380 | ||
381 | void clear_stop_pc () | |
382 | { | |
383 | m_suspend.stop_pc.reset (); | |
384 | } | |
385 | ||
386 | /* Return true if this thread has a cached stop pc value, otherwise | |
387 | return false. */ | |
388 | ||
389 | bool stop_pc_p () const | |
390 | { | |
391 | return m_suspend.stop_pc.has_value (); | |
392 | } | |
393 | ||
1edb66d8 SM |
394 | /* Return true if this thread has a pending wait status. */ |
395 | ||
396 | bool has_pending_waitstatus () const | |
397 | { | |
398 | return m_suspend.waitstatus_pending_p; | |
399 | } | |
400 | ||
401 | /* Get this thread's pending wait status. | |
402 | ||
403 | May only be called if has_pending_waitstatus returns true. */ | |
404 | ||
405 | const target_waitstatus &pending_waitstatus () const | |
406 | { | |
407 | gdb_assert (this->has_pending_waitstatus ()); | |
408 | ||
409 | return m_suspend.waitstatus; | |
410 | } | |
411 | ||
412 | /* Set this thread's pending wait status. | |
413 | ||
414 | May only be called if has_pending_waitstatus returns false. */ | |
415 | ||
416 | void set_pending_waitstatus (const target_waitstatus &ws); | |
417 | ||
418 | /* Clear this thread's pending wait status. | |
419 | ||
420 | May only be called if has_pending_waitstatus returns true. */ | |
421 | ||
422 | void clear_pending_waitstatus (); | |
423 | ||
424 | /* Return this thread's stop signal. */ | |
425 | ||
426 | gdb_signal stop_signal () const | |
427 | { | |
428 | return m_suspend.stop_signal; | |
429 | } | |
430 | ||
431 | /* Set this thread's stop signal. */ | |
432 | ||
433 | void set_stop_signal (gdb_signal sig) | |
434 | { | |
435 | m_suspend.stop_signal = sig; | |
436 | } | |
437 | ||
438 | /* Return this thread's stop reason. */ | |
439 | ||
440 | target_stop_reason stop_reason () const | |
441 | { | |
442 | return m_suspend.stop_reason; | |
443 | } | |
444 | ||
445 | /* Set this thread's stop reason. */ | |
446 | ||
447 | void set_stop_reason (target_stop_reason reason) | |
448 | { | |
449 | m_suspend.stop_reason = reason; | |
450 | } | |
16c381f0 | 451 | |
573269a8 LS |
452 | /* Get the FSM associated with the thread. */ |
453 | ||
454 | struct thread_fsm *thread_fsm () const | |
455 | { | |
456 | return m_thread_fsm.get (); | |
457 | } | |
458 | ||
459 | /* Get the owning reference to the FSM associated with the thread. | |
460 | ||
461 | After a call to this method, "thread_fsm () == nullptr". */ | |
462 | ||
463 | std::unique_ptr<struct thread_fsm> release_thread_fsm () | |
464 | { | |
465 | return std::move (m_thread_fsm); | |
466 | } | |
467 | ||
468 | /* Set the FSM associated with the current thread. | |
469 | ||
470 | It is invalid to set the FSM if another FSM is already installed. */ | |
471 | ||
472 | void set_thread_fsm (std::unique_ptr<struct thread_fsm> fsm) | |
473 | { | |
474 | gdb_assert (m_thread_fsm == nullptr); | |
475 | m_thread_fsm = std::move (fsm); | |
476 | } | |
477 | ||
65c459ab PA |
478 | /* Record the thread options last set for this thread. */ |
479 | ||
480 | void set_thread_options (gdb_thread_options thread_options); | |
481 | ||
482 | /* Get the thread options last set for this thread. */ | |
483 | ||
484 | gdb_thread_options thread_options () const | |
485 | { | |
486 | return m_thread_options; | |
487 | } | |
488 | ||
12316564 YQ |
489 | int current_line = 0; |
490 | struct symtab *current_symtab = NULL; | |
16c381f0 JK |
491 | |
492 | /* Internal stepping state. */ | |
493 | ||
4d9d9d04 PA |
494 | /* Record the pc of the thread the last time it was resumed. (It |
495 | can't be done on stop as the PC may change since the last stop, | |
496 | e.g., "return" command, or "p $pc = 0xf000"). This is maintained | |
497 | by proceed and keep_going, and among other things, it's used in | |
16c381f0 JK |
498 | adjust_pc_after_break to distinguish a hardware single-step |
499 | SIGTRAP from a breakpoint SIGTRAP. */ | |
12316564 | 500 | CORE_ADDR prev_pc = 0; |
16c381f0 | 501 | |
7f5ef605 PA |
502 | /* Did we set the thread stepping a breakpoint instruction? This is |
503 | used in conjunction with PREV_PC to decide whether to adjust the | |
504 | PC. */ | |
12316564 | 505 | int stepped_breakpoint = 0; |
7f5ef605 | 506 | |
4e1c45ea | 507 | /* Should we step over breakpoint next time keep_going is called? */ |
12316564 | 508 | int stepping_over_breakpoint = 0; |
0d06e24b | 509 | |
963f9c80 PA |
510 | /* Should we step over a watchpoint next time keep_going is called? |
511 | This is needed on targets with non-continuable, non-steppable | |
512 | watchpoints. */ | |
12316564 | 513 | int stepping_over_watchpoint = 0; |
963f9c80 | 514 | |
4e1c45ea | 515 | /* Set to TRUE if we should finish single-stepping over a breakpoint |
6aa27652 YQ |
516 | after hitting the current step-resume breakpoint. The context here |
517 | is that GDB is to do `next' or `step' while signal arrives. | |
518 | When stepping over a breakpoint and signal arrives, GDB will attempt | |
519 | to skip signal handler, so it inserts a step_resume_breakpoint at the | |
520 | signal return address, and resume inferior. | |
521 | step_after_step_resume_breakpoint is set to TRUE at this moment in | |
522 | order to keep GDB in mind that there is still a breakpoint to step over | |
523 | when GDB gets back SIGTRAP from step_resume_breakpoint. */ | |
12316564 | 524 | int step_after_step_resume_breakpoint = 0; |
4e1c45ea | 525 | |
e58b0e63 PA |
526 | /* This is used to remember when a fork or vfork event was caught by |
527 | a catchpoint, and thus the event is to be followed at the next | |
528 | resume of the thread, and not immediately. */ | |
529 | struct target_waitstatus pending_follow; | |
530 | ||
252fbfc8 | 531 | /* True if this thread has been explicitly requested to stop. */ |
12316564 | 532 | int stop_requested = 0; |
252fbfc8 | 533 | |
186c406b | 534 | /* The initiating frame of a nexting operation, used for deciding |
e2e4d78b JK |
535 | which exceptions to intercept. If it is null_frame_id no |
536 | bp_longjmp or bp_exception but longjmp has been caught just for | |
537 | bp_longjmp_call_dummy. */ | |
12316564 | 538 | struct frame_id initiating_frame = null_frame_id; |
186c406b | 539 | |
0d06e24b | 540 | /* Private data used by the target vector implementation. */ |
d0ffdf64 | 541 | private_thread_info_up priv; |
02d27625 MM |
542 | |
543 | /* Branch trace information for this thread. */ | |
12316564 | 544 | struct btrace_thread_info btrace {}; |
6c659fc2 SC |
545 | |
546 | /* Flag which indicates that the stack temporaries should be stored while | |
547 | evaluating expressions. */ | |
fdf07f3a | 548 | bool stack_temporaries_enabled = false; |
6c659fc2 SC |
549 | |
550 | /* Values that are stored as temporaries on stack while evaluating | |
551 | expressions. */ | |
fdf07f3a | 552 | std::vector<struct value *> stack_temporaries; |
c2829269 | 553 | |
8b6a69b2 SM |
554 | /* Step-over chain. A thread is in the step-over queue if this node is |
555 | linked. */ | |
556 | intrusive_list_node<thread_info> step_over_list_node; | |
187b041e | 557 | |
a66f7298 SM |
558 | /* Node for list of threads that are resumed and have a pending wait status. |
559 | ||
560 | The list head for this is in process_stratum_target, hence all threads in | |
561 | this list belong to that process target. */ | |
562 | intrusive_list_node<thread_info> resumed_with_pending_wait_status_node; | |
563 | ||
187b041e SM |
564 | /* Displaced-step state for this thread. */ |
565 | displaced_step_thread_state displaced_step_state; | |
7846f3aa SM |
566 | |
567 | private: | |
568 | /* True if this thread is resumed from infrun's perspective. | |
569 | Note that a thread can be marked both as not-executing and | |
570 | resumed at the same time. This happens if we try to resume a | |
571 | thread that has a wait status pending. We shouldn't let the | |
572 | thread really run until that wait status has been processed, but | |
573 | we should not process that wait status if we didn't try to let | |
574 | the thread run. */ | |
575 | bool m_resumed = false; | |
1edb66d8 | 576 | |
611841bb AB |
577 | /* True means the thread is executing. Note: this is different |
578 | from saying that there is an active target and we are stopped at | |
579 | a breakpoint, for instance. This is a real indicator whether the | |
580 | thread is off and running. */ | |
581 | bool m_executing = false; | |
582 | ||
1edb66d8 SM |
583 | /* State of inferior thread to restore after GDB is done with an inferior |
584 | call. See `struct thread_suspend_state'. */ | |
585 | thread_suspend_state m_suspend; | |
25558938 SM |
586 | |
587 | /* The user-given name of the thread. | |
588 | ||
589 | Nullptr if the thread does not have a user-given name. */ | |
590 | gdb::unique_xmalloc_ptr<char> m_name; | |
573269a8 LS |
591 | |
592 | /* Pointer to the state machine manager object that handles what is | |
593 | left to do for the thread's execution command after the target | |
594 | stops. Several execution commands use it. */ | |
595 | std::unique_ptr<struct thread_fsm> m_thread_fsm; | |
65c459ab PA |
596 | |
597 | /* The thread options as last set with a call to | |
598 | set_thread_options. */ | |
599 | gdb_thread_options m_thread_options; | |
0d06e24b JM |
600 | }; |
601 | ||
a66f7298 SM |
602 | using thread_info_resumed_with_pending_wait_status_node |
603 | = intrusive_member_node<thread_info, | |
604 | &thread_info::resumed_with_pending_wait_status_node>; | |
605 | using thread_info_resumed_with_pending_wait_status_list | |
606 | = intrusive_list<thread_info, | |
607 | thread_info_resumed_with_pending_wait_status_node>; | |
608 | ||
00431a78 PA |
609 | /* A gdb::ref_ptr pointer to a thread_info. */ |
610 | ||
611 | using thread_info_ref | |
75cbc781 | 612 | = gdb::ref_ptr<struct thread_info, refcounted_object_ref_policy>; |
00431a78 | 613 | |
cce20f10 PA |
614 | /* A gdb::ref_ptr pointer to an inferior. This would ideally be in |
615 | inferior.h, but it can't due to header dependencies (inferior.h | |
616 | includes gdbthread.h). */ | |
617 | ||
618 | using inferior_ref | |
619 | = gdb::ref_ptr<struct inferior, refcounted_object_ref_policy>; | |
620 | ||
0d06e24b JM |
621 | /* Create an empty thread list, or empty the existing one. */ |
622 | extern void init_thread_list (void); | |
623 | ||
93815fbf VP |
624 | /* Add a thread to the thread list, print a message |
625 | that a new thread is found, and return the pointer to | |
626 | the new thread. Caller my use this pointer to | |
627 | initialize the private thread data. */ | |
5b6d1e4f PA |
628 | extern struct thread_info *add_thread (process_stratum_target *targ, |
629 | ptid_t ptid); | |
0d06e24b | 630 | |
5b6d1e4f PA |
631 | /* Same as add_thread, but does not print a message about new |
632 | thread. */ | |
633 | extern struct thread_info *add_thread_silent (process_stratum_target *targ, | |
634 | ptid_t ptid); | |
93815fbf | 635 | |
17faa917 | 636 | /* Same as add_thread, and sets the private info. */ |
5b6d1e4f PA |
637 | extern struct thread_info *add_thread_with_info (process_stratum_target *targ, |
638 | ptid_t ptid, | |
d0ffdf64 | 639 | private_thread_info_up); |
17faa917 | 640 | |
3922b302 PA |
641 | /* Delete thread THREAD and notify of thread exit. If the thread is |
642 | currently not deletable, don't actually delete it but still tag it | |
9d7d58e7 PA |
643 | as exited and do the notification. EXIT_CODE is the thread's exit |
644 | code. If SILENT, don't actually notify the CLI. THREAD must not | |
645 | be NULL or an assertion will fail. */ | |
646 | extern void delete_thread_with_exit_code (thread_info *thread, | |
647 | ULONGEST exit_code, | |
648 | bool silent = false); | |
649 | ||
650 | /* Delete thread THREAD and notify of thread exit. If the thread is | |
651 | currently not deletable, don't actually delete it but still tag it | |
652 | as exited and do the notification. THREAD must not be NULL or an | |
653 | assertion will fail. */ | |
654 | extern void delete_thread (thread_info *thread); | |
0d06e24b | 655 | |
86be3050 PA |
656 | /* Like delete_thread, but be quiet about it. Used when the process |
657 | this thread belonged to has already exited, for example. */ | |
658 | extern void delete_thread_silent (struct thread_info *thread); | |
659 | ||
bf809310 | 660 | /* Mark the thread exited, but don't delete it or remove it from the |
9d7d58e7 PA |
661 | inferior thread list. EXIT_CODE is the thread's exit code, if |
662 | available. If SILENT, then don't inform the CLI about the | |
663 | exit. */ | |
664 | extern void set_thread_exited (thread_info *tp, | |
6b09f134 | 665 | std::optional<ULONGEST> exit_code = {}, |
9d7d58e7 | 666 | bool silent = false); |
bf809310 | 667 | |
0963b4bd | 668 | /* Delete a step_resume_breakpoint from the thread database. */ |
4e1c45ea | 669 | extern void delete_step_resume_breakpoint (struct thread_info *); |
8601f500 | 670 | |
0963b4bd | 671 | /* Delete an exception_resume_breakpoint from the thread database. */ |
186c406b TT |
672 | extern void delete_exception_resume_breakpoint (struct thread_info *); |
673 | ||
34b7e8a6 PA |
674 | /* Delete the single-step breakpoints of thread TP, if any. */ |
675 | extern void delete_single_step_breakpoints (struct thread_info *tp); | |
676 | ||
677 | /* Check if the thread has software single stepping breakpoints | |
678 | set. */ | |
679 | extern int thread_has_single_step_breakpoints_set (struct thread_info *tp); | |
680 | ||
681 | /* Check whether the thread has software single stepping breakpoints | |
682 | set at PC. */ | |
683 | extern int thread_has_single_step_breakpoint_here (struct thread_info *tp, | |
accd0bcd | 684 | const address_space *aspace, |
34b7e8a6 PA |
685 | CORE_ADDR addr); |
686 | ||
5d5658a1 PA |
687 | /* Returns whether to show inferior-qualified thread IDs, or plain |
688 | thread numbers. Inferior-qualified IDs are shown whenever we have | |
689 | multiple inferiors, or the only inferior left has number > 1. */ | |
690 | extern int show_inferior_qualified_tids (void); | |
0d06e24b | 691 | |
5d5658a1 PA |
692 | /* Return a string version of THR's thread ID. If there are multiple |
693 | inferiors, then this prints the inferior-qualifier form, otherwise | |
694 | it only prints the thread number. The result is stored in a | |
695 | circular static buffer, NUMCELLS deep. */ | |
43792cf0 PA |
696 | const char *print_thread_id (struct thread_info *thr); |
697 | ||
442716d4 AB |
698 | /* Like print_thread_id, but always prints the inferior-qualified form, |
699 | even when there is only a single inferior. */ | |
700 | const char *print_full_thread_id (struct thread_info *thr); | |
701 | ||
00431a78 | 702 | /* Boolean test for an already-known ptid. */ |
5b6d1e4f | 703 | extern bool in_thread_list (process_stratum_target *targ, ptid_t ptid); |
0d06e24b | 704 | |
5d5658a1 PA |
705 | /* Boolean test for an already-known global thread id (GDB's homegrown |
706 | global id, not the system's). */ | |
707 | extern int valid_global_thread_id (int global_id); | |
0d06e24b | 708 | |
5d5658a1 PA |
709 | /* Find thread by GDB global thread ID. */ |
710 | struct thread_info *find_thread_global_id (int global_id); | |
1e92afda | 711 | |
e04ee09e | 712 | /* Find thread by thread library specific handle in inferior INF. */ |
50a82723 KB |
713 | struct thread_info *find_thread_by_handle |
714 | (gdb::array_view<const gdb_byte> handle, struct inferior *inf); | |
e04ee09e | 715 | |
00431a78 | 716 | /* Finds the first thread of the specified inferior. */ |
75cbc781 | 717 | extern struct thread_info *first_thread_of_inferior (inferior *inf); |
bad34192 | 718 | |
00431a78 PA |
719 | /* Returns any thread of inferior INF, giving preference to the |
720 | current thread. */ | |
75cbc781 | 721 | extern struct thread_info *any_thread_of_inferior (inferior *inf); |
2277426b | 722 | |
00431a78 | 723 | /* Returns any non-exited thread of inferior INF, giving preference to |
32990ada | 724 | the current thread, and to not executing threads. */ |
75cbc781 | 725 | extern struct thread_info *any_live_thread_of_inferior (inferior *inf); |
6c95b8df | 726 | |
5231c1fd | 727 | /* Change the ptid of thread OLD_PTID to NEW_PTID. */ |
5b6d1e4f PA |
728 | void thread_change_ptid (process_stratum_target *targ, |
729 | ptid_t old_ptid, ptid_t new_ptid); | |
5231c1fd | 730 | |
0d06e24b JM |
731 | /* Iterator function to call a user-provided callback function |
732 | once for each known thread. */ | |
733 | typedef int (*thread_callback_func) (struct thread_info *, void *); | |
734 | extern struct thread_info *iterate_over_threads (thread_callback_func, void *); | |
735 | ||
08036331 PA |
736 | /* Pull in the internals of the inferiors/threads ranges and |
737 | iterators. Must be done after struct thread_info is defined. */ | |
738 | #include "thread-iter.h" | |
739 | ||
5b6d1e4f PA |
740 | /* Return a range that can be used to walk over threads, with |
741 | range-for. | |
742 | ||
743 | Used like this, it walks over all threads of all inferiors of all | |
744 | targets: | |
08036331 PA |
745 | |
746 | for (thread_info *thr : all_threads ()) | |
747 | { .... } | |
08036331 | 748 | |
5b6d1e4f PA |
749 | FILTER_PTID can be used to filter out threads that don't match. |
750 | FILTER_PTID can be: | |
751 | ||
752 | - minus_one_ptid, meaning walk all threads of all inferiors of | |
753 | PROC_TARGET. If PROC_TARGET is NULL, then of all targets. | |
754 | ||
755 | - A process ptid, in which case walk all threads of the specified | |
756 | process. PROC_TARGET must be non-NULL in this case. | |
757 | ||
758 | - A thread ptid, in which case walk that thread only. PROC_TARGET | |
759 | must be non-NULL in this case. | |
760 | */ | |
5d5658a1 | 761 | |
08036331 | 762 | inline all_matching_threads_range |
5b6d1e4f PA |
763 | all_threads (process_stratum_target *proc_target = nullptr, |
764 | ptid_t filter_ptid = minus_one_ptid) | |
08036331 | 765 | { |
5b6d1e4f | 766 | return all_matching_threads_range (proc_target, filter_ptid); |
08036331 | 767 | } |
5d5658a1 | 768 | |
08036331 | 769 | /* Return a range that can be used to walk over all non-exited threads |
5b6d1e4f PA |
770 | of all inferiors, with range-for. Arguments are like all_threads |
771 | above. */ | |
08036331 PA |
772 | |
773 | inline all_non_exited_threads_range | |
5b6d1e4f PA |
774 | all_non_exited_threads (process_stratum_target *proc_target = nullptr, |
775 | ptid_t filter_ptid = minus_one_ptid) | |
08036331 | 776 | { |
5b6d1e4f | 777 | return all_non_exited_threads_range (proc_target, filter_ptid); |
08036331 | 778 | } |
e5ef252a | 779 | |
08036331 PA |
780 | /* Return a range that can be used to walk over all threads of all |
781 | inferiors, with range-for, safely. I.e., it is safe to delete the | |
782 | currently-iterated thread. When combined with range-for, this | |
783 | allow convenient patterns like this: | |
e5ef252a | 784 | |
08036331 PA |
785 | for (thread_info *t : all_threads_safe ()) |
786 | if (some_condition ()) | |
787 | delete f; | |
788 | */ | |
789 | ||
790 | inline all_threads_safe_range | |
791 | all_threads_safe () | |
792 | { | |
9be25986 | 793 | return all_threads_safe_range (all_threads_iterator::begin_t {}); |
08036331 | 794 | } |
ab970af1 | 795 | |
5b6d1e4f | 796 | extern int thread_count (process_stratum_target *proc_target); |
20874c92 | 797 | |
08036331 PA |
798 | /* Return true if we have any thread in any inferior. */ |
799 | extern bool any_thread_p (); | |
800 | ||
eeaffa60 | 801 | /* Switch context to thread THR. */ |
75cbc781 | 802 | extern void switch_to_thread (struct thread_info *thr); |
00431a78 PA |
803 | |
804 | /* Switch context to no thread selected. */ | |
805 | extern void switch_to_no_thread (); | |
806 | ||
f2ffa92b | 807 | /* Switch from one thread to another. Does not read registers. */ |
6efcd9a8 PA |
808 | extern void switch_to_thread_no_regs (struct thread_info *thread); |
809 | ||
5b6d1e4f PA |
810 | /* Marks or clears thread(s) PTID of TARG as resumed. If PTID is |
811 | MINUS_ONE_PTID, applies to all threads of TARG. If | |
252fbfc8 | 812 | ptid_is_pid(PTID) is true, applies to all threads of the process |
5b6d1e4f PA |
813 | pointed at by {TARG,PTID}. */ |
814 | extern void set_resumed (process_stratum_target *targ, | |
815 | ptid_t ptid, bool resumed); | |
816 | ||
817 | /* Marks thread PTID of TARG as running, or as stopped. If PTID is | |
818 | minus_one_ptid, marks all threads of TARG. */ | |
819 | extern void set_running (process_stratum_target *targ, | |
820 | ptid_t ptid, bool running); | |
821 | ||
822 | /* Marks or clears thread(s) PTID of TARG as having been requested to | |
823 | stop. If PTID is MINUS_ONE_PTID, applies to all threads of TARG. | |
824 | If ptid_is_pid(PTID) is true, applies to all threads of the process | |
825 | pointed at by {TARG, PTID}. If STOP, then the | |
826 | THREAD_STOP_REQUESTED observer is called with PTID as argument. */ | |
827 | extern void set_stop_requested (process_stratum_target *targ, | |
828 | ptid_t ptid, bool stop); | |
829 | ||
830 | /* Marks thread PTID of TARG as executing, or not. If PTID is | |
831 | minus_one_ptid, marks all threads of TARG. | |
0d6431e2 PA |
832 | |
833 | Note that this is different from the running state. See the | |
30596231 | 834 | description of state and executing fields of struct |
0d6431e2 | 835 | thread_info. */ |
5b6d1e4f PA |
836 | extern void set_executing (process_stratum_target *targ, |
837 | ptid_t ptid, bool executing); | |
8ea051c5 | 838 | |
5b6d1e4f PA |
839 | /* True if any (known or unknown) thread of TARG is or may be |
840 | executing. */ | |
841 | extern bool threads_are_executing (process_stratum_target *targ); | |
b57bacec | 842 | |
5b6d1e4f PA |
843 | /* Merge the executing property of thread PTID of TARG over to its |
844 | thread state property (frontend running/stopped view). | |
29f49a6a PA |
845 | |
846 | "not executing" -> "stopped" | |
847 | "executing" -> "running" | |
848 | "exited" -> "exited" | |
849 | ||
5b6d1e4f | 850 | If PTID is minus_one_ptid, go over all threads of TARG. |
29f49a6a PA |
851 | |
852 | Notifications are only emitted if the thread state did change. */ | |
5b6d1e4f | 853 | extern void finish_thread_state (process_stratum_target *targ, ptid_t ptid); |
29f49a6a | 854 | |
731f534f PA |
855 | /* Calls finish_thread_state on scope exit, unless release() is called |
856 | to disengage. */ | |
77f0e74c PA |
857 | using scoped_finish_thread_state |
858 | = FORWARD_SCOPE_EXIT (finish_thread_state); | |
29f49a6a | 859 | |
c906108c SS |
860 | /* Commands with a prefix of `thread'. */ |
861 | extern struct cmd_list_element *thread_cmd_list; | |
862 | ||
981a3fb3 | 863 | extern void thread_command (const char *tidstr, int from_tty); |
f0e8c4c5 | 864 | |
93815fbf VP |
865 | /* Print notices on thread events (attach, detach, etc.), set with |
866 | `set print thread-events'. */ | |
491144b5 | 867 | extern bool print_thread_events; |
93815fbf | 868 | |
5d5658a1 PA |
869 | /* Prints the list of threads and their details on UIOUT. If |
870 | REQUESTED_THREADS, a list of GDB ids/ranges, is not NULL, only | |
871 | print threads whose ID is included in the list. If PID is not -1, | |
872 | only print threads from the process PID. Otherwise, threads from | |
873 | all attached PIDs are printed. If both REQUESTED_THREADS is not | |
874 | NULL and PID is not -1, then the thread is printed if it belongs to | |
875 | the specified process. Otherwise, an error is raised. */ | |
24c54127 TT |
876 | extern void print_thread_info (struct ui_out *uiout, |
877 | const char *requested_threads, | |
3ee1c036 | 878 | int pid); |
8e8901c5 | 879 | |
5ed8105e PA |
880 | /* Save/restore current inferior/thread/frame. */ |
881 | ||
882 | class scoped_restore_current_thread | |
883 | { | |
884 | public: | |
885 | scoped_restore_current_thread (); | |
886 | ~scoped_restore_current_thread (); | |
887 | ||
348da456 SM |
888 | scoped_restore_current_thread (scoped_restore_current_thread &&rhs); |
889 | ||
d6541620 | 890 | DISABLE_COPY_AND_ASSIGN (scoped_restore_current_thread); |
5ed8105e | 891 | |
873657b9 PA |
892 | /* Cancel restoring on scope exit. */ |
893 | void dont_restore () { m_dont_restore = true; } | |
894 | ||
5ed8105e | 895 | private: |
873657b9 PA |
896 | void restore (); |
897 | ||
898 | bool m_dont_restore = false; | |
cce20f10 PA |
899 | thread_info_ref m_thread; |
900 | inferior_ref m_inf; | |
901 | ||
5ed8105e PA |
902 | frame_id m_selected_frame_id; |
903 | int m_selected_frame_level; | |
904 | bool m_was_stopped; | |
79952e69 PA |
905 | /* Save/restore the language as well, because selecting a frame |
906 | changes the current language to the frame's language if "set | |
907 | language auto". */ | |
0a008773 | 908 | scoped_restore_current_language m_lang; |
5ed8105e | 909 | }; |
6208b47d | 910 | |
4e1c45ea PA |
911 | /* Returns a pointer into the thread_info corresponding to |
912 | INFERIOR_PTID. INFERIOR_PTID *must* be in the thread list. */ | |
913 | extern struct thread_info* inferior_thread (void); | |
6208b47d | 914 | |
dc146f7c VP |
915 | extern void update_thread_list (void); |
916 | ||
e8032dde PA |
917 | /* Delete any thread the target says is no longer alive. */ |
918 | ||
919 | extern void prune_threads (void); | |
920 | ||
8a06aea7 PA |
921 | /* Delete threads marked THREAD_EXITED. Unlike prune_threads, this |
922 | does not consult the target about whether the thread is alive right | |
923 | now. */ | |
924 | extern void delete_exited_threads (void); | |
925 | ||
ce4c476a PA |
926 | /* Return true if PC is in the stepping range of THREAD. */ |
927 | ||
6ec27270 | 928 | bool pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread); |
ce4c476a | 929 | |
00431a78 PA |
930 | /* Enable storing stack temporaries for thread THR and disable and |
931 | clear the stack temporaries on destruction. Holds a strong | |
932 | reference to THR. */ | |
fdf07f3a TT |
933 | |
934 | class enable_thread_stack_temporaries | |
935 | { | |
936 | public: | |
937 | ||
75cbc781 | 938 | explicit enable_thread_stack_temporaries (struct thread_info *thr) |
15f4dddd | 939 | : m_thr (thread_info_ref::new_reference (thr)) |
fdf07f3a | 940 | { |
00431a78 PA |
941 | m_thr->stack_temporaries_enabled = true; |
942 | m_thr->stack_temporaries.clear (); | |
fdf07f3a TT |
943 | } |
944 | ||
945 | ~enable_thread_stack_temporaries () | |
946 | { | |
00431a78 PA |
947 | m_thr->stack_temporaries_enabled = false; |
948 | m_thr->stack_temporaries.clear (); | |
fdf07f3a TT |
949 | } |
950 | ||
951 | DISABLE_COPY_AND_ASSIGN (enable_thread_stack_temporaries); | |
952 | ||
953 | private: | |
954 | ||
15f4dddd | 955 | thread_info_ref m_thr; |
fdf07f3a | 956 | }; |
6c659fc2 | 957 | |
75cbc781 | 958 | extern bool thread_stack_temporaries_enabled_p (struct thread_info *tp); |
6c659fc2 | 959 | |
75cbc781 | 960 | extern void push_thread_stack_temporary (struct thread_info *tp, struct value *v); |
6c659fc2 | 961 | |
75cbc781 | 962 | extern value *get_last_thread_stack_temporary (struct thread_info *tp); |
6c659fc2 | 963 | |
00431a78 | 964 | extern bool value_in_thread_stack_temporaries (struct value *, |
75cbc781 | 965 | struct thread_info *thr); |
6c659fc2 | 966 | |
8b6a69b2 SM |
967 | /* Thread step-over list type. */ |
968 | using thread_step_over_list_node | |
969 | = intrusive_member_node<thread_info, &thread_info::step_over_list_node>; | |
970 | using thread_step_over_list | |
971 | = intrusive_list<thread_info, thread_step_over_list_node>; | |
972 | using thread_step_over_list_iterator | |
973 | = reference_to_pointer_iterator<thread_step_over_list::iterator>; | |
974 | using thread_step_over_list_safe_iterator | |
975 | = basic_safe_iterator<thread_step_over_list_iterator>; | |
976 | using thread_step_over_list_safe_range | |
977 | = iterator_range<thread_step_over_list_safe_iterator>; | |
978 | ||
979 | static inline thread_step_over_list_safe_range | |
980 | make_thread_step_over_list_safe_range (thread_step_over_list &list) | |
981 | { | |
982 | return thread_step_over_list_safe_range | |
983 | (thread_step_over_list_safe_iterator (list.begin (), | |
984 | list.end ()), | |
985 | thread_step_over_list_safe_iterator (list.end (), | |
986 | list.end ())); | |
987 | } | |
988 | ||
28d5518b | 989 | /* Add TP to the end of the global pending step-over chain. */ |
c2829269 | 990 | |
28d5518b | 991 | extern void global_thread_step_over_chain_enqueue (thread_info *tp); |
c2829269 | 992 | |
8b6a69b2 | 993 | /* Append the thread step over list LIST to the global thread step over |
187b041e SM |
994 | chain. */ |
995 | ||
996 | extern void global_thread_step_over_chain_enqueue_chain | |
8b6a69b2 | 997 | (thread_step_over_list &&list); |
187b041e | 998 | |
28d5518b | 999 | /* Remove TP from the global pending step-over chain. */ |
c2829269 | 1000 | |
28d5518b | 1001 | extern void global_thread_step_over_chain_remove (thread_info *tp); |
c2829269 | 1002 | |
28d5518b | 1003 | /* Return true if TP is in any step-over chain. */ |
c2829269 PA |
1004 | |
1005 | extern int thread_is_in_step_over_chain (struct thread_info *tp); | |
1006 | ||
187b041e SM |
1007 | /* Return the length of the the step over chain TP is in. |
1008 | ||
1009 | If TP is non-nullptr, the thread must be in a step over chain. | |
1010 | TP may be nullptr, in which case it denotes an empty list, so a length of | |
1011 | 0. */ | |
1012 | ||
8b6a69b2 | 1013 | extern int thread_step_over_chain_length (const thread_step_over_list &l); |
187b041e | 1014 | |
243a9253 PA |
1015 | /* Cancel any ongoing execution command. */ |
1016 | ||
1017 | extern void thread_cancel_execution_command (struct thread_info *thr); | |
1018 | ||
a911d87a PA |
1019 | /* Check whether it makes sense to access a register of the current |
1020 | thread at this point. If not, throw an error (e.g., the thread is | |
1021 | executing). */ | |
1022 | extern void validate_registers_access (void); | |
1023 | ||
00431a78 | 1024 | /* Check whether it makes sense to access a register of THREAD at this point. |
cf77c34e | 1025 | Returns true if registers may be accessed; false otherwise. */ |
75cbc781 | 1026 | extern bool can_access_registers_thread (struct thread_info *thread); |
cf77c34e | 1027 | |
f303dbd6 PA |
1028 | /* Returns whether to show which thread hit the breakpoint, received a |
1029 | signal, etc. and ended up causing a user-visible stop. This is | |
1030 | true iff we ever detected multiple threads. */ | |
1031 | extern int show_thread_that_caused_stop (void); | |
1032 | ||
4034d0ff AT |
1033 | /* Print the message for a thread or/and frame selected. */ |
1034 | extern void print_selected_thread_frame (struct ui_out *uiout, | |
1035 | user_selected_what selection); | |
1036 | ||
65630365 PA |
1037 | /* Helper for the CLI's "thread" command and for MI's -thread-select. |
1038 | Selects thread THR. TIDSTR is the original string the thread ID | |
1039 | was parsed from. This is used in the error message if THR is not | |
1040 | alive anymore. */ | |
7aabaf9d | 1041 | extern void thread_select (const char *tidstr, class thread_info *thr); |
65630365 | 1042 | |
25558938 SM |
1043 | /* Return THREAD's name. |
1044 | ||
1045 | If THREAD has a user-given name, return it. Otherwise, query the thread's | |
1046 | target to get the name. May return nullptr. */ | |
1047 | extern const char *thread_name (thread_info *thread); | |
1048 | ||
bc75fb44 TT |
1049 | /* Switch to thread TP if it is alive. Returns true if successfully |
1050 | switched, false otherwise. */ | |
1051 | ||
1052 | extern bool switch_to_thread_if_alive (thread_info *thr); | |
1053 | ||
1054 | /* Assuming that THR is the current thread, execute CMD. | |
1055 | If ADA_TASK is not empty, it is the Ada task ID, and will | |
1056 | be printed instead of the thread information. | |
1057 | FLAGS.QUIET controls the printing of the thread information. | |
1058 | FLAGS.CONT and FLAGS.SILENT control how to handle errors. Can throw an | |
1059 | exception if !FLAGS.SILENT and !FLAGS.CONT and CMD fails. */ | |
1060 | ||
1061 | extern void thread_try_catch_cmd (thread_info *thr, | |
6b09f134 | 1062 | std::optional<int> ada_task, |
bc75fb44 TT |
1063 | const char *cmd, int from_tty, |
1064 | const qcs_flags &flags); | |
1065 | ||
993248f4 AB |
1066 | /* Return a string representation of STATE. */ |
1067 | ||
1068 | extern const char *thread_state_string (enum thread_state state); | |
1069 | ||
c5aa993b | 1070 | #endif /* GDBTHREAD_H */ |