Commit | Line | Data |
---|---|---|
c906108c | 1 | /* Multi-process/thread control defs for GDB, the GNU debugger. |
197e01b6 | 2 | Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1997, 1998, 1999, |
9b254dd1 | 3 | 2000, 2007, 2008 Free Software Foundation, Inc. |
b6ba6518 KB |
4 | Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA. |
5 | ||
c906108c | 6 | |
c5aa993b | 7 | This file is part of GDB. |
c906108c | 8 | |
c5aa993b JM |
9 | This program is free software; you can redistribute it and/or modify |
10 | it under the terms of the GNU General Public License as published by | |
a9762ec7 | 11 | the Free Software Foundation; either version 3 of the License, or |
c5aa993b | 12 | (at your option) any later version. |
c906108c | 13 | |
c5aa993b JM |
14 | This program is distributed in the hope that it will be useful, |
15 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | GNU General Public License for more details. | |
c906108c | 18 | |
c5aa993b | 19 | You should have received a copy of the GNU General Public License |
a9762ec7 | 20 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
c906108c SS |
21 | |
22 | #ifndef GDBTHREAD_H | |
23 | #define GDBTHREAD_H | |
24 | ||
da3331ec AC |
25 | struct symtab; |
26 | ||
c906108c | 27 | #include "breakpoint.h" |
aa0cd9c1 | 28 | #include "frame.h" |
8e8901c5 | 29 | #include "ui-out.h" |
a474d7c2 | 30 | #include "inferior.h" |
8e8901c5 | 31 | |
0d06e24b JM |
32 | struct thread_info |
33 | { | |
34 | struct thread_info *next; | |
39f77062 | 35 | ptid_t ptid; /* "Actual process id"; |
0d06e24b JM |
36 | In fact, this may be overloaded with |
37 | kernel thread id, etc. */ | |
38 | int num; /* Convenient handle (GDB thread id) */ | |
8ea051c5 PA |
39 | |
40 | /* Non-zero means the thread is executing. Note: this is different | |
41 | from saying that there is an active target and we are stopped at | |
42 | a breakpoint, for instance. This is a real indicator whether the | |
43 | thread is off and running. */ | |
44 | /* This field is internal to thread.c. Never access it directly, | |
45 | use is_executing instead. */ | |
46 | int executing_; | |
47 | ||
4f8d22e3 PA |
48 | /* Frontend view of the thread state. Note that the RUNNING/STOPPED |
49 | states are different from EXECUTING. When the thread is stopped | |
50 | internally while handling an internal event, like a software | |
51 | single-step breakpoint, EXECUTING will be false, but running will | |
52 | still be true. As a possible future extension, this could turn | |
53 | into enum { stopped, exited, stepping, finishing, until(ling), | |
54 | running ... } */ | |
8ea051c5 PA |
55 | /* This field is internal to thread.c. Never access it directly, |
56 | use is_running instead. */ | |
4f8d22e3 PA |
57 | int state_; |
58 | ||
59 | /* If this is > 0, then it means there's code out there that relies | |
60 | on this thread being listed. Don't delete it from the lists even | |
61 | if we detect it exiting. */ | |
62 | int refcount; | |
8ea051c5 | 63 | |
4e1c45ea PA |
64 | /* User/external stepping state. */ |
65 | ||
66 | /* Step-resume or longjmp-resume breakpoint. */ | |
0d06e24b | 67 | struct breakpoint *step_resume_breakpoint; |
4e1c45ea PA |
68 | |
69 | /* Range to single step within. | |
70 | ||
71 | If this is nonzero, respond to a single-step signal by continuing | |
72 | to step if the pc is in this range. | |
73 | ||
74 | If step_range_start and step_range_end are both 1, it means to | |
75 | step for a single instruction (FIXME: it might clean up | |
76 | wait_for_inferior in a minor way if this were changed to the | |
77 | address of the instruction and that address plus one. But maybe | |
78 | not.). */ | |
79 | CORE_ADDR step_range_start; /* Inclusive */ | |
80 | CORE_ADDR step_range_end; /* Exclusive */ | |
81 | ||
82 | /* Stack frame address as of when stepping command was issued. | |
83 | This is how we know when we step into a subroutine call, and how | |
84 | to set the frame for the breakpoint used to step out. */ | |
aa0cd9c1 | 85 | struct frame_id step_frame_id; |
6c0d3f6a MS |
86 | int current_line; |
87 | struct symtab *current_symtab; | |
4e1c45ea PA |
88 | |
89 | /* Internal stepping state. */ | |
90 | ||
91 | /* Record the pc of the thread the last time it stopped. This is | |
92 | maintained by proceed and keep_going, and used in | |
93 | adjust_pc_after_break to distinguish a hardware single-step | |
94 | SIGTRAP from a breakpoint SIGTRAP. */ | |
95 | CORE_ADDR prev_pc; | |
96 | ||
97 | /* Nonzero if we are presently stepping over a breakpoint. | |
98 | ||
99 | If we hit a breakpoint or watchpoint, and then continue, we need | |
100 | to single step the current thread with breakpoints disabled, to | |
101 | avoid hitting the same breakpoint or watchpoint again. And we | |
102 | should step just a single thread and keep other threads stopped, | |
103 | so that other threads don't miss breakpoints while they are | |
104 | removed. | |
105 | ||
106 | So, this variable simultaneously means that we need to single | |
107 | step the current thread, keep other threads stopped, and that | |
108 | breakpoints should be removed while we step. | |
109 | ||
110 | This variable is set either: | |
111 | - in proceed, when we resume inferior on user's explicit request | |
112 | - in keep_going, if handle_inferior_event decides we need to | |
113 | step over breakpoint. | |
114 | ||
115 | The variable is cleared in normal_stop. The proceed calls | |
116 | wait_for_inferior, which calls handle_inferior_event in a loop, | |
117 | and until wait_for_inferior exits, this variable is changed only | |
118 | by keep_going. */ | |
0d06e24b | 119 | int trap_expected; |
4e1c45ea PA |
120 | |
121 | /* Should we step over breakpoint next time keep_going is called? */ | |
ca67fcb8 | 122 | int stepping_over_breakpoint; |
0d06e24b | 123 | |
4e1c45ea PA |
124 | /* Set to TRUE if we should finish single-stepping over a breakpoint |
125 | after hitting the current step-resume breakpoint. */ | |
126 | int step_after_step_resume_breakpoint; | |
127 | ||
0d06e24b JM |
128 | /* This is set TRUE when a catchpoint of a shared library event |
129 | triggers. Since we don't wish to leave the inferior in the | |
130 | solib hook when we report the event, we step the inferior | |
131 | back to user code before stopping and reporting the event. */ | |
132 | int stepping_through_solib_after_catch; | |
133 | ||
134 | /* When stepping_through_solib_after_catch is TRUE, this is a | |
135 | list of the catchpoints that should be reported as triggering | |
136 | when we finally do stop stepping. */ | |
137 | bpstat stepping_through_solib_catchpoints; | |
138 | ||
a474d7c2 PA |
139 | /* The below are only per-thread in non-stop mode. */ |
140 | /* Per-thread command support. */ | |
141 | struct continuation *continuations; | |
142 | struct continuation *intermediate_continuations; | |
32400beb PA |
143 | |
144 | /* Nonzero if the thread is being proceeded for a "finish" command | |
145 | or a similar situation when stop_registers should be saved. */ | |
a474d7c2 | 146 | int proceed_to_finish; |
32400beb | 147 | |
a474d7c2 PA |
148 | enum step_over_calls_kind step_over_calls; |
149 | int stop_step; | |
150 | int step_multi; | |
151 | ||
152 | enum target_signal stop_signal; | |
347bddb7 PA |
153 | |
154 | /* Chain containing status of breakpoint(s) the thread stopped | |
155 | at. */ | |
a474d7c2 PA |
156 | bpstat stop_bpstat; |
157 | ||
0d06e24b JM |
158 | /* Private data used by the target vector implementation. */ |
159 | struct private_thread_info *private; | |
160 | }; | |
161 | ||
162 | /* Create an empty thread list, or empty the existing one. */ | |
163 | extern void init_thread_list (void); | |
164 | ||
93815fbf VP |
165 | /* Add a thread to the thread list, print a message |
166 | that a new thread is found, and return the pointer to | |
167 | the new thread. Caller my use this pointer to | |
168 | initialize the private thread data. */ | |
39f77062 | 169 | extern struct thread_info *add_thread (ptid_t ptid); |
0d06e24b | 170 | |
93815fbf VP |
171 | /* Same as add_thread, but does not print a message |
172 | about new thread. */ | |
173 | extern struct thread_info *add_thread_silent (ptid_t ptid); | |
174 | ||
17faa917 DJ |
175 | /* Same as add_thread, and sets the private info. */ |
176 | extern struct thread_info *add_thread_with_info (ptid_t ptid, | |
177 | struct private_thread_info *); | |
178 | ||
0d06e24b | 179 | /* Delete an existing thread list entry. */ |
39f77062 | 180 | extern void delete_thread (ptid_t); |
0d06e24b | 181 | |
5e0b29c1 PA |
182 | /* Delete an existing thread list entry, and be quiet about it. Used |
183 | after the process this thread having belonged to having already | |
184 | exited, for example. */ | |
185 | extern void delete_thread_silent (ptid_t); | |
186 | ||
8601f500 | 187 | /* Delete a step_resume_breakpoint from the thread database. */ |
4e1c45ea | 188 | extern void delete_step_resume_breakpoint (struct thread_info *); |
8601f500 | 189 | |
0d06e24b JM |
190 | /* Translate the integer thread id (GDB's homegrown id, not the system's) |
191 | into a "pid" (which may be overloaded with extra thread information). */ | |
39f77062 | 192 | extern ptid_t thread_id_to_pid (int); |
0d06e24b JM |
193 | |
194 | /* Translate a 'pid' (which may be overloaded with extra thread information) | |
195 | into the integer thread id (GDB's homegrown id, not the system's). */ | |
39f77062 | 196 | extern int pid_to_thread_id (ptid_t ptid); |
0d06e24b JM |
197 | |
198 | /* Boolean test for an already-known pid (which may be overloaded with | |
199 | extra thread information). */ | |
39f77062 | 200 | extern int in_thread_list (ptid_t ptid); |
0d06e24b JM |
201 | |
202 | /* Boolean test for an already-known thread id (GDB's homegrown id, | |
203 | not the system's). */ | |
204 | extern int valid_thread_id (int thread); | |
205 | ||
206 | /* Search function to lookup a thread by 'pid'. */ | |
39f77062 | 207 | extern struct thread_info *find_thread_pid (ptid_t ptid); |
0d06e24b | 208 | |
1e92afda VP |
209 | /* Find thread by GDB user-visible thread number. */ |
210 | struct thread_info *find_thread_id (int num); | |
211 | ||
5231c1fd PA |
212 | /* Change the ptid of thread OLD_PTID to NEW_PTID. */ |
213 | void thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid); | |
214 | ||
0d06e24b JM |
215 | /* Iterator function to call a user-provided callback function |
216 | once for each known thread. */ | |
217 | typedef int (*thread_callback_func) (struct thread_info *, void *); | |
218 | extern struct thread_info *iterate_over_threads (thread_callback_func, void *); | |
219 | ||
20874c92 VP |
220 | extern int thread_count (void); |
221 | ||
0d06e24b | 222 | /* infrun context switch: save the debugger state for the given thread. */ |
39f77062 | 223 | extern void save_infrun_state (ptid_t ptid, |
a474d7c2 PA |
224 | struct continuation *continuations, |
225 | struct continuation *intermediate_continuations, | |
a474d7c2 PA |
226 | int stop_step, |
227 | int step_multi, | |
347bddb7 | 228 | enum target_signal stop_signal); |
0d06e24b JM |
229 | |
230 | /* infrun context switch: load the debugger state previously saved | |
231 | for the given thread. */ | |
39f77062 | 232 | extern void load_infrun_state (ptid_t ptid, |
a474d7c2 PA |
233 | struct continuation **continuations, |
234 | struct continuation **intermediate_continuations, | |
a474d7c2 PA |
235 | int *stop_step, |
236 | int *step_multi, | |
347bddb7 | 237 | enum target_signal *stop_signal); |
c906108c | 238 | |
6a6b96b9 UW |
239 | /* Switch from one thread to another. */ |
240 | extern void switch_to_thread (ptid_t ptid); | |
241 | ||
e1ac3328 VP |
242 | /* Marks thread PTID is running, or stopped. |
243 | If PIDGET (PTID) is -1, marks all threads. */ | |
244 | extern void set_running (ptid_t ptid, int running); | |
245 | ||
0d6431e2 PA |
246 | /* NOTE: Since the thread state is not a boolean, most times, you do |
247 | not want to check it with negation. If you really want to check if | |
248 | the thread is stopped, | |
e1ac3328 | 249 | |
0d6431e2 PA |
250 | use (good): |
251 | ||
252 | if (is_stopped (ptid)) | |
253 | ||
254 | instead of (bad): | |
255 | ||
256 | if (!is_running (ptid)) | |
257 | ||
258 | The latter also returns true on exited threads, most likelly not | |
259 | what you want. */ | |
260 | ||
261 | /* Reports if in the frontend's perpective, thread PTID is running. */ | |
262 | extern int is_running (ptid_t ptid); | |
8ea051c5 | 263 | |
4f8d22e3 PA |
264 | /* Is this thread listed, but known to have exited? We keep it listed |
265 | (but not visible) until it's safe to delete. */ | |
266 | extern int is_exited (ptid_t ptid); | |
267 | ||
0d6431e2 | 268 | /* In the frontend's perpective, is this thread stopped? */ |
4f8d22e3 PA |
269 | extern int is_stopped (ptid_t ptid); |
270 | ||
0d6431e2 PA |
271 | /* In the frontend's perpective is there any thread running? */ |
272 | extern int any_running (void); | |
273 | ||
274 | /* Marks thread PTID as executing, or not. If PIDGET (PTID) is -1, | |
275 | marks all threads. | |
276 | ||
277 | Note that this is different from the running state. See the | |
278 | description of state_ and executing_ fields of struct | |
279 | thread_info. */ | |
8ea051c5 PA |
280 | extern void set_executing (ptid_t ptid, int executing); |
281 | ||
282 | /* Reports if thread PTID is executing. */ | |
283 | extern int is_executing (ptid_t ptid); | |
284 | ||
c906108c SS |
285 | /* Commands with a prefix of `thread'. */ |
286 | extern struct cmd_list_element *thread_cmd_list; | |
287 | ||
93815fbf VP |
288 | /* Print notices on thread events (attach, detach, etc.), set with |
289 | `set print thread-events'. */ | |
290 | extern int print_thread_events; | |
291 | ||
8e8901c5 VP |
292 | extern void print_thread_info (struct ui_out *uiout, int thread); |
293 | ||
4f8d22e3 | 294 | extern struct cleanup *make_cleanup_restore_current_thread (void); |
6208b47d | 295 | |
4e1c45ea PA |
296 | /* Returns a pointer into the thread_info corresponding to |
297 | INFERIOR_PTID. INFERIOR_PTID *must* be in the thread list. */ | |
298 | extern struct thread_info* inferior_thread (void); | |
6208b47d | 299 | |
c5aa993b | 300 | #endif /* GDBTHREAD_H */ |