gdbthread.h revision 1.5
1/* Multi-process/thread control defs for GDB, the GNU debugger. 2 Copyright (C) 1987-2015 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 24struct symtab; 25 26#include "breakpoint.h" 27#include "frame.h" 28#include "ui-out.h" 29#include "inferior.h" 30#include "btrace.h" 31#include "common/vec.h" 32 33/* Frontend view of the thread state. Possible extensions: stepping, 34 finishing, until(ling),... */ 35enum thread_state 36{ 37 THREAD_STOPPED, 38 THREAD_RUNNING, 39 THREAD_EXITED, 40}; 41 42/* Inferior thread specific part of `struct infcall_control_state'. 43 44 Inferior process counterpart is `struct inferior_control_state'. */ 45 46struct thread_control_state 47{ 48 /* User/external stepping state. */ 49 50 /* Step-resume or longjmp-resume breakpoint. */ 51 struct breakpoint *step_resume_breakpoint; 52 53 /* Exception-resume breakpoint. */ 54 struct breakpoint *exception_resume_breakpoint; 55 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 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 72 not). */ 73 CORE_ADDR step_range_start; /* Inclusive */ 74 CORE_ADDR step_range_end; /* Exclusive */ 75 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 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 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 120 /* Nonzero if the thread is being proceeded for a "finish" command 121 or a similar situation when return value should be printed. */ 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; 136 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; 141 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'. */ 149 150struct thread_suspend_state 151{ 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. */ 159 enum gdb_signal stop_signal; 160}; 161 162typedef struct value *value_ptr; 163DEF_VEC_P (value_ptr); 164typedef VEC (value_ptr) value_vec; 165 166struct 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. */ 182 int executing; 183 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; 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 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 220 /* Should we step over breakpoint next time keep_going is called? */ 221 int stepping_over_breakpoint; 222 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 228 /* Set to TRUE if we should finish single-stepping over a breakpoint 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. */ 237 int step_after_step_resume_breakpoint; 238 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 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 260 /* True if this thread has been explicitly requested to stop. */ 261 int stop_requested; 262 263 /* The initiating frame of a nexting operation, used for deciding 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. */ 267 struct frame_id initiating_frame; 268 269 /* Private data used by the target vector implementation. */ 270 struct private_thread_info *priv; 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 *); 275 276 /* Branch trace information for this thread. */ 277 struct btrace_thread_info btrace; 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; 286}; 287 288/* Create an empty thread list, or empty the existing one. */ 289extern 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. */ 295extern struct thread_info *add_thread (ptid_t ptid); 296 297/* Same as add_thread, but does not print a message 298 about new thread. */ 299extern struct thread_info *add_thread_silent (ptid_t ptid); 300 301/* Same as add_thread, and sets the private info. */ 302extern struct thread_info *add_thread_with_info (ptid_t ptid, 303 struct private_thread_info *); 304 305/* Delete an existing thread list entry. */ 306extern 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. */ 311extern void delete_thread_silent (ptid_t); 312 313/* Delete a step_resume_breakpoint from the thread database. */ 314extern void delete_step_resume_breakpoint (struct thread_info *); 315 316/* Delete an exception_resume_breakpoint from the thread database. */ 317extern void delete_exception_resume_breakpoint (struct thread_info *); 318 319/* Delete the single-step breakpoints of thread TP, if any. */ 320extern void delete_single_step_breakpoints (struct thread_info *tp); 321 322/* Check if the thread has software single stepping breakpoints 323 set. */ 324extern 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. */ 328extern int thread_has_single_step_breakpoint_here (struct thread_info *tp, 329 struct address_space *aspace, 330 CORE_ADDR addr); 331 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). */ 334extern 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). */ 338extern 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). */ 342extern 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). */ 346extern int valid_thread_id (int thread); 347 348/* Search function to lookup a thread by 'pid'. */ 349extern struct thread_info *find_thread_ptid (ptid_t ptid); 350 351/* Find thread by GDB user-visible thread number. */ 352struct 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. */ 356struct thread_info *first_thread_of_process (int pid); 357 358/* Returns any thread of process PID, giving preference to the current 359 thread. */ 360extern struct thread_info *any_thread_of_process (int pid); 361 362/* Returns any non-exited thread of process PID, giving preference to 363 the current thread, and to not executing threads. */ 364extern struct thread_info *any_live_thread_of_process (int pid); 365 366/* Change the ptid of thread OLD_PTID to NEW_PTID. */ 367void 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. */ 371typedef int (*thread_callback_func) (struct thread_info *, void *); 372extern struct thread_info *iterate_over_threads (thread_callback_func, void *); 373 374/* Traverse all threads, except those that have THREAD_EXITED 375 state. */ 376 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)) 387 388extern int thread_count (void); 389 390/* Switch from one thread to another. */ 391extern void switch_to_thread (ptid_t ptid); 392 393/* Marks thread PTID is running, or stopped. 394 If PTID is minus_one_ptid, marks all threads. */ 395extern 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. */ 402extern 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. */ 420extern 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. */ 424extern int is_exited (ptid_t ptid); 425 426/* In the frontend's perpective, is this thread stopped? */ 427extern int is_stopped (ptid_t ptid); 428 429/* Marks thread PTID as executing, or not. If PTID is minus_one_ptid, 430 marks all threads. 431 432 Note that this is different from the running state. See the 433 description of state and executing fields of struct 434 thread_info. */ 435extern void set_executing (ptid_t ptid, int executing); 436 437/* Reports if thread PTID is executing. */ 438extern int is_executing (ptid_t ptid); 439 440/* True if any (known or unknown) thread is or may be executing. */ 441extern int threads_are_executing (void); 442 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 450 If PTID is minus_one_ptid, go over all threads. 451 452 Notifications are only emitted if the thread state did change. */ 453extern 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. */ 458extern void finish_thread_state_cleanup (void *ptid_p); 459 460/* Commands with a prefix of `thread'. */ 461extern struct cmd_list_element *thread_cmd_list; 462 463extern void thread_command (char *tidstr, int from_tty); 464 465/* Print notices on thread events (attach, detach, etc.), set with 466 `set print thread-events'. */ 467extern int print_thread_events; 468 469extern void print_thread_info (struct ui_out *uiout, char *threads, 470 int pid); 471 472extern 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. */ 476extern struct thread_info* inferior_thread (void); 477 478extern void update_thread_list (void); 479 480/* Delete any thread the target says is no longer alive. */ 481 482extern 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. */ 487extern void delete_exited_threads (void); 488 489/* Return true if PC is in the stepping range of THREAD. */ 490 491int pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread); 492 493extern struct cleanup *enable_thread_stack_temporaries (ptid_t ptid); 494 495extern int thread_stack_temporaries_enabled_p (ptid_t ptid); 496 497extern void push_thread_stack_temporary (ptid_t ptid, struct value *v); 498 499extern struct value *get_last_thread_stack_temporary (ptid_t); 500 501extern int value_in_thread_stack_temporaries (struct value *, ptid_t); 502 503extern struct thread_info *thread_list; 504 505#endif /* GDBTHREAD_H */ 506