}
static void
-delegate_detach (struct target_ops *self, const char *arg1, int arg2)
+delegate_detach (struct target_ops *self, inferior *arg1, int arg2)
{
self = self->beneath;
self->to_detach (self, arg1, arg2);
}
static void
-tdefault_detach (struct target_ops *self, const char *arg1, int arg2)
+tdefault_detach (struct target_ops *self, inferior *arg1, int arg2)
{
}
static void
-debug_detach (struct target_ops *self, const char *arg1, int arg2)
+debug_detach (struct target_ops *self, inferior *arg1, int arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", debug_target.to_shortname);
debug_target.to_detach (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_const_char_p (arg1);
+ target_debug_print_inferior_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
fputs_unfiltered (")\n", gdb_stdlog);
}
-static ptid_t
-delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
+static void
+delegate_commit_resume (struct target_ops *self)
{
self = self->beneath;
- return self->to_wait (self, arg1, arg2, arg3);
+ self->to_commit_resume (self);
+}
+
+static void
+tdefault_commit_resume (struct target_ops *self)
+{
+}
+
+static void
+debug_commit_resume (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_commit_resume (...)\n", debug_target.to_shortname);
+ debug_target.to_commit_resume (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_commit_resume (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
}
static ptid_t
-tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
+delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
{
- noprocess ();
+ self = self->beneath;
+ return self->to_wait (self, arg1, arg2, arg3);
}
static ptid_t
}
static int
-delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2, enum remove_bp_reason arg3)
{
self = self->beneath;
- return self->to_remove_breakpoint (self, arg1, arg2);
+ return self->to_remove_breakpoint (self, arg1, arg2, arg3);
}
static int
-debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2, enum remove_bp_reason arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", debug_target.to_shortname);
- result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2);
+ result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_gdbarch_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_remove_bp_reason (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
}
static int
-delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
{
self = self->beneath;
return self->to_insert_mask_watchpoint (self, arg1, arg2, arg3);
}
static int
-tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
{
return 1;
}
static int
-debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_mask_watchpoint (...)\n", debug_target.to_shortname);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg3);
+ target_debug_print_enum_target_hw_bp_type (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
}
static int
-delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
{
self = self->beneath;
return self->to_remove_mask_watchpoint (self, arg1, arg2, arg3);
}
static int
-tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
{
return 1;
}
static int
-debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_mask_watchpoint (...)\n", debug_target.to_shortname);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg3);
+ target_debug_print_enum_target_hw_bp_type (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
+static int
+delegate_can_do_single_step (struct target_ops *self)
+{
+ self = self->beneath;
+ return self->to_can_do_single_step (self);
+}
+
+static int
+tdefault_can_do_single_step (struct target_ops *self)
+{
+ return -1;
+}
+
+static int
+debug_can_do_single_step (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_do_single_step (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_do_single_step (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_do_single_step (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_terminal_init (struct target_ops *self)
{
fputs_unfiltered (")\n", gdb_stdlog);
}
+static void
+delegate_terminal_save_inferior (struct target_ops *self)
+{
+ self = self->beneath;
+ self->to_terminal_save_inferior (self);
+}
+
+static void
+tdefault_terminal_save_inferior (struct target_ops *self)
+{
+}
+
+static void
+debug_terminal_save_inferior (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_save_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_save_inferior (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_save_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static void
delegate_terminal_ours_for_output (struct target_ops *self)
{
return result;
}
-static int
-delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
+static void
+delegate_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
{
self = self->beneath;
- return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4, arg5);
+ self->to_follow_exec (self, arg1, arg2);
}
-static int
-tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
+static void
+tdefault_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
{
- return 1;
}
-static int
-debug_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
+static void
+debug_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
{
- int result;
- fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname);
- result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4, arg5);
- fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname);
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_exec (...)\n", debug_target.to_shortname);
+ debug_target.to_follow_exec (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_exec (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg1);
+ target_debug_print_struct_inferior_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg2);
- fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg3);
- fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg4);
- fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int_p (arg5);
- fputs_unfiltered (") = ", gdb_stdlog);
- target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
- return result;
+ target_debug_print_char_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
}
static int
-delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
+delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view<const int> arg4)
{
self = self->beneath;
- return self->to_has_exited (self, arg1, arg2, arg3);
+ return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4);
}
static int
-tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
+tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view<const int> arg4)
{
- return 0;
+ return 1;
}
static int
-debug_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
+debug_set_syscall_catchpoint (struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view<const int> arg4)
{
int result;
- fprintf_unfiltered (gdb_stdlog, "-> %s->to_has_exited (...)\n", debug_target.to_shortname);
- result = debug_target.to_has_exited (&debug_target, arg1, arg2, arg3);
- fprintf_unfiltered (gdb_stdlog, "<- %s->to_has_exited (", debug_target.to_shortname);
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg2);
+ target_debug_print_bool (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int_p (arg3);
+ target_debug_print_gdb_array_view_const_int (arg4);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
fputs_unfiltered (")\n", gdb_stdlog);
}
-static char *
+static const char *
delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
return self->to_pid_to_str (self, arg1);
}
-static char *
+static const char *
debug_pid_to_str (struct target_ops *self, ptid_t arg1)
{
- char * result;
+ const char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_str (...)\n", debug_target.to_shortname);
result = debug_target.to_pid_to_str (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_str (", debug_target.to_shortname);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ptid_t (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
- target_debug_print_char_p (result);
+ target_debug_print_const_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
-static char *
+static const char *
delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
{
self = self->beneath;
return self->to_extra_thread_info (self, arg1);
}
-static char *
+static const char *
tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
{
return NULL;
}
-static char *
+static const char *
debug_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
{
- char * result;
+ const char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_extra_thread_info (...)\n", debug_target.to_shortname);
result = debug_target.to_extra_thread_info (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_extra_thread_info (", debug_target.to_shortname);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_thread_info_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
- target_debug_print_char_p (result);
+ target_debug_print_const_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
-static char *
+static const char *
delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
{
self = self->beneath;
return self->to_thread_name (self, arg1);
}
-static char *
+static const char *
tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
{
return NULL;
}
-static char *
+static const char *
debug_thread_name (struct target_ops *self, struct thread_info *arg1)
{
- char * result;
+ const char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_name (...)\n", debug_target.to_shortname);
result = debug_target.to_thread_name (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_name (", debug_target.to_shortname);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_thread_info_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
- target_debug_print_char_p (result);
+ target_debug_print_const_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static struct thread_info *
+delegate_thread_handle_to_thread_info (struct target_ops *self, const gdb_byte *arg1, int arg2, struct inferior *arg3)
+{
+ self = self->beneath;
+ return self->to_thread_handle_to_thread_info (self, arg1, arg2, arg3);
+}
+
+static struct thread_info *
+tdefault_thread_handle_to_thread_info (struct target_ops *self, const gdb_byte *arg1, int arg2, struct inferior *arg3)
+{
+ return NULL;
+}
+
+static struct thread_info *
+debug_thread_handle_to_thread_info (struct target_ops *self, const gdb_byte *arg1, int arg2, struct inferior *arg3)
+{
+ struct thread_info * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_handle_to_thread_info (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_handle_to_thread_info (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_handle_to_thread_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_inferior_p (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_thread_info_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
fputs_unfiltered (")\n", gdb_stdlog);
}
+static void
+delegate_interrupt (struct target_ops *self)
+{
+ self = self->beneath;
+ self->to_interrupt (self);
+}
+
+static void
+tdefault_interrupt (struct target_ops *self)
+{
+}
+
+static void
+debug_interrupt (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_interrupt (...)\n", debug_target.to_shortname);
+ debug_target.to_interrupt (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_interrupt (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
+delegate_pass_ctrlc (struct target_ops *self)
+{
+ self = self->beneath;
+ self->to_pass_ctrlc (self);
+}
+
+static void
+debug_pass_ctrlc (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_ctrlc (...)\n", debug_target.to_shortname);
+ debug_target.to_pass_ctrlc (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_ctrlc (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static void
delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
{
fputs_unfiltered (")\n", gdb_stdlog);
}
+static void
+delegate_thread_events (struct target_ops *self, int arg1)
+{
+ self = self->beneath;
+ self->to_thread_events (self, arg1);
+}
+
+static void
+tdefault_thread_events (struct target_ops *self, int arg1)
+{
+}
+
+static void
+debug_thread_events (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_events (...)\n", debug_target.to_shortname);
+ debug_target.to_thread_events (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_events (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_supports_non_stop (struct target_ops *self)
{
return result;
}
-static VEC(mem_region_s) *
+static ULONGEST
+delegate_get_memory_xfer_limit (struct target_ops *self)
+{
+ self = self->beneath;
+ return self->to_get_memory_xfer_limit (self);
+}
+
+static ULONGEST
+tdefault_get_memory_xfer_limit (struct target_ops *self)
+{
+ return ULONGEST_MAX;
+}
+
+static ULONGEST
+debug_get_memory_xfer_limit (struct target_ops *self)
+{
+ ULONGEST result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_memory_xfer_limit (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_memory_xfer_limit (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_memory_xfer_limit (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_ULONGEST (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static std::vector<mem_region>
delegate_memory_map (struct target_ops *self)
{
self = self->beneath;
return self->to_memory_map (self);
}
-static VEC(mem_region_s) *
+static std::vector<mem_region>
tdefault_memory_map (struct target_ops *self)
{
- return NULL;
+ return std::vector<mem_region> ();
}
-static VEC(mem_region_s) *
+static std::vector<mem_region>
debug_memory_map (struct target_ops *self)
{
- VEC(mem_region_s) * result;
+ std::vector<mem_region> result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", debug_target.to_shortname);
result = debug_target.to_memory_map (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (") = ", gdb_stdlog);
- target_debug_print_VEC_mem_region_s__p (result);
+ target_debug_print_std_vector_mem_region (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
}
static void
-delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
+delegate_download_trace_state_variable (struct target_ops *self, const trace_state_variable &arg1)
{
self = self->beneath;
self->to_download_trace_state_variable (self, arg1);
}
static void
-tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
+tdefault_download_trace_state_variable (struct target_ops *self, const trace_state_variable &arg1)
{
tcomplain ();
}
static void
-debug_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
+debug_download_trace_state_variable (struct target_ops *self, const trace_state_variable &arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", debug_target.to_shortname);
debug_target.to_download_trace_state_variable (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_struct_trace_state_variable_p (arg1);
+ target_debug_print_const_trace_state_variable_r (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
fputs_unfiltered (")\n", gdb_stdlog);
}
-static int
-delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
+static bool
+delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, static_tracepoint_marker *arg2)
{
self = self->beneath;
return self->to_static_tracepoint_marker_at (self, arg1, arg2);
}
-static int
-tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
+static bool
+tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, static_tracepoint_marker *arg2)
{
- return 0;
+ return false;
}
-static int
-debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
+static bool
+debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, static_tracepoint_marker *arg2)
{
- int result;
+ bool result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", debug_target.to_shortname);
result = debug_target.to_static_tracepoint_marker_at (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", debug_target.to_shortname);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_struct_static_tracepoint_marker_p (arg2);
+ target_debug_print_static_tracepoint_marker_p (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
- target_debug_print_int (result);
+ target_debug_print_bool (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
-static VEC(static_tracepoint_marker_p) *
+static std::vector<static_tracepoint_marker>
delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
{
self = self->beneath;
return self->to_static_tracepoint_markers_by_strid (self, arg1);
}
-static VEC(static_tracepoint_marker_p) *
+static std::vector<static_tracepoint_marker>
tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
{
tcomplain ();
}
-static VEC(static_tracepoint_marker_p) *
+static std::vector<static_tracepoint_marker>
debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
{
- VEC(static_tracepoint_marker_p) * result;
+ std::vector<static_tracepoint_marker> result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", debug_target.to_shortname);
result = debug_target.to_static_tracepoint_markers_by_strid (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", debug_target.to_shortname);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
- target_debug_print_VEC_static_tracepoint_marker_p__p (result);
+ target_debug_print_std_vector_static_tracepoint_marker (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
-static struct traceframe_info *
+static traceframe_info_up
delegate_traceframe_info (struct target_ops *self)
{
self = self->beneath;
return self->to_traceframe_info (self);
}
-static struct traceframe_info *
+static traceframe_info_up
tdefault_traceframe_info (struct target_ops *self)
{
tcomplain ();
}
-static struct traceframe_info *
+static traceframe_info_up
debug_traceframe_info (struct target_ops *self)
{
- struct traceframe_info * result;
+ traceframe_info_up result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", debug_target.to_shortname);
result = debug_target.to_traceframe_info (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (") = ", gdb_stdlog);
- target_debug_print_struct_traceframe_info_p (result);
+ target_debug_print_traceframe_info_up (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
return result;
}
-static int
-delegate_supports_btrace (struct target_ops *self, enum btrace_format arg1)
-{
- self = self->beneath;
- return self->to_supports_btrace (self, arg1);
-}
-
-static int
-tdefault_supports_btrace (struct target_ops *self, enum btrace_format arg1)
-{
- return 0;
-}
-
-static int
-debug_supports_btrace (struct target_ops *self, enum btrace_format arg1)
-{
- int result;
- fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
- result = debug_target.to_supports_btrace (&debug_target, arg1);
- fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname);
- target_debug_print_struct_target_ops_p (&debug_target);
- fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_enum_btrace_format (arg1);
- fputs_unfiltered (") = ", gdb_stdlog);
- target_debug_print_int (result);
- fputs_unfiltered ("\n", gdb_stdlog);
- return result;
-}
-
static struct btrace_target_info *
delegate_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
{
return result;
}
+static enum record_method
+delegate_record_method (struct target_ops *self, ptid_t arg1)
+{
+ self = self->beneath;
+ return self->to_record_method (self, arg1);
+}
+
+static enum record_method
+tdefault_record_method (struct target_ops *self, ptid_t arg1)
+{
+ return RECORD_METHOD_NONE;
+}
+
+static enum record_method
+debug_record_method (struct target_ops *self, ptid_t arg1)
+{
+ enum record_method result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_method (...)\n", debug_target.to_shortname);
+ result = debug_target.to_record_method (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_method (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_record_method (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_stop_recording (struct target_ops *self)
{
}
static int
-delegate_record_is_replaying (struct target_ops *self)
+delegate_record_is_replaying (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
- return self->to_record_is_replaying (self);
+ return self->to_record_is_replaying (self, arg1);
}
static int
-tdefault_record_is_replaying (struct target_ops *self)
+tdefault_record_is_replaying (struct target_ops *self, ptid_t arg1)
{
return 0;
}
static int
-debug_record_is_replaying (struct target_ops *self)
+debug_record_is_replaying (struct target_ops *self, ptid_t arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
- result = debug_target.to_record_is_replaying (&debug_target);
+ result = debug_target.to_record_is_replaying (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
+static int
+delegate_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
+{
+ self = self->beneath;
+ return self->to_record_will_replay (self, arg1, arg2);
+}
+
+static int
+tdefault_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
+{
+ return 0;
+}
+
+static int
+debug_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_will_replay (...)\n", debug_target.to_shortname);
+ result = debug_target.to_record_will_replay (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_will_replay (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static void
+delegate_record_stop_replaying (struct target_ops *self)
+{
+ self = self->beneath;
+ self->to_record_stop_replaying (self);
+}
+
+static void
+tdefault_record_stop_replaying (struct target_ops *self)
+{
+}
+
+static void
+debug_record_stop_replaying (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_stop_replaying (...)\n", debug_target.to_shortname);
+ debug_target.to_record_stop_replaying (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_stop_replaying (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static void
delegate_goto_record_begin (struct target_ops *self)
{
}
static void
-delegate_insn_history (struct target_ops *self, int arg1, int arg2)
+delegate_insn_history (struct target_ops *self, int arg1, gdb_disassembly_flags arg2)
{
self = self->beneath;
self->to_insn_history (self, arg1, arg2);
}
static void
-tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
+tdefault_insn_history (struct target_ops *self, int arg1, gdb_disassembly_flags arg2)
{
tcomplain ();
}
static void
-debug_insn_history (struct target_ops *self, int arg1, int arg2)
+debug_insn_history (struct target_ops *self, int arg1, gdb_disassembly_flags arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
debug_target.to_insn_history (&debug_target, arg1, arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg2);
+ target_debug_print_gdb_disassembly_flags (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
-delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, gdb_disassembly_flags arg3)
{
self = self->beneath;
self->to_insn_history_from (self, arg1, arg2, arg3);
}
static void
-tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, gdb_disassembly_flags arg3)
{
tcomplain ();
}
static void
-debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, gdb_disassembly_flags arg3)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname);
debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg3);
+ target_debug_print_gdb_disassembly_flags (arg3);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
-delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, gdb_disassembly_flags arg3)
{
self = self->beneath;
self->to_insn_history_range (self, arg1, arg2, arg3);
}
static void
-tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, gdb_disassembly_flags arg3)
{
tcomplain ();
}
static void
-debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, gdb_disassembly_flags arg3)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname);
debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg2);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg3);
+ target_debug_print_gdb_disassembly_flags (arg3);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
-delegate_call_history (struct target_ops *self, int arg1, int arg2)
+delegate_call_history (struct target_ops *self, int arg1, record_print_flags arg2)
{
self = self->beneath;
self->to_call_history (self, arg1, arg2);
}
static void
-tdefault_call_history (struct target_ops *self, int arg1, int arg2)
+tdefault_call_history (struct target_ops *self, int arg1, record_print_flags arg2)
{
tcomplain ();
}
static void
-debug_call_history (struct target_ops *self, int arg1, int arg2)
+debug_call_history (struct target_ops *self, int arg1, record_print_flags arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
debug_target.to_call_history (&debug_target, arg1, arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg2);
+ target_debug_print_record_print_flags (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
-delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, record_print_flags arg3)
{
self = self->beneath;
self->to_call_history_from (self, arg1, arg2, arg3);
}
static void
-tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, record_print_flags arg3)
{
tcomplain ();
}
static void
-debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, record_print_flags arg3)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname);
debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg3);
+ target_debug_print_record_print_flags (arg3);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
-delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, record_print_flags arg3)
{
self = self->beneath;
self->to_call_history_range (self, arg1, arg2, arg3);
}
static void
-tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, record_print_flags arg3)
{
tcomplain ();
}
static void
-debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, record_print_flags arg3)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname);
debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg2);
fputs_unfiltered (", ", gdb_stdlog);
- target_debug_print_int (arg3);
+ target_debug_print_record_print_flags (arg3);
fputs_unfiltered (")\n", gdb_stdlog);
}
ops->to_disconnect = delegate_disconnect;
if (ops->to_resume == NULL)
ops->to_resume = delegate_resume;
+ if (ops->to_commit_resume == NULL)
+ ops->to_commit_resume = delegate_commit_resume;
if (ops->to_wait == NULL)
ops->to_wait = delegate_wait;
if (ops->to_fetch_registers == NULL)
ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
if (ops->to_masked_watch_num_registers == NULL)
ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers;
+ if (ops->to_can_do_single_step == NULL)
+ ops->to_can_do_single_step = delegate_can_do_single_step;
if (ops->to_terminal_init == NULL)
ops->to_terminal_init = delegate_terminal_init;
if (ops->to_terminal_inferior == NULL)
ops->to_terminal_inferior = delegate_terminal_inferior;
+ if (ops->to_terminal_save_inferior == NULL)
+ ops->to_terminal_save_inferior = delegate_terminal_save_inferior;
if (ops->to_terminal_ours_for_output == NULL)
ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
if (ops->to_terminal_ours == NULL)
ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
if (ops->to_remove_exec_catchpoint == NULL)
ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
+ if (ops->to_follow_exec == NULL)
+ ops->to_follow_exec = delegate_follow_exec;
if (ops->to_set_syscall_catchpoint == NULL)
ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
- if (ops->to_has_exited == NULL)
- ops->to_has_exited = delegate_has_exited;
if (ops->to_mourn_inferior == NULL)
ops->to_mourn_inferior = delegate_mourn_inferior;
if (ops->to_can_run == NULL)
ops->to_extra_thread_info = delegate_extra_thread_info;
if (ops->to_thread_name == NULL)
ops->to_thread_name = delegate_thread_name;
+ if (ops->to_thread_handle_to_thread_info == NULL)
+ ops->to_thread_handle_to_thread_info = delegate_thread_handle_to_thread_info;
if (ops->to_stop == NULL)
ops->to_stop = delegate_stop;
+ if (ops->to_interrupt == NULL)
+ ops->to_interrupt = delegate_interrupt;
+ if (ops->to_pass_ctrlc == NULL)
+ ops->to_pass_ctrlc = delegate_pass_ctrlc;
if (ops->to_rcmd == NULL)
ops->to_rcmd = delegate_rcmd;
if (ops->to_pid_to_exec_file == NULL)
ops->to_is_async_p = delegate_is_async_p;
if (ops->to_async == NULL)
ops->to_async = delegate_async;
+ if (ops->to_thread_events == NULL)
+ ops->to_thread_events = delegate_thread_events;
if (ops->to_supports_non_stop == NULL)
ops->to_supports_non_stop = delegate_supports_non_stop;
if (ops->to_always_non_stop_p == NULL)
ops->to_get_thread_local_address = delegate_get_thread_local_address;
if (ops->to_xfer_partial == NULL)
ops->to_xfer_partial = delegate_xfer_partial;
+ if (ops->to_get_memory_xfer_limit == NULL)
+ ops->to_get_memory_xfer_limit = delegate_get_memory_xfer_limit;
if (ops->to_memory_map == NULL)
ops->to_memory_map = delegate_memory_map;
if (ops->to_flash_erase == NULL)
ops->to_use_agent = delegate_use_agent;
if (ops->to_can_use_agent == NULL)
ops->to_can_use_agent = delegate_can_use_agent;
- if (ops->to_supports_btrace == NULL)
- ops->to_supports_btrace = delegate_supports_btrace;
if (ops->to_enable_btrace == NULL)
ops->to_enable_btrace = delegate_enable_btrace;
if (ops->to_disable_btrace == NULL)
ops->to_read_btrace = delegate_read_btrace;
if (ops->to_btrace_conf == NULL)
ops->to_btrace_conf = delegate_btrace_conf;
+ if (ops->to_record_method == NULL)
+ ops->to_record_method = delegate_record_method;
if (ops->to_stop_recording == NULL)
ops->to_stop_recording = delegate_stop_recording;
if (ops->to_info_record == NULL)
ops->to_delete_record = delegate_delete_record;
if (ops->to_record_is_replaying == NULL)
ops->to_record_is_replaying = delegate_record_is_replaying;
+ if (ops->to_record_will_replay == NULL)
+ ops->to_record_will_replay = delegate_record_will_replay;
+ if (ops->to_record_stop_replaying == NULL)
+ ops->to_record_stop_replaying = delegate_record_stop_replaying;
if (ops->to_goto_record_begin == NULL)
ops->to_goto_record_begin = delegate_goto_record_begin;
if (ops->to_goto_record_end == NULL)
ops->to_detach = tdefault_detach;
ops->to_disconnect = tdefault_disconnect;
ops->to_resume = tdefault_resume;
- ops->to_wait = tdefault_wait;
+ ops->to_commit_resume = tdefault_commit_resume;
+ ops->to_wait = default_target_wait;
ops->to_fetch_registers = tdefault_fetch_registers;
ops->to_store_registers = tdefault_store_registers;
ops->to_prepare_to_store = tdefault_prepare_to_store;
ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers;
+ ops->to_can_do_single_step = tdefault_can_do_single_step;
ops->to_terminal_init = tdefault_terminal_init;
ops->to_terminal_inferior = tdefault_terminal_inferior;
+ ops->to_terminal_save_inferior = tdefault_terminal_save_inferior;
ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
ops->to_terminal_ours = tdefault_terminal_ours;
ops->to_terminal_info = default_terminal_info;
ops->to_follow_fork = default_follow_fork;
ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
+ ops->to_follow_exec = tdefault_follow_exec;
ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
- ops->to_has_exited = tdefault_has_exited;
ops->to_mourn_inferior = default_mourn_inferior;
ops->to_can_run = tdefault_can_run;
ops->to_pass_signals = tdefault_pass_signals;
ops->to_pid_to_str = default_pid_to_str;
ops->to_extra_thread_info = tdefault_extra_thread_info;
ops->to_thread_name = tdefault_thread_name;
+ ops->to_thread_handle_to_thread_info = tdefault_thread_handle_to_thread_info;
ops->to_stop = tdefault_stop;
+ ops->to_interrupt = tdefault_interrupt;
+ ops->to_pass_ctrlc = default_target_pass_ctrlc;
ops->to_rcmd = default_rcmd;
ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
ops->to_log_command = tdefault_log_command;
ops->to_can_async_p = tdefault_can_async_p;
ops->to_is_async_p = tdefault_is_async_p;
ops->to_async = tdefault_async;
+ ops->to_thread_events = tdefault_thread_events;
ops->to_supports_non_stop = tdefault_supports_non_stop;
ops->to_always_non_stop_p = tdefault_always_non_stop_p;
ops->to_find_memory_regions = dummy_find_memory_regions;
ops->to_goto_bookmark = tdefault_goto_bookmark;
ops->to_get_thread_local_address = tdefault_get_thread_local_address;
ops->to_xfer_partial = tdefault_xfer_partial;
+ ops->to_get_memory_xfer_limit = tdefault_get_memory_xfer_limit;
ops->to_memory_map = tdefault_memory_map;
ops->to_flash_erase = tdefault_flash_erase;
ops->to_flash_done = tdefault_flash_done;
ops->to_traceframe_info = tdefault_traceframe_info;
ops->to_use_agent = tdefault_use_agent;
ops->to_can_use_agent = tdefault_can_use_agent;
- ops->to_supports_btrace = tdefault_supports_btrace;
ops->to_enable_btrace = tdefault_enable_btrace;
ops->to_disable_btrace = tdefault_disable_btrace;
ops->to_teardown_btrace = tdefault_teardown_btrace;
ops->to_read_btrace = tdefault_read_btrace;
ops->to_btrace_conf = tdefault_btrace_conf;
+ ops->to_record_method = tdefault_record_method;
ops->to_stop_recording = tdefault_stop_recording;
ops->to_info_record = tdefault_info_record;
ops->to_save_record = tdefault_save_record;
ops->to_delete_record = tdefault_delete_record;
ops->to_record_is_replaying = tdefault_record_is_replaying;
+ ops->to_record_will_replay = tdefault_record_will_replay;
+ ops->to_record_stop_replaying = tdefault_record_stop_replaying;
ops->to_goto_record_begin = tdefault_goto_record_begin;
ops->to_goto_record_end = tdefault_goto_record_end;
ops->to_goto_record = tdefault_goto_record;
ops->to_detach = debug_detach;
ops->to_disconnect = debug_disconnect;
ops->to_resume = debug_resume;
+ ops->to_commit_resume = debug_commit_resume;
ops->to_wait = debug_wait;
ops->to_fetch_registers = debug_fetch_registers;
ops->to_store_registers = debug_store_registers;
ops->to_region_ok_for_hw_watchpoint = debug_region_ok_for_hw_watchpoint;
ops->to_can_accel_watchpoint_condition = debug_can_accel_watchpoint_condition;
ops->to_masked_watch_num_registers = debug_masked_watch_num_registers;
+ ops->to_can_do_single_step = debug_can_do_single_step;
ops->to_terminal_init = debug_terminal_init;
ops->to_terminal_inferior = debug_terminal_inferior;
+ ops->to_terminal_save_inferior = debug_terminal_save_inferior;
ops->to_terminal_ours_for_output = debug_terminal_ours_for_output;
ops->to_terminal_ours = debug_terminal_ours;
ops->to_terminal_info = debug_terminal_info;
ops->to_follow_fork = debug_follow_fork;
ops->to_insert_exec_catchpoint = debug_insert_exec_catchpoint;
ops->to_remove_exec_catchpoint = debug_remove_exec_catchpoint;
+ ops->to_follow_exec = debug_follow_exec;
ops->to_set_syscall_catchpoint = debug_set_syscall_catchpoint;
- ops->to_has_exited = debug_has_exited;
ops->to_mourn_inferior = debug_mourn_inferior;
ops->to_can_run = debug_can_run;
ops->to_pass_signals = debug_pass_signals;
ops->to_pid_to_str = debug_pid_to_str;
ops->to_extra_thread_info = debug_extra_thread_info;
ops->to_thread_name = debug_thread_name;
+ ops->to_thread_handle_to_thread_info = debug_thread_handle_to_thread_info;
ops->to_stop = debug_stop;
+ ops->to_interrupt = debug_interrupt;
+ ops->to_pass_ctrlc = debug_pass_ctrlc;
ops->to_rcmd = debug_rcmd;
ops->to_pid_to_exec_file = debug_pid_to_exec_file;
ops->to_log_command = debug_log_command;
ops->to_can_async_p = debug_can_async_p;
ops->to_is_async_p = debug_is_async_p;
ops->to_async = debug_async;
+ ops->to_thread_events = debug_thread_events;
ops->to_supports_non_stop = debug_supports_non_stop;
ops->to_always_non_stop_p = debug_always_non_stop_p;
ops->to_find_memory_regions = debug_find_memory_regions;
ops->to_goto_bookmark = debug_goto_bookmark;
ops->to_get_thread_local_address = debug_get_thread_local_address;
ops->to_xfer_partial = debug_xfer_partial;
+ ops->to_get_memory_xfer_limit = debug_get_memory_xfer_limit;
ops->to_memory_map = debug_memory_map;
ops->to_flash_erase = debug_flash_erase;
ops->to_flash_done = debug_flash_done;
ops->to_traceframe_info = debug_traceframe_info;
ops->to_use_agent = debug_use_agent;
ops->to_can_use_agent = debug_can_use_agent;
- ops->to_supports_btrace = debug_supports_btrace;
ops->to_enable_btrace = debug_enable_btrace;
ops->to_disable_btrace = debug_disable_btrace;
ops->to_teardown_btrace = debug_teardown_btrace;
ops->to_read_btrace = debug_read_btrace;
ops->to_btrace_conf = debug_btrace_conf;
+ ops->to_record_method = debug_record_method;
ops->to_stop_recording = debug_stop_recording;
ops->to_info_record = debug_info_record;
ops->to_save_record = debug_save_record;
ops->to_delete_record = debug_delete_record;
ops->to_record_is_replaying = debug_record_is_replaying;
+ ops->to_record_will_replay = debug_record_will_replay;
+ ops->to_record_stop_replaying = debug_record_stop_replaying;
ops->to_goto_record_begin = debug_goto_record_begin;
ops->to_goto_record_end = debug_goto_record_end;
ops->to_goto_record = debug_goto_record;
projects / deliverable / binutils-gdb.git / blobdiff