#define INFRUN_H 1
#include "symtab.h"
-#include "common/byte-vector.h"
+#include "gdbsupport/byte-vector.h"
struct target_waitstatus;
struct frame_info;
extern unsigned int debug_infrun;
/* True if we are debugging displaced stepping. */
-extern int debug_displaced;
+extern bool debug_displaced;
/* Nonzero if we want to give control to the user when we're notified
of shared library events by the dynamic linker. */
/* True if execution commands resume all threads of all processes by
default; otherwise, resume only threads of the current inferior
process. */
-extern int sched_multi;
+extern bool sched_multi;
/* When set, stop the 'step' command if we enter a function which has
no line number information. The normal behavior is that we step
over such function. */
-extern int step_stop_if_no_debug;
+extern bool step_stop_if_no_debug;
/* If set, the inferior should be controlled in non-stop mode. In
this mode, each thread is controlled independently. Execution
commands apply only to the selected thread by default, and stop
events stop only the thread that had the event -- the other threads
are kept running freely. */
-extern int non_stop;
+extern bool non_stop;
/* When set (default), the target should attempt to disable the
operating system's address space randomization feature when
starting an inferior. */
-extern int disable_randomization;
+extern bool disable_randomization;
/* Returns a unique identifier for the current stop. This can be used
to tell whether a command has proceeded the inferior past the
/* Print current location without a level number, if we have changed
functions or hit a breakpoint. Print source line if we have one.
- If the execution command captured a return value, print it. */
+ If the execution command captured a return value, print it. If
+ DISPLAYS is false, do not call 'do_displays'. */
-extern void print_stop_event (struct ui_out *uiout);
+extern void print_stop_event (struct ui_out *uiout, bool displays = true);
/* Pretty print the results of target_wait, for debugging purposes. */
gdb::byte_vector buf;
};
+/* Per-inferior displaced stepping state. */
+struct displaced_step_inferior_state
+{
+ displaced_step_inferior_state ()
+ {
+ reset ();
+ }
+
+ /* Put this object back in its original state. */
+ void reset ()
+ {
+ failed_before = 0;
+ step_thread = nullptr;
+ step_gdbarch = nullptr;
+ step_closure = nullptr;
+ step_original = 0;
+ step_copy = 0;
+ step_saved_copy.clear ();
+ }
+
+ /* True if preparing a displaced step ever failed. If so, we won't
+ try displaced stepping for this inferior again. */
+ int failed_before;
+
+ /* If this is not nullptr, this is the thread carrying out a
+ displaced single-step in process PID. This thread's state will
+ require fixing up once it has completed its step. */
+ thread_info *step_thread;
+
+ /* The architecture the thread had when we stepped it. */
+ gdbarch *step_gdbarch;
+
+ /* The closure provided gdbarch_displaced_step_copy_insn, to be used
+ for post-step cleanup. */
+ displaced_step_closure *step_closure;
+
+ /* The address of the original instruction, and the copy we
+ made. */
+ CORE_ADDR step_original, step_copy;
+
+ /* Saved contents of copy area. */
+ gdb::byte_vector step_saved_copy;
+};
+
#endif /* INFRUN_H */