auto-generate most target debug methods

The target debug methods are inconsistently maintained.  Most to_*
methods have some kind of targetdebug awareness, but not all of them
do.  The ones that do vary in the quantity and quality of output they
generate.

This patch changes most of the target debug methods to be
automatically generated.  All the arguments are printed, and separate
lines are printed for entering and existing the outermost call to the
target stack.

For example now you'd see:

    -> multi-thread->to_terminal_ours (...)
    -> multi-thread->to_is_async_p (...)
    <- multi-thread->to_is_async_p (0x1ebb580) = 1
    <- multi-thread->to_terminal_ours (0x1ebb580)
    -> multi-thread->to_thread_address_space (...)
    <- multi-thread->to_thread_address_space (0x1ebb580, 26802) = 1

In this case you can see nested calls.  The "multi-thread" on the left
hand side is the topmost target's shortname.

There are some oddities with this patch.  I'm on the fence about it
all, I really just wrote it on a whim.

It's not simple to convert every possible method, since a few don't
participate in target delegation.

Printing is done by type, so I introduced some new
debug-printing-specific typedefs to handle cases where it is nicer to
do something else.

On the plus side, this lays the groundwork for making targetdebug
affect every layer of the target stack.  The idea would be to wrap
each target_ops in the stack with its own debug_target, and then you
could see calls propagate down the stack and back up; I suppose with
indentation to make it prettier.  (That said there are some gotchas
lurking in this idea due to target stack introspection.)

Regtested on x86-64 Fedora 20.

2014-07-24  Tom Tromey  <tromey@redhat.com>

	* make-target-delegates (munge_type, write_debugmethod): New
	functions.
	(debug_names): New global.
	($TARGET_DEBUG_PRINTER): New global.
	(write_function_header): Strip TARGET_DEBUG_PRINTER from the type
	name.
	Write debug methods.  Generate init_debug_target.
	* target-debug.h: New file.
	* target-delegates.c: Rebuild.
	* target.c: Include target-debug.h.
	(debug_target): Hoist definition.
	(target_kill, target_get_section_table, target_memory_map)
	(target_flash_erase, target_flash_done, target_detach)
	(target_disconnect, target_wait, target_resume)
	(target_pass_signals, target_program_signals, target_follow_fork)
	(target_mourn_inferior, target_search_memory)
	(target_thread_address_space, target_close)
	(target_find_new_threads, target_core_of_thread)
	(target_verify_memory, target_insert_mask_watchpoint)
	(target_remove_mask_watchpoint): Remove targetdebug code.
	(debug_to_post_attach, debug_to_prepare_to_store)
	(debug_to_files_info, debug_to_insert_breakpoint)
	(debug_to_remove_breakpoint, debug_to_can_use_hw_breakpoint)
	(debug_to_region_ok_for_hw_watchpoint)
	(debug_to_can_accel_watchpoint_condition)
	(debug_to_stopped_by_watchpoint, debug_to_stopped_data_address)
	(debug_to_watchpoint_addr_within_range)
	(debug_to_insert_hw_breakpoint, debug_to_remove_hw_breakpoint)
	(debug_to_insert_watchpoint, debug_to_remove_watchpoint)
	(debug_to_terminal_init, debug_to_terminal_inferior)
	(debug_to_terminal_ours_for_output, debug_to_terminal_ours)
	(debug_to_terminal_save_ours, debug_to_terminal_info)
	(debug_to_load, debug_to_post_startup_inferior)
	(debug_to_insert_fork_catchpoint)
	(debug_to_remove_fork_catchpoint)
	(debug_to_insert_vfork_catchpoint)
	(debug_to_remove_vfork_catchpoint)
	(debug_to_insert_exec_catchpoint)
	(debug_to_remove_exec_catchpoint, debug_to_has_exited)
	(debug_to_can_run, debug_to_thread_architecture, debug_to_stop)
	(debug_to_rcmd, debug_to_pid_to_exec_file): Remove.
	(setup_target_debug): Call init_debug_target.
	* target.h (TARGET_DEBUG_PRINTER): New macro.
	(struct target_ops) <to_resume, to_wait, to_pass_signals,
	to_program_signals>: Use TARGET_DEBUG_PRINTER.

1 files changed, 2228 insertions, 4 deletions

diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c
index 8c8167282e5..843a9546961 100644
--- a/gdb/target-delegates.c
+++ b/gdb/target-delegates.c
@@ -16,6 +16,18 @@ 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;
@@ -28,6 +40,20 @@ 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;
@@ -41,6 +67,20 @@ tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
 }
 
 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;
@@ -53,6 +93,22 @@ tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal
   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)
 {
@@ -66,6 +122,26 @@ tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *a
   noprocess ();
 }
 
+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)
 {
@@ -79,6 +155,20 @@ tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int ar
 }
 
 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;
@@ -92,6 +182,20 @@ tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int ar
 }
 
 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;
@@ -105,6 +209,18 @@ tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
 }
 
 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;
@@ -116,6 +232,16 @@ 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)
 {
@@ -124,6 +250,24 @@ delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struc
 }
 
 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;
@@ -131,6 +275,24 @@ delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struc
 }
 
 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_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
 {
   self = self->beneath;
@@ -144,6 +306,26 @@ tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int
 }
 
 static int
+debug_can_use_hw_breakpoint (struct target_ops *self, int 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_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 (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
+static int
 delegate_ranged_break_num_registers (struct target_ops *self)
 {
   self = self->beneath;
@@ -157,6 +339,20 @@ tdefault_ranged_break_num_registers (struct target_ops *self)
 }
 
 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;
@@ -170,6 +366,24 @@ tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, st
 }
 
 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;
@@ -183,6 +397,24 @@ tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, st
 }
 
 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, int arg3, struct expression *arg4)
 {
   self = self->beneath;
@@ -196,6 +428,28 @@ tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, i
 }
 
 static int
+debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int 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_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_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 {
   self = self->beneath;
@@ -209,6 +463,28 @@ tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, i
 }
 
 static int
+debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int 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_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_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
 {
   self = self->beneath;
@@ -222,6 +498,26 @@ tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_A
 }
 
 static int
+debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int 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_int (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, int arg3)
 {
   self = self->beneath;
@@ -235,6 +531,26 @@ tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_A
 }
 
 static int
+debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int 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_int (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;
@@ -248,6 +564,20 @@ tdefault_stopped_by_watchpoint (struct target_ops *self)
 }
 
 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;
@@ -261,6 +591,22 @@ tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
 }
 
 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;
@@ -268,6 +614,26 @@ delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1,
 }
 
 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;
@@ -275,6 +641,24 @@ delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, i
 }
 
 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;
@@ -288,6 +672,28 @@ tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1
 }
 
 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;
@@ -300,6 +706,24 @@ tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CO
   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 void
 delegate_terminal_init (struct target_ops *self)
 {
@@ -313,6 +737,16 @@ 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;
@@ -325,6 +759,16 @@ 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;
@@ -337,6 +781,16 @@ 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;
@@ -349,6 +803,16 @@ 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_save_ours (struct target_ops *self)
 {
   self = self->beneath;
@@ -361,6 +825,16 @@ tdefault_terminal_save_ours (struct target_ops *self)
 }
 
 static void
+debug_terminal_save_ours (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_save_ours (...)\n", debug_target.to_shortname);
+  debug_target.to_terminal_save_ours (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_save_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;
@@ -368,6 +842,20 @@ delegate_terminal_info (struct target_ops *self, const char *arg1, int 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;
@@ -381,6 +869,16 @@ tdefault_kill (struct target_ops *self)
 }
 
 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;
@@ -394,6 +892,20 @@ tdefault_load (struct target_ops *self, const char *arg1, int arg2)
 }
 
 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;
@@ -405,6 +917,18 @@ 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)
 {
@@ -419,6 +943,22 @@ tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
 }
 
 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;
@@ -432,6 +972,22 @@ tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
 }
 
 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;
@@ -445,6 +1001,22 @@ tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
 }
 
 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;
@@ -458,6 +1030,22 @@ tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
 }
 
 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;
@@ -465,6 +1053,24 @@ delegate_follow_fork (struct target_ops *self, int arg1, int 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;
@@ -478,6 +1084,22 @@ tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
 }
 
 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;
@@ -491,6 +1113,22 @@ tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
 }
 
 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 int
 delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
 {
   self = self->beneath;
@@ -504,6 +1142,30 @@ tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, in
 }
 
 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;
@@ -516,6 +1178,26 @@ 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)
 {
@@ -523,6 +1205,16 @@ delegate_mourn_inferior (struct target_ops *self)
   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)
 {
@@ -536,30 +1228,72 @@ 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)
+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)
+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)
+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)
+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)
 {
@@ -573,6 +1307,22 @@ 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_find_new_threads (struct target_ops *self)
 {
@@ -585,6 +1335,16 @@ tdefault_find_new_threads (struct target_ops *self)
 {
 }
 
+static void
+debug_find_new_threads (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_new_threads (...)\n", debug_target.to_shortname);
+  debug_target.to_find_new_threads (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_new_threads (", 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)
 {
@@ -593,6 +1353,22 @@ delegate_pid_to_str (struct target_ops *self, ptid_t 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;
@@ -606,6 +1382,22 @@ tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
 }
 
 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 char *
 delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
 {
   self = self->beneath;
@@ -618,6 +1410,22 @@ tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
   return NULL;
 }
 
+static char *
+debug_thread_name (struct target_ops *self, struct thread_info *arg1)
+{
+  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_char_p (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static void
 delegate_stop (struct target_ops *self, ptid_t arg1)
 {
@@ -631,12 +1439,38 @@ 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_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)
 {
@@ -650,6 +1484,22 @@ 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)
 {
@@ -662,6 +1512,18 @@ 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)
 {
@@ -675,6 +1537,20 @@ 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)
 {
@@ -689,6 +1565,20 @@ tdefault_can_async_p (struct target_ops *self)
 }
 
 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;
@@ -701,6 +1591,20 @@ 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, async_callback_ftype *arg1, void *arg2)
 {
@@ -714,6 +1618,20 @@ tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
   tcomplain ();
 }
 
+static void
+debug_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname);
+  debug_target.to_async (&debug_target, arg1, arg2);
+  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_async_callback_ftype_p (arg1);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_void_p (arg2);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
 static int
 delegate_supports_non_stop (struct target_ops *self)
 {
@@ -728,12 +1646,44 @@ tdefault_supports_non_stop (struct target_ops *self)
 }
 
 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_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)
 {
@@ -741,6 +1691,24 @@ delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
   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)
 {
@@ -754,6 +1722,24 @@ 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)
 {
@@ -767,6 +1753,20 @@ 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)
 {
@@ -780,6 +1780,26 @@ tdefault_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_AD
   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)
 {
@@ -793,6 +1813,34 @@ tdefault_xfer_partial (struct target_ops *self, enum target_object arg1, const c
   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)
 {
@@ -806,6 +1854,20 @@ 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)
 {
@@ -820,6 +1882,20 @@ tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
 }
 
 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;
@@ -832,6 +1908,16 @@ 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)
 {
@@ -845,6 +1931,20 @@ 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)
 {
@@ -852,6 +1952,24 @@ delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
   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)
 {
@@ -860,6 +1978,28 @@ delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, C
 }
 
 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;
@@ -867,6 +2007,30 @@ delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2,
 }
 
 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;
@@ -879,6 +2043,20 @@ 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)
 {
@@ -886,6 +2064,20 @@ delegate_execution_direction (struct target_ops *self)
   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)
 {
@@ -900,6 +2092,20 @@ tdefault_supports_multi_process (struct target_ops *self)
 }
 
 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;
@@ -913,6 +2119,20 @@ tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
 }
 
 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;
@@ -926,6 +2146,20 @@ tdefault_supports_string_tracing (struct target_ops *self)
 }
 
 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;
@@ -939,6 +2173,20 @@ tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
 }
 
 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;
@@ -951,6 +2199,20 @@ 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)
 {
@@ -958,6 +2220,22 @@ delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
   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)
 {
@@ -965,6 +2243,22 @@ delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
   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 void
 delegate_trace_init (struct target_ops *self)
 {
@@ -979,6 +2273,16 @@ tdefault_trace_init (struct target_ops *self)
 }
 
 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;
@@ -991,6 +2295,18 @@ 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)
 {
@@ -1004,6 +2320,20 @@ 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)
 {
@@ -1018,6 +2348,18 @@ tdefault_download_trace_state_variable (struct target_ops *self, struct trace_st
 }
 
 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;
@@ -1031,6 +2373,18 @@ tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 }
 
 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;
@@ -1044,6 +2398,18 @@ tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 }
 
 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;
@@ -1057,6 +2423,16 @@ tdefault_trace_set_readonly_regions (struct target_ops *self)
 }
 
 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;
@@ -1069,6 +2445,16 @@ 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);
+}
+
 static int
 delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
 {
@@ -1082,6 +2468,22 @@ tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
   return -1;
 }
 
+static int
+debug_get_trace_status (struct target_ops *self, struct trace_status *arg1)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", debug_target.to_shortname);
+  result = debug_target.to_get_trace_status (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_struct_trace_status_p (arg1);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static void
 delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
 {
@@ -1096,6 +2498,20 @@ tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1
 }
 
 static void
+debug_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", debug_target.to_shortname);
+  debug_target.to_get_tracepoint_status (&debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_struct_breakpoint_p (arg1);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_struct_uploaded_tp_p (arg2);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_trace_stop (struct target_ops *self)
 {
   self = self->beneath;
@@ -1108,6 +2524,16 @@ tdefault_trace_stop (struct target_ops *self)
   tcomplain ();
 }
 
+static void
+debug_trace_stop (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", debug_target.to_shortname);
+  debug_target.to_trace_stop (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
 static int
 delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
 {
@@ -1122,6 +2548,30 @@ tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg
 }
 
 static int
+debug_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", debug_target.to_shortname);
+  result = debug_target.to_trace_find (&debug_target, arg1, arg2, arg3, arg4, arg5);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_enum_trace_find_type (arg1);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_int (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_CORE_ADDR (arg3);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_CORE_ADDR (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_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
 {
   self = self->beneath;
@@ -1135,6 +2585,24 @@ tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONG
 }
 
 static int
+debug_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", debug_target.to_shortname);
+  result = debug_target.to_get_trace_state_variable_value (&debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", 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_LONGEST_p (arg2);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
+static int
 delegate_save_trace_data (struct target_ops *self, const char *arg1)
 {
   self = self->beneath;
@@ -1148,6 +2616,22 @@ tdefault_save_trace_data (struct target_ops *self, const char *arg1)
 }
 
 static int
+debug_save_trace_data (struct target_ops *self, const char *arg1)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", debug_target.to_shortname);
+  result = debug_target.to_save_trace_data (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", 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 (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
+static int
 delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
 {
   self = self->beneath;
@@ -1161,6 +2645,22 @@ tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
 }
 
 static int
+debug_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", debug_target.to_shortname);
+  result = debug_target.to_upload_tracepoints (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_struct_uploaded_tp_pp (arg1);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
+static int
 delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
 {
   self = self->beneath;
@@ -1173,6 +2673,22 @@ tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_
   return 0;
 }
 
+static int
+debug_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", debug_target.to_shortname);
+  result = debug_target.to_upload_trace_state_variables (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_struct_uploaded_tsv_pp (arg1);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static LONGEST
 delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
 {
@@ -1186,6 +2702,26 @@ tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST a
   tcomplain ();
 }
 
+static LONGEST
+debug_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
+{
+  LONGEST result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", debug_target.to_shortname);
+  result = debug_target.to_get_raw_trace_data (&debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_gdb_byte_p (arg1);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_ULONGEST (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_LONGEST (arg3);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_LONGEST (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static int
 delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
 {
@@ -1199,6 +2735,20 @@ tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
   return -1;
 }
 
+static int
+debug_get_min_fast_tracepoint_insn_len (struct target_ops *self)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", debug_target.to_shortname);
+  result = debug_target.to_get_min_fast_tracepoint_insn_len (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", 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_set_disconnected_tracing (struct target_ops *self, int arg1)
 {
@@ -1212,6 +2762,18 @@ tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
 }
 
 static void
+debug_set_disconnected_tracing (struct target_ops *self, int arg1)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", debug_target.to_shortname);
+  debug_target.to_set_disconnected_tracing (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", 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_set_circular_trace_buffer (struct target_ops *self, int arg1)
 {
   self = self->beneath;
@@ -1224,6 +2786,18 @@ tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
 }
 
 static void
+debug_set_circular_trace_buffer (struct target_ops *self, int arg1)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", debug_target.to_shortname);
+  debug_target.to_set_circular_trace_buffer (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", 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_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
 {
   self = self->beneath;
@@ -1235,6 +2809,18 @@ tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
 {
 }
 
+static void
+debug_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", debug_target.to_shortname);
+  debug_target.to_set_trace_buffer_size (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_LONGEST (arg1);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
 static int
 delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
 {
@@ -1249,6 +2835,26 @@ tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char
 }
 
 static int
+debug_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", debug_target.to_shortname);
+  result = debug_target.to_set_trace_notes (&debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", 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_const_char_p (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_const_char_p (arg3);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
+static int
 delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
 {
   self = self->beneath;
@@ -1262,6 +2868,22 @@ tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
 }
 
 static int
+debug_core_of_thread (struct target_ops *self, ptid_t arg1)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", debug_target.to_shortname);
+  result = debug_target.to_core_of_thread (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", 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_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
 {
   self = self->beneath;
@@ -1269,6 +2891,26 @@ delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR
 }
 
 static int
+debug_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", debug_target.to_shortname);
+  result = debug_target.to_verify_memory (&debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", 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_CORE_ADDR (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_ULONGEST (arg3);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
+static int
 delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
 {
   self = self->beneath;
@@ -1281,6 +2923,24 @@ tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
   tcomplain ();
 }
 
+static int
+debug_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", debug_target.to_shortname);
+  result = debug_target.to_get_tib_address (&debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_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_p (arg2);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static void
 delegate_set_permissions (struct target_ops *self)
 {
@@ -1293,6 +2953,16 @@ tdefault_set_permissions (struct target_ops *self)
 {
 }
 
+static void
+debug_set_permissions (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", debug_target.to_shortname);
+  debug_target.to_set_permissions (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
 static int
 delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
 {
@@ -1306,6 +2976,24 @@ tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, s
   return 0;
 }
 
+static int
+debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
+{
+  int 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);
+  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_struct_static_tracepoint_marker_p (arg2);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static VEC(static_tracepoint_marker_p) *
 delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
 {
@@ -1319,6 +3007,22 @@ tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char
   tcomplain ();
 }
 
+static VEC(static_tracepoint_marker_p) *
+debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
+{
+  VEC(static_tracepoint_marker_p) * 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);
+  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_VEC_static_tracepoint_marker_p__p (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static struct traceframe_info *
 delegate_traceframe_info (struct target_ops *self)
 {
@@ -1332,6 +3036,20 @@ tdefault_traceframe_info (struct target_ops *self)
   tcomplain ();
 }
 
+static struct traceframe_info *
+debug_traceframe_info (struct target_ops *self)
+{
+  struct traceframe_info * 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);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static int
 delegate_use_agent (struct target_ops *self, int arg1)
 {
@@ -1346,6 +3064,22 @@ tdefault_use_agent (struct target_ops *self, int arg1)
 }
 
 static int
+debug_use_agent (struct target_ops *self, int arg1)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", debug_target.to_shortname);
+  result = debug_target.to_use_agent (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", 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_can_use_agent (struct target_ops *self)
 {
   self = self->beneath;
@@ -1359,6 +3093,20 @@ tdefault_can_use_agent (struct target_ops *self)
 }
 
 static int
+debug_can_use_agent (struct target_ops *self)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", debug_target.to_shortname);
+  result = debug_target.to_can_use_agent (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", 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_btrace (struct target_ops *self)
 {
   self = self->beneath;
@@ -1371,6 +3119,20 @@ tdefault_supports_btrace (struct target_ops *self)
   return 0;
 }
 
+static int
+debug_supports_btrace (struct target_ops *self)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
+  result = debug_target.to_supports_btrace (&debug_target);
+  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_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static struct btrace_target_info *
 delegate_enable_btrace (struct target_ops *self, ptid_t arg1)
 {
@@ -1384,6 +3146,22 @@ tdefault_enable_btrace (struct target_ops *self, ptid_t arg1)
   tcomplain ();
 }
 
+static struct btrace_target_info *
+debug_enable_btrace (struct target_ops *self, ptid_t arg1)
+{
+  struct btrace_target_info * result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname);
+  result = debug_target.to_enable_btrace (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", 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_btrace_target_info_p (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static void
 delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
 {
@@ -1398,6 +3176,18 @@ tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg
 }
 
 static void
+debug_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname);
+  debug_target.to_disable_btrace (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_struct_btrace_target_info_p (arg1);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
 {
   self = self->beneath;
@@ -1410,6 +3200,18 @@ tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *ar
   tcomplain ();
 }
 
+static void
+debug_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname);
+  debug_target.to_teardown_btrace (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_struct_btrace_target_info_p (arg1);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
 static enum btrace_error
 delegate_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
 {
@@ -1423,6 +3225,26 @@ tdefault_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, stru
   tcomplain ();
 }
 
+static enum btrace_error
+debug_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
+{
+  enum btrace_error result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname);
+  result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_VEC__btrace_block_s__pp (arg1);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_struct_btrace_target_info_p (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_enum_btrace_read_type (arg3);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_enum_btrace_error (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static void
 delegate_stop_recording (struct target_ops *self)
 {
@@ -1436,6 +3258,16 @@ tdefault_stop_recording (struct target_ops *self)
 }
 
 static void
+debug_stop_recording (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname);
+  debug_target.to_stop_recording (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_info_record (struct target_ops *self)
 {
   self = self->beneath;
@@ -1448,6 +3280,16 @@ tdefault_info_record (struct target_ops *self)
 }
 
 static void
+debug_info_record (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", debug_target.to_shortname);
+  debug_target.to_info_record (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_save_record (struct target_ops *self, const char *arg1)
 {
   self = self->beneath;
@@ -1461,6 +3303,18 @@ tdefault_save_record (struct target_ops *self, const char *arg1)
 }
 
 static void
+debug_save_record (struct target_ops *self, const char *arg1)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname);
+  debug_target.to_save_record (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", 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 void
 delegate_delete_record (struct target_ops *self)
 {
   self = self->beneath;
@@ -1473,6 +3327,16 @@ tdefault_delete_record (struct target_ops *self)
   tcomplain ();
 }
 
+static void
+debug_delete_record (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname);
+  debug_target.to_delete_record (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
 static int
 delegate_record_is_replaying (struct target_ops *self)
 {
@@ -1486,6 +3350,20 @@ tdefault_record_is_replaying (struct target_ops *self)
   return 0;
 }
 
+static int
+debug_record_is_replaying (struct target_ops *self)
+{
+  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);
+  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_int (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static void
 delegate_goto_record_begin (struct target_ops *self)
 {
@@ -1500,6 +3378,16 @@ tdefault_goto_record_begin (struct target_ops *self)
 }
 
 static void
+debug_goto_record_begin (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname);
+  debug_target.to_goto_record_begin (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_goto_record_end (struct target_ops *self)
 {
   self = self->beneath;
@@ -1513,6 +3401,16 @@ tdefault_goto_record_end (struct target_ops *self)
 }
 
 static void
+debug_goto_record_end (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname);
+  debug_target.to_goto_record_end (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_goto_record (struct target_ops *self, ULONGEST arg1)
 {
   self = self->beneath;
@@ -1526,6 +3424,18 @@ tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
 }
 
 static void
+debug_goto_record (struct target_ops *self, ULONGEST arg1)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname);
+  debug_target.to_goto_record (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_ULONGEST (arg1);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_insn_history (struct target_ops *self, int arg1, int arg2)
 {
   self = self->beneath;
@@ -1539,6 +3449,20 @@ tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
 }
 
 static void
+debug_insn_history (struct target_ops *self, int arg1, int arg2)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
+  debug_target.to_insn_history (&debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", 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 (")\n", gdb_stdlog);
+}
+
+static void
 delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
 {
   self = self->beneath;
@@ -1552,6 +3476,22 @@ tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, in
 }
 
 static void
+debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int 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);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", 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_int (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_int (arg3);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
 {
   self = self->beneath;
@@ -1565,6 +3505,22 @@ tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST ar
 }
 
 static void
+debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int 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);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", 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_ULONGEST (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_int (arg3);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_call_history (struct target_ops *self, int arg1, int arg2)
 {
   self = self->beneath;
@@ -1578,6 +3534,20 @@ tdefault_call_history (struct target_ops *self, int arg1, int arg2)
 }
 
 static void
+debug_call_history (struct target_ops *self, int arg1, int arg2)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
+  debug_target.to_call_history (&debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", 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 (")\n", gdb_stdlog);
+}
+
+static void
 delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
 {
   self = self->beneath;
@@ -1591,6 +3561,22 @@ tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, in
 }
 
 static void
+debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int 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);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", 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_int (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_int (arg3);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
 {
   self = self->beneath;
@@ -1603,6 +3589,22 @@ tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST ar
   tcomplain ();
 }
 
+static void
+debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int 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);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", 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_ULONGEST (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_int (arg3);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
 static int
 delegate_augmented_libraries_svr4_read (struct target_ops *self)
 {
@@ -1616,6 +3618,20 @@ tdefault_augmented_libraries_svr4_read (struct target_ops *self)
   return 0;
 }
 
+static int
+debug_augmented_libraries_svr4_read (struct target_ops *self)
+{
+  int result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname);
+  result = debug_target.to_augmented_libraries_svr4_read (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", 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 const struct frame_unwind *
 delegate_get_unwinder (struct target_ops *self)
 {
@@ -1630,6 +3646,20 @@ tdefault_get_unwinder (struct target_ops *self)
 }
 
 static const struct frame_unwind *
+debug_get_unwinder (struct target_ops *self)
+{
+  const struct frame_unwind * result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname);
+  result = debug_target.to_get_unwinder (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_const_struct_frame_unwind_p (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
+static const struct frame_unwind *
 delegate_get_tailcall_unwinder (struct target_ops *self)
 {
   self = self->beneath;
@@ -1642,6 +3672,20 @@ tdefault_get_tailcall_unwinder (struct target_ops *self)
   return NULL;
 }
 
+static const struct frame_unwind *
+debug_get_tailcall_unwinder (struct target_ops *self)
+{
+  const struct frame_unwind * result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname);
+  result = debug_target.to_get_tailcall_unwinder (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (") = ", gdb_stdlog);
+  target_debug_print_const_struct_frame_unwind_p (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static CORE_ADDR
 delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
 {
@@ -1649,6 +3693,22 @@ delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
   return self->to_decr_pc_after_break (self, arg1);
 }
 
+static CORE_ADDR
+debug_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
+{
+  CORE_ADDR result;
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_decr_pc_after_break (...)\n", debug_target.to_shortname);
+  result = debug_target.to_decr_pc_after_break (&debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_decr_pc_after_break (", 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_CORE_ADDR (result);
+  fputs_unfiltered ("\n", gdb_stdlog);
+  return result;
+}
+
 static void
 delegate_prepare_to_generate_core (struct target_ops *self)
 {
@@ -1662,6 +3722,16 @@ tdefault_prepare_to_generate_core (struct target_ops *self)
 }
 
 static void
+debug_prepare_to_generate_core (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", debug_target.to_shortname);
+  debug_target.to_prepare_to_generate_core (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 delegate_done_generating_core (struct target_ops *self)
 {
   self = self->beneath;
@@ -1674,6 +3744,16 @@ tdefault_done_generating_core (struct target_ops *self)
 }
 
 static void
+debug_done_generating_core (struct target_ops *self)
+{
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", debug_target.to_shortname);
+  debug_target.to_done_generating_core (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&debug_target);
+  fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
 install_delegators (struct target_ops *ops)
 {
   if (ops->to_post_attach == NULL)
@@ -2099,3 +4179,147 @@ install_dummy_methods (struct target_ops *ops)
   ops->to_prepare_to_generate_core = tdefault_prepare_to_generate_core;
   ops->to_done_generating_core = tdefault_done_generating_core;
 }
+
+static void
+init_debug_target (struct target_ops *ops)
+{
+  ops->to_post_attach = debug_post_attach;
+  ops->to_detach = debug_detach;
+  ops->to_disconnect = debug_disconnect;
+  ops->to_resume = debug_resume;
+  ops->to_wait = debug_wait;
+  ops->to_fetch_registers = debug_fetch_registers;
+  ops->to_store_registers = debug_store_registers;
+  ops->to_prepare_to_store = debug_prepare_to_store;
+  ops->to_files_info = debug_files_info;
+  ops->to_insert_breakpoint = debug_insert_breakpoint;
+  ops->to_remove_breakpoint = debug_remove_breakpoint;
+  ops->to_can_use_hw_breakpoint = debug_can_use_hw_breakpoint;
+  ops->to_ranged_break_num_registers = debug_ranged_break_num_registers;
+  ops->to_insert_hw_breakpoint = debug_insert_hw_breakpoint;
+  ops->to_remove_hw_breakpoint = debug_remove_hw_breakpoint;
+  ops->to_remove_watchpoint = debug_remove_watchpoint;
+  ops->to_insert_watchpoint = debug_insert_watchpoint;
+  ops->to_insert_mask_watchpoint = debug_insert_mask_watchpoint;
+  ops->to_remove_mask_watchpoint = debug_remove_mask_watchpoint;
+  ops->to_stopped_by_watchpoint = debug_stopped_by_watchpoint;
+  ops->to_stopped_data_address = debug_stopped_data_address;
+  ops->to_watchpoint_addr_within_range = debug_watchpoint_addr_within_range;
+  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_terminal_init = debug_terminal_init;
+  ops->to_terminal_inferior = debug_terminal_inferior;
+  ops->to_terminal_ours_for_output = debug_terminal_ours_for_output;
+  ops->to_terminal_ours = debug_terminal_ours;
+  ops->to_terminal_save_ours = debug_terminal_save_ours;
+  ops->to_terminal_info = debug_terminal_info;
+  ops->to_kill = debug_kill;
+  ops->to_load = debug_load;
+  ops->to_post_startup_inferior = debug_post_startup_inferior;
+  ops->to_insert_fork_catchpoint = debug_insert_fork_catchpoint;
+  ops->to_remove_fork_catchpoint = debug_remove_fork_catchpoint;
+  ops->to_insert_vfork_catchpoint = debug_insert_vfork_catchpoint;
+  ops->to_remove_vfork_catchpoint = debug_remove_vfork_catchpoint;
+  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_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_program_signals = debug_program_signals;
+  ops->to_thread_alive = debug_thread_alive;
+  ops->to_find_new_threads = debug_find_new_threads;
+  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_stop = debug_stop;
+  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_get_section_table = debug_get_section_table;
+  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_supports_non_stop = debug_supports_non_stop;
+  ops->to_find_memory_regions = debug_find_memory_regions;
+  ops->to_make_corefile_notes = debug_make_corefile_notes;
+  ops->to_get_bookmark = debug_get_bookmark;
+  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_memory_map = debug_memory_map;
+  ops->to_flash_erase = debug_flash_erase;
+  ops->to_flash_done = debug_flash_done;
+  ops->to_read_description = debug_read_description;
+  ops->to_get_ada_task_ptid = debug_get_ada_task_ptid;
+  ops->to_auxv_parse = debug_auxv_parse;
+  ops->to_search_memory = debug_search_memory;
+  ops->to_can_execute_reverse = debug_can_execute_reverse;
+  ops->to_execution_direction = debug_execution_direction;
+  ops->to_supports_multi_process = debug_supports_multi_process;
+  ops->to_supports_enable_disable_tracepoint = debug_supports_enable_disable_tracepoint;
+  ops->to_supports_string_tracing = debug_supports_string_tracing;
+  ops->to_supports_evaluation_of_breakpoint_conditions = debug_supports_evaluation_of_breakpoint_conditions;
+  ops->to_can_run_breakpoint_commands = debug_can_run_breakpoint_commands;
+  ops->to_thread_architecture = debug_thread_architecture;
+  ops->to_thread_address_space = debug_thread_address_space;
+  ops->to_trace_init = debug_trace_init;
+  ops->to_download_tracepoint = debug_download_tracepoint;
+  ops->to_can_download_tracepoint = debug_can_download_tracepoint;
+  ops->to_download_trace_state_variable = debug_download_trace_state_variable;
+  ops->to_enable_tracepoint = debug_enable_tracepoint;
+  ops->to_disable_tracepoint = debug_disable_tracepoint;
+  ops->to_trace_set_readonly_regions = debug_trace_set_readonly_regions;
+  ops->to_trace_start = debug_trace_start;
+  ops->to_get_trace_status = debug_get_trace_status;
+  ops->to_get_tracepoint_status = debug_get_tracepoint_status;
+  ops->to_trace_stop = debug_trace_stop;
+  ops->to_trace_find = debug_trace_find;
+  ops->to_get_trace_state_variable_value = debug_get_trace_state_variable_value;
+  ops->to_save_trace_data = debug_save_trace_data;
+  ops->to_upload_tracepoints = debug_upload_tracepoints;
+  ops->to_upload_trace_state_variables = debug_upload_trace_state_variables;
+  ops->to_get_raw_trace_data = debug_get_raw_trace_data;
+  ops->to_get_min_fast_tracepoint_insn_len = debug_get_min_fast_tracepoint_insn_len;
+  ops->to_set_disconnected_tracing = debug_set_disconnected_tracing;
+  ops->to_set_circular_trace_buffer = debug_set_circular_trace_buffer;
+  ops->to_set_trace_buffer_size = debug_set_trace_buffer_size;
+  ops->to_set_trace_notes = debug_set_trace_notes;
+  ops->to_core_of_thread = debug_core_of_thread;
+  ops->to_verify_memory = debug_verify_memory;
+  ops->to_get_tib_address = debug_get_tib_address;
+  ops->to_set_permissions = debug_set_permissions;
+  ops->to_static_tracepoint_marker_at = debug_static_tracepoint_marker_at;
+  ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid;
+  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_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_goto_record_begin = debug_goto_record_begin;
+  ops->to_goto_record_end = debug_goto_record_end;
+  ops->to_goto_record = debug_goto_record;
+  ops->to_insn_history = debug_insn_history;
+  ops->to_insn_history_from = debug_insn_history_from;
+  ops->to_insn_history_range = debug_insn_history_range;
+  ops->to_call_history = debug_call_history;
+  ops->to_call_history_from = debug_call_history_from;
+  ops->to_call_history_range = debug_call_history_range;
+  ops->to_augmented_libraries_svr4_read = debug_augmented_libraries_svr4_read;
+  ops->to_get_unwinder = debug_get_unwinder;
+  ops->to_get_tailcall_unwinder = debug_get_tailcall_unwinder;
+  ops->to_decr_pc_after_break = debug_decr_pc_after_break;
+  ops->to_prepare_to_generate_core = debug_prepare_to_generate_core;
+  ops->to_done_generating_core = debug_done_generating_core;
+}