| 1 | /* Copyright (C) 1986-2017 Free Software Foundation, Inc. |
| 2 | |
| 3 | This file is part of GDB. |
| 4 | |
| 5 | This program is free software; you can redistribute it and/or modify |
| 6 | it under the terms of the GNU General Public License as published by |
| 7 | the Free Software Foundation; either version 3 of the License, or |
| 8 | (at your option) any later version. |
| 9 | |
| 10 | This program is distributed in the hope that it will be useful, |
| 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 13 | GNU General Public License for more details. |
| 14 | |
| 15 | You should have received a copy of the GNU General Public License |
| 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
| 17 | |
| 18 | #ifndef INFRUN_H |
| 19 | #define INFRUN_H 1 |
| 20 | |
| 21 | #include "symtab.h" |
| 22 | #include "common/byte-vector.h" |
| 23 | |
| 24 | struct target_waitstatus; |
| 25 | struct frame_info; |
| 26 | struct address_space; |
| 27 | struct return_value_info; |
| 28 | |
| 29 | /* True if we are debugging run control. */ |
| 30 | extern unsigned int debug_infrun; |
| 31 | |
| 32 | /* True if we are debugging displaced stepping. */ |
| 33 | extern int debug_displaced; |
| 34 | |
| 35 | /* Nonzero if we want to give control to the user when we're notified |
| 36 | of shared library events by the dynamic linker. */ |
| 37 | extern int stop_on_solib_events; |
| 38 | |
| 39 | /* True if execution commands resume all threads of all processes by |
| 40 | default; otherwise, resume only threads of the current inferior |
| 41 | process. */ |
| 42 | extern int sched_multi; |
| 43 | |
| 44 | /* When set, stop the 'step' command if we enter a function which has |
| 45 | no line number information. The normal behavior is that we step |
| 46 | over such function. */ |
| 47 | extern int step_stop_if_no_debug; |
| 48 | |
| 49 | /* If set, the inferior should be controlled in non-stop mode. In |
| 50 | this mode, each thread is controlled independently. Execution |
| 51 | commands apply only to the selected thread by default, and stop |
| 52 | events stop only the thread that had the event -- the other threads |
| 53 | are kept running freely. */ |
| 54 | extern int non_stop; |
| 55 | |
| 56 | /* When set (default), the target should attempt to disable the |
| 57 | operating system's address space randomization feature when |
| 58 | starting an inferior. */ |
| 59 | extern int disable_randomization; |
| 60 | |
| 61 | /* Returns a unique identifier for the current stop. This can be used |
| 62 | to tell whether a command has proceeded the inferior past the |
| 63 | current location. */ |
| 64 | extern ULONGEST get_stop_id (void); |
| 65 | |
| 66 | /* Reverse execution. */ |
| 67 | enum exec_direction_kind |
| 68 | { |
| 69 | EXEC_FORWARD, |
| 70 | EXEC_REVERSE |
| 71 | }; |
| 72 | |
| 73 | /* The current execution direction. */ |
| 74 | extern enum exec_direction_kind execution_direction; |
| 75 | |
| 76 | extern void start_remote (int from_tty); |
| 77 | |
| 78 | /* Clear out all variables saying what to do when inferior is |
| 79 | continued or stepped. First do this, then set the ones you want, |
| 80 | then call `proceed'. STEP indicates whether we're preparing for a |
| 81 | step/stepi command. */ |
| 82 | extern void clear_proceed_status (int step); |
| 83 | |
| 84 | extern void proceed (CORE_ADDR, enum gdb_signal); |
| 85 | |
| 86 | /* The `resume' routine should only be called in special circumstances. |
| 87 | Normally, use `proceed', which handles a lot of bookkeeping. */ |
| 88 | extern void resume (enum gdb_signal); |
| 89 | |
| 90 | /* Return a ptid representing the set of threads that we will proceed, |
| 91 | in the perspective of the user/frontend. We may actually resume |
| 92 | fewer threads at first, e.g., if a thread is stopped at a |
| 93 | breakpoint that needs stepping-off, but that should not be visible |
| 94 | to the user/frontend, and neither should the frontend/user be |
| 95 | allowed to proceed any of the threads that happen to be stopped for |
| 96 | internal run control handling, if a previous command wanted them |
| 97 | resumed. */ |
| 98 | extern ptid_t user_visible_resume_ptid (int step); |
| 99 | |
| 100 | extern void wait_for_inferior (void); |
| 101 | |
| 102 | /* Return control to GDB when the inferior stops for real. Print |
| 103 | appropriate messages, remove breakpoints, give terminal our modes, |
| 104 | and run the stop hook. Returns true if the stop hook proceeded the |
| 105 | target, false otherwise. */ |
| 106 | extern int normal_stop (void); |
| 107 | |
| 108 | extern void get_last_target_status (ptid_t *ptid, |
| 109 | struct target_waitstatus *status); |
| 110 | |
| 111 | extern void set_last_target_status (ptid_t ptid, |
| 112 | struct target_waitstatus status); |
| 113 | |
| 114 | /* Stop all threads. Only returns after everything is halted. */ |
| 115 | extern void stop_all_threads (void); |
| 116 | |
| 117 | extern void prepare_for_detach (void); |
| 118 | |
| 119 | extern void fetch_inferior_event (void *); |
| 120 | |
| 121 | extern void init_wait_for_inferior (void); |
| 122 | |
| 123 | extern void insert_step_resume_breakpoint_at_sal (struct gdbarch *, |
| 124 | struct symtab_and_line , |
| 125 | struct frame_id); |
| 126 | |
| 127 | /* Returns true if we're trying to step past the instruction at |
| 128 | ADDRESS in ASPACE. */ |
| 129 | extern int stepping_past_instruction_at (struct address_space *aspace, |
| 130 | CORE_ADDR address); |
| 131 | |
| 132 | /* Returns true if thread whose thread number is THREAD is stepping |
| 133 | over a breakpoint. */ |
| 134 | extern int thread_is_stepping_over_breakpoint (int thread); |
| 135 | |
| 136 | /* Returns true if we're trying to step past an instruction that |
| 137 | triggers a non-steppable watchpoint. */ |
| 138 | extern int stepping_past_nonsteppable_watchpoint (void); |
| 139 | |
| 140 | extern void set_step_info (struct frame_info *frame, |
| 141 | struct symtab_and_line sal); |
| 142 | |
| 143 | /* Several print_*_reason helper functions to print why the inferior |
| 144 | has stopped to the passed in UIOUT. */ |
| 145 | |
| 146 | /* Signal received, print why the inferior has stopped. */ |
| 147 | extern void print_signal_received_reason (struct ui_out *uiout, |
| 148 | enum gdb_signal siggnal); |
| 149 | |
| 150 | /* Print why the inferior has stopped. We are done with a |
| 151 | step/next/si/ni command, print why the inferior has stopped. */ |
| 152 | extern void print_end_stepping_range_reason (struct ui_out *uiout); |
| 153 | |
| 154 | /* The inferior was terminated by a signal, print why it stopped. */ |
| 155 | extern void print_signal_exited_reason (struct ui_out *uiout, |
| 156 | enum gdb_signal siggnal); |
| 157 | |
| 158 | /* The inferior program is finished, print why it stopped. */ |
| 159 | extern void print_exited_reason (struct ui_out *uiout, int exitstatus); |
| 160 | |
| 161 | /* Reverse execution: target ran out of history info, print why the |
| 162 | inferior has stopped. */ |
| 163 | extern void print_no_history_reason (struct ui_out *uiout); |
| 164 | |
| 165 | /* Print the result of a function at the end of a 'finish' command. |
| 166 | RV points at an object representing the captured return value/type |
| 167 | and its position in the value history. */ |
| 168 | |
| 169 | extern void print_return_value (struct ui_out *uiout, |
| 170 | struct return_value_info *rv); |
| 171 | |
| 172 | /* Print current location without a level number, if we have changed |
| 173 | functions or hit a breakpoint. Print source line if we have one. |
| 174 | If the execution command captured a return value, print it. */ |
| 175 | |
| 176 | extern void print_stop_event (struct ui_out *uiout); |
| 177 | |
| 178 | /* Pretty print the results of target_wait, for debugging purposes. */ |
| 179 | |
| 180 | extern void print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid, |
| 181 | const struct target_waitstatus *ws); |
| 182 | |
| 183 | extern int signal_stop_state (int); |
| 184 | |
| 185 | extern int signal_print_state (int); |
| 186 | |
| 187 | extern int signal_pass_state (int); |
| 188 | |
| 189 | extern int signal_stop_update (int, int); |
| 190 | |
| 191 | extern int signal_print_update (int, int); |
| 192 | |
| 193 | extern int signal_pass_update (int, int); |
| 194 | |
| 195 | extern void update_signals_program_target (void); |
| 196 | |
| 197 | /* Clear the convenience variables associated with the exit of the |
| 198 | inferior. Currently, those variables are $_exitcode and |
| 199 | $_exitsignal. */ |
| 200 | extern void clear_exit_convenience_vars (void); |
| 201 | |
| 202 | /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */ |
| 203 | extern void displaced_step_dump_bytes (struct ui_file *file, |
| 204 | const gdb_byte *buf, size_t len); |
| 205 | |
| 206 | extern struct displaced_step_closure *get_displaced_step_closure_by_addr |
| 207 | (CORE_ADDR addr); |
| 208 | |
| 209 | extern void update_observer_mode (void); |
| 210 | |
| 211 | extern void signal_catch_update (const unsigned int *); |
| 212 | |
| 213 | /* In some circumstances we allow a command to specify a numeric |
| 214 | signal. The idea is to keep these circumstances limited so that |
| 215 | users (and scripts) develop portable habits. For comparison, |
| 216 | POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a |
| 217 | numeric signal at all is obsolescent. We are slightly more lenient |
| 218 | and allow 1-15 which should match host signal numbers on most |
| 219 | systems. Use of symbolic signal names is strongly encouraged. */ |
| 220 | enum gdb_signal gdb_signal_from_command (int num); |
| 221 | |
| 222 | /* Enables/disables infrun's async event source in the event loop. */ |
| 223 | extern void infrun_async (int enable); |
| 224 | |
| 225 | /* Call infrun's event handler the next time through the event |
| 226 | loop. */ |
| 227 | extern void mark_infrun_async_event_handler (void); |
| 228 | |
| 229 | /* The global queue of threads that need to do a step-over operation |
| 230 | to get past e.g., a breakpoint. */ |
| 231 | extern struct thread_info *step_over_queue_head; |
| 232 | |
| 233 | /* Remove breakpoints if possible (usually that means, if everything |
| 234 | is stopped). On failure, print a message. */ |
| 235 | extern void maybe_remove_breakpoints (void); |
| 236 | |
| 237 | /* If a UI was in sync execution mode, and now isn't, restore its |
| 238 | prompt (a synchronous execution command has finished, and we're |
| 239 | ready for input). */ |
| 240 | extern void all_uis_check_sync_execution_done (void); |
| 241 | |
| 242 | /* If a UI was in sync execution mode, and hasn't displayed the prompt |
| 243 | yet, re-disable its prompt (a synchronous execution command was |
| 244 | started or re-started). */ |
| 245 | extern void all_uis_on_sync_execution_starting (void); |
| 246 | |
| 247 | /* Base class for displaced stepping closures (the arch-specific data). */ |
| 248 | |
| 249 | struct displaced_step_closure |
| 250 | { |
| 251 | virtual ~displaced_step_closure () = 0; |
| 252 | }; |
| 253 | |
| 254 | /* A simple displaced step closure that contains only a byte buffer. */ |
| 255 | |
| 256 | struct buf_displaced_step_closure : displaced_step_closure |
| 257 | { |
| 258 | buf_displaced_step_closure (int buf_size) |
| 259 | : buf (buf_size) |
| 260 | {} |
| 261 | |
| 262 | gdb::byte_vector buf; |
| 263 | }; |
| 264 | |
| 265 | #endif /* INFRUN_H */ |