This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [RFC] auto-generate most target debug methods


Pedro> I like the idea of this patch a lot.
[...]
Pedro> Did you try an __attribute__(())-like approach?  Something like:

Appended is a patch that works this way.

Pedro> Another similar idea, but written out of line:
Pedro>      void (*to_resume) (struct target_ops *, ptid_t, int step,
Pedro> 		       enum gdb_signal)
Pedro>        TARGET_DEBUG_PRINT (step, print_target_resume_step)
Pedro>        TARGET_DEFAULT_NORETURN (noprocess ());

I mentioned that I thought this might help with some current cases.
However, the only cases I could find were in target_store_registers and
target_fetch_registers, and in the resulting target.c those just end up
with a little extra code:

  if (targetdebug)
    debug_print_register ("target_fetch_registers", regcache, regno);

... and so it didn't seem worth adding more machinery just to support
this case.

Tom

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

	* make-target-delegates (munge_type, write_debugmethod): New
	functions.
	(debug_names): New global.
	Write debug methods.  Generate init_debug_target.  Define
	TARGET_DEBUG_PRINTER in the output.
	* 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.

diff --git a/gdb/make-target-delegates b/gdb/make-target-delegates
index 28db447..3a4d636 100755
--- a/gdb/make-target-delegates
+++ b/gdb/make-target-delegates
@@ -217,15 +217,88 @@ sub write_tdefault($$$$@) {
     return tdname ($name);
 }
 
+sub munge_type($) {
+    my ($typename) = @_;
+    my ($result);
+
+    if ($typename =~ m/TARGET_DEBUG_PRINTER\s*\(([^)]*)\)/) {
+	$result = $1;
+    } else {
+	($result = $typename) =~ s/\s+$//;
+	$result =~ s/[ ()]/_/g;
+	$result =~ s/[*]/p/g;
+	$result = 'target_debug_print_' . $result;
+    }
+
+    return $result;
+}
+
+# Write out a debug method.
+sub write_debugmethod($$$$@) {
+    my ($content, $style, $name, $return_type, @argtypes) = @_;
+
+    my ($debugname) = $name;
+    $debugname =~ s/to_/debug_/;
+    my ($targetname) = $name;
+    $targetname =~ s/to_/target_/;
+
+    my (@names) = write_function_header ($debugname, $return_type, @argtypes);
+
+    if ($return_type ne 'void') {
+	print "  $return_type result;\n";
+    }
+
+    print "  fprintf_unfiltered (gdb_stdlog, \"-> %s->$name (...)\\n\", debug_target.to_shortname);\n";
+
+    # Delegate to the beneath target.
+    print "  ";
+    if ($return_type ne 'void') {
+	print "result = ";
+    }
+    print "debug_target." . $name . " (";
+    my @names2 = @names;
+    @names2[0] = "&debug_target";
+    print join (', ', @names2);
+    print ");\n";
+
+    # Now print the arguments.
+    print "  fprintf_unfiltered (gdb_stdlog, \"<- %s->$name (\", debug_target.to_shortname);\n";
+    for my $i (0 .. $#argtypes) {
+	print "  fputs_unfiltered (\", \", gdb_stdlog);\n" if $i > 0;
+	my $printer = munge_type ($argtypes[$i]);
+	print "  $printer ($names2[$i]);\n";
+    }
+    if ($return_type ne 'void') {
+	print "  fputs_unfiltered (\") = \", gdb_stdlog);\n";
+	my $printer = munge_type ($return_type);
+	print "  $printer (result);\n";
+	print "  fputs_unfiltered (\"\\n\", gdb_stdlog);\n";
+    } else {
+	print "  fputs_unfiltered (\")\\n\", gdb_stdlog);\n";
+    }
+
+    if ($return_type ne 'void') {
+	print "  return result;\n";
+    }
+
+    print "}\n\n";
+
+    return $debugname;
+}
+
 print "/* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */\n";
 print "/* vi:set ro: */\n\n";
 print "/* To regenerate this file, run:*/\n";
 print "/*      make-target-delegates target.h > target-delegates.c */\n";
 
+# This simplifies things a bit.
+print "#define TARGET_DEBUG_PRINTER(FUNC)\n";
+
 @lines = scan_target_h();
 
 
 %tdefault_names = ();
+%debug_names = ();
 @delegators = ();
 foreach $current_line (@lines) {
     next unless $current_line =~ m/$METHOD/;
@@ -248,6 +321,10 @@ foreach $current_line (@lines) {
 	$tdefault_names{$name} = write_tdefault ($tdefault, $style,
 						 $name, $return_type,
 						 @argtypes);
+
+	$debug_names{$name} = write_debugmethod ($tdefault, $style,
+						 $name, $return_type,
+						 @argtypes);
     }
 }
 
@@ -266,4 +343,11 @@ print "static void\ninstall_dummy_methods (struct target_ops *ops)\n{\n";
 for $iter (@delegators) {
     print "  ops->" . $iter . " = " . $tdefault_names{$iter} . ";\n";
 }
+print "}\n\n";
+
+# The debug method code.
+print "static void\ninit_debug_target (struct target_ops *ops)\n{\n";
+for $iter (@delegators) {
+    print "  ops->" . $iter . " = " . $debug_names{$iter} . ";\n";
+}
 print "}\n";
diff --git a/gdb/target-debug.h b/gdb/target-debug.h
new file mode 100644
index 0000000..3dd705c
--- /dev/null
+++ b/gdb/target-debug.h
@@ -0,0 +1,188 @@
+/* GDB target debugging macros
+
+   Copyright (C) 2014 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef TARGET_DEBUG_H
+#define TARGET_DEBUG_H
+
+/* Printers for the debug target.  Each prints an object of a given
+   type to a string that needn't be freed.  Most printers are macros,
+   for brevity, but a few are static functions where more complicated
+   behavior is needed.
+
+   References to these printers are automatically generated by
+   make-target-delegates.  See the generated file target-delegates.c.
+
+   In a couple cases, a special printing function is defined and then
+   used via the TARGET_DEBUG_PRINTER macro.  See target.h.
+
+   A few methods still have some explicit targetdebug code in
+   target.c.  In most cases this is because target delegation hasn't
+   been done for the method; but individual cases vary.  For instance,
+   target_store_registers does some special register printing that is
+   more simply done there, and target_xfer_partial additionally
+   bypasses the debug target.  */
+
+
+/* Helper macro.  */
+
+#define target_debug_do_print(E)			\
+  fputs_unfiltered ((E), gdb_stdlog);
+
+#define target_debug_print_struct_target_ops_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_enum_target_object(X)	\
+  target_debug_do_print (plongest (X))
+#define target_debug_print_CORE_ADDR(X)		\
+  target_debug_do_print (core_addr_to_string (X))
+#define target_debug_print_const_char_p(X)	\
+  target_debug_do_print (((X) ? (X) : "(null)"))
+#define target_debug_print_char_p(X)		\
+  target_debug_do_print (((X) ? (X) : "(null)"))
+#define target_debug_print_int(X)		\
+  target_debug_do_print (plongest (X))
+#define target_debug_print_long(X)		\
+  target_debug_do_print (plongest (X))
+#define target_debug_print_enum_target_xfer_status(X)	\
+  target_debug_do_print (plongest (X))
+#define target_debug_print_enum_exec_direction_kind(X)	\
+  target_debug_do_print (plongest (X))
+#define target_debug_print_enum_trace_find_type(X)	\
+  target_debug_do_print (plongest (X))
+#define target_debug_print_enum_btrace_read_type(X)	\
+  target_debug_do_print (plongest (X))
+#define target_debug_print_enum_btrace_error(X) \
+  target_debug_do_print (plongest (X))
+#define target_debug_print_ptid_t(X)		\
+  target_debug_do_print (plongest (ptid_get_pid (X)))
+#define target_debug_print_struct_gdbarch_p(X)	\
+  target_debug_do_print (gdbarch_bfd_arch_info (X)->printable_name)
+#define target_debug_print_const_gdb_byte_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_gdb_byte_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_gdb_byte_pp(X)	\
+  target_debug_do_print (host_address_to_string (*(X)))
+#define target_debug_print_enum_gdb_signal(X)	\
+  target_debug_do_print (gdb_signal_to_name (X))
+#define target_debug_print_ULONGEST(X)		\
+  target_debug_do_print (hex_string (X))
+#define target_debug_print_ULONGEST_p(X)	\
+  target_debug_do_print (hex_string (*(X)))
+#define target_debug_print_LONGEST(X)		\
+  target_debug_do_print (phex (X, 0))
+#define target_debug_print_LONGEST_p(X)		\
+  target_debug_do_print (phex (*(X), 0))
+#define target_debug_print_struct_address_space_p(X)	\
+  target_debug_do_print (plongest (address_space_num (X)))
+#define target_debug_print_struct_bp_target_info_p(X)	\
+  target_debug_do_print (core_addr_to_string ((X)->placed_address))
+#define target_debug_print_struct_expression_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_CORE_ADDR_p(X)	\
+  target_debug_do_print (core_addr_to_string (*(X)))
+#define target_debug_print_int_p(X)		\
+  target_debug_do_print (plongest (*(X)))
+#define target_debug_print_struct_regcache_p(X) \
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_thread_info_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_ui_file_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_target_section_table_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_async_callback_ftype_p(X) \
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_void_p(X) \
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_find_memory_region_ftype(X) \
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_bfd_p(X) \
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC_mem_region_s__p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC_static_tracepoint_marker_p__p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_const_struct_target_desc_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_bp_location_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_trace_state_variable_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_trace_status_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_breakpoint_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tp_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tp_pp(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tsv_pp(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_static_tracepoint_marker_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_traceframe_info_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_btrace_target_info_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC__btrace_block_s__pp(X)	\
+  target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_const_struct_frame_unwind_p(X)	\
+  target_debug_do_print (host_address_to_string (X))
+
+static void
+target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
+{
+  char *str = target_waitstatus_to_string (status);
+
+  fputs_unfiltered (str, gdb_stdlog);
+  xfree (str);
+}
+
+
+
+/* Macros or functions that are used via TARGET_DEBUG_PRINTER.  */
+
+#define target_debug_print_step(X) \
+  target_debug_do_print ((X) ? "step" : "continue")
+
+static void
+target_debug_print_options (int options)
+{
+  char *str = target_options_to_string (options);
+
+  fputs_unfiltered (str, gdb_stdlog);
+  xfree (str);
+}
+
+static void
+target_debug_print_signals (unsigned char *sigs)
+{
+  fputs_unfiltered ("{", gdb_stdlog);
+  if (sigs != NULL)
+    {
+      int i;
+
+      for (i = 0; i < GDB_SIGNAL_LAST; i++)
+	if (sigs[i])
+	  fprintf_unfiltered (gdb_stdlog, " %s", gdb_signal_to_name (i));
+    }
+  fputs_unfiltered (" }", gdb_stdlog);
+}
+
+#endif /* TARGET_DEBUG_H */
diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c
index 8c81672..e8ff3cf 100644
--- a/gdb/target-delegates.c
+++ b/gdb/target-delegates.c
@@ -3,6 +3,7 @@
 
 /* To regenerate this file, run:*/
 /*      make-target-delegates target.h > target-delegates.c */
+#define TARGET_DEBUG_PRINTER(FUNC)
 static void
 delegate_post_attach (struct target_ops *self, int arg1)
 {
@@ -16,6 +17,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 +41,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,31 +68,81 @@ tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
 }
 
 static void
-delegate_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
+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 TARGET_DEBUG_PRINTER (target_debug_print_step) arg2, enum gdb_signal arg3)
 {
   self = self->beneath;
   self->to_resume (self, arg1, arg2, arg3);
 }
 
 static void
-tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
+tdefault_resume (struct target_ops *self, ptid_t arg1, int TARGET_DEBUG_PRINTER (target_debug_print_step) arg2, enum gdb_signal arg3)
 {
   noprocess ();
 }
 
+static void
+debug_resume (struct target_ops *self, ptid_t arg1, int TARGET_DEBUG_PRINTER (target_debug_print_step) 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)
+delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int TARGET_DEBUG_PRINTER (target_debug_print_options) arg3)
 {
   self = self->beneath;
   return self->to_wait (self, arg1, arg2, arg3);
 }
 
 static ptid_t
-tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
+tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int TARGET_DEBUG_PRINTER (target_debug_print_options) arg3)
 {
   noprocess ();
 }
 
+static ptid_t
+debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int TARGET_DEBUG_PRINTER (target_debug_print_options) 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 +156,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 +183,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 +210,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 +233,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 +251,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 +276,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 +307,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 +340,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 +367,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 +398,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 +429,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 +464,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 +499,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 +532,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 +565,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 +592,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 +615,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 +642,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 +673,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 +707,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 +738,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 +760,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 +782,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 +804,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 +826,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 +843,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 +870,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 +893,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 +918,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 +944,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 +973,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 +1002,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 +1031,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 +1054,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 +1085,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 +1114,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 +1143,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 +1179,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 +1206,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,28 +1229,70 @@ 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 * TARGET_DEBUG_PRINTER (target_debug_print_signals) 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 * TARGET_DEBUG_PRINTER (target_debug_print_signals) arg2)
+{
+}
+
+static void
+debug_pass_signals (struct target_ops *self, int arg1, unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals) 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 * TARGET_DEBUG_PRINTER (target_debug_print_signals) 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 * TARGET_DEBUG_PRINTER (target_debug_print_signals) arg2)
+{
+}
+
+static void
+debug_program_signals (struct target_ops *self, int arg1, unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals) 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
@@ -573,6 +1308,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 +1336,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 +1354,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 +1383,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 +1411,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 +1440,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 +1485,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 +1513,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 +1538,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 +1566,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 +1592,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 +1619,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 +1647,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 +1692,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 +1723,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 +1754,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 +1781,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 +1814,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 +1855,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 +1883,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 +1909,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 +1932,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 +1953,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 +1979,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 +2008,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 +2044,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 +2065,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 +2093,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 +2120,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 +2147,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 +2174,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 +2200,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 +2221,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 +2244,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 +2274,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 +2296,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 +2321,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 +2349,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 +2374,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 +2399,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 +2424,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 +2446,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 +2469,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 +2499,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 +2525,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 +2549,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 +2586,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 +2617,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 +2646,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 +2674,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 +2703,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 +2736,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 +2763,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 +2787,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 +2810,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 +2836,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 +2869,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 +2892,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 +2924,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 +2954,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 +2977,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 +3008,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 +3037,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 +3065,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 +3094,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 +3120,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 +3147,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 +3177,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 +3201,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 +3226,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 +3259,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 +3281,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 +3304,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 +3328,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 +3351,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 +3379,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 +3402,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 +3425,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 +3450,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 +3477,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 +3506,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 +3535,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 +3562,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 +3590,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 +3619,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 +3647,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 +3673,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 +3694,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 +3723,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 +3745,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 +4180,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;
+}
diff --git a/gdb/target.c b/gdb/target.c
index 07d029a..b9310cf 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -46,6 +46,7 @@
 #include "gdb/fileio.h"
 #include "agent.h"
 #include "auxv.h"
+#include "target-debug.h"
 
 static void target_info (char *, int);
 
@@ -111,72 +112,14 @@ static enum exec_direction_kind default_execution_direction
 static CORE_ADDR default_target_decr_pc_after_break (struct target_ops *ops,
 						     struct gdbarch *gdbarch);
 
+static struct target_ops debug_target;
+
 #include "target-delegates.c"
 
 static void init_dummy_target (void);
 
-static struct target_ops debug_target;
-
 static void debug_to_open (char *, int);
 
-static void debug_to_prepare_to_store (struct target_ops *self,
-				       struct regcache *);
-
-static void debug_to_files_info (struct target_ops *);
-
-static int debug_to_insert_breakpoint (struct target_ops *, struct gdbarch *,
-				       struct bp_target_info *);
-
-static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *,
-				       struct bp_target_info *);
-
-static int debug_to_can_use_hw_breakpoint (struct target_ops *self,
-					   int, int, int);
-
-static int debug_to_insert_hw_breakpoint (struct target_ops *self,
-					  struct gdbarch *,
-					  struct bp_target_info *);
-
-static int debug_to_remove_hw_breakpoint (struct target_ops *self,
-					  struct gdbarch *,
-					  struct bp_target_info *);
-
-static int debug_to_insert_watchpoint (struct target_ops *self,
-				       CORE_ADDR, int, int,
-				       struct expression *);
-
-static int debug_to_remove_watchpoint (struct target_ops *self,
-				       CORE_ADDR, int, int,
-				       struct expression *);
-
-static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
-
-static int debug_to_watchpoint_addr_within_range (struct target_ops *,
-						  CORE_ADDR, CORE_ADDR, int);
-
-static int debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
-						 CORE_ADDR, int);
-
-static int debug_to_can_accel_watchpoint_condition (struct target_ops *self,
-						    CORE_ADDR, int, int,
-						    struct expression *);
-
-static void debug_to_terminal_init (struct target_ops *self);
-
-static void debug_to_terminal_inferior (struct target_ops *self);
-
-static void debug_to_terminal_ours_for_output (struct target_ops *self);
-
-static void debug_to_terminal_save_ours (struct target_ops *self);
-
-static void debug_to_terminal_ours (struct target_ops *self);
-
-static void debug_to_load (struct target_ops *self, const char *, int);
-
-static int debug_to_can_run (struct target_ops *self);
-
-static void debug_to_stop (struct target_ops *self, ptid_t);
-
 /* Pointer to array of target architecture structures; the size of the
    array; the current index into the array; the allocated size of the
    array.  */
@@ -471,9 +414,6 @@ add_deprecated_target_alias (struct target_ops *t, char *alias)
 void
 target_kill (void)
 {
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
-
   current_target.to_kill (&current_target);
 }
 
@@ -921,9 +861,6 @@ done:
 struct target_section_table *
 target_get_section_table (struct target_ops *target)
 {
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
-
   return (*target->to_get_section_table) (target);
 }
 
@@ -1398,9 +1335,6 @@ target_memory_map (void)
   int ix;
   struct target_ops *t;
 
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
-
   result = current_target.to_memory_map (&current_target);
   if (result == NULL)
     return NULL;
@@ -1432,17 +1366,12 @@ target_memory_map (void)
 void
 target_flash_erase (ULONGEST address, LONGEST length)
 {
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
-			hex_string (address), phex (length, 0));
   current_target.to_flash_erase (&current_target, address, length);
 }
 
 void
 target_flash_done (void)
 {
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
   current_target.to_flash_done (&current_target);
 }
 
@@ -2083,9 +2012,6 @@ target_detach (const char *args, int from_tty)
   prepare_for_detach ();
 
   current_target.to_detach (&current_target, args, from_tty);
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
-			args, from_tty);
 }
 
 void
@@ -2096,36 +2022,13 @@ target_disconnect (const char *args, int from_tty)
      disconnecting.  */
   remove_breakpoints ();
 
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
-			args, from_tty);
   current_target.to_disconnect (&current_target, args, from_tty);
 }
 
 ptid_t
 target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
 {
-  struct target_ops *t;
-  ptid_t retval = (current_target.to_wait) (&current_target, ptid,
-					    status, options);
-
-  if (targetdebug)
-    {
-      char *status_string;
-      char *options_string;
-
-      status_string = target_waitstatus_to_string (status);
-      options_string = target_options_to_string (options);
-      fprintf_unfiltered (gdb_stdlog,
-			  "target_wait (%d, status, options={%s})"
-			  " = %d,   %s\n",
-			  ptid_get_pid (ptid), options_string,
-			  ptid_get_pid (retval), status_string);
-      xfree (status_string);
-      xfree (options_string);
-    }
-
-  return retval;
+  return (current_target.to_wait) (&current_target, ptid, status, options);
 }
 
 char *
@@ -2148,11 +2051,6 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal)
   target_dcache_invalidate ();
 
   current_target.to_resume (&current_target, ptid, step, signal);
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
-			ptid_get_pid (ptid),
-			step ? "step" : "continue",
-			gdb_signal_to_name (signal));
 
   registers_changed_ptid (ptid);
   /* We only set the internal executing state here.  The user/frontend
@@ -2164,42 +2062,12 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal)
 void
 target_pass_signals (int numsigs, unsigned char *pass_signals)
 {
-  if (targetdebug)
-    {
-      int i;
-
-      fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
-			  numsigs);
-
-      for (i = 0; i < numsigs; i++)
-	if (pass_signals[i])
-	  fprintf_unfiltered (gdb_stdlog, " %s",
-			      gdb_signal_to_name (i));
-
-      fprintf_unfiltered (gdb_stdlog, " })\n");
-    }
-
   (*current_target.to_pass_signals) (&current_target, numsigs, pass_signals);
 }
 
 void
 target_program_signals (int numsigs, unsigned char *program_signals)
 {
-  if (targetdebug)
-    {
-      int i;
-
-      fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
-			  numsigs);
-
-      for (i = 0; i < numsigs; i++)
-	if (program_signals[i])
-	  fprintf_unfiltered (gdb_stdlog, " %s",
-			      gdb_signal_to_name (i));
-
-      fprintf_unfiltered (gdb_stdlog, " })\n");
-    }
-
   (*current_target.to_program_signals) (&current_target,
 					numsigs, program_signals);
 }
@@ -2219,14 +2087,8 @@ default_follow_fork (struct target_ops *self, int follow_child,
 int
 target_follow_fork (int follow_child, int detach_fork)
 {
-  int retval = current_target.to_follow_fork (&current_target,
-					      follow_child, detach_fork);
-
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog,
-			"target_follow_fork (%d, %d) = %d\n",
-			follow_child, detach_fork, retval);
-  return retval;
+  return current_target.to_follow_fork (&current_target,
+					follow_child, detach_fork);
 }
 
 static void
@@ -2240,8 +2102,6 @@ void
 target_mourn_inferior (void)
 {
   current_target.to_mourn_inferior (&current_target);
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
 
   /* We no longer need to keep handles on any of the object files.
      Make sure to release them to avoid unnecessarily locking any
@@ -2391,20 +2251,9 @@ target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
 		      const gdb_byte *pattern, ULONGEST pattern_len,
 		      CORE_ADDR *found_addrp)
 {
-  int found;
-
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
-			hex_string (start_addr));
-
-  found = current_target.to_search_memory (&current_target, start_addr,
-					   search_space_len,
-					   pattern, pattern_len, found_addrp);
-
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "  = %d\n", found);
-
-  return found;
+  return current_target.to_search_memory (&current_target, start_addr,
+					  search_space_len,
+					  pattern, pattern_len, found_addrp);
 }
 
 /* Look through the currently pushed targets.  If none of them will
@@ -2643,12 +2492,6 @@ target_thread_address_space (ptid_t ptid)
   aspace = current_target.to_thread_address_space (&current_target, ptid);
   gdb_assert (aspace != NULL);
 
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog,
-			"target_thread_address_space (%s) = %d\n",
-			target_pid_to_str (ptid),
-			address_space_num (aspace));
-
   return aspace;
 }
 
@@ -3128,22 +2971,13 @@ target_close (struct target_ops *targ)
 int
 target_thread_alive (ptid_t ptid)
 {
-  int retval;
-
-  retval = current_target.to_thread_alive (&current_target, ptid);
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
-			ptid_get_pid (ptid), retval);
-
-  return retval;
+  return current_target.to_thread_alive (&current_target, ptid);
 }
 
 void
 target_find_new_threads (void)
 {
   current_target.to_find_new_threads (&current_target);
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
 }
 
 void
@@ -3158,14 +2992,6 @@ target_stop (ptid_t ptid)
   (*current_target.to_stop) (&current_target, ptid);
 }
 
-static void
-debug_to_post_attach (struct target_ops *self, int pid)
-{
-  debug_target.to_post_attach (&debug_target, pid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
-}
-
 /* Concatenate ELEM to LIST, a comma separate list, and return the
    result.  The LIST incoming argument is released.  */
 
@@ -3277,13 +3103,7 @@ target_store_registers (struct regcache *regcache, int regno)
 int
 target_core_of_thread (ptid_t ptid)
 {
-  int retval = current_target.to_core_of_thread (&current_target, ptid);
-
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog,
-			"target_core_of_thread (%d) = %d\n",
-			ptid_get_pid (ptid), retval);
-  return retval;
+  return current_target.to_core_of_thread (&current_target, ptid);
 }
 
 int
@@ -3328,16 +3148,8 @@ default_verify_memory (struct target_ops *self,
 int
 target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
 {
-  int retval = current_target.to_verify_memory (&current_target,
-						data, memaddr, size);
-
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog,
-			"target_verify_memory (%s, %s) = %d\n",
-			paddress (target_gdbarch (), memaddr),
-			pulongest (size),
-			retval);
-  return retval;
+  return current_target.to_verify_memory (&current_target,
+					  data, memaddr, size);
 }
 
 /* The documentation for this function is in its prototype declaration in
@@ -3346,18 +3158,8 @@ target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
 int
 target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
 {
-  int ret;
-
-  ret = current_target.to_insert_mask_watchpoint (&current_target,
-						  addr, mask, rw);
-
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "\
-target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
-			core_addr_to_string (addr),
-			core_addr_to_string (mask), rw, ret);
-  
-  return ret;
+  return current_target.to_insert_mask_watchpoint (&current_target,
+						   addr, mask, rw);
 }
 
 /* The documentation for this function is in its prototype declaration in
@@ -3366,18 +3168,8 @@ target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
 int
 target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
 {
-  int ret;
-
-  ret = current_target.to_remove_mask_watchpoint (&current_target,
-						  addr, mask, rw);
-
-  if (targetdebug)
-    fprintf_unfiltered (gdb_stdlog, "\
-target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
-			core_addr_to_string (addr),
-			core_addr_to_string (mask), rw, ret);
-
-  return ret;
+  return current_target.to_remove_mask_watchpoint (&current_target,
+						   addr, mask, rw);
 }
 
 /* The documentation for this function is in its prototype declaration
@@ -3551,14 +3343,6 @@ target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
   current_target.to_call_history_range (&current_target, begin, end, flags);
 }
 
-static void
-debug_to_prepare_to_store (struct target_ops *self, struct regcache *regcache)
-{
-  debug_target.to_prepare_to_store (&debug_target, regcache);
-
-  fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
-}
-
 /* See target.h.  */
 
 const struct frame_unwind *
@@ -3609,470 +3393,12 @@ target_done_generating_core (void)
 }
 
 static void
-debug_to_files_info (struct target_ops *target)
-{
-  debug_target.to_files_info (target);
-
-  fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
-}
-
-static int
-debug_to_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
-			    struct bp_target_info *bp_tgt)
-{
-  int retval;
-
-  retval = debug_target.to_insert_breakpoint (&debug_target, gdbarch, bp_tgt);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_insert_breakpoint (%s, xxx) = %ld\n",
-		      core_addr_to_string (bp_tgt->placed_address),
-		      (unsigned long) retval);
-  return retval;
-}
-
-static int
-debug_to_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
-			    struct bp_target_info *bp_tgt)
-{
-  int retval;
-
-  retval = debug_target.to_remove_breakpoint (&debug_target, gdbarch, bp_tgt);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_remove_breakpoint (%s, xxx) = %ld\n",
-		      core_addr_to_string (bp_tgt->placed_address),
-		      (unsigned long) retval);
-  return retval;
-}
-
-static int
-debug_to_can_use_hw_breakpoint (struct target_ops *self,
-				int type, int cnt, int from_tty)
-{
-  int retval;
-
-  retval = debug_target.to_can_use_hw_breakpoint (&debug_target,
-						  type, cnt, from_tty);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
-		      (unsigned long) type,
-		      (unsigned long) cnt,
-		      (unsigned long) from_tty,
-		      (unsigned long) retval);
-  return retval;
-}
-
-static int
-debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
-				      CORE_ADDR addr, int len)
-{
-  CORE_ADDR retval;
-
-  retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target,
-							addr, len);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
-		      core_addr_to_string (addr), (unsigned long) len,
-		      core_addr_to_string (retval));
-  return retval;
-}
-
-static int
-debug_to_can_accel_watchpoint_condition (struct target_ops *self,
-					 CORE_ADDR addr, int len, int rw,
-					 struct expression *cond)
-{
-  int retval;
-
-  retval = debug_target.to_can_accel_watchpoint_condition (&debug_target,
-							   addr, len,
-							   rw, cond);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_can_accel_watchpoint_condition "
-		      "(%s, %d, %d, %s) = %ld\n",
-		      core_addr_to_string (addr), len, rw,
-		      host_address_to_string (cond), (unsigned long) retval);
-  return retval;
-}
-
-static int
-debug_to_stopped_by_watchpoint (struct target_ops *ops)
-{
-  int retval;
-
-  retval = debug_target.to_stopped_by_watchpoint (&debug_target);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_stopped_by_watchpoint () = %ld\n",
-		      (unsigned long) retval);
-  return retval;
-}
-
-static int
-debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
-{
-  int retval;
-
-  retval = debug_target.to_stopped_data_address (target, addr);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_stopped_data_address ([%s]) = %ld\n",
-		      core_addr_to_string (*addr),
-		      (unsigned long)retval);
-  return retval;
-}
-
-static int
-debug_to_watchpoint_addr_within_range (struct target_ops *target,
-				       CORE_ADDR addr,
-				       CORE_ADDR start, int length)
-{
-  int retval;
-
-  retval = debug_target.to_watchpoint_addr_within_range (target, addr,
-							 start, length);
-
-  fprintf_filtered (gdb_stdlog,
-		    "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
-		    core_addr_to_string (addr), core_addr_to_string (start),
-		    length, retval);
-  return retval;
-}
-
-static int
-debug_to_insert_hw_breakpoint (struct target_ops *self,
-			       struct gdbarch *gdbarch,
-			       struct bp_target_info *bp_tgt)
-{
-  int retval;
-
-  retval = debug_target.to_insert_hw_breakpoint (&debug_target,
-						 gdbarch, bp_tgt);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
-		      core_addr_to_string (bp_tgt->placed_address),
-		      (unsigned long) retval);
-  return retval;
-}
-
-static int
-debug_to_remove_hw_breakpoint (struct target_ops *self,
-			       struct gdbarch *gdbarch,
-			       struct bp_target_info *bp_tgt)
-{
-  int retval;
-
-  retval = debug_target.to_remove_hw_breakpoint (&debug_target,
-						 gdbarch, bp_tgt);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
-		      core_addr_to_string (bp_tgt->placed_address),
-		      (unsigned long) retval);
-  return retval;
-}
-
-static int
-debug_to_insert_watchpoint (struct target_ops *self,
-			    CORE_ADDR addr, int len, int type,
-			    struct expression *cond)
-{
-  int retval;
-
-  retval = debug_target.to_insert_watchpoint (&debug_target,
-					      addr, len, type, cond);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
-		      core_addr_to_string (addr), len, type,
-		      host_address_to_string (cond), (unsigned long) retval);
-  return retval;
-}
-
-static int
-debug_to_remove_watchpoint (struct target_ops *self,
-			    CORE_ADDR addr, int len, int type,
-			    struct expression *cond)
-{
-  int retval;
-
-  retval = debug_target.to_remove_watchpoint (&debug_target,
-					      addr, len, type, cond);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
-		      core_addr_to_string (addr), len, type,
-		      host_address_to_string (cond), (unsigned long) retval);
-  return retval;
-}
-
-static void
-debug_to_terminal_init (struct target_ops *self)
-{
-  debug_target.to_terminal_init (&debug_target);
-
-  fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
-}
-
-static void
-debug_to_terminal_inferior (struct target_ops *self)
-{
-  debug_target.to_terminal_inferior (&debug_target);
-
-  fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
-}
-
-static void
-debug_to_terminal_ours_for_output (struct target_ops *self)
-{
-  debug_target.to_terminal_ours_for_output (&debug_target);
-
-  fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
-}
-
-static void
-debug_to_terminal_ours (struct target_ops *self)
-{
-  debug_target.to_terminal_ours (&debug_target);
-
-  fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
-}
-
-static void
-debug_to_terminal_save_ours (struct target_ops *self)
-{
-  debug_target.to_terminal_save_ours (&debug_target);
-
-  fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
-}
-
-static void
-debug_to_terminal_info (struct target_ops *self,
-			const char *arg, int from_tty)
-{
-  debug_target.to_terminal_info (&debug_target, arg, from_tty);
-
-  fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
-		      from_tty);
-}
-
-static void
-debug_to_load (struct target_ops *self, const char *args, int from_tty)
-{
-  debug_target.to_load (&debug_target, args, from_tty);
-
-  fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
-}
-
-static void
-debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid)
-{
-  debug_target.to_post_startup_inferior (&debug_target, ptid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
-		      ptid_get_pid (ptid));
-}
-
-static int
-debug_to_insert_fork_catchpoint (struct target_ops *self, int pid)
-{
-  int retval;
-
-  retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
-		      pid, retval);
-
-  return retval;
-}
-
-static int
-debug_to_remove_fork_catchpoint (struct target_ops *self, int pid)
-{
-  int retval;
-
-  retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
-		      pid, retval);
-
-  return retval;
-}
-
-static int
-debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid)
-{
-  int retval;
-
-  retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
-		      pid, retval);
-
-  return retval;
-}
-
-static int
-debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid)
-{
-  int retval;
-
-  retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
-		      pid, retval);
-
-  return retval;
-}
-
-static int
-debug_to_insert_exec_catchpoint (struct target_ops *self, int pid)
-{
-  int retval;
-
-  retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
-		      pid, retval);
-
-  return retval;
-}
-
-static int
-debug_to_remove_exec_catchpoint (struct target_ops *self, int pid)
-{
-  int retval;
-
-  retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
-		      pid, retval);
-
-  return retval;
-}
-
-static int
-debug_to_has_exited (struct target_ops *self,
-		     int pid, int wait_status, int *exit_status)
-{
-  int has_exited;
-
-  has_exited = debug_target.to_has_exited (&debug_target,
-					   pid, wait_status, exit_status);
-
-  fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
-		      pid, wait_status, *exit_status, has_exited);
-
-  return has_exited;
-}
-
-static int
-debug_to_can_run (struct target_ops *self)
-{
-  int retval;
-
-  retval = debug_target.to_can_run (&debug_target);
-
-  fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
-
-  return retval;
-}
-
-static struct gdbarch *
-debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
-{
-  struct gdbarch *retval;
-
-  retval = debug_target.to_thread_architecture (ops, ptid);
-
-  fprintf_unfiltered (gdb_stdlog, 
-		      "target_thread_architecture (%s) = %s [%s]\n",
-		      target_pid_to_str (ptid),
-		      host_address_to_string (retval),
-		      gdbarch_bfd_arch_info (retval)->printable_name);
-  return retval;
-}
-
-static void
-debug_to_stop (struct target_ops *self, ptid_t ptid)
-{
-  debug_target.to_stop (&debug_target, ptid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
-		      target_pid_to_str (ptid));
-}
-
-static void
-debug_to_rcmd (struct target_ops *self, const char *command,
-	       struct ui_file *outbuf)
-{
-  debug_target.to_rcmd (&debug_target, command, outbuf);
-  fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
-}
-
-static char *
-debug_to_pid_to_exec_file (struct target_ops *self, int pid)
-{
-  char *exec_file;
-
-  exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid);
-
-  fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
-		      pid, exec_file);
-
-  return exec_file;
-}
-
-static void
 setup_target_debug (void)
 {
   memcpy (&debug_target, &current_target, sizeof debug_target);
 
   current_target.to_open = debug_to_open;
-  current_target.to_post_attach = debug_to_post_attach;
-  current_target.to_prepare_to_store = debug_to_prepare_to_store;
-  current_target.to_files_info = debug_to_files_info;
-  current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
-  current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
-  current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
-  current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
-  current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
-  current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
-  current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
-  current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
-  current_target.to_stopped_data_address = debug_to_stopped_data_address;
-  current_target.to_watchpoint_addr_within_range
-    = debug_to_watchpoint_addr_within_range;
-  current_target.to_region_ok_for_hw_watchpoint
-    = debug_to_region_ok_for_hw_watchpoint;
-  current_target.to_can_accel_watchpoint_condition
-    = debug_to_can_accel_watchpoint_condition;
-  current_target.to_terminal_init = debug_to_terminal_init;
-  current_target.to_terminal_inferior = debug_to_terminal_inferior;
-  current_target.to_terminal_ours_for_output
-    = debug_to_terminal_ours_for_output;
-  current_target.to_terminal_ours = debug_to_terminal_ours;
-  current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
-  current_target.to_terminal_info = debug_to_terminal_info;
-  current_target.to_load = debug_to_load;
-  current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
-  current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
-  current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
-  current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
-  current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
-  current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
-  current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
-  current_target.to_has_exited = debug_to_has_exited;
-  current_target.to_can_run = debug_to_can_run;
-  current_target.to_stop = debug_to_stop;
-  current_target.to_rcmd = debug_to_rcmd;
-  current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
-  current_target.to_thread_architecture = debug_to_thread_architecture;
+  init_debug_target (&current_target);
 }
 
 
diff --git a/gdb/target.h b/gdb/target.h
index 8c8ce00..92572ff 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -357,6 +357,16 @@ struct thread_info;		/* fwd decl for parameter list below: */
 typedef void async_callback_ftype (enum inferior_event_type event_type,
 				   void *context);
 
+/* Normally target debug printing is purely type-based.  However,
+   sometimes it is necessary to override the debug printing on a
+   per-argument basis.  This macro can be used, attribute-style, to
+   name the target debug printing function for a particular method
+   argument.  FUNC is the name of the function.  The macro's
+   definition is empty because it is only used by the
+   make-target-delegates script.  */
+
+#define TARGET_DEBUG_PRINTER(FUNC)
+
 /* These defines are used to mark target_ops methods.  The script
    make-target-delegates scans these and auto-generates the base
    method implementations.  There are four macros that can be used:
@@ -416,10 +426,13 @@ struct target_ops
       TARGET_DEFAULT_IGNORE ();
     void (*to_disconnect) (struct target_ops *, const char *, int)
       TARGET_DEFAULT_NORETURN (tcomplain ());
-    void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal)
+    void (*to_resume) (struct target_ops *, ptid_t,
+		       int TARGET_DEBUG_PRINTER (target_debug_print_step),
+		       enum gdb_signal)
       TARGET_DEFAULT_NORETURN (noprocess ());
     ptid_t (*to_wait) (struct target_ops *,
-		       ptid_t, struct target_waitstatus *, int)
+		       ptid_t, struct target_waitstatus *,
+		       int TARGET_DEBUG_PRINTER (target_debug_print_options))
       TARGET_DEFAULT_NORETURN (noprocess ());
     void (*to_fetch_registers) (struct target_ops *, struct regcache *, int)
       TARGET_DEFAULT_IGNORE ();
@@ -539,12 +552,14 @@ struct target_ops
 
     /* Documentation of this routine is provided with the corresponding
        target_* macro.  */
-    void (*to_pass_signals) (struct target_ops *, int, unsigned char *)
+    void (*to_pass_signals) (struct target_ops *, int,
+			     unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals))
       TARGET_DEFAULT_IGNORE ();
 
     /* Documentation of this routine is provided with the
        corresponding target_* function.  */
-    void (*to_program_signals) (struct target_ops *, int, unsigned char *)
+    void (*to_program_signals) (struct target_ops *, int,
+				unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals))
       TARGET_DEFAULT_IGNORE ();
 
     int (*to_thread_alive) (struct target_ops *, ptid_t ptid)


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]