| 1 | /* Multi-process/thread control defs for GDB, the GNU debugger. |
| 2 | Copyright (C) 1987-2014 Free Software Foundation, Inc. |
| 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" |
| 30 | #include "btrace.h" |
| 31 | |
| 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 | |
| 41 | /* Inferior thread specific part of `struct infcall_control_state'. |
| 42 | |
| 43 | Inferior process counterpart is `struct inferior_control_state'. */ |
| 44 | |
| 45 | struct thread_control_state |
| 46 | { |
| 47 | /* User/external stepping state. */ |
| 48 | |
| 49 | /* Step-resume or longjmp-resume breakpoint. */ |
| 50 | struct breakpoint *step_resume_breakpoint; |
| 51 | |
| 52 | /* Exception-resume breakpoint. */ |
| 53 | struct breakpoint *exception_resume_breakpoint; |
| 54 | |
| 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 |
| 64 | not). */ |
| 65 | CORE_ADDR step_range_start; /* Inclusive */ |
| 66 | CORE_ADDR step_range_end; /* Exclusive */ |
| 67 | |
| 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 | |
| 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. */ |
| 79 | struct frame_id step_frame_id; |
| 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 | |
| 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. */ |
| 107 | int trap_expected; |
| 108 | |
| 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; |
| 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; |
| 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). */ |
| 139 | enum gdb_signal stop_signal; |
| 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 | |
| 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 | |
| 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. */ |
| 158 | int executing; |
| 159 | |
| 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; |
| 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 | |
| 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 | |
| 191 | /* Should we step over breakpoint next time keep_going is called? */ |
| 192 | int stepping_over_breakpoint; |
| 193 | |
| 194 | /* Set to TRUE if we should finish single-stepping over a breakpoint |
| 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. */ |
| 203 | int step_after_step_resume_breakpoint; |
| 204 | |
| 205 | /* Per-thread command support. */ |
| 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. */ |
| 210 | struct continuation *continuations; |
| 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. */ |
| 215 | struct continuation *intermediate_continuations; |
| 216 | |
| 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. */ |
| 219 | int step_multi; |
| 220 | |
| 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 | |
| 226 | /* True if this thread has been explicitly requested to stop. */ |
| 227 | int stop_requested; |
| 228 | |
| 229 | /* The initiating frame of a nexting operation, used for deciding |
| 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. */ |
| 233 | struct frame_id initiating_frame; |
| 234 | |
| 235 | /* Private data used by the target vector implementation. */ |
| 236 | struct private_thread_info *private; |
| 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 *); |
| 241 | |
| 242 | /* Branch trace information for this thread. */ |
| 243 | struct btrace_thread_info btrace; |
| 244 | }; |
| 245 | |
| 246 | /* Create an empty thread list, or empty the existing one. */ |
| 247 | extern void init_thread_list (void); |
| 248 | |
| 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. */ |
| 253 | extern struct thread_info *add_thread (ptid_t ptid); |
| 254 | |
| 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 | |
| 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 | |
| 263 | /* Delete an existing thread list entry. */ |
| 264 | extern void delete_thread (ptid_t); |
| 265 | |
| 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 | |
| 271 | /* Delete a step_resume_breakpoint from the thread database. */ |
| 272 | extern void delete_step_resume_breakpoint (struct thread_info *); |
| 273 | |
| 274 | /* Delete an exception_resume_breakpoint from the thread database. */ |
| 275 | extern void delete_exception_resume_breakpoint (struct thread_info *); |
| 276 | |
| 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). */ |
| 279 | extern ptid_t thread_id_to_pid (int); |
| 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). */ |
| 283 | extern int pid_to_thread_id (ptid_t ptid); |
| 284 | |
| 285 | /* Boolean test for an already-known pid (which may be overloaded with |
| 286 | extra thread information). */ |
| 287 | extern int in_thread_list (ptid_t ptid); |
| 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'. */ |
| 294 | extern struct thread_info *find_thread_ptid (ptid_t ptid); |
| 295 | |
| 296 | /* Find thread by GDB user-visible thread number. */ |
| 297 | struct thread_info *find_thread_id (int num); |
| 298 | |
| 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 | |
| 303 | /* Returns any thread of process PID. */ |
| 304 | extern struct thread_info *any_thread_of_process (int pid); |
| 305 | |
| 306 | /* Returns any non-exited thread of process PID, giving preference for |
| 307 | not executing threads. */ |
| 308 | extern struct thread_info *any_live_thread_of_process (int pid); |
| 309 | |
| 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 | |
| 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 | |
| 318 | /* Traverse all threads, except those that have THREAD_EXITED |
| 319 | state. */ |
| 320 | |
| 321 | #define ALL_NON_EXITED_THREADS(T) \ |
| 322 | for (T = thread_list; T; T = T->next) \ |
| 323 | if ((T)->state != THREAD_EXITED) |
| 324 | |
| 325 | extern int thread_count (void); |
| 326 | |
| 327 | /* Switch from one thread to another. */ |
| 328 | extern void switch_to_thread (ptid_t ptid); |
| 329 | |
| 330 | /* Marks thread PTID is running, or stopped. |
| 331 | If ptid_get_pid (PTID) is -1, marks all threads. */ |
| 332 | extern void set_running (ptid_t ptid, int running); |
| 333 | |
| 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 | |
| 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, |
| 344 | |
| 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); |
| 358 | |
| 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 | |
| 363 | /* In the frontend's perpective, is this thread stopped? */ |
| 364 | extern int is_stopped (ptid_t ptid); |
| 365 | |
| 366 | /* Marks thread PTID as executing, or not. If ptid_get_pid (PTID) is -1, |
| 367 | marks all threads. |
| 368 | |
| 369 | Note that this is different from the running state. See the |
| 370 | description of state and executing fields of struct |
| 371 | thread_info. */ |
| 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 | |
| 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 | |
| 384 | If ptid_get_pid (PTID) is -1, go over all threads. |
| 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 | |
| 394 | /* Commands with a prefix of `thread'. */ |
| 395 | extern struct cmd_list_element *thread_cmd_list; |
| 396 | |
| 397 | /* Print notices on thread events (attach, detach, etc.), set with |
| 398 | `set print thread-events'. */ |
| 399 | extern int print_thread_events; |
| 400 | |
| 401 | extern void print_thread_info (struct ui_out *uiout, char *threads, |
| 402 | int pid); |
| 403 | |
| 404 | extern struct cleanup *make_cleanup_restore_current_thread (void); |
| 405 | |
| 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); |
| 409 | |
| 410 | extern void update_thread_list (void); |
| 411 | |
| 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 | |
| 416 | extern struct thread_info *thread_list; |
| 417 | |
| 418 | #endif /* GDBTHREAD_H */ |