introduce the target stack

there's a huge hack in multi_target_compatible

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

	* target-delegates.c: Rebuild.
	* make-target-delegates (write_debugmethod): Update for change to
	debug_target.
	* progspace.c (add_program_space): Acquire a reference to the
	target stack.
	(release_program_space): Release reference to the program space.
	(set_current_program_space): Set the target stack.
	* progspace.h (struct program_space) <target_stack>: New field.
	* target.c (target_ops_ptr): New typedef.
	(struct target_stack): New.
	(target_stack): Change type.
	(current_target): Update comment.
	(update_current_target): Update.
	(multi_target_compatible, ensure_multi_target_ok): New functions.
	(push_target): Update.  Add multi-target check.
	(unpush_target, pop_all_targets_above, target_is_pushed)
	(target_info, target_require_runnable): Update.
	(target_stack_set): New global.
	(currently_multi_target, target_stack_incref, target_stack_decref)
	(target_stack_set_current, new_target_stack): New functions.
	(maintenance_print_target_stack): Update.
	(initialize_targets): Initialize target_stack_set, target_stack.
	Update.
	(target_stack_id): New function.
	(next_available_target_id): New global.
	(print_one_target_stack): New function.
	(maintenance_print_target_stack): Move earlier.  Rewrite.
	(debug_target): Remove.
	(debug_to_open, setup_target_debug): Update.
	* target.h (target_stack_incref, target_stack_decref)
	(target_stack_set_current, new_target_stack, target_stack_id):
	Declare.
        * testsuite/gdb.base/auto-connect-native-target.exp: Update.

diff --git a/gdb/make-target-delegates b/gdb/make-target-delegates
index 88ea775919ccb782cbe7315e042d5b8c041a2480..e079bfd14bb2288446cd526eb906d1891e2d2346 100755 (executable)
--- a/gdb/make-target-delegates
+++ b/gdb/make-target-delegates
@@ -255,21 +255,21 @@ sub write_debugmethod($$$$@) {
        print "  $return_type result;\n";
     }
 
-    print "  fprintf_unfiltered (gdb_stdlog, \"-> %s->$name (...)\\n\", debug_target.to_shortname);\n";
+    print "  fprintf_unfiltered (gdb_stdlog, \"-> %s->$name (...)\\n\", target_stack->debug_target.to_shortname);\n";
 
     # Delegate to the beneath target.
     print "  ";
     if ($return_type ne 'void') {
        print "result = ";
     }
-    print "debug_target." . $name . " (";
+    print "target_stack->debug_target." . $name . " (";
     my @names2 = @names;
-    @names2[0] = "&debug_target";
+    @names2[0] = "&target_stack->debug_target";
     print join (', ', @names2);
     print ");\n";
 
     # Now print the arguments.
-    print "  fprintf_unfiltered (gdb_stdlog, \"<- %s->$name (\", debug_target.to_shortname);\n";
+    print "  fprintf_unfiltered (gdb_stdlog, \"<- %s->$name (\", target_stack->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]);

diff --git a/gdb/progspace.c b/gdb/progspace.c
index 3d7e4759772858556ef732f52a2e58fa35bcda13..1cdbb48e535c51a1e8e85ef404b3e4e1dfa6e6e9 100644 (file)
--- a/gdb/progspace.c
+++ b/gdb/progspace.c
@@ -133,6 +133,8 @@ add_program_space (struct address_space *aspace)
 
   program_space_alloc_data (pspace);
 
+  pspace->target_stack = target_stack_incref ();
+
   pspace->next = program_spaces;
   program_spaces = pspace;
 
@@ -162,6 +164,9 @@ release_program_space (struct program_space *pspace)
     free_address_space (pspace->aspace);
   clear_section_table (&pspace->target_sections);
   clear_program_space_solib_cache (pspace);
+
+  target_stack_decref (pspace->target_stack);
+
     /* Discard any data modules have associated with the PSPACE.  */
   program_space_free_data (pspace);
   xfree (pspace);
@@ -204,6 +209,7 @@ set_current_program_space (struct program_space *pspace)
   gdb_assert (pspace != NULL);
 
   current_program_space = pspace;
+  target_stack_set_current (pspace->target_stack);
 
   /* Different symbols change our view of the frame chain.  */
   reinit_frame_cache ();

diff --git a/gdb/progspace.h b/gdb/progspace.h
index cbb3f2b3d6e1db700b9eef49f398e7cbc0372190..2e289ce8200b37a433f717766980f73d5ccb4113 100644 (file)
--- a/gdb/progspace.h
+++ b/gdb/progspace.h
@@ -209,6 +209,10 @@ struct program_space
     /* Binary file diddling handle for the core file.  */
     bfd *cbfd;
 
+    /* The target stack.  The program space owns a reference to
+       it.  */
+    struct target_stack *target_stack;
+
     /* Per pspace data-pointers required by other GDB modules.  */
     REGISTRY_FIELDS;
   };

diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c
index a7271fa943a4f5f4562fe53b87b02e0908a83c99..2e30f40306c847dc98b9eff0a1aae2df6cf22aff 100644 (file)
--- a/gdb/target-delegates.c
+++ b/gdb/target-delegates.c
@@ -18,10 +18,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_post_attach (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -42,10 +42,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_detach (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -69,10 +69,10 @@ tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
 static void
 debug_disconnect (struct target_ops *self, const char *arg1, int arg2)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", debug_target.to_shortname);
-  debug_target.to_disconnect (&debug_target, arg1, arg2);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_disconnect (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -96,10 +96,10 @@ tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal
 static void
 debug_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", debug_target.to_shortname);
-  debug_target.to_resume (&debug_target, arg1, arg2, arg3);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_resume (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -120,10 +120,10 @@ static ptid_t
 debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
 {
   ptid_t result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", debug_target.to_shortname);
-  result = debug_target.to_wait (&debug_target, arg1, arg2, arg3);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_wait (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -151,10 +151,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_fetch_registers (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_regcache_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -178,10 +178,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_store_registers (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_regcache_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -205,10 +205,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_prepare_to_store (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_regcache_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -229,10 +229,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_files_info (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_files_info (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_files_info (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -247,10 +247,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_breakpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_insert_breakpoint (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_breakpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_gdbarch_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -272,10 +272,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_remove_breakpoint (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_gdbarch_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -303,10 +303,10 @@ static int
 debug_stopped_by_sw_breakpoint (struct target_ops *self)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname);
-  result = debug_target.to_stopped_by_sw_breakpoint (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_sw_breakpoint (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_sw_breakpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_stopped_by_sw_breakpoint (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_sw_breakpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -330,10 +330,10 @@ static int
 debug_supports_stopped_by_sw_breakpoint (struct target_ops *self)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname);
-  result = debug_target.to_supports_stopped_by_sw_breakpoint (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_sw_breakpoint (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_sw_breakpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_supports_stopped_by_sw_breakpoint (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_sw_breakpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -357,10 +357,10 @@ static int
 debug_stopped_by_hw_breakpoint (struct target_ops *self)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname);
-  result = debug_target.to_stopped_by_hw_breakpoint (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_hw_breakpoint (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_hw_breakpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_stopped_by_hw_breakpoint (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_hw_breakpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -384,10 +384,10 @@ static int
 debug_supports_stopped_by_hw_breakpoint (struct target_ops *self)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname);
-  result = debug_target.to_supports_stopped_by_hw_breakpoint (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_hw_breakpoint (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_hw_breakpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_supports_stopped_by_hw_breakpoint (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_hw_breakpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -411,10 +411,10 @@ static int
 debug_can_use_hw_breakpoint (struct target_ops *self, enum bptype arg1, int arg2, int arg3)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", debug_target.to_shortname);
-  result = debug_target.to_can_use_hw_breakpoint (&debug_target, arg1, arg2, arg3);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_can_use_hw_breakpoint (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_enum_bptype (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -444,10 +444,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_ranged_break_num_registers (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_ranged_break_num_registers (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_ranged_break_num_registers (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -471,10 +471,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_hw_breakpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_insert_hw_breakpoint (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_hw_breakpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_gdbarch_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -502,10 +502,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_hw_breakpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_remove_hw_breakpoint (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_hw_breakpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_gdbarch_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -533,10 +533,10 @@ static int
 debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", debug_target.to_shortname);
-  result = debug_target.to_remove_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_remove_watchpoint (&target_stack->debug_target, arg1, arg2, arg3, arg4);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -568,10 +568,10 @@ static int
 debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", debug_target.to_shortname);
-  result = debug_target.to_insert_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_insert_watchpoint (&target_stack->debug_target, arg1, arg2, arg3, arg4);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -603,10 +603,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_mask_watchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_insert_mask_watchpoint (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_mask_watchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -636,10 +636,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_mask_watchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_remove_mask_watchpoint (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_mask_watchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -669,10 +669,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_watchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_stopped_by_watchpoint (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_watchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -696,10 +696,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_data_address (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_stopped_data_address (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_data_address (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR_p (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -719,10 +719,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_watchpoint_addr_within_range (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_watchpoint_addr_within_range (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_watchpoint_addr_within_range (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -746,10 +746,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_region_ok_for_hw_watchpoint (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_region_ok_for_hw_watchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -777,10 +777,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_accel_watchpoint_condition (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_can_accel_watchpoint_condition (&target_stack->debug_target, arg1, arg2, arg3, arg4);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_accel_watchpoint_condition (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -812,10 +812,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_masked_watch_num_registers (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_masked_watch_num_registers (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_masked_watch_num_registers (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -843,10 +843,10 @@ static int
 debug_can_do_single_step (struct target_ops *self)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_do_single_step (...)\n", debug_target.to_shortname);
-  result = debug_target.to_can_do_single_step (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_do_single_step (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_do_single_step (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_can_do_single_step (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_do_single_step (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -868,10 +868,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_init (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_terminal_init (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_init (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -890,10 +890,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_inferior (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_terminal_inferior (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_inferior (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -912,10 +912,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours_for_output (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_terminal_ours_for_output (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours_for_output (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -934,10 +934,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_terminal_ours (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -951,10 +951,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_info (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_terminal_info (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_info (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -978,10 +978,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_kill (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_kill (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_kill (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -1001,10 +1001,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_load (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_load (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_load (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1027,10 +1027,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_startup_inferior (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_post_startup_inferior (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_startup_inferior (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -1053,10 +1053,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_fork_catchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_insert_fork_catchpoint (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_fork_catchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1082,10 +1082,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_fork_catchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_remove_fork_catchpoint (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_fork_catchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1111,10 +1111,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_vfork_catchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_insert_vfork_catchpoint (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_vfork_catchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1140,10 +1140,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_vfork_catchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_remove_vfork_catchpoint (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_vfork_catchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1163,10 +1163,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_fork (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_follow_fork (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_fork (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1194,10 +1194,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_exec_catchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_insert_exec_catchpoint (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_exec_catchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1223,10 +1223,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_exec_catchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_remove_exec_catchpoint (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_exec_catchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1250,10 +1250,10 @@ tdefault_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2
 static void
 debug_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_exec (...)\n", debug_target.to_shortname);
-  debug_target.to_follow_exec (&debug_target, arg1, arg2);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_exec (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_exec (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_follow_exec (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_exec (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_inferior_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1278,10 +1278,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_set_syscall_catchpoint (&target_stack->debug_target, arg1, arg2, arg3, arg4, arg5);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1315,10 +1315,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_has_exited (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_has_exited (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_has_exited (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1341,10 +1341,10 @@ delegate_mourn_inferior (struct target_ops *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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_mourn_inferior (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_mourn_inferior (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_mourn_inferior (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -1365,10 +1365,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_can_run (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -1390,10 +1390,10 @@ tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
 static void
 debug_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", debug_target.to_shortname);
-  debug_target.to_pass_signals (&debug_target, arg1, arg2);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_pass_signals (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1416,10 +1416,10 @@ tdefault_program_signals (struct target_ops *self, int arg1, unsigned char * arg
 static void
 debug_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", debug_target.to_shortname);
-  debug_target.to_program_signals (&debug_target, arg1, arg2);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_program_signals (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1444,10 +1444,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_alive (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_thread_alive (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_alive (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1471,10 +1471,10 @@ tdefault_update_thread_list (struct target_ops *self)
 static void
 debug_update_thread_list (struct target_ops *self)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_update_thread_list (...)\n", debug_target.to_shortname);
-  debug_target.to_update_thread_list (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_update_thread_list (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_update_thread_list (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_update_thread_list (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_update_thread_list (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -1489,10 +1489,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_str (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_pid_to_str (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_str (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1518,10 +1518,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_extra_thread_info (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_extra_thread_info (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_extra_thread_info (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_thread_info_p (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1547,10 +1547,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_name (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_thread_name (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_name (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_thread_info_p (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1574,10 +1574,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_stop (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -1598,10 +1598,10 @@ tdefault_interrupt (struct target_ops *self, ptid_t arg1)
 static void
 debug_interrupt (struct target_ops *self, ptid_t arg1)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_interrupt (...)\n", debug_target.to_shortname);
-  debug_target.to_interrupt (&debug_target, arg1);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_interrupt (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_interrupt (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_interrupt (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_interrupt (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -1622,10 +1622,10 @@ tdefault_check_pending_interrupt (struct target_ops *self)
 static void
 debug_check_pending_interrupt (struct target_ops *self)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_check_pending_interrupt (...)\n", debug_target.to_shortname);
-  debug_target.to_check_pending_interrupt (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_check_pending_interrupt (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_check_pending_interrupt (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_check_pending_interrupt (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_check_pending_interrupt (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -1639,10 +1639,10 @@ delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_rcmd (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_rcmd (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_rcmd (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1667,10 +1667,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_exec_file (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_pid_to_exec_file (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_exec_file (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -1694,10 +1694,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_log_command (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_log_command (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_log_command (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -1720,10 +1720,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_section_table (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_section_table (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_section_table (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_struct_target_section_table_p (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -1747,10 +1747,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_async_p (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_can_async_p (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_async_p (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -1774,10 +1774,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_is_async_p (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_is_async_p (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_is_async_p (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -1800,10 +1800,10 @@ tdefault_async (struct target_ops *self, int arg1)
 static void
 debug_async (struct target_ops *self, int arg1)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname);
-  debug_target.to_async (&debug_target, arg1);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_async (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -1826,10 +1826,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_supports_non_stop (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -1853,10 +1853,10 @@ static int
 debug_always_non_stop_p (struct target_ops *self)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_always_non_stop_p (...)\n", debug_target.to_shortname);
-  result = debug_target.to_always_non_stop_p (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_always_non_stop_p (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_always_non_stop_p (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_always_non_stop_p (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_always_non_stop_p (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -1874,10 +1874,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_find_memory_regions (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_find_memory_region_ftype (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1899,10 +1899,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_make_corefile_notes (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_bfd_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1930,10 +1930,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_bookmark (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1960,10 +1960,10 @@ tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_goto_bookmark (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_gdb_byte_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -1988,10 +1988,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_thread_local_address (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_thread_local_address (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_thread_local_address (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2021,10 +2021,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_xfer_partial (&target_stack->debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_enum_target_object (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2062,10 +2062,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_memory_map (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_VEC_mem_region_s__p (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2088,10 +2088,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_flash_erase (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ULONGEST (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2115,10 +2115,10 @@ tdefault_flash_done (struct target_ops *self)
 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_flash_done (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -2139,10 +2139,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_read_description (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_const_struct_target_desc_p (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2160,10 +2160,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_ada_task_ptid (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_long (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2185,10 +2185,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_auxv_parse (&target_stack->debug_target, arg1, arg2, arg3, arg4);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_gdb_byte_pp (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2214,10 +2214,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_search_memory (&target_stack->debug_target, arg1, arg2, arg3, arg4, arg5);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2251,10 +2251,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_can_execute_reverse (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2272,10 +2272,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_execution_direction (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_enum_exec_direction_kind (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2299,10 +2299,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_supports_multi_process (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2326,10 +2326,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_supports_enable_disable_tracepoint (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2353,10 +2353,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_supports_string_tracing (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2380,10 +2380,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_supports_evaluation_of_breakpoint_conditions (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2407,10 +2407,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_can_run_breakpoint_commands (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2428,10 +2428,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_thread_architecture (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -2451,10 +2451,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_thread_address_space (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -2480,10 +2480,10 @@ static int
 debug_filesystem_is_local (struct target_ops *self)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_filesystem_is_local (...)\n", debug_target.to_shortname);
-  result = debug_target.to_filesystem_is_local (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_filesystem_is_local (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_filesystem_is_local (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_filesystem_is_local (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_filesystem_is_local (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2506,10 +2506,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_trace_init (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -2529,10 +2529,10 @@ tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_download_tracepoint (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_bp_location_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -2555,10 +2555,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_can_download_tracepoint (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2581,10 +2581,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_download_trace_state_variable (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_trace_state_variable_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -2606,10 +2606,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_enable_tracepoint (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_bp_location_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -2631,10 +2631,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_disable_tracepoint (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_bp_location_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -2656,10 +2656,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_trace_set_readonly_regions (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -2679,10 +2679,10 @@ tdefault_trace_start (struct target_ops *self)
 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_trace_start (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -2703,10 +2703,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_trace_status (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_trace_status_p (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -2731,10 +2731,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_get_tracepoint_status (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_breakpoint_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2758,10 +2758,10 @@ tdefault_trace_stop (struct target_ops *self)
 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_trace_stop (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -2782,10 +2782,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_trace_find (&target_stack->debug_target, arg1, arg2, arg3, arg4, arg5);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_enum_trace_find_type (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2819,10 +2819,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_trace_state_variable_value (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2850,10 +2850,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_save_trace_data (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -2879,10 +2879,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_upload_tracepoints (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_uploaded_tp_pp (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -2908,10 +2908,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_upload_trace_state_variables (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_uploaded_tsv_pp (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -2937,10 +2937,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_raw_trace_data (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_gdb_byte_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -2970,10 +2970,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_min_fast_tracepoint_insn_len (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -2995,10 +2995,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_set_disconnected_tracing (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -3019,10 +3019,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_set_circular_trace_buffer (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -3043,10 +3043,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_set_trace_buffer_size (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_LONGEST (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -3069,10 +3069,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_set_trace_notes (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3102,10 +3102,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_core_of_thread (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -3125,10 +3125,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_verify_memory (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_gdb_byte_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3158,10 +3158,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_tib_address (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_address (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3187,10 +3187,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_set_permissions (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -3211,10 +3211,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_static_tracepoint_marker_at (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_CORE_ADDR (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3242,10 +3242,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_static_tracepoint_markers_by_strid (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -3271,10 +3271,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_traceframe_info (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_struct_traceframe_info_p (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -3298,10 +3298,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_use_agent (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -3327,10 +3327,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_can_use_agent (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -3354,10 +3354,10 @@ static int
 debug_supports_btrace (struct target_ops *self, enum btrace_format arg1)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
-  result = debug_target.to_supports_btrace (&debug_target, arg1);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_supports_btrace (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_enum_btrace_format (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -3383,10 +3383,10 @@ static struct btrace_target_info *
 debug_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
 {
   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, arg2);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_enable_btrace (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3413,10 +3413,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_disable_btrace (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_btrace_target_info_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -3438,10 +3438,10 @@ tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *ar
 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_teardown_btrace (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_btrace_target_info_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -3464,10 +3464,10 @@ static enum btrace_error
 debug_read_btrace (struct target_ops *self, struct btrace_data *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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_read_btrace (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_struct_btrace_data_p (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3497,10 +3497,10 @@ static const struct btrace_config *
 debug_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
 {
   const struct btrace_config * result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_btrace_conf (...)\n", debug_target.to_shortname);
-  result = debug_target.to_btrace_conf (&debug_target, arg1);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_btrace_conf (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_btrace_conf (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_btrace_conf (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_btrace_conf (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_struct_btrace_target_info_p (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -3524,10 +3524,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_stop_recording (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -3546,10 +3546,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_info_record (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -3569,10 +3569,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_save_record (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_const_char_p (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -3594,10 +3594,10 @@ tdefault_delete_record (struct target_ops *self)
 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_delete_record (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -3618,10 +3618,10 @@ static int
 debug_record_is_replaying (struct target_ops *self, ptid_t arg1)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
-  result = debug_target.to_record_is_replaying (&debug_target, arg1);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_record_is_replaying (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (") = ", gdb_stdlog);
@@ -3647,10 +3647,10 @@ static int
 debug_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
 {
   int result;
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_will_replay (...)\n", debug_target.to_shortname);
-  result = debug_target.to_record_will_replay (&debug_target, arg1, arg2);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_will_replay (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_will_replay (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_record_will_replay (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_will_replay (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ptid_t (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3676,10 +3676,10 @@ tdefault_record_stop_replaying (struct target_ops *self)
 static void
 debug_record_stop_replaying (struct target_ops *self)
 {
-  fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_stop_replaying (...)\n", debug_target.to_shortname);
-  debug_target.to_record_stop_replaying (&debug_target);
-  fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_stop_replaying (", debug_target.to_shortname);
-  target_debug_print_struct_target_ops_p (&debug_target);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_stop_replaying (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_record_stop_replaying (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_stop_replaying (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -3699,10 +3699,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_goto_record_begin (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -3722,10 +3722,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_goto_record_end (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -3745,10 +3745,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_goto_record (&target_stack->debug_target, arg1);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ULONGEST (arg1);
   fputs_unfiltered (")\n", gdb_stdlog);
@@ -3770,10 +3770,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_insn_history (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3797,10 +3797,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_insn_history_from (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ULONGEST (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3826,10 +3826,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_insn_history_range (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ULONGEST (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3855,10 +3855,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_call_history (&target_stack->debug_target, arg1, arg2);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_int (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3882,10 +3882,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_call_history_from (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ULONGEST (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3911,10 +3911,10 @@ tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST ar
 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_call_history_range (&target_stack->debug_target, arg1, arg2, arg3);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (", ", gdb_stdlog);
   target_debug_print_ULONGEST (arg1);
   fputs_unfiltered (", ", gdb_stdlog);
@@ -3941,10 +3941,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_augmented_libraries_svr4_read (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_int (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -3968,10 +3968,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_unwinder (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_const_struct_frame_unwind_p (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -3995,10 +3995,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", target_stack->debug_target.to_shortname);
+  result = target_stack->debug_target.to_get_tailcall_unwinder (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (") = ", gdb_stdlog);
   target_debug_print_const_struct_frame_unwind_p (result);
   fputs_unfiltered ("\n", gdb_stdlog);
@@ -4020,10 +4020,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_prepare_to_generate_core (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 
@@ -4042,10 +4042,10 @@ 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);
+  fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", target_stack->debug_target.to_shortname);
+  target_stack->debug_target.to_done_generating_core (&target_stack->debug_target);
+  fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", target_stack->debug_target.to_shortname);
+  target_debug_print_struct_target_ops_p (&target_stack->debug_target);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 

diff --git a/gdb/target.c b/gdb/target.c
index 345a668517508b9073b3c4ae71fb59c028e4097f..1d7a4cf468180ed1770e20a565b5a33e9022ff16 100644 (file)
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -107,12 +107,12 @@ static enum exec_direction_kind default_execution_direction
 
 static struct target_ops debug_target;
 
-#include "target-delegates.c"
-
 static void init_dummy_target (void);
 
 static void update_current_target (void);
 
+static int currently_multi_target (void);
+
 /* Vector of existing target structures. */
 typedef struct target_ops *target_ops_p;
 DEF_VEC_P (target_ops_p);
@@ -123,15 +123,48 @@ static VEC (target_ops_p) *target_structs;
 
 static struct target_ops dummy_target;
 
-/* Top of target stack.  */
+/* The next available target id.  */
+
+static int next_available_target_id;
+
+/* The type of the target stack.  */
+
+struct target_stack
+{
+  /* The targets making up the current stack.  */
+
+  struct target_ops *top;
 
-static struct target_ops *target_stack;
+  /* Reference count.  */
+
+  int refc;
+
+  /* Target id.  */
+
+  int id;
+
+  /* The "smashed" target_ops.  */
+
+  struct target_ops smashed;
+
+  /* When the debug target is pushed, this holds a copy of the
+     previous smashed target.  */
+
+  struct target_ops debug_target;
+};
+
+/* The current target stack.  */
+
+static struct target_stack *target_stack;
 
 /* The target structure we are currently using to talk to a process
-   or file or whatever "inferior" we have.  */
+   or file or whatever "inferior" we have.  This is always equal to
+   TARGET_STACK->smashed.  */
 
 struct target_ops *current_target;
 
+#include "target-delegates.c"
+
 /* Command list for target.  */
 
 static struct cmd_list_element *targetlist = NULL;
@@ -627,7 +660,7 @@ update_current_target (void)
   /* Install the delegators.  */
   install_delegators (current_target);
 
-  current_target->to_stratum = target_stack->to_stratum;
+  current_target->to_stratum = target_stack->top->to_stratum;
 
 #define INHERIT(FIELD, TARGET) \
       if (!current_target->FIELD) \
@@ -635,7 +668,7 @@ update_current_target (void)
 
   /* Do not add any new INHERITs here.  Instead, use the delegation
      mechanism provided by make-target-delegates.  */
-  for (t = target_stack; t; t = t->beneath)
+  for (t = target_stack->top; t; t = t->beneath)
     {
       INHERIT (to_shortname, t);
       INHERIT (to_longname, t);
@@ -649,12 +682,40 @@ update_current_target (void)
   /* Finally, position the target-stack beneath the squashed
      "current_target".  That way code looking for a non-inherited
      target method can quickly and simply find it.  */
-  current_target->beneath = target_stack;
+  current_target->beneath = target_stack->top;
 
   if (targetdebug)
     setup_target_debug ();
 }
 
+/* Return true if target T is multi-target-compatible.  */
+
+static int
+multi_target_compatible (struct target_ops *t)
+{
+  /* The main sentinel is the existence of to_xclose.  Ideally all
+     targets would be converted to this approach.  */
+  if (t->to_xclose != NULL)
+    return 1;
+
+  /* Dummy target is always ok.  */
+  if (t == &dummy_target)
+    return 1;
+
+  /* "child" targets are native and thus always ok.  Super hack.  */
+  return strcmp (t->to_shortname, "child") == 0;
+}
+
+/* Require T to be multi-target-compatible.  */
+
+static void
+ensure_multi_target_ok (struct target_ops *t)
+{
+  if (!multi_target_compatible (t))
+    error (_("Target %s cannot be used in multi-target mode"),
+          t->to_shortname);
+}
+
 /* Push a new target type into the stack of the existing target accessors,
    possibly superseding some of the existing accessors.
 
@@ -679,13 +740,16 @@ push_target (struct target_ops *t)
     }
 
   /* Find the proper stratum to install this target in.  */
-  for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
+  for (cur = &target_stack->top; (*cur) != NULL; cur = &(*cur)->beneath)
     {
       if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
        break;
     }
 
-  /* If there's already targets at this stratum, remove them.  */
+  if (currently_multi_target ())
+    ensure_multi_target_ok (t);
+
+  /* If there's already a target at this stratum, remove them.  */
   /* FIXME: cagney/2003-10-15: I think this should be popping all
      targets to CUR, and not just those at this stratum level.  */
   while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
@@ -742,7 +806,7 @@ unpush_target (struct target_ops *t)
   /* Look for the specified target.  Note that we assume that a target
      can only occur once in the target stack.  */
 
-  for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
+  for (cur = &target_stack->top; (*cur) != NULL; cur = &(*cur)->beneath)
     {
       if ((*cur) == t || (*cur)->to_identity == t)
        break;
@@ -773,11 +837,11 @@ pop_all_targets_above (enum strata above_stratum)
 {
   while ((int) (current_target->to_stratum) > (int) above_stratum)
     {
-      if (!unpush_target (target_stack))
+      if (!unpush_target (target_stack->top))
        {
          fprintf_unfiltered (gdb_stderr,
                              "pop_all_targets couldn't find target %s\n",
-                             target_stack->to_shortname);
+                             target_stack->top->to_shortname);
          internal_error (__FILE__, __LINE__,
                          _("failed internal consistency check"));
          break;
@@ -809,7 +873,7 @@ target_is_pushed (struct target_ops *t)
                      _("failed internal consistency check"));
     }
 
-  for (cur = target_stack; cur != NULL; cur = cur->beneath)
+  for (cur = target_stack->top; cur != NULL; cur = cur->beneath)
     if (cur == t || cur->to_identity == t)
       return 1;
 
@@ -2106,7 +2170,7 @@ target_info (char *args, int from_tty)
     printf_unfiltered (_("Symbols from \"%s\".\n"),
                       objfile_name (symfile_objfile));
 
-  for (t = target_stack; t != NULL; t = t->beneath)
+  for (t = target_stack->top; t != NULL; t = t->beneath)
     {
       if (!(*t->to_has_memory) (t))
        continue;
@@ -2508,7 +2572,7 @@ target_require_runnable (void)
 {
   struct target_ops *t;
 
-  for (t = target_stack; t != NULL; t = t->beneath)
+  for (t = target_stack->top; t != NULL; t = t->beneath)
     {
       /* If this target knows how to create a new program, then
         assume we will still be able to after killing the current
@@ -3806,12 +3870,152 @@ target_done_generating_core (void)
 static void
 setup_target_debug (void)
 {
-  memcpy (&debug_target, current_target, sizeof debug_target);
+  memcpy (&target_stack->debug_target, current_target,
+         sizeof (struct target_ops));
 
   init_debug_target (current_target);
 }
 \f
 
+/* A set of all current target stacks.  */
+
+static htab_t target_stack_set;
+
+/* Return true if there are already multiple target stacks.  */
+
+static int
+currently_multi_target (void)
+{
+  return htab_elements (target_stack_set) > 1;
+}
+
+/* See target.h.  */
+
+struct target_stack *
+target_stack_incref (void)
+{
+  ++target_stack->refc;
+  return target_stack;
+}
+
+/* See target.h.  */
+
+void
+target_stack_decref (struct target_stack *tstack)
+{
+  --tstack->refc;
+  if (tstack->refc == 0)
+    {
+      /* It is ok to delete any random target stack as long as it only
+        has the dummy target.  If any other target has been pushed,
+        then the target stack being deleted must be the current
+        target stack.  */
+      if (tstack->smashed.to_stratum != dummy_stratum)
+       {
+         gdb_assert (tstack == target_stack);
+
+         pop_all_targets ();
+         target_stack = NULL;
+         current_target = NULL;
+       }
+
+      htab_remove_elt (target_stack_set, tstack);
+      xfree (tstack);
+    }
+}
+
+/* See target.h.  */
+
+void
+target_stack_set_current (struct target_stack *tstack)
+{
+  target_stack = tstack;
+  current_target = &tstack->smashed;
+}
+
+/* See target.h.  */
+
+struct target_stack *
+new_target_stack (void)
+{
+  struct target_stack *save = target_stack;
+  struct target_stack *result;
+  void **slot;
+
+  if (!currently_multi_target () && target_stack != NULL)
+    {
+      struct target_ops *t;
+
+      for (t = target_stack->top; t != NULL; t = t->beneath)
+       ensure_multi_target_ok (t);
+    }
+
+  /* Overwrite the globals so that push_target can work.  */
+  target_stack = XCNEW (struct target_stack);
+  target_stack->refc = 1;
+  /* A subtlety here is that post-increment ensures that the first
+     target stack we create has an id of 0.  This will be handy once
+     we introduce a way to create a per-target ptid -- unconverted,
+     non-multi-capable targets will continue to do the right
+     thing.  */
+  target_stack->id = next_available_target_id++;
+  current_target = &target_stack->smashed;
+
+  slot = htab_find_slot (target_stack_set, target_stack, INSERT);
+  gdb_assert (*slot == NULL);
+  *slot = target_stack;
+
+  push_target (&dummy_target);
+
+  result = target_stack;
+  target_stack = save;
+  if (target_stack == NULL)
+    current_target = NULL;
+  else
+    current_target = &save->smashed;
+
+  return result;
+}
+
+/* See target.h.  */
+
+int target_stack_id (void)
+{
+  return target_stack->id;
+}
+
+/* Print a single target stack.  */
+
+static int
+print_one_target_stack (void **slot, void *arg)
+{
+  struct target_stack *stack = *slot;
+  struct target_ops *t;
+  int i;
+
+  printf_filtered (_("Target stack %s"), host_address_to_string (stack));
+  if (stack == target_stack)
+    printf_filtered (_(" (current)"));
+  printf_filtered (_("\n"));
+
+  for (t = stack->top; t != NULL; t = t->beneath)
+    {
+      printf_filtered ("  - %s (%s)\n", t->to_shortname, t->to_longname);
+    }
+
+  return 1;
+}
+
+/* Print the name of each layers of our target stack.  */
+
+static void
+maintenance_print_target_stack (char *cmd, int from_tty)
+{
+  htab_traverse (target_stack_set, print_one_target_stack, NULL);
+}
+
+\f
+
 static char targ_desc[] =
 "Names of targets and files being debugged.\nShows the entire \
 stack of targets currently in use (including the exec-file,\n\
@@ -3831,21 +4035,6 @@ do_monitor_command (char *cmd,
   target_rcmd (cmd, gdb_stdtarg);
 }
 
-/* Print the name of each layers of our target stack.  */
-
-static void
-maintenance_print_target_stack (char *cmd, int from_tty)
-{
-  struct target_ops *t;
-
-  printf_filtered (_("The current target stack is:\n"));
-
-  for (t = target_stack; t != NULL; t = t->beneath)
-    {
-      printf_filtered ("  - %s (%s)\n", t->to_shortname, t->to_longname);
-    }
-}
-
 /* See target.h.  */
 
 void
@@ -4006,10 +4195,14 @@ set_write_memory_permission (char *args, int from_tty,
 void
 initialize_targets (void)
 {
-  current_target = XCNEW (struct target_ops);
-
   init_dummy_target ();
-  push_target (&dummy_target);
+
+  target_stack_set = htab_create_alloc (1, htab_hash_pointer,
+                                       htab_eq_pointer, NULL,
+                                       xcalloc, xfree);
+
+  target_stack = new_target_stack ();
+  current_target = &target_stack->smashed;
 
   add_info ("target", target_info, targ_desc);
   add_info ("files", target_info, targ_desc);

diff --git a/gdb/target.h b/gdb/target.h
index e31927111beddf45d0673fae0e7df959c7218a2a..78610bf7b4d7a31319166902ffdbc03ecde6badf 100644 (file)
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -39,6 +39,7 @@ struct traceframe_info;
 struct expression;
 struct dcache_struct;
 struct inferior;
+struct target_stack;
 
 #include "infrun.h" /* For enum exec_direction_kind.  */
 #include "breakpoint.h" /* For enum bptype.  */
@@ -1256,6 +1257,28 @@ struct target_ops
 
 #define        OPS_MAGIC       3840
 
+/* Acquire a reference to the target stack.  */
+
+extern struct target_stack *target_stack_incref (void);
+
+/* Release a reference to the target stack.  */
+
+extern void target_stack_decref (struct target_stack *);
+
+/* Set target_stack and current_target from TSTACK.  */
+
+extern void target_stack_set_current (struct target_stack *tstack);
+
+/* Create a new "empty" target stack and return it.  The current
+   target stack is not changed.  The new stack is initialized with a
+   single reference count, which is owned by the caller.  */
+
+extern struct target_stack *new_target_stack (void);
+
+/* Return the numeric identifier of the current target stack.  */
+
+extern int target_stack_id (void);
+
 /* The ops structure for our "current" target process.  This should
    never be NULL.  If there is no target, it points to the dummy_target.  */
 

diff --git a/gdb/testsuite/gdb.base/auto-connect-native-target.exp b/gdb/testsuite/gdb.base/auto-connect-native-target.exp
index 7d729dc34cefca0624d928f96428bb5caa5fc91e..b05027eb291009c465c5c9d800cdbda6be3304ad 100644 (file)
--- a/gdb/testsuite/gdb.base/auto-connect-native-target.exp
+++ b/gdb/testsuite/gdb.base/auto-connect-native-target.exp
@@ -49,7 +49,7 @@ proc get_topmost_target {test} {
     set topmost "unknown"
 
     gdb_test_multiple "maint print target-stack" $test {
-       -re "The current target stack is:\r\n  - (\[^ \]+) .*$gdb_prompt $" {
+       -re "Target stack 0x\[0-9a-f\]+ \\(current\\)\r\n  - (\[^ \]+) .*$gdb_prompt $" {
            set topmost $expect_out(1,string)
            pass $test
        }
@@ -131,7 +131,7 @@ gdb_test "target native" \
 
 proc test_native_target_remains_pushed {} {
     gdb_test "maint print target-stack"  \
-       "The current target stack is:\r\n  .* native .* exec .*" \
+       "Target stack 0x\[0-9a-f\]+ \\(current\\)\r\n  .* native .* exec .*" \
        "native target remains pushed"
 }