Commit | Line | Data |
---|---|---|
c906108c | 1 | /* Multi-process/thread control defs for GDB, the GNU debugger. |
ecd75fc8 | 2 | Copyright (C) 1987-2014 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" |
a474d7c2 | 29 | #include "inferior.h" |
02d27625 | 30 | #include "btrace.h" |
8e8901c5 | 31 | |
30596231 PA |
32 | /* Frontend view of the thread state. Possible extensions: stepping, |
33 | finishing, until(ling),... */ | |
34 | enum thread_state | |
35 | { | |
36 | THREAD_STOPPED, | |
37 | THREAD_RUNNING, | |
38 | THREAD_EXITED, | |
39 | }; | |
40 | ||
16c381f0 | 41 | /* Inferior thread specific part of `struct infcall_control_state'. |
8ea051c5 | 42 | |
16c381f0 | 43 | Inferior process counterpart is `struct inferior_control_state'. */ |
8ea051c5 | 44 | |
16c381f0 JK |
45 | struct thread_control_state |
46 | { | |
4e1c45ea PA |
47 | /* User/external stepping state. */ |
48 | ||
8358c15c JK |
49 | /* Step-resume or longjmp-resume breakpoint. */ |
50 | struct breakpoint *step_resume_breakpoint; | |
51 | ||
186c406b TT |
52 | /* Exception-resume breakpoint. */ |
53 | struct breakpoint *exception_resume_breakpoint; | |
54 | ||
4e1c45ea PA |
55 | /* Range to single step within. |
56 | ||
57 | If this is nonzero, respond to a single-step signal by continuing | |
58 | to step if the pc is in this range. | |
59 | ||
60 | If step_range_start and step_range_end are both 1, it means to | |
61 | step for a single instruction (FIXME: it might clean up | |
62 | wait_for_inferior in a minor way if this were changed to the | |
63 | address of the instruction and that address plus one. But maybe | |
0963b4bd | 64 | not). */ |
4e1c45ea PA |
65 | CORE_ADDR step_range_start; /* Inclusive */ |
66 | CORE_ADDR step_range_end; /* Exclusive */ | |
67 | ||
c1e36e3e PA |
68 | /* If GDB issues a target step request, and this is nonzero, the |
69 | target should single-step this thread once, and then continue | |
70 | single-stepping it without GDB core involvement as long as the | |
71 | thread stops in the step range above. If this is zero, the | |
72 | target should ignore the step range, and only issue one single | |
73 | step. */ | |
74 | int may_range_step; | |
75 | ||
4e1c45ea PA |
76 | /* Stack frame address as of when stepping command was issued. |
77 | This is how we know when we step into a subroutine call, and how | |
78 | to set the frame for the breakpoint used to step out. */ | |
aa0cd9c1 | 79 | struct frame_id step_frame_id; |
edb3359d DJ |
80 | |
81 | /* Similarly, the frame ID of the underlying stack frame (skipping | |
82 | any inlined frames). */ | |
83 | struct frame_id step_stack_frame_id; | |
84 | ||
4e1c45ea PA |
85 | /* Nonzero if we are presently stepping over a breakpoint. |
86 | ||
87 | If we hit a breakpoint or watchpoint, and then continue, we need | |
88 | to single step the current thread with breakpoints disabled, to | |
89 | avoid hitting the same breakpoint or watchpoint again. And we | |
90 | should step just a single thread and keep other threads stopped, | |
91 | so that other threads don't miss breakpoints while they are | |
92 | removed. | |
93 | ||
94 | So, this variable simultaneously means that we need to single | |
95 | step the current thread, keep other threads stopped, and that | |
96 | breakpoints should be removed while we step. | |
97 | ||
98 | This variable is set either: | |
99 | - in proceed, when we resume inferior on user's explicit request | |
100 | - in keep_going, if handle_inferior_event decides we need to | |
101 | step over breakpoint. | |
102 | ||
103 | The variable is cleared in normal_stop. The proceed calls | |
104 | wait_for_inferior, which calls handle_inferior_event in a loop, | |
105 | and until wait_for_inferior exits, this variable is changed only | |
106 | by keep_going. */ | |
0d06e24b | 107 | int trap_expected; |
4e1c45ea | 108 | |
16c381f0 JK |
109 | /* Nonzero if the thread is being proceeded for a "finish" command |
110 | or a similar situation when stop_registers should be saved. */ | |
111 | int proceed_to_finish; | |
112 | ||
113 | /* Nonzero if the thread is being proceeded for an inferior function | |
114 | call. */ | |
115 | int in_infcall; | |
116 | ||
117 | enum step_over_calls_kind step_over_calls; | |
118 | ||
119 | /* Nonzero if stopped due to a step command. */ | |
120 | int stop_step; | |
121 | ||
122 | /* Chain containing status of breakpoint(s) the thread stopped | |
123 | at. */ | |
124 | bpstat stop_bpstat; | |
17b2616c PA |
125 | |
126 | /* The interpreter that issued the execution command. NULL if the | |
127 | thread was resumed as a result of a command applied to some other | |
128 | thread (e.g., "next" with scheduler-locking off). */ | |
129 | struct interp *command_interp; | |
16c381f0 JK |
130 | }; |
131 | ||
132 | /* Inferior thread specific part of `struct infcall_suspend_state'. | |
133 | ||
134 | Inferior process counterpart is `struct inferior_suspend_state'. */ | |
135 | ||
136 | struct thread_suspend_state | |
137 | { | |
138 | /* Last signal that the inferior received (why it stopped). */ | |
2ea28649 | 139 | enum gdb_signal stop_signal; |
16c381f0 JK |
140 | }; |
141 | ||
142 | struct thread_info | |
143 | { | |
144 | struct thread_info *next; | |
145 | ptid_t ptid; /* "Actual process id"; | |
146 | In fact, this may be overloaded with | |
147 | kernel thread id, etc. */ | |
148 | int num; /* Convenient handle (GDB thread id) */ | |
149 | ||
4694da01 TT |
150 | /* The name of the thread, as specified by the user. This is NULL |
151 | if the thread does not have a user-given name. */ | |
152 | char *name; | |
153 | ||
16c381f0 JK |
154 | /* Non-zero means the thread is executing. Note: this is different |
155 | from saying that there is an active target and we are stopped at | |
156 | a breakpoint, for instance. This is a real indicator whether the | |
157 | thread is off and running. */ | |
30596231 | 158 | int executing; |
16c381f0 | 159 | |
f6e29b6e YQ |
160 | /* Frontend view of the thread state. Note that the THREAD_RUNNING/ |
161 | THREAD_STOPPED states are different from EXECUTING. When the | |
162 | thread is stopped internally while handling an internal event, | |
163 | like a software single-step breakpoint, EXECUTING will be false, | |
164 | but STATE will still be THREAD_RUNNING. */ | |
165 | enum thread_state state; | |
16c381f0 JK |
166 | |
167 | /* If this is > 0, then it means there's code out there that relies | |
168 | on this thread being listed. Don't delete it from the lists even | |
169 | if we detect it exiting. */ | |
170 | int refcount; | |
171 | ||
172 | /* State of GDB control of inferior thread execution. | |
173 | See `struct thread_control_state'. */ | |
174 | struct thread_control_state control; | |
175 | ||
176 | /* State of inferior thread to restore after GDB is done with an inferior | |
177 | call. See `struct thread_suspend_state'. */ | |
178 | struct thread_suspend_state suspend; | |
179 | ||
16c381f0 JK |
180 | int current_line; |
181 | struct symtab *current_symtab; | |
182 | ||
183 | /* Internal stepping state. */ | |
184 | ||
185 | /* Record the pc of the thread the last time it stopped. This is | |
186 | maintained by proceed and keep_going, and used in | |
187 | adjust_pc_after_break to distinguish a hardware single-step | |
188 | SIGTRAP from a breakpoint SIGTRAP. */ | |
189 | CORE_ADDR prev_pc; | |
190 | ||
4e1c45ea | 191 | /* Should we step over breakpoint next time keep_going is called? */ |
ca67fcb8 | 192 | int stepping_over_breakpoint; |
0d06e24b | 193 | |
4e1c45ea | 194 | /* Set to TRUE if we should finish single-stepping over a breakpoint |
6aa27652 YQ |
195 | after hitting the current step-resume breakpoint. The context here |
196 | is that GDB is to do `next' or `step' while signal arrives. | |
197 | When stepping over a breakpoint and signal arrives, GDB will attempt | |
198 | to skip signal handler, so it inserts a step_resume_breakpoint at the | |
199 | signal return address, and resume inferior. | |
200 | step_after_step_resume_breakpoint is set to TRUE at this moment in | |
201 | order to keep GDB in mind that there is still a breakpoint to step over | |
202 | when GDB gets back SIGTRAP from step_resume_breakpoint. */ | |
4e1c45ea PA |
203 | int step_after_step_resume_breakpoint; |
204 | ||
a474d7c2 | 205 | /* Per-thread command support. */ |
95e54da7 PA |
206 | |
207 | /* Pointer to what is left to do for an execution command after the | |
208 | target stops. Used only in asynchronous mode, by targets that | |
209 | support async execution. Several execution commands use it. */ | |
a474d7c2 | 210 | struct continuation *continuations; |
95e54da7 PA |
211 | |
212 | /* Similar to the above, but used when a single execution command | |
213 | requires several resume/stop iterations. Used by the step | |
214 | command. */ | |
a474d7c2 | 215 | struct continuation *intermediate_continuations; |
32400beb | 216 | |
af679fd0 PA |
217 | /* If stepping, nonzero means step count is > 1 so don't print frame |
218 | next time inferior stops if it stops due to stepping. */ | |
a474d7c2 PA |
219 | int step_multi; |
220 | ||
e58b0e63 PA |
221 | /* This is used to remember when a fork or vfork event was caught by |
222 | a catchpoint, and thus the event is to be followed at the next | |
223 | resume of the thread, and not immediately. */ | |
224 | struct target_waitstatus pending_follow; | |
225 | ||
252fbfc8 PA |
226 | /* True if this thread has been explicitly requested to stop. */ |
227 | int stop_requested; | |
228 | ||
186c406b | 229 | /* The initiating frame of a nexting operation, used for deciding |
e2e4d78b JK |
230 | which exceptions to intercept. If it is null_frame_id no |
231 | bp_longjmp or bp_exception but longjmp has been caught just for | |
232 | bp_longjmp_call_dummy. */ | |
186c406b TT |
233 | struct frame_id initiating_frame; |
234 | ||
0d06e24b JM |
235 | /* Private data used by the target vector implementation. */ |
236 | struct private_thread_info *private; | |
dc146f7c VP |
237 | |
238 | /* Function that is called to free PRIVATE. If this is NULL, then | |
239 | xfree will be called on PRIVATE. */ | |
240 | void (*private_dtor) (struct private_thread_info *); | |
02d27625 MM |
241 | |
242 | /* Branch trace information for this thread. */ | |
243 | struct btrace_thread_info btrace; | |
0d06e24b JM |
244 | }; |
245 | ||
246 | /* Create an empty thread list, or empty the existing one. */ | |
247 | extern void init_thread_list (void); | |
248 | ||
93815fbf VP |
249 | /* Add a thread to the thread list, print a message |
250 | that a new thread is found, and return the pointer to | |
251 | the new thread. Caller my use this pointer to | |
252 | initialize the private thread data. */ | |
39f77062 | 253 | extern struct thread_info *add_thread (ptid_t ptid); |
0d06e24b | 254 | |
93815fbf VP |
255 | /* Same as add_thread, but does not print a message |
256 | about new thread. */ | |
257 | extern struct thread_info *add_thread_silent (ptid_t ptid); | |
258 | ||
17faa917 DJ |
259 | /* Same as add_thread, and sets the private info. */ |
260 | extern struct thread_info *add_thread_with_info (ptid_t ptid, | |
261 | struct private_thread_info *); | |
262 | ||
0d06e24b | 263 | /* Delete an existing thread list entry. */ |
39f77062 | 264 | extern void delete_thread (ptid_t); |
0d06e24b | 265 | |
5e0b29c1 PA |
266 | /* Delete an existing thread list entry, and be quiet about it. Used |
267 | after the process this thread having belonged to having already | |
268 | exited, for example. */ | |
269 | extern void delete_thread_silent (ptid_t); | |
270 | ||
0963b4bd | 271 | /* Delete a step_resume_breakpoint from the thread database. */ |
4e1c45ea | 272 | extern void delete_step_resume_breakpoint (struct thread_info *); |
8601f500 | 273 | |
0963b4bd | 274 | /* Delete an exception_resume_breakpoint from the thread database. */ |
186c406b TT |
275 | extern void delete_exception_resume_breakpoint (struct thread_info *); |
276 | ||
0d06e24b JM |
277 | /* Translate the integer thread id (GDB's homegrown id, not the system's) |
278 | into a "pid" (which may be overloaded with extra thread information). */ | |
39f77062 | 279 | extern ptid_t thread_id_to_pid (int); |
0d06e24b JM |
280 | |
281 | /* Translate a 'pid' (which may be overloaded with extra thread information) | |
282 | into the integer thread id (GDB's homegrown id, not the system's). */ | |
39f77062 | 283 | extern int pid_to_thread_id (ptid_t ptid); |
0d06e24b JM |
284 | |
285 | /* Boolean test for an already-known pid (which may be overloaded with | |
286 | extra thread information). */ | |
39f77062 | 287 | extern int in_thread_list (ptid_t ptid); |
0d06e24b JM |
288 | |
289 | /* Boolean test for an already-known thread id (GDB's homegrown id, | |
290 | not the system's). */ | |
291 | extern int valid_thread_id (int thread); | |
292 | ||
293 | /* Search function to lookup a thread by 'pid'. */ | |
e09875d4 | 294 | extern struct thread_info *find_thread_ptid (ptid_t ptid); |
0d06e24b | 295 | |
1e92afda VP |
296 | /* Find thread by GDB user-visible thread number. */ |
297 | struct thread_info *find_thread_id (int num); | |
298 | ||
bad34192 PA |
299 | /* Finds the first thread of the inferior given by PID. If PID is -1, |
300 | returns the first thread in the list. */ | |
301 | struct thread_info *first_thread_of_process (int pid); | |
302 | ||
2277426b PA |
303 | /* Returns any thread of process PID. */ |
304 | extern struct thread_info *any_thread_of_process (int pid); | |
305 | ||
6c95b8df | 306 | /* Returns any non-exited thread of process PID, giving preference for |
9941e0c5 | 307 | not executing threads. */ |
6c95b8df PA |
308 | extern struct thread_info *any_live_thread_of_process (int pid); |
309 | ||
5231c1fd PA |
310 | /* Change the ptid of thread OLD_PTID to NEW_PTID. */ |
311 | void thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid); | |
312 | ||
0d06e24b JM |
313 | /* Iterator function to call a user-provided callback function |
314 | once for each known thread. */ | |
315 | typedef int (*thread_callback_func) (struct thread_info *, void *); | |
316 | extern struct thread_info *iterate_over_threads (thread_callback_func, void *); | |
317 | ||
034f788c PA |
318 | /* Traverse all threads, except those that have THREAD_EXITED |
319 | state. */ | |
e5ef252a | 320 | |
034f788c PA |
321 | #define ALL_NON_EXITED_THREADS(T) \ |
322 | for (T = thread_list; T; T = T->next) \ | |
323 | if ((T)->state != THREAD_EXITED) | |
e5ef252a | 324 | |
20874c92 VP |
325 | extern int thread_count (void); |
326 | ||
6a6b96b9 UW |
327 | /* Switch from one thread to another. */ |
328 | extern void switch_to_thread (ptid_t ptid); | |
329 | ||
e1ac3328 | 330 | /* Marks thread PTID is running, or stopped. |
dfd4cc63 | 331 | If ptid_get_pid (PTID) is -1, marks all threads. */ |
e1ac3328 VP |
332 | extern void set_running (ptid_t ptid, int running); |
333 | ||
252fbfc8 PA |
334 | /* Marks or clears thread(s) PTID as having been requested to stop. |
335 | If PTID is MINUS_ONE_PTID, applies to all threads. If | |
336 | ptid_is_pid(PTID) is true, applies to all threads of the process | |
337 | pointed at by PTID. If STOP, then the THREAD_STOP_REQUESTED | |
338 | observer is called with PTID as argument. */ | |
339 | extern void set_stop_requested (ptid_t ptid, int stop); | |
340 | ||
0d6431e2 PA |
341 | /* NOTE: Since the thread state is not a boolean, most times, you do |
342 | not want to check it with negation. If you really want to check if | |
343 | the thread is stopped, | |
e1ac3328 | 344 | |
0d6431e2 PA |
345 | use (good): |
346 | ||
347 | if (is_stopped (ptid)) | |
348 | ||
349 | instead of (bad): | |
350 | ||
351 | if (!is_running (ptid)) | |
352 | ||
353 | The latter also returns true on exited threads, most likelly not | |
354 | what you want. */ | |
355 | ||
356 | /* Reports if in the frontend's perpective, thread PTID is running. */ | |
357 | extern int is_running (ptid_t ptid); | |
8ea051c5 | 358 | |
4f8d22e3 PA |
359 | /* Is this thread listed, but known to have exited? We keep it listed |
360 | (but not visible) until it's safe to delete. */ | |
361 | extern int is_exited (ptid_t ptid); | |
362 | ||
0d6431e2 | 363 | /* In the frontend's perpective, is this thread stopped? */ |
4f8d22e3 PA |
364 | extern int is_stopped (ptid_t ptid); |
365 | ||
dfd4cc63 | 366 | /* Marks thread PTID as executing, or not. If ptid_get_pid (PTID) is -1, |
0d6431e2 PA |
367 | marks all threads. |
368 | ||
369 | Note that this is different from the running state. See the | |
30596231 | 370 | description of state and executing fields of struct |
0d6431e2 | 371 | thread_info. */ |
8ea051c5 PA |
372 | extern void set_executing (ptid_t ptid, int executing); |
373 | ||
374 | /* Reports if thread PTID is executing. */ | |
375 | extern int is_executing (ptid_t ptid); | |
376 | ||
29f49a6a PA |
377 | /* Merge the executing property of thread PTID over to its thread |
378 | state property (frontend running/stopped view). | |
379 | ||
380 | "not executing" -> "stopped" | |
381 | "executing" -> "running" | |
382 | "exited" -> "exited" | |
383 | ||
dfd4cc63 | 384 | If ptid_get_pid (PTID) is -1, go over all threads. |
29f49a6a PA |
385 | |
386 | Notifications are only emitted if the thread state did change. */ | |
387 | extern void finish_thread_state (ptid_t ptid); | |
388 | ||
389 | /* Same as FINISH_THREAD_STATE, but with an interface suitable to be | |
390 | registered as a cleanup. PTID_P points to the ptid_t that is | |
391 | passed to FINISH_THREAD_STATE. */ | |
392 | extern void finish_thread_state_cleanup (void *ptid_p); | |
393 | ||
c906108c SS |
394 | /* Commands with a prefix of `thread'. */ |
395 | extern struct cmd_list_element *thread_cmd_list; | |
396 | ||
93815fbf VP |
397 | /* Print notices on thread events (attach, detach, etc.), set with |
398 | `set print thread-events'. */ | |
399 | extern int print_thread_events; | |
400 | ||
aea5b279 | 401 | extern void print_thread_info (struct ui_out *uiout, char *threads, |
3ee1c036 | 402 | int pid); |
8e8901c5 | 403 | |
4f8d22e3 | 404 | extern struct cleanup *make_cleanup_restore_current_thread (void); |
6208b47d | 405 | |
4e1c45ea PA |
406 | /* Returns a pointer into the thread_info corresponding to |
407 | INFERIOR_PTID. INFERIOR_PTID *must* be in the thread list. */ | |
408 | extern struct thread_info* inferior_thread (void); | |
6208b47d | 409 | |
dc146f7c VP |
410 | extern void update_thread_list (void); |
411 | ||
ce4c476a PA |
412 | /* Return true if PC is in the stepping range of THREAD. */ |
413 | ||
414 | int pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread); | |
415 | ||
e5ef252a PA |
416 | extern struct thread_info *thread_list; |
417 | ||
c5aa993b | 418 | #endif /* GDBTHREAD_H */ |