gdb/infrun.h

   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 */