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