| 1 | /* Multi-process/thread control defs for GDB, the GNU debugger. |
| 2 | Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1997, 1998, 1999, |
| 3 | 2000, 2007, 2008 Free Software Foundation, Inc. |
| 4 | Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA. |
| 5 | |
| 6 | |
| 7 | This file is part of GDB. |
| 8 | |
| 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 |
| 11 | the Free Software Foundation; either version 3 of the License, or |
| 12 | (at your option) any later version. |
| 13 | |
| 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. |
| 18 | |
| 19 | You should have received a copy of the GNU General Public License |
| 20 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
| 21 | |
| 22 | #ifndef GDBTHREAD_H |
| 23 | #define GDBTHREAD_H |
| 24 | |
| 25 | struct symtab; |
| 26 | |
| 27 | #include "breakpoint.h" |
| 28 | #include "frame.h" |
| 29 | #include "ui-out.h" |
| 30 | #include "inferior.h" |
| 31 | |
| 32 | struct thread_info |
| 33 | { |
| 34 | struct thread_info *next; |
| 35 | ptid_t ptid; /* "Actual process id"; |
| 36 | In fact, this may be overloaded with |
| 37 | kernel thread id, etc. */ |
| 38 | int num; /* Convenient handle (GDB thread id) */ |
| 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 | |
| 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 ... } */ |
| 55 | /* This field is internal to thread.c. Never access it directly, |
| 56 | use is_running instead. */ |
| 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; |
| 63 | |
| 64 | /* State from wait_for_inferior */ |
| 65 | CORE_ADDR prev_pc; |
| 66 | struct breakpoint *step_resume_breakpoint; |
| 67 | CORE_ADDR step_range_start; |
| 68 | CORE_ADDR step_range_end; |
| 69 | struct frame_id step_frame_id; |
| 70 | int current_line; |
| 71 | struct symtab *current_symtab; |
| 72 | int trap_expected; |
| 73 | int stepping_over_breakpoint; |
| 74 | |
| 75 | /* This is set TRUE when a catchpoint of a shared library event |
| 76 | triggers. Since we don't wish to leave the inferior in the |
| 77 | solib hook when we report the event, we step the inferior |
| 78 | back to user code before stopping and reporting the event. */ |
| 79 | int stepping_through_solib_after_catch; |
| 80 | |
| 81 | /* When stepping_through_solib_after_catch is TRUE, this is a |
| 82 | list of the catchpoints that should be reported as triggering |
| 83 | when we finally do stop stepping. */ |
| 84 | bpstat stepping_through_solib_catchpoints; |
| 85 | |
| 86 | /* The below are only per-thread in non-stop mode. */ |
| 87 | /* Per-thread command support. */ |
| 88 | struct continuation *continuations; |
| 89 | struct continuation *intermediate_continuations; |
| 90 | int proceed_to_finish; |
| 91 | enum step_over_calls_kind step_over_calls; |
| 92 | int stop_step; |
| 93 | int step_multi; |
| 94 | |
| 95 | enum target_signal stop_signal; |
| 96 | /* Used in continue_command to set the proceed count of the |
| 97 | breakpoint the thread stopped at. */ |
| 98 | bpstat stop_bpstat; |
| 99 | |
| 100 | /* Private data used by the target vector implementation. */ |
| 101 | struct private_thread_info *private; |
| 102 | }; |
| 103 | |
| 104 | /* Create an empty thread list, or empty the existing one. */ |
| 105 | extern void init_thread_list (void); |
| 106 | |
| 107 | /* Add a thread to the thread list, print a message |
| 108 | that a new thread is found, and return the pointer to |
| 109 | the new thread. Caller my use this pointer to |
| 110 | initialize the private thread data. */ |
| 111 | extern struct thread_info *add_thread (ptid_t ptid); |
| 112 | |
| 113 | /* Same as add_thread, but does not print a message |
| 114 | about new thread. */ |
| 115 | extern struct thread_info *add_thread_silent (ptid_t ptid); |
| 116 | |
| 117 | /* Same as add_thread, and sets the private info. */ |
| 118 | extern struct thread_info *add_thread_with_info (ptid_t ptid, |
| 119 | struct private_thread_info *); |
| 120 | |
| 121 | /* Delete an existing thread list entry. */ |
| 122 | extern void delete_thread (ptid_t); |
| 123 | |
| 124 | /* Delete an existing thread list entry, and be quiet about it. Used |
| 125 | after the process this thread having belonged to having already |
| 126 | exited, for example. */ |
| 127 | extern void delete_thread_silent (ptid_t); |
| 128 | |
| 129 | /* Delete a step_resume_breakpoint from the thread database. */ |
| 130 | extern void delete_step_resume_breakpoint (void *); |
| 131 | |
| 132 | /* Translate the integer thread id (GDB's homegrown id, not the system's) |
| 133 | into a "pid" (which may be overloaded with extra thread information). */ |
| 134 | extern ptid_t thread_id_to_pid (int); |
| 135 | |
| 136 | /* Translate a 'pid' (which may be overloaded with extra thread information) |
| 137 | into the integer thread id (GDB's homegrown id, not the system's). */ |
| 138 | extern int pid_to_thread_id (ptid_t ptid); |
| 139 | |
| 140 | /* Boolean test for an already-known pid (which may be overloaded with |
| 141 | extra thread information). */ |
| 142 | extern int in_thread_list (ptid_t ptid); |
| 143 | |
| 144 | /* Boolean test for an already-known thread id (GDB's homegrown id, |
| 145 | not the system's). */ |
| 146 | extern int valid_thread_id (int thread); |
| 147 | |
| 148 | /* Search function to lookup a thread by 'pid'. */ |
| 149 | extern struct thread_info *find_thread_pid (ptid_t ptid); |
| 150 | |
| 151 | /* Find thread by GDB user-visible thread number. */ |
| 152 | struct thread_info *find_thread_id (int num); |
| 153 | |
| 154 | /* Change the ptid of thread OLD_PTID to NEW_PTID. */ |
| 155 | void thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid); |
| 156 | |
| 157 | /* Iterator function to call a user-provided callback function |
| 158 | once for each known thread. */ |
| 159 | typedef int (*thread_callback_func) (struct thread_info *, void *); |
| 160 | extern struct thread_info *iterate_over_threads (thread_callback_func, void *); |
| 161 | |
| 162 | extern int thread_count (void); |
| 163 | |
| 164 | /* infrun context switch: save the debugger state for the given thread. */ |
| 165 | extern void save_infrun_state (ptid_t ptid, |
| 166 | CORE_ADDR prev_pc, |
| 167 | int trap_expected, |
| 168 | struct breakpoint *step_resume_breakpoint, |
| 169 | CORE_ADDR step_range_start, |
| 170 | CORE_ADDR step_range_end, |
| 171 | const struct frame_id *step_frame_id, |
| 172 | int another_trap, |
| 173 | int stepping_through_solib_after_catch, |
| 174 | bpstat stepping_through_solib_catchpoints, |
| 175 | int current_line, |
| 176 | struct symtab *current_symtab, |
| 177 | struct continuation *continuations, |
| 178 | struct continuation *intermediate_continuations, |
| 179 | int proceed_to_finish, |
| 180 | enum step_over_calls_kind step_over_calls, |
| 181 | int stop_step, |
| 182 | int step_multi, |
| 183 | enum target_signal stop_signal, |
| 184 | bpstat stop_bpstat); |
| 185 | |
| 186 | /* infrun context switch: load the debugger state previously saved |
| 187 | for the given thread. */ |
| 188 | extern void load_infrun_state (ptid_t ptid, |
| 189 | CORE_ADDR *prev_pc, |
| 190 | int *trap_expected, |
| 191 | struct breakpoint **step_resume_breakpoint, |
| 192 | CORE_ADDR *step_range_start, |
| 193 | CORE_ADDR *step_range_end, |
| 194 | struct frame_id *step_frame_id, |
| 195 | int *another_trap, |
| 196 | int *stepping_through_solib_after_catch, |
| 197 | bpstat *stepping_through_solib_catchpoints, |
| 198 | int *current_line, |
| 199 | struct symtab **current_symtab, |
| 200 | struct continuation **continuations, |
| 201 | struct continuation **intermediate_continuations, |
| 202 | int *proceed_to_finish, |
| 203 | enum step_over_calls_kind *step_over_calls, |
| 204 | int *stop_step, |
| 205 | int *step_multi, |
| 206 | enum target_signal *stop_signal, |
| 207 | bpstat *stop_bpstat); |
| 208 | |
| 209 | /* Switch from one thread to another. */ |
| 210 | extern void switch_to_thread (ptid_t ptid); |
| 211 | |
| 212 | /* Marks thread PTID is running, or stopped. |
| 213 | If PIDGET (PTID) is -1, marks all threads. */ |
| 214 | extern void set_running (ptid_t ptid, int running); |
| 215 | |
| 216 | /* NOTE: Since the thread state is not a boolean, most times, you do |
| 217 | not want to check it with negation. If you really want to check if |
| 218 | the thread is stopped, |
| 219 | |
| 220 | use (good): |
| 221 | |
| 222 | if (is_stopped (ptid)) |
| 223 | |
| 224 | instead of (bad): |
| 225 | |
| 226 | if (!is_running (ptid)) |
| 227 | |
| 228 | The latter also returns true on exited threads, most likelly not |
| 229 | what you want. */ |
| 230 | |
| 231 | /* Reports if in the frontend's perpective, thread PTID is running. */ |
| 232 | extern int is_running (ptid_t ptid); |
| 233 | |
| 234 | /* Is this thread listed, but known to have exited? We keep it listed |
| 235 | (but not visible) until it's safe to delete. */ |
| 236 | extern int is_exited (ptid_t ptid); |
| 237 | |
| 238 | /* In the frontend's perpective, is this thread stopped? */ |
| 239 | extern int is_stopped (ptid_t ptid); |
| 240 | |
| 241 | /* In the frontend's perpective is there any thread running? */ |
| 242 | extern int any_running (void); |
| 243 | |
| 244 | /* Marks thread PTID as executing, or not. If PIDGET (PTID) is -1, |
| 245 | marks all threads. |
| 246 | |
| 247 | Note that this is different from the running state. See the |
| 248 | description of state_ and executing_ fields of struct |
| 249 | thread_info. */ |
| 250 | extern void set_executing (ptid_t ptid, int executing); |
| 251 | |
| 252 | /* Reports if thread PTID is executing. */ |
| 253 | extern int is_executing (ptid_t ptid); |
| 254 | |
| 255 | /* Commands with a prefix of `thread'. */ |
| 256 | extern struct cmd_list_element *thread_cmd_list; |
| 257 | |
| 258 | /* Print notices on thread events (attach, detach, etc.), set with |
| 259 | `set print thread-events'. */ |
| 260 | extern int print_thread_events; |
| 261 | |
| 262 | extern void print_thread_info (struct ui_out *uiout, int thread); |
| 263 | |
| 264 | extern struct cleanup *make_cleanup_restore_current_thread (void); |
| 265 | |
| 266 | |
| 267 | #endif /* GDBTHREAD_H */ |