Commit | Line | Data |
---|---|---|
5796c8dc | 1 | /* Multi-process/thread control defs for GDB, the GNU debugger. |
25e4902b | 2 | Copyright (C) 1987-2015 Free Software Foundation, Inc. |
5796c8dc SS |
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 "inferior.h" | |
ef5ccd6c | 30 | #include "btrace.h" |
25e4902b | 31 | #include "common/vec.h" |
5796c8dc | 32 | |
a45ae5f8 JM |
33 | /* Frontend view of the thread state. Possible extensions: stepping, |
34 | finishing, until(ling),... */ | |
35 | enum thread_state | |
36 | { | |
37 | THREAD_STOPPED, | |
38 | THREAD_RUNNING, | |
39 | THREAD_EXITED, | |
40 | }; | |
41 | ||
c50c785c | 42 | /* Inferior thread specific part of `struct infcall_control_state'. |
5796c8dc | 43 | |
c50c785c | 44 | Inferior process counterpart is `struct inferior_control_state'. */ |
5796c8dc | 45 | |
c50c785c JM |
46 | struct thread_control_state |
47 | { | |
5796c8dc SS |
48 | /* User/external stepping state. */ |
49 | ||
50 | /* Step-resume or longjmp-resume breakpoint. */ | |
51 | struct breakpoint *step_resume_breakpoint; | |
52 | ||
c50c785c JM |
53 | /* Exception-resume breakpoint. */ |
54 | struct breakpoint *exception_resume_breakpoint; | |
55 | ||
25e4902b AHJ |
56 | /* Breakpoints used for software single stepping. Plural, because |
57 | it may have multiple locations. E.g., if stepping over a | |
58 | conditional branch instruction we can't decode the condition for, | |
59 | we'll need to put a breakpoint at the branch destination, and | |
60 | another at the instruction after the branch. */ | |
61 | struct breakpoint *single_step_breakpoints; | |
62 | ||
5796c8dc SS |
63 | /* Range to single step within. |
64 | ||
65 | If this is nonzero, respond to a single-step signal by continuing | |
66 | to step if the pc is in this range. | |
67 | ||
68 | If step_range_start and step_range_end are both 1, it means to | |
69 | step for a single instruction (FIXME: it might clean up | |
70 | wait_for_inferior in a minor way if this were changed to the | |
71 | address of the instruction and that address plus one. But maybe | |
c50c785c | 72 | not). */ |
5796c8dc SS |
73 | CORE_ADDR step_range_start; /* Inclusive */ |
74 | CORE_ADDR step_range_end; /* Exclusive */ | |
75 | ||
25e4902b AHJ |
76 | /* Function the thread was in as of last it started stepping. */ |
77 | struct symbol *step_start_function; | |
78 | ||
79 | /* If GDB issues a target step request, and this is nonzero, the | |
80 | target should single-step this thread once, and then continue | |
81 | single-stepping it without GDB core involvement as long as the | |
82 | thread stops in the step range above. If this is zero, the | |
83 | target should ignore the step range, and only issue one single | |
84 | step. */ | |
85 | int may_range_step; | |
86 | ||
5796c8dc SS |
87 | /* Stack frame address as of when stepping command was issued. |
88 | This is how we know when we step into a subroutine call, and how | |
89 | to set the frame for the breakpoint used to step out. */ | |
90 | struct frame_id step_frame_id; | |
91 | ||
92 | /* Similarly, the frame ID of the underlying stack frame (skipping | |
93 | any inlined frames). */ | |
94 | struct frame_id step_stack_frame_id; | |
95 | ||
5796c8dc SS |
96 | /* Nonzero if we are presently stepping over a breakpoint. |
97 | ||
98 | If we hit a breakpoint or watchpoint, and then continue, we need | |
99 | to single step the current thread with breakpoints disabled, to | |
100 | avoid hitting the same breakpoint or watchpoint again. And we | |
101 | should step just a single thread and keep other threads stopped, | |
102 | so that other threads don't miss breakpoints while they are | |
103 | removed. | |
104 | ||
105 | So, this variable simultaneously means that we need to single | |
106 | step the current thread, keep other threads stopped, and that | |
107 | breakpoints should be removed while we step. | |
108 | ||
109 | This variable is set either: | |
110 | - in proceed, when we resume inferior on user's explicit request | |
111 | - in keep_going, if handle_inferior_event decides we need to | |
112 | step over breakpoint. | |
113 | ||
114 | The variable is cleared in normal_stop. The proceed calls | |
115 | wait_for_inferior, which calls handle_inferior_event in a loop, | |
116 | and until wait_for_inferior exits, this variable is changed only | |
117 | by keep_going. */ | |
118 | int trap_expected; | |
119 | ||
c50c785c | 120 | /* Nonzero if the thread is being proceeded for a "finish" command |
25e4902b | 121 | or a similar situation when return value should be printed. */ |
c50c785c JM |
122 | int proceed_to_finish; |
123 | ||
124 | /* Nonzero if the thread is being proceeded for an inferior function | |
125 | call. */ | |
126 | int in_infcall; | |
127 | ||
128 | enum step_over_calls_kind step_over_calls; | |
129 | ||
130 | /* Nonzero if stopped due to a step command. */ | |
131 | int stop_step; | |
132 | ||
133 | /* Chain containing status of breakpoint(s) the thread stopped | |
134 | at. */ | |
135 | bpstat stop_bpstat; | |
c50c785c | 136 | |
25e4902b AHJ |
137 | /* The interpreter that issued the execution command. NULL if the |
138 | thread was resumed as a result of a command applied to some other | |
139 | thread (e.g., "next" with scheduler-locking off). */ | |
140 | struct interp *command_interp; | |
c50c785c | 141 | |
25e4902b AHJ |
142 | /* Whether the command that started the thread was a stepping |
143 | command. This is used to decide whether "set scheduler-locking | |
144 | step" behaves like "on" or "off". */ | |
145 | int stepping_command; | |
146 | }; | |
147 | ||
148 | /* Inferior thread specific part of `struct infcall_suspend_state'. */ | |
c50c785c JM |
149 | |
150 | struct thread_suspend_state | |
151 | { | |
25e4902b AHJ |
152 | /* Last signal that the inferior received (why it stopped). When |
153 | the thread is resumed, this signal is delivered. Note: the | |
154 | target should not check whether the signal is in pass state, | |
155 | because the signal may have been explicitly passed with the | |
156 | "signal" command, which overrides "handle nopass". If the signal | |
157 | should be suppressed, the core will take care of clearing this | |
158 | before the target is resumed. */ | |
ef5ccd6c | 159 | enum gdb_signal stop_signal; |
c50c785c JM |
160 | }; |
161 | ||
25e4902b AHJ |
162 | typedef struct value *value_ptr; |
163 | DEF_VEC_P (value_ptr); | |
164 | typedef VEC (value_ptr) value_vec; | |
165 | ||
c50c785c JM |
166 | struct thread_info |
167 | { | |
168 | struct thread_info *next; | |
169 | ptid_t ptid; /* "Actual process id"; | |
170 | In fact, this may be overloaded with | |
171 | kernel thread id, etc. */ | |
172 | int num; /* Convenient handle (GDB thread id) */ | |
173 | ||
174 | /* The name of the thread, as specified by the user. This is NULL | |
175 | if the thread does not have a user-given name. */ | |
176 | char *name; | |
177 | ||
178 | /* Non-zero means the thread is executing. Note: this is different | |
179 | from saying that there is an active target and we are stopped at | |
180 | a breakpoint, for instance. This is a real indicator whether the | |
181 | thread is off and running. */ | |
a45ae5f8 | 182 | int executing; |
c50c785c | 183 | |
25e4902b AHJ |
184 | /* Frontend view of the thread state. Note that the THREAD_RUNNING/ |
185 | THREAD_STOPPED states are different from EXECUTING. When the | |
186 | thread is stopped internally while handling an internal event, | |
187 | like a software single-step breakpoint, EXECUTING will be false, | |
188 | but STATE will still be THREAD_RUNNING. */ | |
189 | enum thread_state state; | |
c50c785c JM |
190 | |
191 | /* If this is > 0, then it means there's code out there that relies | |
192 | on this thread being listed. Don't delete it from the lists even | |
193 | if we detect it exiting. */ | |
194 | int refcount; | |
195 | ||
196 | /* State of GDB control of inferior thread execution. | |
197 | See `struct thread_control_state'. */ | |
198 | struct thread_control_state control; | |
199 | ||
200 | /* State of inferior thread to restore after GDB is done with an inferior | |
201 | call. See `struct thread_suspend_state'. */ | |
202 | struct thread_suspend_state suspend; | |
203 | ||
204 | int current_line; | |
205 | struct symtab *current_symtab; | |
206 | ||
207 | /* Internal stepping state. */ | |
208 | ||
209 | /* Record the pc of the thread the last time it stopped. This is | |
210 | maintained by proceed and keep_going, and used in | |
211 | adjust_pc_after_break to distinguish a hardware single-step | |
212 | SIGTRAP from a breakpoint SIGTRAP. */ | |
213 | CORE_ADDR prev_pc; | |
214 | ||
25e4902b AHJ |
215 | /* Did we set the thread stepping a breakpoint instruction? This is |
216 | used in conjunction with PREV_PC to decide whether to adjust the | |
217 | PC. */ | |
218 | int stepped_breakpoint; | |
219 | ||
5796c8dc SS |
220 | /* Should we step over breakpoint next time keep_going is called? */ |
221 | int stepping_over_breakpoint; | |
222 | ||
25e4902b AHJ |
223 | /* Should we step over a watchpoint next time keep_going is called? |
224 | This is needed on targets with non-continuable, non-steppable | |
225 | watchpoints. */ | |
226 | int stepping_over_watchpoint; | |
227 | ||
5796c8dc | 228 | /* Set to TRUE if we should finish single-stepping over a breakpoint |
a45ae5f8 JM |
229 | after hitting the current step-resume breakpoint. The context here |
230 | is that GDB is to do `next' or `step' while signal arrives. | |
231 | When stepping over a breakpoint and signal arrives, GDB will attempt | |
232 | to skip signal handler, so it inserts a step_resume_breakpoint at the | |
233 | signal return address, and resume inferior. | |
234 | step_after_step_resume_breakpoint is set to TRUE at this moment in | |
235 | order to keep GDB in mind that there is still a breakpoint to step over | |
236 | when GDB gets back SIGTRAP from step_resume_breakpoint. */ | |
5796c8dc SS |
237 | int step_after_step_resume_breakpoint; |
238 | ||
5796c8dc SS |
239 | /* Per-thread command support. */ |
240 | ||
241 | /* Pointer to what is left to do for an execution command after the | |
242 | target stops. Used only in asynchronous mode, by targets that | |
243 | support async execution. Several execution commands use it. */ | |
244 | struct continuation *continuations; | |
245 | ||
246 | /* Similar to the above, but used when a single execution command | |
247 | requires several resume/stop iterations. Used by the step | |
248 | command. */ | |
249 | struct continuation *intermediate_continuations; | |
250 | ||
5796c8dc SS |
251 | /* If stepping, nonzero means step count is > 1 so don't print frame |
252 | next time inferior stops if it stops due to stepping. */ | |
253 | int step_multi; | |
254 | ||
255 | /* This is used to remember when a fork or vfork event was caught by | |
256 | a catchpoint, and thus the event is to be followed at the next | |
257 | resume of the thread, and not immediately. */ | |
258 | struct target_waitstatus pending_follow; | |
259 | ||
5796c8dc SS |
260 | /* True if this thread has been explicitly requested to stop. */ |
261 | int stop_requested; | |
262 | ||
c50c785c | 263 | /* The initiating frame of a nexting operation, used for deciding |
ef5ccd6c JM |
264 | which exceptions to intercept. If it is null_frame_id no |
265 | bp_longjmp or bp_exception but longjmp has been caught just for | |
266 | bp_longjmp_call_dummy. */ | |
c50c785c JM |
267 | struct frame_id initiating_frame; |
268 | ||
5796c8dc | 269 | /* Private data used by the target vector implementation. */ |
25e4902b | 270 | struct private_thread_info *priv; |
cf7f2e2d JM |
271 | |
272 | /* Function that is called to free PRIVATE. If this is NULL, then | |
273 | xfree will be called on PRIVATE. */ | |
274 | void (*private_dtor) (struct private_thread_info *); | |
ef5ccd6c JM |
275 | |
276 | /* Branch trace information for this thread. */ | |
277 | struct btrace_thread_info btrace; | |
25e4902b AHJ |
278 | |
279 | /* Flag which indicates that the stack temporaries should be stored while | |
280 | evaluating expressions. */ | |
281 | int stack_temporaries_enabled; | |
282 | ||
283 | /* Values that are stored as temporaries on stack while evaluating | |
284 | expressions. */ | |
285 | value_vec *stack_temporaries; | |
5796c8dc SS |
286 | }; |
287 | ||
288 | /* Create an empty thread list, or empty the existing one. */ | |
289 | extern void init_thread_list (void); | |
290 | ||
291 | /* Add a thread to the thread list, print a message | |
292 | that a new thread is found, and return the pointer to | |
293 | the new thread. Caller my use this pointer to | |
294 | initialize the private thread data. */ | |
295 | extern struct thread_info *add_thread (ptid_t ptid); | |
296 | ||
297 | /* Same as add_thread, but does not print a message | |
298 | about new thread. */ | |
299 | extern struct thread_info *add_thread_silent (ptid_t ptid); | |
300 | ||
301 | /* Same as add_thread, and sets the private info. */ | |
302 | extern struct thread_info *add_thread_with_info (ptid_t ptid, | |
303 | struct private_thread_info *); | |
304 | ||
305 | /* Delete an existing thread list entry. */ | |
306 | extern void delete_thread (ptid_t); | |
307 | ||
308 | /* Delete an existing thread list entry, and be quiet about it. Used | |
309 | after the process this thread having belonged to having already | |
310 | exited, for example. */ | |
311 | extern void delete_thread_silent (ptid_t); | |
312 | ||
c50c785c | 313 | /* Delete a step_resume_breakpoint from the thread database. */ |
5796c8dc SS |
314 | extern void delete_step_resume_breakpoint (struct thread_info *); |
315 | ||
c50c785c JM |
316 | /* Delete an exception_resume_breakpoint from the thread database. */ |
317 | extern void delete_exception_resume_breakpoint (struct thread_info *); | |
318 | ||
25e4902b AHJ |
319 | /* Delete the single-step breakpoints of thread TP, if any. */ |
320 | extern void delete_single_step_breakpoints (struct thread_info *tp); | |
321 | ||
322 | /* Check if the thread has software single stepping breakpoints | |
323 | set. */ | |
324 | extern int thread_has_single_step_breakpoints_set (struct thread_info *tp); | |
325 | ||
326 | /* Check whether the thread has software single stepping breakpoints | |
327 | set at PC. */ | |
328 | extern int thread_has_single_step_breakpoint_here (struct thread_info *tp, | |
329 | struct address_space *aspace, | |
330 | CORE_ADDR addr); | |
331 | ||
5796c8dc SS |
332 | /* Translate the integer thread id (GDB's homegrown id, not the system's) |
333 | into a "pid" (which may be overloaded with extra thread information). */ | |
334 | extern ptid_t thread_id_to_pid (int); | |
335 | ||
336 | /* Translate a 'pid' (which may be overloaded with extra thread information) | |
337 | into the integer thread id (GDB's homegrown id, not the system's). */ | |
338 | extern int pid_to_thread_id (ptid_t ptid); | |
339 | ||
340 | /* Boolean test for an already-known pid (which may be overloaded with | |
341 | extra thread information). */ | |
342 | extern int in_thread_list (ptid_t ptid); | |
343 | ||
344 | /* Boolean test for an already-known thread id (GDB's homegrown id, | |
345 | not the system's). */ | |
346 | extern int valid_thread_id (int thread); | |
347 | ||
348 | /* Search function to lookup a thread by 'pid'. */ | |
349 | extern struct thread_info *find_thread_ptid (ptid_t ptid); | |
350 | ||
351 | /* Find thread by GDB user-visible thread number. */ | |
352 | struct thread_info *find_thread_id (int num); | |
353 | ||
354 | /* Finds the first thread of the inferior given by PID. If PID is -1, | |
355 | returns the first thread in the list. */ | |
356 | struct thread_info *first_thread_of_process (int pid); | |
357 | ||
25e4902b AHJ |
358 | /* Returns any thread of process PID, giving preference to the current |
359 | thread. */ | |
5796c8dc SS |
360 | extern struct thread_info *any_thread_of_process (int pid); |
361 | ||
25e4902b AHJ |
362 | /* Returns any non-exited thread of process PID, giving preference to |
363 | the current thread, and to not executing threads. */ | |
cf7f2e2d JM |
364 | extern struct thread_info *any_live_thread_of_process (int pid); |
365 | ||
5796c8dc SS |
366 | /* Change the ptid of thread OLD_PTID to NEW_PTID. */ |
367 | void thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid); | |
368 | ||
369 | /* Iterator function to call a user-provided callback function | |
370 | once for each known thread. */ | |
371 | typedef int (*thread_callback_func) (struct thread_info *, void *); | |
372 | extern struct thread_info *iterate_over_threads (thread_callback_func, void *); | |
373 | ||
25e4902b AHJ |
374 | /* Traverse all threads, except those that have THREAD_EXITED |
375 | state. */ | |
ef5ccd6c | 376 | |
25e4902b AHJ |
377 | #define ALL_NON_EXITED_THREADS(T) \ |
378 | for (T = thread_list; T; T = T->next) \ | |
379 | if ((T)->state != THREAD_EXITED) | |
380 | ||
381 | /* Traverse all threads, including those that have THREAD_EXITED | |
382 | state. Allows deleting the currently iterated thread. */ | |
383 | #define ALL_THREADS_SAFE(T, TMP) \ | |
384 | for ((T) = thread_list; \ | |
385 | (T) != NULL ? ((TMP) = (T)->next, 1): 0; \ | |
386 | (T) = (TMP)) | |
ef5ccd6c | 387 | |
5796c8dc SS |
388 | extern int thread_count (void); |
389 | ||
390 | /* Switch from one thread to another. */ | |
391 | extern void switch_to_thread (ptid_t ptid); | |
392 | ||
393 | /* Marks thread PTID is running, or stopped. | |
25e4902b | 394 | If PTID is minus_one_ptid, marks all threads. */ |
5796c8dc SS |
395 | extern void set_running (ptid_t ptid, int running); |
396 | ||
397 | /* Marks or clears thread(s) PTID as having been requested to stop. | |
398 | If PTID is MINUS_ONE_PTID, applies to all threads. If | |
399 | ptid_is_pid(PTID) is true, applies to all threads of the process | |
400 | pointed at by PTID. If STOP, then the THREAD_STOP_REQUESTED | |
401 | observer is called with PTID as argument. */ | |
402 | extern void set_stop_requested (ptid_t ptid, int stop); | |
403 | ||
404 | /* NOTE: Since the thread state is not a boolean, most times, you do | |
405 | not want to check it with negation. If you really want to check if | |
406 | the thread is stopped, | |
407 | ||
408 | use (good): | |
409 | ||
410 | if (is_stopped (ptid)) | |
411 | ||
412 | instead of (bad): | |
413 | ||
414 | if (!is_running (ptid)) | |
415 | ||
416 | The latter also returns true on exited threads, most likelly not | |
417 | what you want. */ | |
418 | ||
419 | /* Reports if in the frontend's perpective, thread PTID is running. */ | |
420 | extern int is_running (ptid_t ptid); | |
421 | ||
422 | /* Is this thread listed, but known to have exited? We keep it listed | |
423 | (but not visible) until it's safe to delete. */ | |
424 | extern int is_exited (ptid_t ptid); | |
425 | ||
426 | /* In the frontend's perpective, is this thread stopped? */ | |
427 | extern int is_stopped (ptid_t ptid); | |
428 | ||
25e4902b | 429 | /* Marks thread PTID as executing, or not. If PTID is minus_one_ptid, |
5796c8dc SS |
430 | marks all threads. |
431 | ||
432 | Note that this is different from the running state. See the | |
a45ae5f8 | 433 | description of state and executing fields of struct |
5796c8dc SS |
434 | thread_info. */ |
435 | extern void set_executing (ptid_t ptid, int executing); | |
436 | ||
437 | /* Reports if thread PTID is executing. */ | |
438 | extern int is_executing (ptid_t ptid); | |
439 | ||
25e4902b AHJ |
440 | /* True if any (known or unknown) thread is or may be executing. */ |
441 | extern int threads_are_executing (void); | |
442 | ||
5796c8dc SS |
443 | /* Merge the executing property of thread PTID over to its thread |
444 | state property (frontend running/stopped view). | |
445 | ||
446 | "not executing" -> "stopped" | |
447 | "executing" -> "running" | |
448 | "exited" -> "exited" | |
449 | ||
25e4902b | 450 | If PTID is minus_one_ptid, go over all threads. |
5796c8dc SS |
451 | |
452 | Notifications are only emitted if the thread state did change. */ | |
453 | extern void finish_thread_state (ptid_t ptid); | |
454 | ||
455 | /* Same as FINISH_THREAD_STATE, but with an interface suitable to be | |
456 | registered as a cleanup. PTID_P points to the ptid_t that is | |
457 | passed to FINISH_THREAD_STATE. */ | |
458 | extern void finish_thread_state_cleanup (void *ptid_p); | |
459 | ||
460 | /* Commands with a prefix of `thread'. */ | |
461 | extern struct cmd_list_element *thread_cmd_list; | |
462 | ||
25e4902b AHJ |
463 | extern void thread_command (char *tidstr, int from_tty); |
464 | ||
5796c8dc SS |
465 | /* Print notices on thread events (attach, detach, etc.), set with |
466 | `set print thread-events'. */ | |
467 | extern int print_thread_events; | |
468 | ||
c50c785c | 469 | extern void print_thread_info (struct ui_out *uiout, char *threads, |
5796c8dc SS |
470 | int pid); |
471 | ||
472 | extern struct cleanup *make_cleanup_restore_current_thread (void); | |
473 | ||
474 | /* Returns a pointer into the thread_info corresponding to | |
475 | INFERIOR_PTID. INFERIOR_PTID *must* be in the thread list. */ | |
476 | extern struct thread_info* inferior_thread (void); | |
477 | ||
cf7f2e2d JM |
478 | extern void update_thread_list (void); |
479 | ||
25e4902b AHJ |
480 | /* Delete any thread the target says is no longer alive. */ |
481 | ||
482 | extern void prune_threads (void); | |
483 | ||
484 | /* Delete threads marked THREAD_EXITED. Unlike prune_threads, this | |
485 | does not consult the target about whether the thread is alive right | |
486 | now. */ | |
487 | extern void delete_exited_threads (void); | |
488 | ||
489 | /* Return true if PC is in the stepping range of THREAD. */ | |
490 | ||
491 | int pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread); | |
492 | ||
493 | extern struct cleanup *enable_thread_stack_temporaries (ptid_t ptid); | |
494 | ||
495 | extern int thread_stack_temporaries_enabled_p (ptid_t ptid); | |
496 | ||
497 | extern void push_thread_stack_temporary (ptid_t ptid, struct value *v); | |
498 | ||
499 | extern struct value *get_last_thread_stack_temporary (ptid_t); | |
500 | ||
501 | extern int value_in_thread_stack_temporaries (struct value *, ptid_t); | |
502 | ||
ef5ccd6c JM |
503 | extern struct thread_info *thread_list; |
504 | ||
5796c8dc | 505 | #endif /* GDBTHREAD_H */ |