blob: 03aa2cc51002e5697f6fc5c963af998b59fe2325 [file] [log] [blame]
/* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
/* vi:set ro: */
/* To regenerate this file, run:*/
/* make-target-delegates target.h > target-delegates.c */
static void
delegate_post_attach (struct target_ops *self, int arg1)
{
self = self->beneath;
self->to_post_attach (self, arg1);
}
static void
tdefault_post_attach (struct target_ops *self, int arg1)
{
}
static void
debug_post_attach (struct target_ops *self, int arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", debug_target.to_shortname);
debug_target.to_post_attach (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", 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 void
delegate_detach (struct target_ops *self, const char *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)
{
}
static void
debug_detach (struct target_ops *self, const char *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);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_disconnect (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
self->to_disconnect (self, arg1, arg2);
}
static void
tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
{
tcomplain ();
}
static void
debug_disconnect (struct target_ops *self, const char *arg1, int arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", debug_target.to_shortname);
debug_target.to_disconnect (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
{
self = self->beneath;
self->to_resume (self, arg1, arg2, arg3);
}
static void
tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
{
noprocess ();
}
static void
debug_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", debug_target.to_shortname);
debug_target.to_resume (&debug_target, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", 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_step (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_gdb_signal (arg3);
fputs_unfiltered (")\n", gdb_stdlog);
}
static ptid_t
delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
{
self = self->beneath;
return self->to_wait (self, arg1, arg2, arg3);
}
static ptid_t
debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
{
ptid_t result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", debug_target.to_shortname);
result = debug_target.to_wait (&debug_target, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", 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_struct_target_waitstatus_p (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_options (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_ptid_t (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static void
delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
self = self->beneath;
self->to_fetch_registers (self, arg1, arg2);
}
static void
tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
}
static void
debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname);
debug_target.to_fetch_registers (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_regcache_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
self = self->beneath;
self->to_store_registers (self, arg1, arg2);
}
static void
tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
noprocess ();
}
static void
debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
debug_target.to_store_registers (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_regcache_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
{
self = self->beneath;
self->to_prepare_to_store (self, arg1);
}
static void
tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
{
noprocess ();
}
static void
debug_prepare_to_store (struct target_ops *self, struct regcache *arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", debug_target.to_shortname);
debug_target.to_prepare_to_store (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_regcache_p (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_files_info (struct target_ops *self)
{
self = self->beneath;
self->to_files_info (self);
}
static void
tdefault_files_info (struct target_ops *self)
{
}
static void
debug_files_info (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_files_info (...)\n", debug_target.to_shortname);
debug_target.to_files_info (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_files_info (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static int
delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
return self->to_insert_breakpoint (self, arg1, arg2);
}
static int
debug_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_breakpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_insert_breakpoint (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_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_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
return self->to_remove_breakpoint (self, arg1, arg2);
}
static int
debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
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);
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_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_stopped_by_sw_breakpoint (struct target_ops *self)
{
self = self->beneath;
return self->to_stopped_by_sw_breakpoint (self);
}
static int
tdefault_stopped_by_sw_breakpoint (struct target_ops *self)
{
return 0;
}
static int
debug_stopped_by_sw_breakpoint (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_stopped_by_sw_breakpoint (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_sw_breakpoint (", 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 int
delegate_supports_stopped_by_sw_breakpoint (struct target_ops *self)
{
self = self->beneath;
return self->to_supports_stopped_by_sw_breakpoint (self);
}
static int
tdefault_supports_stopped_by_sw_breakpoint (struct target_ops *self)
{
return 0;
}
static int
debug_supports_stopped_by_sw_breakpoint (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_supports_stopped_by_sw_breakpoint (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_sw_breakpoint (", 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 int
delegate_stopped_by_hw_breakpoint (struct target_ops *self)
{
self = self->beneath;
return self->to_stopped_by_hw_breakpoint (self);
}
static int
tdefault_stopped_by_hw_breakpoint (struct target_ops *self)
{
return 0;
}
static int
debug_stopped_by_hw_breakpoint (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_stopped_by_hw_breakpoint (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_hw_breakpoint (", 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 int
delegate_supports_stopped_by_hw_breakpoint (struct target_ops *self)
{
self = self->beneath;
return self->to_supports_stopped_by_hw_breakpoint (self);
}
static int
tdefault_supports_stopped_by_hw_breakpoint (struct target_ops *self)
{
return 0;
}
static int
debug_supports_stopped_by_hw_breakpoint (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_supports_stopped_by_hw_breakpoint (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_hw_breakpoint (", 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 int
delegate_can_use_hw_breakpoint (struct target_ops *self, enum bptype arg1, int arg2, int arg3)
{
self = self->beneath;
return self->to_can_use_hw_breakpoint (self, arg1, arg2, arg3);
}
static int
tdefault_can_use_hw_breakpoint (struct target_ops *self, enum bptype arg1, int arg2, int arg3)
{
return 0;
}
static int
debug_can_use_hw_breakpoint (struct target_ops *self, enum bptype arg1, int arg2, int arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_can_use_hw_breakpoint (&debug_target, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_bptype (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 (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_ranged_break_num_registers (struct target_ops *self)
{
self = self->beneath;
return self->to_ranged_break_num_registers (self);
}
static int
tdefault_ranged_break_num_registers (struct target_ops *self)
{
return -1;
}
static int
debug_ranged_break_num_registers (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_ranged_break_num_registers (...)\n", debug_target.to_shortname);
result = debug_target.to_ranged_break_num_registers (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_ranged_break_num_registers (", 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 int
delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
return self->to_insert_hw_breakpoint (self, arg1, arg2);
}
static int
tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
return -1;
}
static int
debug_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_hw_breakpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_insert_hw_breakpoint (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_hw_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_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
return self->to_remove_hw_breakpoint (self, arg1, arg2);
}
static int
tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
return -1;
}
static int
debug_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_hw_breakpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_remove_hw_breakpoint (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_hw_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_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
{
self = self->beneath;
return self->to_remove_watchpoint (self, arg1, arg2, arg3, arg4);
}
static int
tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
{
return -1;
}
static int
debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_remove_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_expression_p (arg4);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
{
self = self->beneath;
return self->to_insert_watchpoint (self, arg1, arg2, arg3, arg4);
}
static int
tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
{
return -1;
}
static int
debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_insert_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_expression_p (arg4);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
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, enum target_hw_bp_type arg3)
{
return 1;
}
static int
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);
result = debug_target.to_insert_mask_watchpoint (&debug_target, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_mask_watchpoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
fputs_unfiltered (", ", gdb_stdlog);
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_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, enum target_hw_bp_type arg3)
{
return 1;
}
static int
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);
result = debug_target.to_remove_mask_watchpoint (&debug_target, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_mask_watchpoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
fputs_unfiltered (", ", gdb_stdlog);
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_stopped_by_watchpoint (struct target_ops *self)
{
self = self->beneath;
return self->to_stopped_by_watchpoint (self);
}
static int
tdefault_stopped_by_watchpoint (struct target_ops *self)
{
return 0;
}
static int
debug_stopped_by_watchpoint (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_watchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_stopped_by_watchpoint (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_watchpoint (", 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 int
delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
{
self = self->beneath;
return self->to_stopped_data_address (self, arg1);
}
static int
tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
{
return 0;
}
static int
debug_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_data_address (...)\n", debug_target.to_shortname);
result = debug_target.to_stopped_data_address (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_data_address (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
return self->to_watchpoint_addr_within_range (self, arg1, arg2, arg3);
}
static int
debug_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_watchpoint_addr_within_range (...)\n", debug_target.to_shortname);
result = debug_target.to_watchpoint_addr_within_range (&debug_target, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_watchpoint_addr_within_range (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
{
self = self->beneath;
return self->to_region_ok_for_hw_watchpoint (self, arg1, arg2);
}
static int
debug_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_region_ok_for_hw_watchpoint (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_region_ok_for_hw_watchpoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (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 int
delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
return self->to_can_accel_watchpoint_condition (self, arg1, arg2, arg3, arg4);
}
static int
tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
return 0;
}
static int
debug_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_accel_watchpoint_condition (...)\n", debug_target.to_shortname);
result = debug_target.to_can_accel_watchpoint_condition (&debug_target, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_accel_watchpoint_condition (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (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_struct_expression_p (arg4);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
{
self = self->beneath;
return self->to_masked_watch_num_registers (self, arg1, arg2);
}
static int
tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
{
return -1;
}
static int
debug_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_masked_watch_num_registers (...)\n", debug_target.to_shortname);
result = debug_target.to_masked_watch_num_registers (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_masked_watch_num_registers (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
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)
{
self = self->beneath;
self->to_terminal_init (self);
}
static void
tdefault_terminal_init (struct target_ops *self)
{
}
static void
debug_terminal_init (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_init (...)\n", debug_target.to_shortname);
debug_target.to_terminal_init (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_init (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_terminal_inferior (struct target_ops *self)
{
self = self->beneath;
self->to_terminal_inferior (self);
}
static void
tdefault_terminal_inferior (struct target_ops *self)
{
}
static void
debug_terminal_inferior (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_inferior (...)\n", debug_target.to_shortname);
debug_target.to_terminal_inferior (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_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)
{
self = self->beneath;
self->to_terminal_ours_for_output (self);
}
static void
tdefault_terminal_ours_for_output (struct target_ops *self)
{
}
static void
debug_terminal_ours_for_output (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours_for_output (...)\n", debug_target.to_shortname);
debug_target.to_terminal_ours_for_output (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours_for_output (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_terminal_ours (struct target_ops *self)
{
self = self->beneath;
self->to_terminal_ours (self);
}
static void
tdefault_terminal_ours (struct target_ops *self)
{
}
static void
debug_terminal_ours (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours (...)\n", debug_target.to_shortname);
debug_target.to_terminal_ours (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
self->to_terminal_info (self, arg1, arg2);
}
static void
debug_terminal_info (struct target_ops *self, const char *arg1, int arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_info (...)\n", debug_target.to_shortname);
debug_target.to_terminal_info (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_info (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_kill (struct target_ops *self)
{
self = self->beneath;
self->to_kill (self);
}
static void
tdefault_kill (struct target_ops *self)
{
noprocess ();
}
static void
debug_kill (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_kill (...)\n", debug_target.to_shortname);
debug_target.to_kill (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_kill (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_load (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
self->to_load (self, arg1, arg2);
}
static void
tdefault_load (struct target_ops *self, const char *arg1, int arg2)
{
tcomplain ();
}
static void
debug_load (struct target_ops *self, const char *arg1, int arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_load (...)\n", debug_target.to_shortname);
debug_target.to_load (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_load (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
self->to_post_startup_inferior (self, arg1);
}
static void
tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
{
}
static void
debug_post_startup_inferior (struct target_ops *self, ptid_t arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_startup_inferior (...)\n", debug_target.to_shortname);
debug_target.to_post_startup_inferior (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_startup_inferior (", 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 (")\n", gdb_stdlog);
}
static int
delegate_insert_fork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
return self->to_insert_fork_catchpoint (self, arg1);
}
static int
tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
{
return 1;
}
static int
debug_insert_fork_catchpoint (struct target_ops *self, int arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_fork_catchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_insert_fork_catchpoint (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_fork_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 (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_remove_fork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
return self->to_remove_fork_catchpoint (self, arg1);
}
static int
tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
{
return 1;
}
static int
debug_remove_fork_catchpoint (struct target_ops *self, int arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_fork_catchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_remove_fork_catchpoint (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_fork_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 (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
return self->to_insert_vfork_catchpoint (self, arg1);
}
static int
tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
{
return 1;
}
static int
debug_insert_vfork_catchpoint (struct target_ops *self, int arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_vfork_catchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_insert_vfork_catchpoint (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_vfork_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 (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
return self->to_remove_vfork_catchpoint (self, arg1);
}
static int
tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
{
return 1;
}
static int
debug_remove_vfork_catchpoint (struct target_ops *self, int arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_vfork_catchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_remove_vfork_catchpoint (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_vfork_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 (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
return self->to_follow_fork (self, arg1, arg2);
}
static int
debug_follow_fork (struct target_ops *self, int arg1, int arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_fork (...)\n", debug_target.to_shortname);
result = debug_target.to_follow_fork (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_fork (", 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);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_insert_exec_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
return self->to_insert_exec_catchpoint (self, arg1);
}
static int
tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
{
return 1;
}
static int
debug_insert_exec_catchpoint (struct target_ops *self, int arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_exec_catchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_insert_exec_catchpoint (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_exec_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 (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_remove_exec_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
return self->to_remove_exec_catchpoint (self, arg1);
}
static int
tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
{
return 1;
}
static int
debug_remove_exec_catchpoint (struct target_ops *self, int arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_exec_catchpoint (...)\n", debug_target.to_shortname);
result = debug_target.to_remove_exec_catchpoint (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_exec_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 (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static void
delegate_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
{
self = self->beneath;
self->to_follow_exec (self, arg1, arg2);
}
static void
tdefault_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
{
}
static void
debug_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
{
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_struct_inferior_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_char_p (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static int
delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
{
self = self->beneath;
return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4, arg5);
}
static int
tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
{
return 1;
}
static int
debug_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
{
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);
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);
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;
}
static int
delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
{
self = self->beneath;
return self->to_has_exited (self, arg1, arg2, arg3);
}
static int
tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
{
return 0;
}
static int
debug_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
{
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);
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);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int_p (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static void
delegate_mourn_inferior (struct target_ops *self)
{
self = self->beneath;
self->to_mourn_inferior (self);
}
static void
debug_mourn_inferior (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_mourn_inferior (...)\n", debug_target.to_shortname);
debug_target.to_mourn_inferior (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_mourn_inferior (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static int
delegate_can_run (struct target_ops *self)
{
self = self->beneath;
return self->to_can_run (self);
}
static int
tdefault_can_run (struct target_ops *self)
{
return 0;
}
static int
debug_can_run (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run (...)\n", debug_target.to_shortname);
result = debug_target.to_can_run (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run (", 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_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
self = self->beneath;
self->to_pass_signals (self, arg1, arg2);
}
static void
tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
}
static void
debug_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", debug_target.to_shortname);
debug_target.to_pass_signals (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", 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_signals (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
self = self->beneath;
self->to_program_signals (self, arg1, arg2);
}
static void
tdefault_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
}
static void
debug_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", debug_target.to_shortname);
debug_target.to_program_signals (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", 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_signals (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static int
delegate_thread_alive (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
return self->to_thread_alive (self, arg1);
}
static int
tdefault_thread_alive (struct target_ops *self, ptid_t arg1)
{
return 0;
}
static int
debug_thread_alive (struct target_ops *self, ptid_t arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_alive (...)\n", debug_target.to_shortname);
result = debug_target.to_thread_alive (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_alive (", 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 void
delegate_update_thread_list (struct target_ops *self)
{
self = self->beneath;
self->to_update_thread_list (self);
}
static void
tdefault_update_thread_list (struct target_ops *self)
{
}
static void
debug_update_thread_list (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_update_thread_list (...)\n", debug_target.to_shortname);
debug_target.to_update_thread_list (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_update_thread_list (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static 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 *
debug_pid_to_str (struct target_ops *self, ptid_t arg1)
{
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);
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_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static 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 *
tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
{
return NULL;
}
static char *
debug_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
{
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);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_thread_info_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
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 const char *
tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
{
return NULL;
}
static const char *
debug_thread_name (struct target_ops *self, struct thread_info *arg1)
{
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);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_thread_info_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_const_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static void
delegate_stop (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
self->to_stop (self, arg1);
}
static void
tdefault_stop (struct target_ops *self, ptid_t arg1)
{
}
static void
debug_stop (struct target_ops *self, ptid_t arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop (...)\n", debug_target.to_shortname);
debug_target.to_stop (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop (", 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 (")\n", gdb_stdlog);
}
static void
delegate_interrupt (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
self->to_interrupt (self, arg1);
}
static void
tdefault_interrupt (struct target_ops *self, ptid_t arg1)
{
}
static void
debug_interrupt (struct target_ops *self, ptid_t arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_interrupt (...)\n", debug_target.to_shortname);
debug_target.to_interrupt (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_interrupt (", 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 (")\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)
{
self = self->beneath;
self->to_rcmd (self, arg1, arg2);
}
static void
debug_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_rcmd (...)\n", debug_target.to_shortname);
debug_target.to_rcmd (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_rcmd (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_ui_file_p (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static char *
delegate_pid_to_exec_file (struct target_ops *self, int arg1)
{
self = self->beneath;
return self->to_pid_to_exec_file (self, arg1);
}
static char *
tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
{
return NULL;
}
static char *
debug_pid_to_exec_file (struct target_ops *self, int arg1)
{
char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_exec_file (...)\n", debug_target.to_shortname);
result = debug_target.to_pid_to_exec_file (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_exec_file (", 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_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static void
delegate_log_command (struct target_ops *self, const char *arg1)
{
self = self->beneath;
self->to_log_command (self, arg1);
}
static void
tdefault_log_command (struct target_ops *self, const char *arg1)
{
}
static void
debug_log_command (struct target_ops *self, const char *arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_log_command (...)\n", debug_target.to_shortname);
debug_target.to_log_command (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_log_command (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
static struct target_section_table *
delegate_get_section_table (struct target_ops *self)
{
self = self->beneath;
return self->to_get_section_table (self);
}
static struct target_section_table *
tdefault_get_section_table (struct target_ops *self)
{
return NULL;
}
static struct target_section_table *
debug_get_section_table (struct target_ops *self)
{
struct target_section_table * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_section_table (...)\n", debug_target.to_shortname);
result = debug_target.to_get_section_table (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_section_table (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_struct_target_section_table_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_can_async_p (struct target_ops *self)
{
self = self->beneath;
return self->to_can_async_p (self);
}
static int
tdefault_can_async_p (struct target_ops *self)
{
return 0;
}
static int
debug_can_async_p (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_async_p (...)\n", debug_target.to_shortname);
result = debug_target.to_can_async_p (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_async_p (", 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 int
delegate_is_async_p (struct target_ops *self)
{
self = self->beneath;
return self->to_is_async_p (self);
}
static int
tdefault_is_async_p (struct target_ops *self)
{
return 0;
}
static int
debug_is_async_p (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_is_async_p (...)\n", debug_target.to_shortname);
result = debug_target.to_is_async_p (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_is_async_p (", 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_async (struct target_ops *self, int arg1)
{
self = self->beneath;
self->to_async (self, arg1);
}
static void
tdefault_async (struct target_ops *self, int arg1)
{
tcomplain ();
}
static void
debug_async (struct target_ops *self, int arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname);
debug_target.to_async (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", 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 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)
{
self = self->beneath;
return self->to_supports_non_stop (self);
}
static int
tdefault_supports_non_stop (struct target_ops *self)
{
return 0;
}
static int
debug_supports_non_stop (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", debug_target.to_shortname);
result = debug_target.to_supports_non_stop (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", 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 int
delegate_always_non_stop_p (struct target_ops *self)
{
self = self->beneath;
return self->to_always_non_stop_p (self);
}
static int
tdefault_always_non_stop_p (struct target_ops *self)
{
return 0;
}
static int
debug_always_non_stop_p (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_always_non_stop_p (...)\n", debug_target.to_shortname);
result = debug_target.to_always_non_stop_p (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_always_non_stop_p (", 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 int
delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
{
self = self->beneath;
return self->to_find_memory_regions (self, arg1, arg2);
}
static int
debug_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", debug_target.to_shortname);
result = debug_target.to_find_memory_regions (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_find_memory_region_ftype (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_void_p (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static char *
delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
{
self = self->beneath;
return self->to_make_corefile_notes (self, arg1, arg2);
}
static char *
debug_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
{
char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", debug_target.to_shortname);
result = debug_target.to_make_corefile_notes (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_bfd_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int_p (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static gdb_byte *
delegate_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
return self->to_get_bookmark (self, arg1, arg2);
}
static gdb_byte *
tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
{
tcomplain ();
}
static gdb_byte *
debug_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
{
gdb_byte * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", debug_target.to_shortname);
result = debug_target.to_get_bookmark (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_gdb_byte_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static void
delegate_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
{
self = self->beneath;
self->to_goto_bookmark (self, arg1, arg2);
}
static void
tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
{
tcomplain ();
}
static void
debug_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", debug_target.to_shortname);
debug_target.to_goto_bookmark (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", 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 (")\n", gdb_stdlog);
}
static CORE_ADDR
delegate_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
{
self = self->beneath;
return self->to_get_thread_local_address (self, arg1, arg2, arg3);
}
static CORE_ADDR
tdefault_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
{
generic_tls_error ();
}
static CORE_ADDR
debug_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
{
CORE_ADDR result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_thread_local_address (...)\n", debug_target.to_shortname);
result = debug_target.to_get_thread_local_address (&debug_target, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_thread_local_address (", 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_CORE_ADDR (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_CORE_ADDR (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static enum target_xfer_status
delegate_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
{
self = self->beneath;
return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
static enum target_xfer_status
tdefault_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
{
return TARGET_XFER_E_IO;
}
static enum target_xfer_status
debug_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
{
enum target_xfer_status result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", debug_target.to_shortname);
result = debug_target.to_xfer_partial (&debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_target_object (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_gdb_byte_p (arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_gdb_byte_p (arg4);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg5);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg6);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST_p (arg7);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_enum_target_xfer_status (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static VEC(mem_region_s) *
delegate_memory_map (struct target_ops *self)
{
self = self->beneath;
return self->to_memory_map (self);
}
static VEC(mem_region_s) *
tdefault_memory_map (struct target_ops *self)
{
return NULL;
}
static VEC(mem_region_s) *
debug_memory_map (struct target_ops *self)
{
VEC(mem_region_s) * 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);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static void
delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
{
self = self->beneath;
self->to_flash_erase (self, arg1, arg2);
}
static void
tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
{
tcomplain ();
}
static void
debug_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", debug_target.to_shortname);
debug_target.to_flash_erase (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_LONGEST (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_flash_done (struct target_ops *self)
{
self = self->beneath;
self->to_flash_done (self);
}
static void
tdefault_flash_done (struct target_ops *self)
{
tcomplain ();
}
static void
debug_flash_done (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", debug_target.to_shortname);
debug_target.to_flash_done (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static const struct target_desc *
delegate_read_description (struct target_ops *self)
{
self = self->beneath;
return self->to_read_description (self);
}
static const struct target_desc *
tdefault_read_description (struct target_ops *self)
{
return NULL;
}
static const struct target_desc *
debug_read_description (struct target_ops *self)
{
const struct target_desc * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", debug_target.to_shortname);
result = debug_target.to_read_description (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_const_struct_target_desc_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static ptid_t
delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
{
self = self->beneath;
return self->to_get_ada_task_ptid (self, arg1, arg2);
}
static ptid_t
debug_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
{
ptid_t result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", debug_target.to_shortname);
result = debug_target.to_get_ada_task_ptid (&debug_target, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_long (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_long (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_ptid_t (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
{
self = self->beneath;
return self->to_auxv_parse (self, arg1, arg2, arg3, arg4);
}
static int
debug_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", debug_target.to_shortname);
result = debug_target.to_auxv_parse (&debug_target, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_gdb_byte_pp (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_gdb_byte_p (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg4);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
{
self = self->beneath;
return self->to_search_memory (self, arg1, arg2, arg3, arg4, arg5);
}
static int
debug_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", debug_target.to_shortname);
result = debug_target.to_search_memory (&debug_target, arg1, arg2, arg3, arg4, arg5);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_gdb_byte_p (arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg4);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg5);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_can_execute_reverse (struct target_ops *self)
{
self = self->beneath;
return self->to_can_execute_reverse (self);
}
static int
tdefault_can_execute_reverse (struct target_ops *self)
{
return 0;
}
static int
debug_can_execute_reverse (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", debug_target.to_shortname);
result = debug_target.to_can_execute_reverse (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", 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 enum exec_direction_kind
delegate_execution_direction (struct target_ops *self)
{
self = self->beneath;
return self->to_execution_direction (self);
}
static enum exec_direction_kind
debug_execution_direction (struct target_ops *self)
{
enum exec_direction_kind result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", debug_target.to_shortname);
result = debug_target.to_execution_direction (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_enum_exec_direction_kind (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_supports_multi_process (struct target_ops *self)
{
self = self->beneath;
return self->to_supports_multi_process (self);
}
static int
tdefault_supports_multi_process (struct target_ops *self)
{
return 0;
}
static int
debug_supports_multi_process (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", debug_target.to_shortname);
result = debug_target.to_supports_multi_process (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", 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 int
delegate_supports_enable_disable_tracepoint (struct target_ops *self)
{
self = self->beneath;
return self->to_supports_enable_disable_tracepoint (self);
}
static int
tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
{
return 0;
}
static int
debug_supports_enable_disable_tracepoint (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", debug_target.to_shortname);
result = debug_target.to_supports_enable_disable_tracepoint (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", 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 int
delegate_supports_string_tracing (struct target_ops *self)
{
self = self->beneath;
return self->to_supports_string_tracing (self);
}
static int
tdefault_supports_string_tracing (struct target_ops *self)
{
return 0;
}
static int
debug_supports_string_tracing (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", debug_target.to_shortname);
result = debug_target.to_supports_string_tracing (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", 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 int
delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
{
self = self->beneath;
return self->to_supports_evaluation_of_breakpoint_conditions (self);
}
static int
tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
{
return 0;
}
static int
debug_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", debug_target.to_shortname);
result = debug_target.to_supports_evaluation_of_breakpoint_conditions (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", 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 int
delegate_can_run_breakpoint_commands (struct target_ops *self)
{
self = self->beneath;
return self->to_can_run_breakpoint_commands (self);
}
static int
tdefault_can_run_breakpoint_commands (struct target_ops *self)
{
return 0;
}
static int
debug_can_run_breakpoint_commands (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", debug_target.to_shortname);
result = debug_target.to_can_run_breakpoint_commands (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", 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 struct gdbarch *
delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
return self->to_thread_architecture (self, arg1);
}
static struct gdbarch *
debug_thread_architecture (struct target_ops *self, ptid_t arg1)
{
struct gdbarch * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", debug_target.to_shortname);
result = debug_target.to_thread_architecture (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", 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_struct_gdbarch_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static struct address_space *
delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
return self->to_thread_address_space (self, arg1);
}
static struct address_space *
debug_thread_address_space (struct target_ops *self, ptid_t arg1)
{
struct address_space * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", debug_target.to_shortname);
result = debug_target.to_thread_address_space (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", 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_struct_address_space_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
static int
delegate_filesystem_is_local (struct target_ops *self)
{
self = self->beneath;
return self->to_filesystem_is_local (self);
}
static int
tdefault_filesystem_is_local (struct target_ops *self)
{
return 1;
}
static int
debug_filesystem_is_local (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_filesystem_is_local (...)\n", debug_target.to_shortname);
result = debug_target.to_filesystem_is_local (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_filesystem_is_local (", 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_trace_init (struct target_ops *self)
{
self = self->beneath;
self->to_trace_init (self);
}
static void
tdefault_trace_init (struct target_ops *self)
{
tcomplain ();
}
static void
debug_trace_init (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", debug_target.to_shortname);
debug_target.to_trace_init (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
self->to_download_tracepoint (self, arg1);
}
static void
tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
tcomplain ();
}
static void
debug_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", debug_target.to_shortname);
debug_target.to_download_tracepoint (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_bp_location_p (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
static int
delegate_can_download_tracepoint (struct target_ops *self)
{
self = self->beneath;
return self->to_can_download_tracepoint (self);
}
static int
tdefault_can_download_tracepoint (struct target_ops *self)
{
return 0;
}
static int
debug_can_download_tracepoint (struct target_ops *self)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", debug_target.to_shortname);
result = debug_target.to_can_download_tracepoint (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", 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_download_trace_state_variable (struct target_ops *self, struct 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)
{
tcomplain ();
}
static void
debug_download_trace_state_variable (struct target_ops *self, struct 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);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
self->to_enable_tracepoint (self, arg1);
}
static void
tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
tcomplain ();
}
static void
debug_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", debug_target.to_shortname);
debug_target.to_enable_tracepoint (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_bp_location_p (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
self->to_disable_tracepoint (self, arg1);
}
static void
tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
tcomplain ();
}
static void
debug_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", debug_target.to_shortname);
debug_target.to_disable_tracepoint (&debug_target, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_bp_location_p (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_trace_set_readonly_regions (struct target_ops *self)
{
self = self->beneath;
self->to_trace_set_readonly_regions (self);
}
static void
tdefault_trace_set_readonly_regions (struct target_ops *self)
{
tcomplain ();
}
static void
debug_trace_set_readonly_regions (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", debug_target.to_shortname);
debug_target.to_trace_set_readonly_regions (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}
static void
delegate_trace_start (struct target_ops *self)
{
self = self->beneath;
self->to_trace_start (self);
}
static void
tdefault_trace_start (struct target_ops *self)
{
tcomplain ();
}
static void
debug_trace_start (struct target_ops *self)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", debug_target.to_shortname);
debug_target.to_trace_start (&debug_target);
fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", debug_target.to_shortname);
target_debug_print_struct_target_ops_p (&debug_target);
fputs_unfiltered (")\n", gdb_stdlog);
}