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