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