-/* Copyright (C) 1986-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
#define INFRUN_H 1
#include "symtab.h"
+#include "common/byte-vector.h"
struct target_waitstatus;
struct frame_info;
of shared library events by the dynamic linker. */
extern int stop_on_solib_events;
-/* Are we simulating synchronous execution? This is used in async gdb
- to implement the 'run', 'continue' etc commands, which will not
- redisplay the prompt until the execution is actually over. */
-extern int sync_execution;
-
/* True if execution commands resume all threads of all processes by
default; otherwise, resume only threads of the current inferior
process. */
starting an inferior. */
extern int 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
+ current location. */
+extern ULONGEST get_stop_id (void);
+
/* Reverse execution. */
enum exec_direction_kind
{
EXEC_REVERSE
};
-/* The current execution direction. This should only be set to enum
- exec_direction_kind values. It is only an int to make it
- compatible with make_cleanup_restore_integer. */
-extern int execution_direction;
+/* The current execution direction. */
+extern enum exec_direction_kind execution_direction;
extern void start_remote (int from_tty);
extern void proceed (CORE_ADDR, enum gdb_signal);
-/* The `resume' routine should only be called in special circumstances.
- Normally, use `proceed', which handles a lot of bookkeeping. */
-extern void resume (enum gdb_signal);
-
/* Return a ptid representing the set of threads that we will proceed,
in the perspective of the user/frontend. We may actually resume
fewer threads at first, e.g., if a thread is stopped at a
extern void wait_for_inferior (void);
-extern void normal_stop (void);
+/* Return control to GDB when the inferior stops for real. Print
+ appropriate messages, remove breakpoints, give terminal our modes,
+ and run the stop hook. Returns true if the stop hook proceeded the
+ target, false otherwise. */
+extern int normal_stop (void);
extern void get_last_target_status (ptid_t *ptid,
struct target_waitstatus *status);
+extern void set_last_target_status (ptid_t ptid,
+ struct target_waitstatus status);
+
+/* Stop all threads. Only returns after everything is halted. */
+extern void stop_all_threads (void);
+
extern void prepare_for_detach (void);
extern void fetch_inferior_event (void *);
extern int stepping_past_instruction_at (struct address_space *aspace,
CORE_ADDR address);
+/* Returns true if thread whose thread number is THREAD is stepping
+ over a breakpoint. */
+extern int thread_is_stepping_over_breakpoint (int thread);
+
/* Returns true if we're trying to step past an instruction that
triggers a non-steppable watchpoint. */
extern int stepping_past_nonsteppable_watchpoint (void);
/* 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. */
is stopped). On failure, print a message. */
extern void maybe_remove_breakpoints (void);
+/* If a UI was in sync execution mode, and now isn't, restore its
+ prompt (a synchronous execution command has finished, and we're
+ ready for input). */
+extern void all_uis_check_sync_execution_done (void);
+
+/* If a UI was in sync execution mode, and hasn't displayed the prompt
+ yet, re-disable its prompt (a synchronous execution command was
+ started or re-started). */
+extern void all_uis_on_sync_execution_starting (void);
+
+/* Base class for displaced stepping closures (the arch-specific data). */
+
+struct displaced_step_closure
+{
+ virtual ~displaced_step_closure () = 0;
+};
+
+/* A simple displaced step closure that contains only a byte buffer. */
+
+struct buf_displaced_step_closure : displaced_step_closure
+{
+ buf_displaced_step_closure (int buf_size)
+ : buf (buf_size)
+ {}
+
+ 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 */
projects / deliverable / binutils-gdb.git / blobdiff