Commit | Line | Data |
---|---|---|
b811d2c2 | 1 | /* Copyright (C) 1986-2020 Free Software Foundation, Inc. |
45741a9c PA |
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 | ||
45741a9c | 21 | #include "symtab.h" |
268a13a5 | 22 | #include "gdbsupport/byte-vector.h" |
45741a9c PA |
23 | |
24 | struct target_waitstatus; | |
25 | struct frame_info; | |
26 | struct address_space; | |
243a9253 | 27 | struct return_value_info; |
45741a9c PA |
28 | |
29 | /* True if we are debugging run control. */ | |
30 | extern unsigned int debug_infrun; | |
31 | ||
32 | /* True if we are debugging displaced stepping. */ | |
491144b5 | 33 | extern bool debug_displaced; |
45741a9c PA |
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 | ||
45741a9c PA |
39 | /* True if execution commands resume all threads of all processes by |
40 | default; otherwise, resume only threads of the current inferior | |
41 | process. */ | |
491144b5 | 42 | extern bool sched_multi; |
45741a9c PA |
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. */ | |
491144b5 | 47 | extern bool step_stop_if_no_debug; |
45741a9c PA |
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. */ | |
491144b5 | 54 | extern bool non_stop; |
45741a9c PA |
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. */ | |
491144b5 | 59 | extern bool disable_randomization; |
45741a9c | 60 | |
4c2f2a79 PA |
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 | ||
45741a9c PA |
66 | /* Reverse execution. */ |
67 | enum exec_direction_kind | |
68 | { | |
69 | EXEC_FORWARD, | |
70 | EXEC_REVERSE | |
71 | }; | |
72 | ||
170742de PA |
73 | /* The current execution direction. */ |
74 | extern enum exec_direction_kind execution_direction; | |
45741a9c | 75 | |
45741a9c PA |
76 | extern void start_remote (int from_tty); |
77 | ||
70509625 PA |
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); | |
45741a9c | 83 | |
64ce06e4 | 84 | extern void proceed (CORE_ADDR, enum gdb_signal); |
45741a9c | 85 | |
70509625 | 86 | /* Return a ptid representing the set of threads that we will proceed, |
f3263aa4 PA |
87 | in the perspective of the user/frontend. We may actually resume |
88 | fewer threads at first, e.g., if a thread is stopped at a | |
89 | breakpoint that needs stepping-off, but that should not be visible | |
90 | to the user/frontend, and neither should the frontend/user be | |
91 | allowed to proceed any of the threads that happen to be stopped for | |
92 | internal run control handling, if a previous command wanted them | |
93 | resumed. */ | |
45741a9c PA |
94 | extern ptid_t user_visible_resume_ptid (int step); |
95 | ||
96 | extern void wait_for_inferior (void); | |
97 | ||
4c2f2a79 PA |
98 | /* Return control to GDB when the inferior stops for real. Print |
99 | appropriate messages, remove breakpoints, give terminal our modes, | |
100 | and run the stop hook. Returns true if the stop hook proceeded the | |
101 | target, false otherwise. */ | |
102 | extern int normal_stop (void); | |
45741a9c | 103 | |
ab1ddbcf PA |
104 | /* Return the cached copy of the last ptid/waitstatus returned |
105 | by target_wait()/deprecated_target_wait_hook(). The data is | |
106 | actually cached by handle_inferior_event(), which gets called | |
107 | immediately after target_wait()/deprecated_target_wait_hook(). */ | |
45741a9c PA |
108 | extern void get_last_target_status (ptid_t *ptid, |
109 | struct target_waitstatus *status); | |
110 | ||
ab1ddbcf | 111 | /* Set the cached copy of the last ptid/waitstatus. */ |
6efcd9a8 PA |
112 | extern void set_last_target_status (ptid_t ptid, |
113 | struct target_waitstatus status); | |
114 | ||
ab1ddbcf PA |
115 | /* Clear the cached copy of the last ptid/waitstatus returned by |
116 | target_wait(). */ | |
117 | extern void nullify_last_target_wait_ptid (); | |
118 | ||
6efcd9a8 PA |
119 | /* Stop all threads. Only returns after everything is halted. */ |
120 | extern void stop_all_threads (void); | |
121 | ||
45741a9c PA |
122 | extern void prepare_for_detach (void); |
123 | ||
124 | extern void fetch_inferior_event (void *); | |
125 | ||
126 | extern void init_wait_for_inferior (void); | |
127 | ||
128 | extern void insert_step_resume_breakpoint_at_sal (struct gdbarch *, | |
129 | struct symtab_and_line , | |
130 | struct frame_id); | |
131 | ||
45741a9c PA |
132 | /* Returns true if we're trying to step past the instruction at |
133 | ADDRESS in ASPACE. */ | |
134 | extern int stepping_past_instruction_at (struct address_space *aspace, | |
135 | CORE_ADDR address); | |
136 | ||
21edc42f YQ |
137 | /* Returns true if thread whose thread number is THREAD is stepping |
138 | over a breakpoint. */ | |
139 | extern int thread_is_stepping_over_breakpoint (int thread); | |
140 | ||
963f9c80 PA |
141 | /* Returns true if we're trying to step past an instruction that |
142 | triggers a non-steppable watchpoint. */ | |
143 | extern int stepping_past_nonsteppable_watchpoint (void); | |
144 | ||
45741a9c PA |
145 | extern void set_step_info (struct frame_info *frame, |
146 | struct symtab_and_line sal); | |
147 | ||
fd664c91 PA |
148 | /* Several print_*_reason helper functions to print why the inferior |
149 | has stopped to the passed in UIOUT. */ | |
150 | ||
151 | /* Signal received, print why the inferior has stopped. */ | |
152 | extern void print_signal_received_reason (struct ui_out *uiout, | |
153 | enum gdb_signal siggnal); | |
154 | ||
155 | /* Print why the inferior has stopped. We are done with a | |
156 | step/next/si/ni command, print why the inferior has stopped. */ | |
157 | extern void print_end_stepping_range_reason (struct ui_out *uiout); | |
158 | ||
159 | /* The inferior was terminated by a signal, print why it stopped. */ | |
160 | extern void print_signal_exited_reason (struct ui_out *uiout, | |
161 | enum gdb_signal siggnal); | |
162 | ||
163 | /* The inferior program is finished, print why it stopped. */ | |
164 | extern void print_exited_reason (struct ui_out *uiout, int exitstatus); | |
165 | ||
166 | /* Reverse execution: target ran out of history info, print why the | |
167 | inferior has stopped. */ | |
168 | extern void print_no_history_reason (struct ui_out *uiout); | |
169 | ||
243a9253 PA |
170 | /* Print the result of a function at the end of a 'finish' command. |
171 | RV points at an object representing the captured return value/type | |
172 | and its position in the value history. */ | |
173 | ||
174 | extern void print_return_value (struct ui_out *uiout, | |
175 | struct return_value_info *rv); | |
176 | ||
177 | /* Print current location without a level number, if we have changed | |
178 | functions or hit a breakpoint. Print source line if we have one. | |
4c7d57e7 TT |
179 | If the execution command captured a return value, print it. If |
180 | DISPLAYS is false, do not call 'do_displays'. */ | |
243a9253 | 181 | |
4c7d57e7 | 182 | extern void print_stop_event (struct ui_out *uiout, bool displays = true); |
45741a9c | 183 | |
221e1a37 PA |
184 | /* Pretty print the results of target_wait, for debugging purposes. */ |
185 | ||
186 | extern void print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid, | |
187 | const struct target_waitstatus *ws); | |
188 | ||
45741a9c PA |
189 | extern int signal_stop_state (int); |
190 | ||
191 | extern int signal_print_state (int); | |
192 | ||
193 | extern int signal_pass_state (int); | |
194 | ||
195 | extern int signal_stop_update (int, int); | |
196 | ||
197 | extern int signal_print_update (int, int); | |
198 | ||
199 | extern int signal_pass_update (int, int); | |
200 | ||
201 | extern void update_signals_program_target (void); | |
202 | ||
203 | /* Clear the convenience variables associated with the exit of the | |
204 | inferior. Currently, those variables are $_exitcode and | |
205 | $_exitsignal. */ | |
206 | extern void clear_exit_convenience_vars (void); | |
207 | ||
208 | /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */ | |
209 | extern void displaced_step_dump_bytes (struct ui_file *file, | |
210 | const gdb_byte *buf, size_t len); | |
211 | ||
212 | extern struct displaced_step_closure *get_displaced_step_closure_by_addr | |
213 | (CORE_ADDR addr); | |
214 | ||
215 | extern void update_observer_mode (void); | |
216 | ||
217 | extern void signal_catch_update (const unsigned int *); | |
218 | ||
219 | /* In some circumstances we allow a command to specify a numeric | |
220 | signal. The idea is to keep these circumstances limited so that | |
221 | users (and scripts) develop portable habits. For comparison, | |
222 | POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a | |
223 | numeric signal at all is obsolescent. We are slightly more lenient | |
224 | and allow 1-15 which should match host signal numbers on most | |
225 | systems. Use of symbolic signal names is strongly encouraged. */ | |
226 | enum gdb_signal gdb_signal_from_command (int num); | |
227 | ||
372316f1 PA |
228 | /* Enables/disables infrun's async event source in the event loop. */ |
229 | extern void infrun_async (int enable); | |
230 | ||
0b333c5e PA |
231 | /* Call infrun's event handler the next time through the event |
232 | loop. */ | |
233 | extern void mark_infrun_async_event_handler (void); | |
234 | ||
c2829269 PA |
235 | /* The global queue of threads that need to do a step-over operation |
236 | to get past e.g., a breakpoint. */ | |
237 | extern struct thread_info *step_over_queue_head; | |
238 | ||
388a7084 PA |
239 | /* Remove breakpoints if possible (usually that means, if everything |
240 | is stopped). On failure, print a message. */ | |
241 | extern void maybe_remove_breakpoints (void); | |
242 | ||
3b12939d PA |
243 | /* If a UI was in sync execution mode, and now isn't, restore its |
244 | prompt (a synchronous execution command has finished, and we're | |
245 | ready for input). */ | |
246 | extern void all_uis_check_sync_execution_done (void); | |
247 | ||
a8836c93 PA |
248 | /* If a UI was in sync execution mode, and hasn't displayed the prompt |
249 | yet, re-disable its prompt (a synchronous execution command was | |
250 | started or re-started). */ | |
251 | extern void all_uis_on_sync_execution_starting (void); | |
252 | ||
cfba9872 SM |
253 | /* Base class for displaced stepping closures (the arch-specific data). */ |
254 | ||
255 | struct displaced_step_closure | |
256 | { | |
257 | virtual ~displaced_step_closure () = 0; | |
258 | }; | |
259 | ||
260 | /* A simple displaced step closure that contains only a byte buffer. */ | |
261 | ||
262 | struct buf_displaced_step_closure : displaced_step_closure | |
263 | { | |
264 | buf_displaced_step_closure (int buf_size) | |
265 | : buf (buf_size) | |
266 | {} | |
267 | ||
268 | gdb::byte_vector buf; | |
269 | }; | |
270 | ||
d20172fc SM |
271 | /* Per-inferior displaced stepping state. */ |
272 | struct displaced_step_inferior_state | |
273 | { | |
274 | displaced_step_inferior_state () | |
275 | { | |
276 | reset (); | |
277 | } | |
278 | ||
279 | /* Put this object back in its original state. */ | |
280 | void reset () | |
281 | { | |
282 | failed_before = 0; | |
283 | step_thread = nullptr; | |
284 | step_gdbarch = nullptr; | |
285 | step_closure = nullptr; | |
286 | step_original = 0; | |
287 | step_copy = 0; | |
288 | step_saved_copy.clear (); | |
289 | } | |
290 | ||
291 | /* True if preparing a displaced step ever failed. If so, we won't | |
292 | try displaced stepping for this inferior again. */ | |
293 | int failed_before; | |
294 | ||
295 | /* If this is not nullptr, this is the thread carrying out a | |
296 | displaced single-step in process PID. This thread's state will | |
297 | require fixing up once it has completed its step. */ | |
298 | thread_info *step_thread; | |
299 | ||
300 | /* The architecture the thread had when we stepped it. */ | |
301 | gdbarch *step_gdbarch; | |
302 | ||
303 | /* The closure provided gdbarch_displaced_step_copy_insn, to be used | |
304 | for post-step cleanup. */ | |
305 | displaced_step_closure *step_closure; | |
306 | ||
307 | /* The address of the original instruction, and the copy we | |
308 | made. */ | |
309 | CORE_ADDR step_original, step_copy; | |
310 | ||
311 | /* Saved contents of copy area. */ | |
312 | gdb::byte_vector step_saved_copy; | |
313 | }; | |
314 | ||
45741a9c | 315 | #endif /* INFRUN_H */ |