* [RFC] auto-generate most target debug methods
@ 2014-06-19 20:04 Tom Tromey
2014-06-20 8:00 ` Yao Qi
2014-07-15 11:17 ` Pedro Alves
0 siblings, 2 replies; 14+ messages in thread
From: Tom Tromey @ 2014-06-19 20:04 UTC (permalink / raw)
To: gdb-patches; +Cc: Tom Tromey
The target debug methods are inconsistently maintained. Most to_*
methods have some kind of targetdebug awareness, but not all of them
do. The ones that do vary in the quantity and quality of output they
generate.
This patch changes most of the target debug methods to be
automatically generated. All the arguments are printed, and separate
lines are printed for entering and existing the outermost call to the
target stack.
For example now you'd see:
-> multi-thread->to_terminal_ours (...)
-> multi-thread->to_is_async_p (...)
<- multi-thread->to_is_async_p (0x1ebb580) = 1
<- multi-thread->to_terminal_ours (0x1ebb580)
-> multi-thread->to_thread_address_space (...)
<- multi-thread->to_thread_address_space (0x1ebb580, 26802) = 1
In this case you can see nested calls. The "multi-thread" on the left
hand side is the topmost target's shortname.
There are some oddities with this patch. I'm on the fence about it
all, I really just wrote it on a whim.
It's not simple to convert every possible method, since a few don't
participate in target delegation.
Printing is done by type, so I introduced some new
debug-printing-specific typedefs to handle cases where it is nicer to
do something else.
On the plus side, this lays the groundwork for making targetdebug
affect every layer of the target stack. The idea would be to wrap
each target_ops in the stack with its own debug_target, and then you
could see calls propagate down the stack and back up; I suppose with
indentation to make it prettier. (That said there are some gotchas
lurking in this idea due to target stack introspection.)
Regtested on x86-64 Fedora 20.
2014-06-19 Tom Tromey <tromey@redhat.com>
* make-target-delegates (munge_type, write_debugmethod): New
functions.
(debug_names): New global.
Write debug methods. Generate init_debug_target.
* target-debug.h: New file.
* target-delegates.c: Rebuild.
* target.c: Include target-debug.h.
(debug_target): Hoist definition.
(target_kill, target_get_section_table, target_memory_map)
(target_flash_erase, target_flash_done, target_detach)
(target_disconnect, target_wait, target_resume)
(target_pass_signals, target_program_signals, target_follow_fork)
(target_mourn_inferior, target_search_memory)
(target_thread_address_space, target_close)
(target_find_new_threads, target_core_of_thread)
(target_verify_memory, target_insert_mask_watchpoint)
(target_remove_mask_watchpoint): Remove targetdebug code.
(debug_to_post_attach, debug_to_prepare_to_store)
(debug_to_files_info, debug_to_insert_breakpoint)
(debug_to_remove_breakpoint, debug_to_can_use_hw_breakpoint)
(debug_to_region_ok_for_hw_watchpoint)
(debug_to_can_accel_watchpoint_condition)
(debug_to_stopped_by_watchpoint, debug_to_stopped_data_address)
(debug_to_watchpoint_addr_within_range)
(debug_to_insert_hw_breakpoint, debug_to_remove_hw_breakpoint)
(debug_to_insert_watchpoint, debug_to_remove_watchpoint)
(debug_to_terminal_init, debug_to_terminal_inferior)
(debug_to_terminal_ours_for_output, debug_to_terminal_ours)
(debug_to_terminal_save_ours, debug_to_terminal_info)
(debug_to_load, debug_to_post_startup_inferior)
(debug_to_insert_fork_catchpoint)
(debug_to_remove_fork_catchpoint)
(debug_to_insert_vfork_catchpoint)
(debug_to_remove_vfork_catchpoint)
(debug_to_insert_exec_catchpoint)
(debug_to_remove_exec_catchpoint, debug_to_has_exited)
(debug_to_can_run, debug_to_thread_architecture, debug_to_stop)
(debug_to_rcmd, debug_to_pid_to_exec_file): Remove.
(setup_target_debug): Call init_debug_target.
* target.h (target_debug_options, target_debug_step): New
typedefs.
(struct target_ops) <to_resume>: Use target_debug_step.
<to_wait>: use target_debug_options.
---
gdb/ChangeLog | 46 +
gdb/make-target-delegates | 78 ++
gdb/target-debug.h | 182 ++++
gdb/target-delegates.c | 2178 ++++++++++++++++++++++++++++++++++++++++++++-
gdb/target.c | 712 +--------------
gdb/target.h | 12 +-
6 files changed, 2509 insertions(+), 699 deletions(-)
create mode 100644 gdb/target-debug.h
diff --git a/gdb/make-target-delegates b/gdb/make-target-delegates
index f09f89d..f049447 100755
--- a/gdb/make-target-delegates
+++ b/gdb/make-target-delegates
@@ -188,6 +188,72 @@ sub write_tdefault($$$$@) {
return tdname ($name);
}
+sub munge_type($) {
+ my ($typename) = @_;
+
+ $typename =~ s/\s+$//;
+ $typename =~ s/[ ()]/_/g;
+ $typename =~ s/[*]/p/g;
+
+ return $typename;
+}
+
+# Write out a debug method.
+sub write_debugmethod($$$$@) {
+ my ($content, $style, $name, $return_type, @argtypes) = @_;
+
+ my ($debugname) = $name;
+ $debugname =~ s/to_/debug_/;
+ my ($targetname) = $name;
+ $targetname =~ s/to_/target_/;
+
+ my (@names) = write_function_header ($debugname, $return_type, @argtypes);
+
+ if ($return_type ne 'void') {
+ print " $return_type result;\n";
+ }
+ ## print " struct target_ops *beneath;\n";
+
+ print " fprintf_unfiltered (gdb_stdlog, \"-> %s->$name (...)\\n\", debug_target.to_shortname);\n";
+
+ # Delegate to the beneath target.
+ ## print " beneath = $names[0]->beneath;\n";
+ print " ";
+ if ($return_type ne 'void') {
+ print "result = ";
+ }
+ ## print "beneath->" . $name . " (";
+ print "debug_target." . $name . " (";
+ my @names2 = @names;
+ @names2[0] = "&debug_target";
+ print join (', ', @names2);
+ print ");\n";
+
+ # Now print the arguments.
+ print " fprintf_unfiltered (gdb_stdlog, \"<- %s->$name (\", debug_target.to_shortname);\n";
+ for my $i (0 .. $#argtypes) {
+ print " fputs_unfiltered (\", \", gdb_stdlog);\n" if $i > 0;
+ my $typename = munge_type ($argtypes[$i]);
+ print " target_debug_print_$typename ($names2[$i]);\n";
+ }
+ if ($return_type ne 'void') {
+ print " fputs_unfiltered (\") = \", gdb_stdlog);\n";
+ my $typename = munge_type ($return_type);
+ print " target_debug_print_$typename (result);\n";
+ print " fputs_unfiltered (\"\\n\", gdb_stdlog);\n";
+ } else {
+ print " fputs_unfiltered (\")\\n\", gdb_stdlog);\n";
+ }
+
+ if ($return_type ne 'void') {
+ print " return result;\n";
+ }
+
+ print "}\n\n";
+
+ return $debugname;
+}
+
print "/* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */\n";
print "/* vi:set ro: */\n\n";
print "/* To regenerate this file, run:*/\n";
@@ -196,6 +262,7 @@ print "/* make-target-delegates target.h > target-delegates.c */\n";
find_trigger();
%tdefault_names = ();
+%debug_names = ();
@delegators = ();
$current_line = '';
while (<>) {
@@ -228,6 +295,10 @@ while (<>) {
$tdefault_names{$name} = write_tdefault ($tdefault, $style,
$name, $return_type,
@argtypes);
+
+ $debug_names{$name} = write_debugmethod ($tdefault, $style,
+ $name, $return_type,
+ @argtypes);
}
}
@@ -250,4 +321,11 @@ print "static void\ninstall_dummy_methods (struct target_ops *ops)\n{\n";
for $iter (@delegators) {
print " ops->" . $iter . " = " . $tdefault_names{$iter} . ";\n";
}
+print "}\n\n";
+
+# The debug method code.
+print "static void\ninit_debug_target (struct target_ops *ops)\n{\n";
+for $iter (@delegators) {
+ print " ops->" . $iter . " = " . $debug_names{$iter} . ";\n";
+}
print "}\n";
diff --git a/gdb/target-debug.h b/gdb/target-debug.h
new file mode 100644
index 0000000..8458a96
--- /dev/null
+++ b/gdb/target-debug.h
@@ -0,0 +1,182 @@
+/* GDB target debugging macros
+
+ Copyright (C) 2014 Free Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef TARGET_DEBUG_H
+#define TARGET_DEBUG_H
+
+/* Printers for the debug target. Each prints an object of a given
+ type to a string that needn't be freed. In a few cases, a new
+ typedef is introduced just to override the normal printing approach
+ for the underlying type; see target.h for those. Most printers are
+ macros, for brevity, but a few are static functions where more
+ complicated behavior is needed.
+
+ References to these printers are automatically generated by
+ make-target-delegates. See the generated file target-delegates.c.
+
+ A few methods are still handled explicitly in target.c:
+ target_fetch_registers target_store_registers target_xfer_partial
+ target_fileio_* target_close target_info_proc
+
+ In most cases this is because target delegation hasn't been done for
+ the method. */
+
+
+/* Helper macro. */
+
+#define target_debug_do_print(E) \
+ fputs_unfiltered ((E), gdb_stdlog);
+
+#define target_debug_print_struct_target_ops_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_enum_target_object(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_CORE_ADDR(X) \
+ target_debug_do_print (core_addr_to_string (X))
+#define target_debug_print_const_char_p(X) \
+ target_debug_do_print (((X) ? (X) : "(null)"))
+#define target_debug_print_char_p(X) \
+ target_debug_do_print (((X) ? (X) : "(null)"))
+#define target_debug_print_int(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_long(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_target_xfer_status(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_exec_direction_kind(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_trace_find_type(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_btrace_read_type(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_btrace_error(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_ptid_t(X) \
+ target_debug_do_print (plongest (ptid_get_pid (X)))
+#define target_debug_print_struct_gdbarch_p(X) \
+ target_debug_do_print (gdbarch_bfd_arch_info (X)->printable_name)
+#define target_debug_print_const_gdb_byte_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_gdb_byte_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_gdb_byte_pp(X) \
+ target_debug_do_print (host_address_to_string (*(X)))
+#define target_debug_print_enum_gdb_signal(X) \
+ target_debug_do_print (gdb_signal_to_name (X))
+#define target_debug_print_ULONGEST(X) \
+ target_debug_do_print (hex_string (X))
+#define target_debug_print_ULONGEST_p(X) \
+ target_debug_do_print (hex_string (*(X)))
+#define target_debug_print_LONGEST(X) \
+ target_debug_do_print (phex (X, 0))
+#define target_debug_print_LONGEST_p(X) \
+ target_debug_do_print (phex (*(X), 0))
+#define target_debug_print_struct_address_space_p(X) \
+ target_debug_do_print (plongest (address_space_num (X)))
+#define target_debug_print_struct_bp_target_info_p(X) \
+ target_debug_do_print (core_addr_to_string ((X)->placed_address))
+#define target_debug_print_struct_expression_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_CORE_ADDR_p(X) \
+ target_debug_do_print (core_addr_to_string (*(X)))
+#define target_debug_print_int_p(X) \
+ target_debug_do_print (plongest (*(X)))
+#define target_debug_print_target_debug_step(X) \
+ target_debug_do_print ((X) ? "step" : "continue")
+#define target_debug_print_struct_regcache_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_thread_info_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_ui_file_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_target_section_table_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_async_callback_ftype_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_void_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_find_memory_region_ftype(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_bfd_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC_mem_region_s__p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC_static_tracepoint_marker_p__p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_const_struct_target_desc_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_bp_location_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_trace_state_variable_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_trace_status_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_breakpoint_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tp_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tp_pp(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tsv_pp(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_static_tracepoint_marker_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_traceframe_info_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_btrace_target_info_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC__btrace_block_s__pp(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_const_struct_frame_unwind_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+
+static void
+target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
+{
+ char *str = target_waitstatus_to_string (status);
+
+ fputs_unfiltered (str, gdb_stdlog);
+ xfree (str);
+}
+
+static void
+target_debug_print_target_debug_options (target_debug_options options)
+{
+ char *str = target_options_to_string (options);
+
+ fputs_unfiltered (str, gdb_stdlog);
+ xfree (str);
+}
+
+static void
+target_debug_print_unsigned_char_p (unsigned char *sigs)
+{
+ fputs_unfiltered ("{", gdb_stdlog);
+ if (sigs != NULL)
+ {
+ int i;
+
+ for (i = 0; i < GDB_SIGNAL_LAST; i++)
+ if (sigs[i])
+ fprintf_unfiltered (gdb_stdlog, " %s", gdb_signal_to_name (i));
+ }
+ fputs_unfiltered (" }", gdb_stdlog);
+}
+
+#endif /* TARGET_DEBUG_H */
diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c
index 4eefae8..55b1144 100644
--- a/gdb/target-delegates.c
+++ b/gdb/target-delegates.c
@@ -16,6 +16,18 @@ tdefault_post_attach (struct target_ops *self, int arg1)
}
static void
+debug_post_attach (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", debug_target.to_shortname);
+ debug_target.to_post_attach (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_detach (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -28,6 +40,20 @@ tdefault_detach (struct target_ops *self, const char *arg1, int arg2)
}
static void
+debug_detach (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", debug_target.to_shortname);
+ debug_target.to_detach (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_disconnect (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -41,31 +67,81 @@ tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
}
static void
-delegate_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
+debug_disconnect (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", debug_target.to_shortname);
+ debug_target.to_disconnect (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
+delegate_resume (struct target_ops *self, ptid_t arg1, target_debug_step arg2, enum gdb_signal arg3)
{
self = self->beneath;
self->to_resume (self, arg1, arg2, arg3);
}
static void
-tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
+tdefault_resume (struct target_ops *self, ptid_t arg1, target_debug_step arg2, enum gdb_signal arg3)
{
noprocess ();
}
+static void
+debug_resume (struct target_ops *self, ptid_t arg1, target_debug_step arg2, enum gdb_signal arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", debug_target.to_shortname);
+ debug_target.to_resume (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_target_debug_step (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_gdb_signal (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static ptid_t
-delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
+delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, target_debug_options arg3)
{
self = self->beneath;
return self->to_wait (self, arg1, arg2, arg3);
}
static ptid_t
-tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
+tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, target_debug_options arg3)
{
noprocess ();
}
+static ptid_t
+debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, target_debug_options arg3)
+{
+ ptid_t result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", debug_target.to_shortname);
+ result = debug_target.to_wait (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_target_waitstatus_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_target_debug_options (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_ptid_t (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
@@ -79,6 +155,20 @@ tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int ar
}
static void
+debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname);
+ debug_target.to_fetch_registers (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_regcache_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
self = self->beneath;
@@ -92,6 +182,20 @@ tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int ar
}
static void
+debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
+ debug_target.to_store_registers (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_regcache_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
{
self = self->beneath;
@@ -105,6 +209,18 @@ tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
}
static void
+debug_prepare_to_store (struct target_ops *self, struct regcache *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", debug_target.to_shortname);
+ debug_target.to_prepare_to_store (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_regcache_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_files_info (struct target_ops *self)
{
self = self->beneath;
@@ -116,6 +232,16 @@ tdefault_files_info (struct target_ops *self)
{
}
+static void
+debug_files_info (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_files_info (...)\n", debug_target.to_shortname);
+ debug_target.to_files_info (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_files_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
@@ -124,6 +250,24 @@ delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struc
}
static int
+debug_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
@@ -131,6 +275,24 @@ delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struc
}
static int
+debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
{
self = self->beneath;
@@ -144,6 +306,26 @@ tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int
}
static int
+debug_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_use_hw_breakpoint (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_ranged_break_num_registers (struct target_ops *self)
{
self = self->beneath;
@@ -157,6 +339,20 @@ tdefault_ranged_break_num_registers (struct target_ops *self)
}
static int
+debug_ranged_break_num_registers (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_ranged_break_num_registers (...)\n", debug_target.to_shortname);
+ result = debug_target.to_ranged_break_num_registers (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_ranged_break_num_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
@@ -170,6 +366,24 @@ tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, st
}
static int
+debug_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_hw_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_hw_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_hw_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
@@ -183,6 +397,24 @@ tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, st
}
static int
+debug_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_hw_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_hw_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_hw_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
@@ -196,6 +428,28 @@ tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, i
}
static int
+debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_expression_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
@@ -209,6 +463,28 @@ tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, i
}
static int
+debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_expression_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
@@ -222,6 +498,26 @@ tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_A
}
static int
+debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_mask_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_mask_watchpoint (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_mask_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
@@ -235,6 +531,26 @@ tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_A
}
static int
+debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_mask_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_mask_watchpoint (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_mask_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_stopped_by_watchpoint (struct target_ops *self)
{
self = self->beneath;
@@ -248,6 +564,20 @@ tdefault_stopped_by_watchpoint (struct target_ops *self)
}
static int
+debug_stopped_by_watchpoint (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_stopped_by_watchpoint (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
{
self = self->beneath;
@@ -261,6 +591,22 @@ tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
}
static int
+debug_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_data_address (...)\n", debug_target.to_shortname);
+ result = debug_target.to_stopped_data_address (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_data_address (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
@@ -268,6 +614,26 @@ delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1,
}
static int
+debug_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_watchpoint_addr_within_range (...)\n", debug_target.to_shortname);
+ result = debug_target.to_watchpoint_addr_within_range (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_watchpoint_addr_within_range (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
{
self = self->beneath;
@@ -275,6 +641,24 @@ delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, i
}
static int
+debug_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_region_ok_for_hw_watchpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_region_ok_for_hw_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
@@ -288,6 +672,28 @@ tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1
}
static int
+debug_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_accel_watchpoint_condition (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_accel_watchpoint_condition (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_accel_watchpoint_condition (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_expression_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
{
self = self->beneath;
@@ -300,6 +706,24 @@ tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CO
return -1;
}
+static int
+debug_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_masked_watch_num_registers (...)\n", debug_target.to_shortname);
+ result = debug_target.to_masked_watch_num_registers (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_masked_watch_num_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_terminal_init (struct target_ops *self)
{
@@ -313,6 +737,16 @@ tdefault_terminal_init (struct target_ops *self)
}
static void
+debug_terminal_init (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_init (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_init (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_init (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_inferior (struct target_ops *self)
{
self = self->beneath;
@@ -325,6 +759,16 @@ tdefault_terminal_inferior (struct target_ops *self)
}
static void
+debug_terminal_inferior (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_inferior (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_ours_for_output (struct target_ops *self)
{
self = self->beneath;
@@ -337,6 +781,16 @@ tdefault_terminal_ours_for_output (struct target_ops *self)
}
static void
+debug_terminal_ours_for_output (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours_for_output (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_ours_for_output (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours_for_output (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_ours (struct target_ops *self)
{
self = self->beneath;
@@ -349,6 +803,16 @@ tdefault_terminal_ours (struct target_ops *self)
}
static void
+debug_terminal_ours (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_ours (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_save_ours (struct target_ops *self)
{
self = self->beneath;
@@ -361,6 +825,16 @@ tdefault_terminal_save_ours (struct target_ops *self)
}
static void
+debug_terminal_save_ours (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_save_ours (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_save_ours (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_save_ours (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -368,6 +842,20 @@ delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
}
static void
+debug_terminal_info (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_info (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_info (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_kill (struct target_ops *self)
{
self = self->beneath;
@@ -381,6 +869,16 @@ tdefault_kill (struct target_ops *self)
}
static void
+debug_kill (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_kill (...)\n", debug_target.to_shortname);
+ debug_target.to_kill (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_kill (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_load (struct target_ops *self, char *arg1, int arg2)
{
self = self->beneath;
@@ -394,6 +892,20 @@ tdefault_load (struct target_ops *self, char *arg1, int arg2)
}
static void
+debug_load (struct target_ops *self, char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_load (...)\n", debug_target.to_shortname);
+ debug_target.to_load (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_load (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
@@ -405,6 +917,18 @@ tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
{
}
+static void
+debug_post_startup_inferior (struct target_ops *self, ptid_t arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_startup_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_post_startup_inferior (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_startup_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_insert_fork_catchpoint (struct target_ops *self, int arg1)
{
@@ -419,6 +943,22 @@ tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_insert_fork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_fork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_fork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_fork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_fork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -432,6 +972,22 @@ tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_remove_fork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_fork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_fork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_fork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -445,6 +1001,22 @@ tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_insert_vfork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_vfork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_vfork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_vfork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -458,6 +1030,22 @@ tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_remove_vfork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_vfork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_vfork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_vfork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
@@ -465,6 +1053,24 @@ delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
}
static int
+debug_follow_fork (struct target_ops *self, int arg1, int arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_fork (...)\n", debug_target.to_shortname);
+ result = debug_target.to_follow_fork (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_fork (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_exec_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -478,6 +1084,22 @@ tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_insert_exec_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_exec_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_exec_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_exec_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_exec_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -491,6 +1113,22 @@ tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_remove_exec_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_exec_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_exec_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_exec_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
{
self = self->beneath;
@@ -504,6 +1142,30 @@ tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, in
}
static int
+debug_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg5);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
{
self = self->beneath;
@@ -516,6 +1178,26 @@ tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
return 0;
}
+static int
+debug_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_has_exited (...)\n", debug_target.to_shortname);
+ result = debug_target.to_has_exited (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_has_exited (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_mourn_inferior (struct target_ops *self)
{
@@ -523,6 +1205,16 @@ delegate_mourn_inferior (struct target_ops *self)
self->to_mourn_inferior (self);
}
+static void
+debug_mourn_inferior (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_mourn_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_mourn_inferior (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_mourn_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_can_run (struct target_ops *self)
{
@@ -536,6 +1228,20 @@ tdefault_can_run (struct target_ops *self)
return 0;
}
+static int
+debug_can_run (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_run (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_pass_signals (struct target_ops *self, int arg1, unsigned char *arg2)
{
@@ -549,6 +1255,20 @@ tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char *arg2)
}
static void
+debug_pass_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", debug_target.to_shortname);
+ debug_target.to_pass_signals (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_unsigned_char_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_program_signals (struct target_ops *self, int arg1, unsigned char *arg2)
{
self = self->beneath;
@@ -560,6 +1280,20 @@ tdefault_program_signals (struct target_ops *self, int arg1, unsigned char *arg2
{
}
+static void
+debug_program_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", debug_target.to_shortname);
+ debug_target.to_program_signals (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_unsigned_char_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_thread_alive (struct target_ops *self, ptid_t arg1)
{
@@ -573,6 +1307,22 @@ tdefault_thread_alive (struct target_ops *self, ptid_t arg1)
return 0;
}
+static int
+debug_thread_alive (struct target_ops *self, ptid_t arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_alive (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_alive (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_alive (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_find_new_threads (struct target_ops *self)
{
@@ -585,6 +1335,16 @@ tdefault_find_new_threads (struct target_ops *self)
{
}
+static void
+debug_find_new_threads (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_new_threads (...)\n", debug_target.to_shortname);
+ debug_target.to_find_new_threads (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_new_threads (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static char *
delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
{
@@ -593,6 +1353,22 @@ delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
}
static char *
+debug_pid_to_str (struct target_ops *self, ptid_t arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_str (...)\n", debug_target.to_shortname);
+ result = debug_target.to_pid_to_str (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_str (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static char *
delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
{
self = self->beneath;
@@ -606,6 +1382,22 @@ tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
}
static char *
+debug_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_extra_thread_info (...)\n", debug_target.to_shortname);
+ result = debug_target.to_extra_thread_info (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_extra_thread_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_thread_info_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static char *
delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
{
self = self->beneath;
@@ -618,6 +1410,22 @@ tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
return NULL;
}
+static char *
+debug_thread_name (struct target_ops *self, struct thread_info *arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_name (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_name (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_name (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_thread_info_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_stop (struct target_ops *self, ptid_t arg1)
{
@@ -631,12 +1439,38 @@ tdefault_stop (struct target_ops *self, ptid_t arg1)
}
static void
+debug_stop (struct target_ops *self, ptid_t arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop (...)\n", debug_target.to_shortname);
+ debug_target.to_stop (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
{
self = self->beneath;
self->to_rcmd (self, arg1, arg2);
}
+static void
+debug_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_rcmd (...)\n", debug_target.to_shortname);
+ debug_target.to_rcmd (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_rcmd (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_ui_file_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static char *
delegate_pid_to_exec_file (struct target_ops *self, int arg1)
{
@@ -650,6 +1484,22 @@ tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
return NULL;
}
+static char *
+debug_pid_to_exec_file (struct target_ops *self, int arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_exec_file (...)\n", debug_target.to_shortname);
+ result = debug_target.to_pid_to_exec_file (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_exec_file (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_log_command (struct target_ops *self, const char *arg1)
{
@@ -662,6 +1512,18 @@ tdefault_log_command (struct target_ops *self, const char *arg1)
{
}
+static void
+debug_log_command (struct target_ops *self, const char *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_log_command (...)\n", debug_target.to_shortname);
+ debug_target.to_log_command (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_log_command (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static struct target_section_table *
delegate_get_section_table (struct target_ops *self)
{
@@ -675,6 +1537,20 @@ tdefault_get_section_table (struct target_ops *self)
return NULL;
}
+static struct target_section_table *
+debug_get_section_table (struct target_ops *self)
+{
+ struct target_section_table * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_section_table (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_section_table (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_section_table (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_target_section_table_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_can_async_p (struct target_ops *self)
{
@@ -689,6 +1565,20 @@ tdefault_can_async_p (struct target_ops *self)
}
static int
+debug_can_async_p (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_async_p (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_async_p (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_async_p (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_is_async_p (struct target_ops *self)
{
self = self->beneath;
@@ -701,6 +1591,20 @@ tdefault_is_async_p (struct target_ops *self)
return 0;
}
+static int
+debug_is_async_p (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_is_async_p (...)\n", debug_target.to_shortname);
+ result = debug_target.to_is_async_p (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_is_async_p (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
{
@@ -714,6 +1618,20 @@ tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
tcomplain ();
}
+static void
+debug_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname);
+ debug_target.to_async (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_async_callback_ftype_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_void_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_supports_non_stop (struct target_ops *self)
{
@@ -728,12 +1646,44 @@ tdefault_supports_non_stop (struct target_ops *self)
}
static int
+debug_supports_non_stop (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_non_stop (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
{
self = self->beneath;
return self->to_find_memory_regions (self, arg1, arg2);
}
+static int
+debug_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", debug_target.to_shortname);
+ result = debug_target.to_find_memory_regions (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_find_memory_region_ftype (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_void_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static char *
delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
{
@@ -741,6 +1691,24 @@ delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
return self->to_make_corefile_notes (self, arg1, arg2);
}
+static char *
+debug_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", debug_target.to_shortname);
+ result = debug_target.to_make_corefile_notes (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_bfd_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static gdb_byte *
delegate_get_bookmark (struct target_ops *self, char *arg1, int arg2)
{
@@ -754,6 +1722,24 @@ tdefault_get_bookmark (struct target_ops *self, char *arg1, int arg2)
tcomplain ();
}
+static gdb_byte *
+debug_get_bookmark (struct target_ops *self, char *arg1, int arg2)
+{
+ gdb_byte * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_bookmark (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_goto_bookmark (struct target_ops *self, gdb_byte *arg1, int arg2)
{
@@ -767,6 +1753,20 @@ tdefault_goto_bookmark (struct target_ops *self, gdb_byte *arg1, int arg2)
tcomplain ();
}
+static void
+debug_goto_bookmark (struct target_ops *self, gdb_byte *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_bookmark (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static enum target_xfer_status
delegate_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
{
@@ -780,6 +1780,34 @@ tdefault_xfer_partial (struct target_ops *self, enum target_object arg1, const
return TARGET_XFER_E_IO;
}
+static enum target_xfer_status
+debug_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
+{
+ enum target_xfer_status result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", debug_target.to_shortname);
+ result = debug_target.to_xfer_partial (&debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_target_object (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg5);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg6);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST_p (arg7);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_target_xfer_status (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static VEC(mem_region_s) *
delegate_memory_map (struct target_ops *self)
{
@@ -793,6 +1821,20 @@ tdefault_memory_map (struct target_ops *self)
return NULL;
}
+static VEC(mem_region_s) *
+debug_memory_map (struct target_ops *self)
+{
+ VEC(mem_region_s) * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", debug_target.to_shortname);
+ result = debug_target.to_memory_map (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_VEC_mem_region_s__p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
{
@@ -807,6 +1849,20 @@ tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
}
static void
+debug_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", debug_target.to_shortname);
+ debug_target.to_flash_erase (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_flash_done (struct target_ops *self)
{
self = self->beneath;
@@ -819,6 +1875,16 @@ tdefault_flash_done (struct target_ops *self)
tcomplain ();
}
+static void
+debug_flash_done (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", debug_target.to_shortname);
+ debug_target.to_flash_done (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static const struct target_desc *
delegate_read_description (struct target_ops *self)
{
@@ -832,6 +1898,20 @@ tdefault_read_description (struct target_ops *self)
return NULL;
}
+static const struct target_desc *
+debug_read_description (struct target_ops *self)
+{
+ const struct target_desc * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", debug_target.to_shortname);
+ result = debug_target.to_read_description (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_const_struct_target_desc_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static ptid_t
delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
{
@@ -839,6 +1919,24 @@ delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
return self->to_get_ada_task_ptid (self, arg1, arg2);
}
+static ptid_t
+debug_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
+{
+ ptid_t result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_ada_task_ptid (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_long (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_long (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_ptid_t (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
{
@@ -847,6 +1945,28 @@ delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, C
}
static int
+debug_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", debug_target.to_shortname);
+ result = debug_target.to_auxv_parse (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_pp (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
{
self = self->beneath;
@@ -854,6 +1974,30 @@ delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2,
}
static int
+debug_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", debug_target.to_shortname);
+ result = debug_target.to_search_memory (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg5);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_execute_reverse (struct target_ops *self)
{
self = self->beneath;
@@ -866,6 +2010,20 @@ tdefault_can_execute_reverse (struct target_ops *self)
return 0;
}
+static int
+debug_can_execute_reverse (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_execute_reverse (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static enum exec_direction_kind
delegate_execution_direction (struct target_ops *self)
{
@@ -873,6 +2031,20 @@ delegate_execution_direction (struct target_ops *self)
return self->to_execution_direction (self);
}
+static enum exec_direction_kind
+debug_execution_direction (struct target_ops *self)
+{
+ enum exec_direction_kind result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", debug_target.to_shortname);
+ result = debug_target.to_execution_direction (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_exec_direction_kind (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_supports_multi_process (struct target_ops *self)
{
@@ -887,6 +2059,20 @@ tdefault_supports_multi_process (struct target_ops *self)
}
static int
+debug_supports_multi_process (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_multi_process (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_enable_disable_tracepoint (struct target_ops *self)
{
self = self->beneath;
@@ -900,6 +2086,20 @@ tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
}
static int
+debug_supports_enable_disable_tracepoint (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_enable_disable_tracepoint (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_string_tracing (struct target_ops *self)
{
self = self->beneath;
@@ -913,6 +2113,20 @@ tdefault_supports_string_tracing (struct target_ops *self)
}
static int
+debug_supports_string_tracing (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_string_tracing (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
{
self = self->beneath;
@@ -926,6 +2140,20 @@ tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
}
static int
+debug_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_evaluation_of_breakpoint_conditions (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_run_breakpoint_commands (struct target_ops *self)
{
self = self->beneath;
@@ -938,6 +2166,20 @@ tdefault_can_run_breakpoint_commands (struct target_ops *self)
return 0;
}
+static int
+debug_can_run_breakpoint_commands (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_run_breakpoint_commands (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct gdbarch *
delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
{
@@ -945,6 +2187,22 @@ delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
return self->to_thread_architecture (self, arg1);
}
+static struct gdbarch *
+debug_thread_architecture (struct target_ops *self, ptid_t arg1)
+{
+ struct gdbarch * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_architecture (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct address_space *
delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
{
@@ -952,6 +2210,22 @@ delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
return self->to_thread_address_space (self, arg1);
}
+static struct address_space *
+debug_thread_address_space (struct target_ops *self, ptid_t arg1)
+{
+ struct address_space * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_address_space (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_address_space_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_trace_init (struct target_ops *self)
{
@@ -966,6 +2240,16 @@ tdefault_trace_init (struct target_ops *self)
}
static void
+debug_trace_init (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_init (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
@@ -978,6 +2262,18 @@ tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
tcomplain ();
}
+static void
+debug_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", debug_target.to_shortname);
+ debug_target.to_download_tracepoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_location_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_can_download_tracepoint (struct target_ops *self)
{
@@ -991,6 +2287,20 @@ tdefault_can_download_tracepoint (struct target_ops *self)
return 0;
}
+static int
+debug_can_download_tracepoint (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_download_tracepoint (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
{
@@ -1005,6 +2315,18 @@ tdefault_download_trace_state_variable (struct target_ops *self, struct trace_st
}
static void
+debug_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", debug_target.to_shortname);
+ debug_target.to_download_trace_state_variable (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_trace_state_variable_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
@@ -1018,6 +2340,18 @@ tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
}
static void
+debug_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", debug_target.to_shortname);
+ debug_target.to_enable_tracepoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_location_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
@@ -1031,6 +2365,18 @@ tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
}
static void
+debug_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", debug_target.to_shortname);
+ debug_target.to_disable_tracepoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_location_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_trace_set_readonly_regions (struct target_ops *self)
{
self = self->beneath;
@@ -1044,6 +2390,16 @@ tdefault_trace_set_readonly_regions (struct target_ops *self)
}
static void
+debug_trace_set_readonly_regions (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_set_readonly_regions (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_trace_start (struct target_ops *self)
{
self = self->beneath;
@@ -1056,6 +2412,16 @@ tdefault_trace_start (struct target_ops *self)
tcomplain ();
}
+static void
+debug_trace_start (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_start (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
{
@@ -1069,6 +2435,22 @@ tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
return -1;
}
+static int
+debug_get_trace_status (struct target_ops *self, struct trace_status *arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_trace_status (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_trace_status_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
{
@@ -1083,6 +2465,20 @@ tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1
}
static void
+debug_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", debug_target.to_shortname);
+ debug_target.to_get_tracepoint_status (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_breakpoint_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_uploaded_tp_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_trace_stop (struct target_ops *self)
{
self = self->beneath;
@@ -1095,6 +2491,16 @@ tdefault_trace_stop (struct target_ops *self)
tcomplain ();
}
+static void
+debug_trace_stop (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_stop (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
{
@@ -1109,6 +2515,30 @@ tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int ar
}
static int
+debug_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", debug_target.to_shortname);
+ result = debug_target.to_trace_find (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_trace_find_type (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg5);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
{
self = self->beneath;
@@ -1122,6 +2552,24 @@ tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONG
}
static int
+debug_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_trace_state_variable_value (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_save_trace_data (struct target_ops *self, const char *arg1)
{
self = self->beneath;
@@ -1135,6 +2583,22 @@ tdefault_save_trace_data (struct target_ops *self, const char *arg1)
}
static int
+debug_save_trace_data (struct target_ops *self, const char *arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", debug_target.to_shortname);
+ result = debug_target.to_save_trace_data (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
{
self = self->beneath;
@@ -1148,6 +2612,22 @@ tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
}
static int
+debug_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", debug_target.to_shortname);
+ result = debug_target.to_upload_tracepoints (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_uploaded_tp_pp (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
{
self = self->beneath;
@@ -1160,6 +2640,22 @@ tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_
return 0;
}
+static int
+debug_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", debug_target.to_shortname);
+ result = debug_target.to_upload_trace_state_variables (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_uploaded_tsv_pp (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static LONGEST
delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
{
@@ -1173,6 +2669,26 @@ tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST a
tcomplain ();
}
+static LONGEST
+debug_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
+{
+ LONGEST result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_raw_trace_data (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_LONGEST (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
{
@@ -1186,6 +2702,20 @@ tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
return -1;
}
+static int
+debug_get_min_fast_tracepoint_insn_len (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_min_fast_tracepoint_insn_len (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
{
@@ -1199,6 +2729,18 @@ tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
}
static void
+debug_set_disconnected_tracing (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", debug_target.to_shortname);
+ debug_target.to_set_disconnected_tracing (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -1211,6 +2753,18 @@ tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
}
static void
+debug_set_circular_trace_buffer (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", debug_target.to_shortname);
+ debug_target.to_set_circular_trace_buffer (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
{
self = self->beneath;
@@ -1222,6 +2776,18 @@ tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
{
}
+static void
+debug_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", debug_target.to_shortname);
+ debug_target.to_set_trace_buffer_size (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
{
@@ -1236,6 +2802,26 @@ tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char
}
static int
+debug_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", debug_target.to_shortname);
+ result = debug_target.to_set_trace_notes (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
@@ -1249,6 +2835,22 @@ tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
}
static int
+debug_core_of_thread (struct target_ops *self, ptid_t arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", debug_target.to_shortname);
+ result = debug_target.to_core_of_thread (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
{
self = self->beneath;
@@ -1256,6 +2858,26 @@ delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR
}
static int
+debug_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", debug_target.to_shortname);
+ result = debug_target.to_verify_memory (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
{
self = self->beneath;
@@ -1268,6 +2890,24 @@ tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
tcomplain ();
}
+static int
+debug_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_tib_address (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_address (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_set_permissions (struct target_ops *self)
{
@@ -1280,6 +2920,16 @@ tdefault_set_permissions (struct target_ops *self)
{
}
+static void
+debug_set_permissions (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", debug_target.to_shortname);
+ debug_target.to_set_permissions (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
{
@@ -1293,6 +2943,24 @@ tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, s
return 0;
}
+static int
+debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", debug_target.to_shortname);
+ result = debug_target.to_static_tracepoint_marker_at (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_static_tracepoint_marker_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static VEC(static_tracepoint_marker_p) *
delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
{
@@ -1306,6 +2974,22 @@ tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char
tcomplain ();
}
+static VEC(static_tracepoint_marker_p) *
+debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
+{
+ VEC(static_tracepoint_marker_p) * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", debug_target.to_shortname);
+ result = debug_target.to_static_tracepoint_markers_by_strid (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_VEC_static_tracepoint_marker_p__p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct traceframe_info *
delegate_traceframe_info (struct target_ops *self)
{
@@ -1319,6 +3003,20 @@ tdefault_traceframe_info (struct target_ops *self)
tcomplain ();
}
+static struct traceframe_info *
+debug_traceframe_info (struct target_ops *self)
+{
+ struct traceframe_info * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", debug_target.to_shortname);
+ result = debug_target.to_traceframe_info (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_traceframe_info_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_use_agent (struct target_ops *self, int arg1)
{
@@ -1333,6 +3031,22 @@ tdefault_use_agent (struct target_ops *self, int arg1)
}
static int
+debug_use_agent (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", debug_target.to_shortname);
+ result = debug_target.to_use_agent (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_use_agent (struct target_ops *self)
{
self = self->beneath;
@@ -1346,6 +3060,20 @@ tdefault_can_use_agent (struct target_ops *self)
}
static int
+debug_can_use_agent (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_use_agent (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_btrace (struct target_ops *self)
{
self = self->beneath;
@@ -1358,6 +3086,20 @@ tdefault_supports_btrace (struct target_ops *self)
return 0;
}
+static int
+debug_supports_btrace (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_btrace (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct btrace_target_info *
delegate_enable_btrace (struct target_ops *self, ptid_t arg1)
{
@@ -1371,6 +3113,22 @@ tdefault_enable_btrace (struct target_ops *self, ptid_t arg1)
tcomplain ();
}
+static struct btrace_target_info *
+debug_enable_btrace (struct target_ops *self, ptid_t arg1)
+{
+ struct btrace_target_info * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname);
+ result = debug_target.to_enable_btrace (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
{
@@ -1385,6 +3143,18 @@ tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg
}
static void
+debug_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname);
+ debug_target.to_disable_btrace (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
{
self = self->beneath;
@@ -1397,6 +3167,18 @@ tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *ar
tcomplain ();
}
+static void
+debug_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname);
+ debug_target.to_teardown_btrace (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static enum btrace_error
delegate_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
{
@@ -1410,6 +3192,26 @@ tdefault_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, stru
tcomplain ();
}
+static enum btrace_error
+debug_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
+{
+ enum btrace_error result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname);
+ result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_VEC__btrace_block_s__pp (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_btrace_read_type (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_btrace_error (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_stop_recording (struct target_ops *self)
{
@@ -1423,6 +3225,16 @@ tdefault_stop_recording (struct target_ops *self)
}
static void
+debug_stop_recording (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname);
+ debug_target.to_stop_recording (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_save_record (struct target_ops *self, const char *arg1)
{
self = self->beneath;
@@ -1436,6 +3248,18 @@ tdefault_save_record (struct target_ops *self, const char *arg1)
}
static void
+debug_save_record (struct target_ops *self, const char *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname);
+ debug_target.to_save_record (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_delete_record (struct target_ops *self)
{
self = self->beneath;
@@ -1448,6 +3272,16 @@ tdefault_delete_record (struct target_ops *self)
tcomplain ();
}
+static void
+debug_delete_record (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname);
+ debug_target.to_delete_record (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_record_is_replaying (struct target_ops *self)
{
@@ -1461,6 +3295,20 @@ tdefault_record_is_replaying (struct target_ops *self)
return 0;
}
+static int
+debug_record_is_replaying (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
+ result = debug_target.to_record_is_replaying (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_goto_record_begin (struct target_ops *self)
{
@@ -1475,6 +3323,16 @@ tdefault_goto_record_begin (struct target_ops *self)
}
static void
+debug_goto_record_begin (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_record_begin (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_goto_record_end (struct target_ops *self)
{
self = self->beneath;
@@ -1488,6 +3346,16 @@ tdefault_goto_record_end (struct target_ops *self)
}
static void
+debug_goto_record_end (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_record_end (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_goto_record (struct target_ops *self, ULONGEST arg1)
{
self = self->beneath;
@@ -1501,6 +3369,18 @@ tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
}
static void
+debug_goto_record (struct target_ops *self, ULONGEST arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_record (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_insn_history (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
@@ -1514,6 +3394,20 @@ tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
}
static void
+debug_insn_history (struct target_ops *self, int arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
+ debug_target.to_insn_history (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
{
self = self->beneath;
@@ -1527,6 +3421,22 @@ tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, in
}
static void
+debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname);
+ debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
{
self = self->beneath;
@@ -1540,6 +3450,22 @@ tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST ar
}
static void
+debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname);
+ debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_call_history (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
@@ -1553,6 +3479,20 @@ tdefault_call_history (struct target_ops *self, int arg1, int arg2)
}
static void
+debug_call_history (struct target_ops *self, int arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
+ debug_target.to_call_history (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
{
self = self->beneath;
@@ -1566,6 +3506,22 @@ tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, in
}
static void
+debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname);
+ debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
{
self = self->beneath;
@@ -1578,6 +3534,22 @@ tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST ar
tcomplain ();
}
+static void
+debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname);
+ debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_augmented_libraries_svr4_read (struct target_ops *self)
{
@@ -1591,6 +3563,20 @@ tdefault_augmented_libraries_svr4_read (struct target_ops *self)
return 0;
}
+static int
+debug_augmented_libraries_svr4_read (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname);
+ result = debug_target.to_augmented_libraries_svr4_read (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static const struct frame_unwind *
delegate_get_unwinder (struct target_ops *self)
{
@@ -1605,6 +3591,20 @@ tdefault_get_unwinder (struct target_ops *self)
}
static const struct frame_unwind *
+debug_get_unwinder (struct target_ops *self)
+{
+ const struct frame_unwind * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_unwinder (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_const_struct_frame_unwind_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static const struct frame_unwind *
delegate_get_tailcall_unwinder (struct target_ops *self)
{
self = self->beneath;
@@ -1617,6 +3617,20 @@ tdefault_get_tailcall_unwinder (struct target_ops *self)
return NULL;
}
+static const struct frame_unwind *
+debug_get_tailcall_unwinder (struct target_ops *self)
+{
+ const struct frame_unwind * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_tailcall_unwinder (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_const_struct_frame_unwind_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static CORE_ADDR
delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
{
@@ -1624,6 +3638,22 @@ delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
return self->to_decr_pc_after_break (self, arg1);
}
+static CORE_ADDR
+debug_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
+{
+ CORE_ADDR result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_decr_pc_after_break (...)\n", debug_target.to_shortname);
+ result = debug_target.to_decr_pc_after_break (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_decr_pc_after_break (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
install_delegators (struct target_ops *ops)
{
@@ -2038,3 +4068,143 @@ install_dummy_methods (struct target_ops *ops)
ops->to_get_tailcall_unwinder = tdefault_get_tailcall_unwinder;
ops->to_decr_pc_after_break = default_target_decr_pc_after_break;
}
+
+static void
+init_debug_target (struct target_ops *ops)
+{
+ ops->to_post_attach = debug_post_attach;
+ ops->to_detach = debug_detach;
+ ops->to_disconnect = debug_disconnect;
+ ops->to_resume = debug_resume;
+ ops->to_wait = debug_wait;
+ ops->to_fetch_registers = debug_fetch_registers;
+ ops->to_store_registers = debug_store_registers;
+ ops->to_prepare_to_store = debug_prepare_to_store;
+ ops->to_files_info = debug_files_info;
+ ops->to_insert_breakpoint = debug_insert_breakpoint;
+ ops->to_remove_breakpoint = debug_remove_breakpoint;
+ ops->to_can_use_hw_breakpoint = debug_can_use_hw_breakpoint;
+ ops->to_ranged_break_num_registers = debug_ranged_break_num_registers;
+ ops->to_insert_hw_breakpoint = debug_insert_hw_breakpoint;
+ ops->to_remove_hw_breakpoint = debug_remove_hw_breakpoint;
+ ops->to_remove_watchpoint = debug_remove_watchpoint;
+ ops->to_insert_watchpoint = debug_insert_watchpoint;
+ ops->to_insert_mask_watchpoint = debug_insert_mask_watchpoint;
+ ops->to_remove_mask_watchpoint = debug_remove_mask_watchpoint;
+ ops->to_stopped_by_watchpoint = debug_stopped_by_watchpoint;
+ ops->to_stopped_data_address = debug_stopped_data_address;
+ ops->to_watchpoint_addr_within_range = debug_watchpoint_addr_within_range;
+ ops->to_region_ok_for_hw_watchpoint = debug_region_ok_for_hw_watchpoint;
+ ops->to_can_accel_watchpoint_condition = debug_can_accel_watchpoint_condition;
+ ops->to_masked_watch_num_registers = debug_masked_watch_num_registers;
+ ops->to_terminal_init = debug_terminal_init;
+ ops->to_terminal_inferior = debug_terminal_inferior;
+ ops->to_terminal_ours_for_output = debug_terminal_ours_for_output;
+ ops->to_terminal_ours = debug_terminal_ours;
+ ops->to_terminal_save_ours = debug_terminal_save_ours;
+ ops->to_terminal_info = debug_terminal_info;
+ ops->to_kill = debug_kill;
+ ops->to_load = debug_load;
+ ops->to_post_startup_inferior = debug_post_startup_inferior;
+ ops->to_insert_fork_catchpoint = debug_insert_fork_catchpoint;
+ ops->to_remove_fork_catchpoint = debug_remove_fork_catchpoint;
+ ops->to_insert_vfork_catchpoint = debug_insert_vfork_catchpoint;
+ ops->to_remove_vfork_catchpoint = debug_remove_vfork_catchpoint;
+ ops->to_follow_fork = debug_follow_fork;
+ ops->to_insert_exec_catchpoint = debug_insert_exec_catchpoint;
+ ops->to_remove_exec_catchpoint = debug_remove_exec_catchpoint;
+ ops->to_set_syscall_catchpoint = debug_set_syscall_catchpoint;
+ ops->to_has_exited = debug_has_exited;
+ ops->to_mourn_inferior = debug_mourn_inferior;
+ ops->to_can_run = debug_can_run;
+ ops->to_pass_signals = debug_pass_signals;
+ ops->to_program_signals = debug_program_signals;
+ ops->to_thread_alive = debug_thread_alive;
+ ops->to_find_new_threads = debug_find_new_threads;
+ ops->to_pid_to_str = debug_pid_to_str;
+ ops->to_extra_thread_info = debug_extra_thread_info;
+ ops->to_thread_name = debug_thread_name;
+ ops->to_stop = debug_stop;
+ ops->to_rcmd = debug_rcmd;
+ ops->to_pid_to_exec_file = debug_pid_to_exec_file;
+ ops->to_log_command = debug_log_command;
+ ops->to_get_section_table = debug_get_section_table;
+ ops->to_can_async_p = debug_can_async_p;
+ ops->to_is_async_p = debug_is_async_p;
+ ops->to_async = debug_async;
+ ops->to_supports_non_stop = debug_supports_non_stop;
+ ops->to_find_memory_regions = debug_find_memory_regions;
+ ops->to_make_corefile_notes = debug_make_corefile_notes;
+ ops->to_get_bookmark = debug_get_bookmark;
+ ops->to_goto_bookmark = debug_goto_bookmark;
+ ops->to_xfer_partial = debug_xfer_partial;
+ ops->to_memory_map = debug_memory_map;
+ ops->to_flash_erase = debug_flash_erase;
+ ops->to_flash_done = debug_flash_done;
+ ops->to_read_description = debug_read_description;
+ ops->to_get_ada_task_ptid = debug_get_ada_task_ptid;
+ ops->to_auxv_parse = debug_auxv_parse;
+ ops->to_search_memory = debug_search_memory;
+ ops->to_can_execute_reverse = debug_can_execute_reverse;
+ ops->to_execution_direction = debug_execution_direction;
+ ops->to_supports_multi_process = debug_supports_multi_process;
+ ops->to_supports_enable_disable_tracepoint = debug_supports_enable_disable_tracepoint;
+ ops->to_supports_string_tracing = debug_supports_string_tracing;
+ ops->to_supports_evaluation_of_breakpoint_conditions = debug_supports_evaluation_of_breakpoint_conditions;
+ ops->to_can_run_breakpoint_commands = debug_can_run_breakpoint_commands;
+ ops->to_thread_architecture = debug_thread_architecture;
+ ops->to_thread_address_space = debug_thread_address_space;
+ ops->to_trace_init = debug_trace_init;
+ ops->to_download_tracepoint = debug_download_tracepoint;
+ ops->to_can_download_tracepoint = debug_can_download_tracepoint;
+ ops->to_download_trace_state_variable = debug_download_trace_state_variable;
+ ops->to_enable_tracepoint = debug_enable_tracepoint;
+ ops->to_disable_tracepoint = debug_disable_tracepoint;
+ ops->to_trace_set_readonly_regions = debug_trace_set_readonly_regions;
+ ops->to_trace_start = debug_trace_start;
+ ops->to_get_trace_status = debug_get_trace_status;
+ ops->to_get_tracepoint_status = debug_get_tracepoint_status;
+ ops->to_trace_stop = debug_trace_stop;
+ ops->to_trace_find = debug_trace_find;
+ ops->to_get_trace_state_variable_value = debug_get_trace_state_variable_value;
+ ops->to_save_trace_data = debug_save_trace_data;
+ ops->to_upload_tracepoints = debug_upload_tracepoints;
+ ops->to_upload_trace_state_variables = debug_upload_trace_state_variables;
+ ops->to_get_raw_trace_data = debug_get_raw_trace_data;
+ ops->to_get_min_fast_tracepoint_insn_len = debug_get_min_fast_tracepoint_insn_len;
+ ops->to_set_disconnected_tracing = debug_set_disconnected_tracing;
+ ops->to_set_circular_trace_buffer = debug_set_circular_trace_buffer;
+ ops->to_set_trace_buffer_size = debug_set_trace_buffer_size;
+ ops->to_set_trace_notes = debug_set_trace_notes;
+ ops->to_core_of_thread = debug_core_of_thread;
+ ops->to_verify_memory = debug_verify_memory;
+ ops->to_get_tib_address = debug_get_tib_address;
+ ops->to_set_permissions = debug_set_permissions;
+ ops->to_static_tracepoint_marker_at = debug_static_tracepoint_marker_at;
+ ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid;
+ ops->to_traceframe_info = debug_traceframe_info;
+ ops->to_use_agent = debug_use_agent;
+ ops->to_can_use_agent = debug_can_use_agent;
+ ops->to_supports_btrace = debug_supports_btrace;
+ ops->to_enable_btrace = debug_enable_btrace;
+ ops->to_disable_btrace = debug_disable_btrace;
+ ops->to_teardown_btrace = debug_teardown_btrace;
+ ops->to_read_btrace = debug_read_btrace;
+ ops->to_stop_recording = debug_stop_recording;
+ ops->to_save_record = debug_save_record;
+ ops->to_delete_record = debug_delete_record;
+ ops->to_record_is_replaying = debug_record_is_replaying;
+ ops->to_goto_record_begin = debug_goto_record_begin;
+ ops->to_goto_record_end = debug_goto_record_end;
+ ops->to_goto_record = debug_goto_record;
+ ops->to_insn_history = debug_insn_history;
+ ops->to_insn_history_from = debug_insn_history_from;
+ ops->to_insn_history_range = debug_insn_history_range;
+ ops->to_call_history = debug_call_history;
+ ops->to_call_history_from = debug_call_history_from;
+ ops->to_call_history_range = debug_call_history_range;
+ ops->to_augmented_libraries_svr4_read = debug_augmented_libraries_svr4_read;
+ ops->to_get_unwinder = debug_get_unwinder;
+ ops->to_get_tailcall_unwinder = debug_get_tailcall_unwinder;
+ ops->to_decr_pc_after_break = debug_decr_pc_after_break;
+}
diff --git a/gdb/target.c b/gdb/target.c
index 075425d..0f58212 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -46,6 +46,7 @@
#include "gdb/fileio.h"
#include "agent.h"
#include "auxv.h"
+#include "target-debug.h"
static void target_info (char *, int);
@@ -109,72 +110,14 @@ static enum exec_direction_kind default_execution_direction
static CORE_ADDR default_target_decr_pc_after_break (struct target_ops *ops,
struct gdbarch *gdbarch);
+static struct target_ops debug_target;
+
#include "target-delegates.c"
static void init_dummy_target (void);
-static struct target_ops debug_target;
-
static void debug_to_open (char *, int);
-static void debug_to_prepare_to_store (struct target_ops *self,
- struct regcache *);
-
-static void debug_to_files_info (struct target_ops *);
-
-static int debug_to_insert_breakpoint (struct target_ops *, struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_can_use_hw_breakpoint (struct target_ops *self,
- int, int, int);
-
-static int debug_to_insert_hw_breakpoint (struct target_ops *self,
- struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_remove_hw_breakpoint (struct target_ops *self,
- struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_insert_watchpoint (struct target_ops *self,
- CORE_ADDR, int, int,
- struct expression *);
-
-static int debug_to_remove_watchpoint (struct target_ops *self,
- CORE_ADDR, int, int,
- struct expression *);
-
-static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
-
-static int debug_to_watchpoint_addr_within_range (struct target_ops *,
- CORE_ADDR, CORE_ADDR, int);
-
-static int debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
- CORE_ADDR, int);
-
-static int debug_to_can_accel_watchpoint_condition (struct target_ops *self,
- CORE_ADDR, int, int,
- struct expression *);
-
-static void debug_to_terminal_init (struct target_ops *self);
-
-static void debug_to_terminal_inferior (struct target_ops *self);
-
-static void debug_to_terminal_ours_for_output (struct target_ops *self);
-
-static void debug_to_terminal_save_ours (struct target_ops *self);
-
-static void debug_to_terminal_ours (struct target_ops *self);
-
-static void debug_to_load (struct target_ops *self, char *, int);
-
-static int debug_to_can_run (struct target_ops *self);
-
-static void debug_to_stop (struct target_ops *self, ptid_t);
-
/* Pointer to array of target architecture structures; the size of the
array; the current index into the array; the allocated size of the
array. */
@@ -469,9 +412,6 @@ add_deprecated_target_alias (struct target_ops *t, char *alias)
void
target_kill (void)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
-
current_target.to_kill (¤t_target);
}
@@ -919,9 +859,6 @@ done:
struct target_section_table *
target_get_section_table (struct target_ops *target)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
-
return (*target->to_get_section_table) (target);
}
@@ -1396,9 +1333,6 @@ target_memory_map (void)
int ix;
struct target_ops *t;
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
-
result = current_target.to_memory_map (¤t_target);
if (result == NULL)
return NULL;
@@ -1430,17 +1364,12 @@ target_memory_map (void)
void
target_flash_erase (ULONGEST address, LONGEST length)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
- hex_string (address), phex (length, 0));
current_target.to_flash_erase (¤t_target, address, length);
}
void
target_flash_done (void)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
current_target.to_flash_done (¤t_target);
}
@@ -2081,9 +2010,6 @@ target_detach (const char *args, int from_tty)
prepare_for_detach ();
current_target.to_detach (¤t_target, args, from_tty);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
- args, from_tty);
}
void
@@ -2094,36 +2020,13 @@ target_disconnect (const char *args, int from_tty)
disconnecting. */
remove_breakpoints ();
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
- args, from_tty);
current_target.to_disconnect (¤t_target, args, from_tty);
}
ptid_t
target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
{
- struct target_ops *t;
- ptid_t retval = (current_target.to_wait) (¤t_target, ptid,
- status, options);
-
- if (targetdebug)
- {
- char *status_string;
- char *options_string;
-
- status_string = target_waitstatus_to_string (status);
- options_string = target_options_to_string (options);
- fprintf_unfiltered (gdb_stdlog,
- "target_wait (%d, status, options={%s})"
- " = %d, %s\n",
- ptid_get_pid (ptid), options_string,
- ptid_get_pid (retval), status_string);
- xfree (status_string);
- xfree (options_string);
- }
-
- return retval;
+ return (current_target.to_wait) (¤t_target, ptid, status, options);
}
char *
@@ -2139,18 +2042,13 @@ target_thread_name (struct thread_info *info)
}
void
-target_resume (ptid_t ptid, int step, enum gdb_signal signal)
+target_resume (ptid_t ptid, target_debug_step step, enum gdb_signal signal)
{
struct target_ops *t;
target_dcache_invalidate ();
current_target.to_resume (¤t_target, ptid, step, signal);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
- ptid_get_pid (ptid),
- step ? "step" : "continue",
- gdb_signal_to_name (signal));
registers_changed_ptid (ptid);
/* We only set the internal executing state here. The user/frontend
@@ -2162,42 +2060,12 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal)
void
target_pass_signals (int numsigs, unsigned char *pass_signals)
{
- if (targetdebug)
- {
- int i;
-
- fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
- numsigs);
-
- for (i = 0; i < numsigs; i++)
- if (pass_signals[i])
- fprintf_unfiltered (gdb_stdlog, " %s",
- gdb_signal_to_name (i));
-
- fprintf_unfiltered (gdb_stdlog, " })\n");
- }
-
(*current_target.to_pass_signals) (¤t_target, numsigs, pass_signals);
}
void
target_program_signals (int numsigs, unsigned char *program_signals)
{
- if (targetdebug)
- {
- int i;
-
- fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
- numsigs);
-
- for (i = 0; i < numsigs; i++)
- if (program_signals[i])
- fprintf_unfiltered (gdb_stdlog, " %s",
- gdb_signal_to_name (i));
-
- fprintf_unfiltered (gdb_stdlog, " })\n");
- }
-
(*current_target.to_program_signals) (¤t_target,
numsigs, program_signals);
}
@@ -2217,14 +2085,8 @@ default_follow_fork (struct target_ops *self, int follow_child,
int
target_follow_fork (int follow_child, int detach_fork)
{
- int retval = current_target.to_follow_fork (¤t_target,
- follow_child, detach_fork);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_follow_fork (%d, %d) = %d\n",
- follow_child, detach_fork, retval);
- return retval;
+ return current_target.to_follow_fork (¤t_target,
+ follow_child, detach_fork);
}
static void
@@ -2238,8 +2100,6 @@ void
target_mourn_inferior (void)
{
current_target.to_mourn_inferior (¤t_target);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
/* We no longer need to keep handles on any of the object files.
Make sure to release them to avoid unnecessarily locking any
@@ -2389,20 +2249,9 @@ target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp)
{
- int found;
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
- hex_string (start_addr));
-
- found = current_target.to_search_memory (¤t_target, start_addr,
- search_space_len,
- pattern, pattern_len, found_addrp);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
-
- return found;
+ return current_target.to_search_memory (¤t_target, start_addr,
+ search_space_len,
+ pattern, pattern_len, found_addrp);
}
/* Look through the currently pushed targets. If none of them will
@@ -2640,12 +2489,6 @@ target_thread_address_space (ptid_t ptid)
aspace = current_target.to_thread_address_space (¤t_target, ptid);
gdb_assert (aspace != NULL);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_thread_address_space (%s) = %d\n",
- target_pid_to_str (ptid),
- address_space_num (aspace));
-
return aspace;
}
@@ -3125,22 +2968,13 @@ target_close (struct target_ops *targ)
int
target_thread_alive (ptid_t ptid)
{
- int retval;
-
- retval = current_target.to_thread_alive (¤t_target, ptid);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
- ptid_get_pid (ptid), retval);
-
- return retval;
+ return current_target.to_thread_alive (¤t_target, ptid);
}
void
target_find_new_threads (void)
{
current_target.to_find_new_threads (¤t_target);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
}
void
@@ -3155,14 +2989,6 @@ target_stop (ptid_t ptid)
(*current_target.to_stop) (¤t_target, ptid);
}
-static void
-debug_to_post_attach (struct target_ops *self, int pid)
-{
- debug_target.to_post_attach (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
-}
-
/* Concatenate ELEM to LIST, a comma separate list, and return the
result. The LIST incoming argument is released. */
@@ -3274,13 +3100,7 @@ target_store_registers (struct regcache *regcache, int regno)
int
target_core_of_thread (ptid_t ptid)
{
- int retval = current_target.to_core_of_thread (¤t_target, ptid);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_core_of_thread (%d) = %d\n",
- ptid_get_pid (ptid), retval);
- return retval;
+ return current_target.to_core_of_thread (¤t_target, ptid);
}
int
@@ -3325,16 +3145,8 @@ default_verify_memory (struct target_ops *self,
int
target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
{
- int retval = current_target.to_verify_memory (¤t_target,
- data, memaddr, size);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_verify_memory (%s, %s) = %d\n",
- paddress (target_gdbarch (), memaddr),
- pulongest (size),
- retval);
- return retval;
+ return current_target.to_verify_memory (¤t_target,
+ data, memaddr, size);
}
/* The documentation for this function is in its prototype declaration in
@@ -3343,18 +3155,8 @@ target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
int
target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
{
- int ret;
-
- ret = current_target.to_insert_mask_watchpoint (¤t_target,
- addr, mask, rw);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "\
-target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
- core_addr_to_string (addr),
- core_addr_to_string (mask), rw, ret);
-
- return ret;
+ return current_target.to_insert_mask_watchpoint (¤t_target,
+ addr, mask, rw);
}
/* The documentation for this function is in its prototype declaration in
@@ -3363,18 +3165,8 @@ target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
int
target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
{
- int ret;
-
- ret = current_target.to_remove_mask_watchpoint (¤t_target,
- addr, mask, rw);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "\
-target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
- core_addr_to_string (addr),
- core_addr_to_string (mask), rw, ret);
-
- return ret;
+ return current_target.to_remove_mask_watchpoint (¤t_target,
+ addr, mask, rw);
}
/* The documentation for this function is in its prototype declaration
@@ -3565,14 +3357,6 @@ target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
current_target.to_call_history_range (¤t_target, begin, end, flags);
}
-static void
-debug_to_prepare_to_store (struct target_ops *self, struct regcache *regcache)
-{
- debug_target.to_prepare_to_store (&debug_target, regcache);
-
- fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
-}
-
/* See target.h. */
const struct frame_unwind *
@@ -3607,470 +3391,12 @@ target_decr_pc_after_break (struct gdbarch *gdbarch)
}
static void
-debug_to_files_info (struct target_ops *target)
-{
- debug_target.to_files_info (target);
-
- fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
-}
-
-static int
-debug_to_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_insert_breakpoint (&debug_target, gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_insert_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_remove_breakpoint (&debug_target, gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_remove_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_can_use_hw_breakpoint (struct target_ops *self,
- int type, int cnt, int from_tty)
-{
- int retval;
-
- retval = debug_target.to_can_use_hw_breakpoint (&debug_target,
- type, cnt, from_tty);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
- (unsigned long) type,
- (unsigned long) cnt,
- (unsigned long) from_tty,
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len)
-{
- CORE_ADDR retval;
-
- retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target,
- addr, len);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
- core_addr_to_string (addr), (unsigned long) len,
- core_addr_to_string (retval));
- return retval;
-}
-
-static int
-debug_to_can_accel_watchpoint_condition (struct target_ops *self,
- CORE_ADDR addr, int len, int rw,
- struct expression *cond)
-{
- int retval;
-
- retval = debug_target.to_can_accel_watchpoint_condition (&debug_target,
- addr, len,
- rw, cond);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_can_accel_watchpoint_condition "
- "(%s, %d, %d, %s) = %ld\n",
- core_addr_to_string (addr), len, rw,
- host_address_to_string (cond), (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_stopped_by_watchpoint (struct target_ops *ops)
-{
- int retval;
-
- retval = debug_target.to_stopped_by_watchpoint (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_stopped_by_watchpoint () = %ld\n",
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
-{
- int retval;
-
- retval = debug_target.to_stopped_data_address (target, addr);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_stopped_data_address ([%s]) = %ld\n",
- core_addr_to_string (*addr),
- (unsigned long)retval);
- return retval;
-}
-
-static int
-debug_to_watchpoint_addr_within_range (struct target_ops *target,
- CORE_ADDR addr,
- CORE_ADDR start, int length)
-{
- int retval;
-
- retval = debug_target.to_watchpoint_addr_within_range (target, addr,
- start, length);
-
- fprintf_filtered (gdb_stdlog,
- "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
- core_addr_to_string (addr), core_addr_to_string (start),
- length, retval);
- return retval;
-}
-
-static int
-debug_to_insert_hw_breakpoint (struct target_ops *self,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_insert_hw_breakpoint (&debug_target,
- gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_remove_hw_breakpoint (struct target_ops *self,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_remove_hw_breakpoint (&debug_target,
- gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_insert_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
- struct expression *cond)
-{
- int retval;
-
- retval = debug_target.to_insert_watchpoint (&debug_target,
- addr, len, type, cond);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
- core_addr_to_string (addr), len, type,
- host_address_to_string (cond), (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_remove_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
- struct expression *cond)
-{
- int retval;
-
- retval = debug_target.to_remove_watchpoint (&debug_target,
- addr, len, type, cond);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
- core_addr_to_string (addr), len, type,
- host_address_to_string (cond), (unsigned long) retval);
- return retval;
-}
-
-static void
-debug_to_terminal_init (struct target_ops *self)
-{
- debug_target.to_terminal_init (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
-}
-
-static void
-debug_to_terminal_inferior (struct target_ops *self)
-{
- debug_target.to_terminal_inferior (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
-}
-
-static void
-debug_to_terminal_ours_for_output (struct target_ops *self)
-{
- debug_target.to_terminal_ours_for_output (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
-}
-
-static void
-debug_to_terminal_ours (struct target_ops *self)
-{
- debug_target.to_terminal_ours (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
-}
-
-static void
-debug_to_terminal_save_ours (struct target_ops *self)
-{
- debug_target.to_terminal_save_ours (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
-}
-
-static void
-debug_to_terminal_info (struct target_ops *self,
- const char *arg, int from_tty)
-{
- debug_target.to_terminal_info (&debug_target, arg, from_tty);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
- from_tty);
-}
-
-static void
-debug_to_load (struct target_ops *self, char *args, int from_tty)
-{
- debug_target.to_load (&debug_target, args, from_tty);
-
- fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
-}
-
-static void
-debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid)
-{
- debug_target.to_post_startup_inferior (&debug_target, ptid);
-
- fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
- ptid_get_pid (ptid));
-}
-
-static int
-debug_to_insert_fork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_remove_fork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_insert_exec_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_remove_exec_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_has_exited (struct target_ops *self,
- int pid, int wait_status, int *exit_status)
-{
- int has_exited;
-
- has_exited = debug_target.to_has_exited (&debug_target,
- pid, wait_status, exit_status);
-
- fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
- pid, wait_status, *exit_status, has_exited);
-
- return has_exited;
-}
-
-static int
-debug_to_can_run (struct target_ops *self)
-{
- int retval;
-
- retval = debug_target.to_can_run (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
-
- return retval;
-}
-
-static struct gdbarch *
-debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
-{
- struct gdbarch *retval;
-
- retval = debug_target.to_thread_architecture (ops, ptid);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_thread_architecture (%s) = %s [%s]\n",
- target_pid_to_str (ptid),
- host_address_to_string (retval),
- gdbarch_bfd_arch_info (retval)->printable_name);
- return retval;
-}
-
-static void
-debug_to_stop (struct target_ops *self, ptid_t ptid)
-{
- debug_target.to_stop (&debug_target, ptid);
-
- fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
- target_pid_to_str (ptid));
-}
-
-static void
-debug_to_rcmd (struct target_ops *self, const char *command,
- struct ui_file *outbuf)
-{
- debug_target.to_rcmd (&debug_target, command, outbuf);
- fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
-}
-
-static char *
-debug_to_pid_to_exec_file (struct target_ops *self, int pid)
-{
- char *exec_file;
-
- exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
- pid, exec_file);
-
- return exec_file;
-}
-
-static void
setup_target_debug (void)
{
memcpy (&debug_target, ¤t_target, sizeof debug_target);
current_target.to_open = debug_to_open;
- current_target.to_post_attach = debug_to_post_attach;
- current_target.to_prepare_to_store = debug_to_prepare_to_store;
- current_target.to_files_info = debug_to_files_info;
- current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
- current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
- current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
- current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
- current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
- current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
- current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
- current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
- current_target.to_stopped_data_address = debug_to_stopped_data_address;
- current_target.to_watchpoint_addr_within_range
- = debug_to_watchpoint_addr_within_range;
- current_target.to_region_ok_for_hw_watchpoint
- = debug_to_region_ok_for_hw_watchpoint;
- current_target.to_can_accel_watchpoint_condition
- = debug_to_can_accel_watchpoint_condition;
- current_target.to_terminal_init = debug_to_terminal_init;
- current_target.to_terminal_inferior = debug_to_terminal_inferior;
- current_target.to_terminal_ours_for_output
- = debug_to_terminal_ours_for_output;
- current_target.to_terminal_ours = debug_to_terminal_ours;
- current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
- current_target.to_terminal_info = debug_to_terminal_info;
- current_target.to_load = debug_to_load;
- current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
- current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
- current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
- current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
- current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
- current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
- current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
- current_target.to_has_exited = debug_to_has_exited;
- current_target.to_can_run = debug_to_can_run;
- current_target.to_stop = debug_to_stop;
- current_target.to_rcmd = debug_to_rcmd;
- current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
- current_target.to_thread_architecture = debug_to_thread_architecture;
+ init_debug_target (¤t_target);
}
\f
diff --git a/gdb/target.h b/gdb/target.h
index e563f2f..092afde 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -357,6 +357,12 @@ struct thread_info; /* fwd decl for parameter list below: */
typedef void async_callback_ftype (enum inferior_event_type event_type,
void *context);
+/* Some typedefs whose only purpose is to provide nicer debug
+ printing. */
+
+typedef int target_debug_options;
+typedef int target_debug_step;
+
/* These defines are used to mark target_ops methods. The script
make-target-delegates scans these and auto-generates the base
method implementations. There are four macros that can be used:
@@ -416,10 +422,12 @@ struct target_ops
TARGET_DEFAULT_IGNORE ();
void (*to_disconnect) (struct target_ops *, const char *, int)
TARGET_DEFAULT_NORETURN (tcomplain ());
- void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal)
+ void (*to_resume) (struct target_ops *, ptid_t, target_debug_step,
+ enum gdb_signal)
TARGET_DEFAULT_NORETURN (noprocess ());
ptid_t (*to_wait) (struct target_ops *,
- ptid_t, struct target_waitstatus *, int)
+ ptid_t, struct target_waitstatus *,
+ target_debug_options)
TARGET_DEFAULT_NORETURN (noprocess ());
void (*to_fetch_registers) (struct target_ops *, struct regcache *, int)
TARGET_DEFAULT_IGNORE ();
--
1.9.3
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-06-19 20:04 [RFC] auto-generate most target debug methods Tom Tromey
@ 2014-06-20 8:00 ` Yao Qi
2014-06-20 14:04 ` Tom Tromey
2014-07-15 11:17 ` Pedro Alves
1 sibling, 1 reply; 14+ messages in thread
From: Yao Qi @ 2014-06-20 8:00 UTC (permalink / raw)
To: Tom Tromey, gdb-patches
On 06/20/2014 04:03 AM, Tom Tromey wrote:
> +static void
> +target_debug_print_unsigned_char_p (unsigned char *sigs)
> +{
> + fputs_unfiltered ("{", gdb_stdlog);
> + if (sigs != NULL)
> + {
> + int i;
> +
> + for (i = 0; i < GDB_SIGNAL_LAST; i++)
> + if (sigs[i])
> + fprintf_unfiltered (gdb_stdlog, " %s", gdb_signal_to_name (i));
> + }
> + fputs_unfiltered (" }", gdb_stdlog);
> +}
This function should be renamed to target_debug_print_signal, for
example, and typedef unsigned char * signal, if I understand your
script correctly.
> +/* Printers for the debug target. Each prints an object of a given
> + type to a string that needn't be freed. In a few cases, a new
> + typedef is introduced just to override the normal printing approach
> + for the underlying type; see target.h for those. Most printers are
> + macros, for brevity, but a few are static functions where more
> + complicated behavior is needed.
> +
> + References to these printers are automatically generated by
> + make-target-delegates. See the generated file target-delegates.c.
> +
> + A few methods are still handled explicitly in target.c:
> + target_fetch_registers target_store_registers target_xfer_partial
This isn't valid to me. I do see debug_fetch_registers,
debug_store_registers and debug_xfer_partial are generated.
> + target_fileio_* target_close target_info_proc
> +
> + In most cases this is because target delegation hasn't been done for
> + the method. */
Otherwise, this patch looks good.
--
Yao (é½å°§)
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-06-20 8:00 ` Yao Qi
@ 2014-06-20 14:04 ` Tom Tromey
0 siblings, 0 replies; 14+ messages in thread
From: Tom Tromey @ 2014-06-20 14:04 UTC (permalink / raw)
To: Yao Qi; +Cc: gdb-patches
>>>>> "Yao" == Yao Qi <yao@codesourcery.com> writes:
Yao> This function should be renamed to target_debug_print_signal, for
Yao> example, and typedef unsigned char * signal, if I understand your
Yao> script correctly.
Yeah, that would be cleaner. I'll fix it up.
>> + A few methods are still handled explicitly in target.c:
>> + target_fetch_registers target_store_registers target_xfer_partial
Yao> This isn't valid to me. I do see debug_fetch_registers,
Yao> debug_store_registers and debug_xfer_partial are generated.
The comment is a bit off.
target_store_registers still has some targetdebug code to call
debug_print_register, which can't really be handled using the type-based
method.
to_xfer_partial has a debug method generated but due to the way
target_xfer_partial is written, the debug method is never actually
called. Note that a similar issue exists in the current code with
debug_to_open -- I think it can't ever be called because the target's
to_open is passed directly to add_cmd.
Tom
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-06-19 20:04 [RFC] auto-generate most target debug methods Tom Tromey
2014-06-20 8:00 ` Yao Qi
@ 2014-07-15 11:17 ` Pedro Alves
2014-07-15 15:20 ` Tom Tromey
2014-07-16 15:46 ` Tom Tromey
1 sibling, 2 replies; 14+ messages in thread
From: Pedro Alves @ 2014-07-15 11:17 UTC (permalink / raw)
To: Tom Tromey, gdb-patches
Hi Tom,
I like the idea of this patch a lot.
On 06/19/2014 09:03 PM, Tom Tromey wrote:
> - void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal)
> + void (*to_resume) (struct target_ops *, ptid_t, target_debug_step,
> + enum gdb_signal)
> TARGET_DEFAULT_NORETURN (noprocess ());
What I'm not sure I like is the need for new typedefs. Seems odd to
me to have a textual mismatch between the declaration and all
the implementations.
Did you try an __attribute__(())-like approach? Something like:
void (*to_resume) (struct target_ops *,
ptid_t,
int step TDP (print_target_resume_step),
enum gdb_signal)
TARGET_DEFAULT_NORETURN (noprocess ());
Parameters that have no explicit attribute would still fallback
to type based printing. It'd be a way to override the default.
Another similar idea, but written out of line:
void (*to_resume) (struct target_ops *, ptid_t, int step,
enum gdb_signal)
TARGET_DEBUG_PRINT (step, print_target_resume_step)
TARGET_DEFAULT_NORETURN (noprocess ());
?
--
Pedro Alves
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-15 11:17 ` Pedro Alves
@ 2014-07-15 15:20 ` Tom Tromey
2014-07-16 15:46 ` Tom Tromey
1 sibling, 0 replies; 14+ messages in thread
From: Tom Tromey @ 2014-07-15 15:20 UTC (permalink / raw)
To: Pedro Alves; +Cc: gdb-patches
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:
Pedro> What I'm not sure I like is the need for new typedefs. Seems odd to
Pedro> me to have a textual mismatch between the declaration and all
Pedro> the implementations.
Yeah.
Pedro> Did you try an __attribute__(())-like approach?
I thought of it, but I didn't give it a try, I think just because the
whole idea was speculative enough that I didn't want to sink a lot of
time into it.
Pedro> void (*to_resume) (struct target_ops *, ptid_t, int step,
Pedro> enum gdb_signal)
Pedro> TARGET_DEBUG_PRINT (step, print_target_resume_step)
Pedro> TARGET_DEFAULT_NORETURN (noprocess ());
Syntactically I think I prefer the attributes next to the parameters;
though perhaps this other approach can be used to solve the
debug_print_register problem.
I'll go a bit deeper.
Tom
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-15 11:17 ` Pedro Alves
2014-07-15 15:20 ` Tom Tromey
@ 2014-07-16 15:46 ` Tom Tromey
2014-07-17 14:50 ` Pedro Alves
1 sibling, 1 reply; 14+ messages in thread
From: Tom Tromey @ 2014-07-16 15:46 UTC (permalink / raw)
To: Pedro Alves; +Cc: gdb-patches
Pedro> I like the idea of this patch a lot.
[...]
Pedro> Did you try an __attribute__(())-like approach? Something like:
Appended is a patch that works this way.
Pedro> Another similar idea, but written out of line:
Pedro> void (*to_resume) (struct target_ops *, ptid_t, int step,
Pedro> enum gdb_signal)
Pedro> TARGET_DEBUG_PRINT (step, print_target_resume_step)
Pedro> TARGET_DEFAULT_NORETURN (noprocess ());
I mentioned that I thought this might help with some current cases.
However, the only cases I could find were in target_store_registers and
target_fetch_registers, and in the resulting target.c those just end up
with a little extra code:
if (targetdebug)
debug_print_register ("target_fetch_registers", regcache, regno);
... and so it didn't seem worth adding more machinery just to support
this case.
Tom
2014-07-15 Tom Tromey <tromey@redhat.com>
* make-target-delegates (munge_type, write_debugmethod): New
functions.
(debug_names): New global.
Write debug methods. Generate init_debug_target. Define
TARGET_DEBUG_PRINTER in the output.
* target-debug.h: New file.
* target-delegates.c: Rebuild.
* target.c: Include target-debug.h.
(debug_target): Hoist definition.
(target_kill, target_get_section_table, target_memory_map)
(target_flash_erase, target_flash_done, target_detach)
(target_disconnect, target_wait, target_resume)
(target_pass_signals, target_program_signals, target_follow_fork)
(target_mourn_inferior, target_search_memory)
(target_thread_address_space, target_close)
(target_find_new_threads, target_core_of_thread)
(target_verify_memory, target_insert_mask_watchpoint)
(target_remove_mask_watchpoint): Remove targetdebug code.
(debug_to_post_attach, debug_to_prepare_to_store)
(debug_to_files_info, debug_to_insert_breakpoint)
(debug_to_remove_breakpoint, debug_to_can_use_hw_breakpoint)
(debug_to_region_ok_for_hw_watchpoint)
(debug_to_can_accel_watchpoint_condition)
(debug_to_stopped_by_watchpoint, debug_to_stopped_data_address)
(debug_to_watchpoint_addr_within_range)
(debug_to_insert_hw_breakpoint, debug_to_remove_hw_breakpoint)
(debug_to_insert_watchpoint, debug_to_remove_watchpoint)
(debug_to_terminal_init, debug_to_terminal_inferior)
(debug_to_terminal_ours_for_output, debug_to_terminal_ours)
(debug_to_terminal_save_ours, debug_to_terminal_info)
(debug_to_load, debug_to_post_startup_inferior)
(debug_to_insert_fork_catchpoint)
(debug_to_remove_fork_catchpoint)
(debug_to_insert_vfork_catchpoint)
(debug_to_remove_vfork_catchpoint)
(debug_to_insert_exec_catchpoint)
(debug_to_remove_exec_catchpoint, debug_to_has_exited)
(debug_to_can_run, debug_to_thread_architecture, debug_to_stop)
(debug_to_rcmd, debug_to_pid_to_exec_file): Remove.
(setup_target_debug): Call init_debug_target.
* target.h (TARGET_DEBUG_PRINTER): New macro.
(struct target_ops) <to_resume, to_wait, to_pass_signals,
to_program_signals>: Use TARGET_DEBUG_PRINTER.
diff --git a/gdb/make-target-delegates b/gdb/make-target-delegates
index 28db447..3a4d636 100755
--- a/gdb/make-target-delegates
+++ b/gdb/make-target-delegates
@@ -217,15 +217,88 @@ sub write_tdefault($$$$@) {
return tdname ($name);
}
+sub munge_type($) {
+ my ($typename) = @_;
+ my ($result);
+
+ if ($typename =~ m/TARGET_DEBUG_PRINTER\s*\(([^)]*)\)/) {
+ $result = $1;
+ } else {
+ ($result = $typename) =~ s/\s+$//;
+ $result =~ s/[ ()]/_/g;
+ $result =~ s/[*]/p/g;
+ $result = 'target_debug_print_' . $result;
+ }
+
+ return $result;
+}
+
+# Write out a debug method.
+sub write_debugmethod($$$$@) {
+ my ($content, $style, $name, $return_type, @argtypes) = @_;
+
+ my ($debugname) = $name;
+ $debugname =~ s/to_/debug_/;
+ my ($targetname) = $name;
+ $targetname =~ s/to_/target_/;
+
+ my (@names) = write_function_header ($debugname, $return_type, @argtypes);
+
+ if ($return_type ne 'void') {
+ print " $return_type result;\n";
+ }
+
+ print " fprintf_unfiltered (gdb_stdlog, \"-> %s->$name (...)\\n\", debug_target.to_shortname);\n";
+
+ # Delegate to the beneath target.
+ print " ";
+ if ($return_type ne 'void') {
+ print "result = ";
+ }
+ print "debug_target." . $name . " (";
+ my @names2 = @names;
+ @names2[0] = "&debug_target";
+ print join (', ', @names2);
+ print ");\n";
+
+ # Now print the arguments.
+ print " fprintf_unfiltered (gdb_stdlog, \"<- %s->$name (\", debug_target.to_shortname);\n";
+ for my $i (0 .. $#argtypes) {
+ print " fputs_unfiltered (\", \", gdb_stdlog);\n" if $i > 0;
+ my $printer = munge_type ($argtypes[$i]);
+ print " $printer ($names2[$i]);\n";
+ }
+ if ($return_type ne 'void') {
+ print " fputs_unfiltered (\") = \", gdb_stdlog);\n";
+ my $printer = munge_type ($return_type);
+ print " $printer (result);\n";
+ print " fputs_unfiltered (\"\\n\", gdb_stdlog);\n";
+ } else {
+ print " fputs_unfiltered (\")\\n\", gdb_stdlog);\n";
+ }
+
+ if ($return_type ne 'void') {
+ print " return result;\n";
+ }
+
+ print "}\n\n";
+
+ return $debugname;
+}
+
print "/* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */\n";
print "/* vi:set ro: */\n\n";
print "/* To regenerate this file, run:*/\n";
print "/* make-target-delegates target.h > target-delegates.c */\n";
+# This simplifies things a bit.
+print "#define TARGET_DEBUG_PRINTER(FUNC)\n";
+
@lines = scan_target_h();
%tdefault_names = ();
+%debug_names = ();
@delegators = ();
foreach $current_line (@lines) {
next unless $current_line =~ m/$METHOD/;
@@ -248,6 +321,10 @@ foreach $current_line (@lines) {
$tdefault_names{$name} = write_tdefault ($tdefault, $style,
$name, $return_type,
@argtypes);
+
+ $debug_names{$name} = write_debugmethod ($tdefault, $style,
+ $name, $return_type,
+ @argtypes);
}
}
@@ -266,4 +343,11 @@ print "static void\ninstall_dummy_methods (struct target_ops *ops)\n{\n";
for $iter (@delegators) {
print " ops->" . $iter . " = " . $tdefault_names{$iter} . ";\n";
}
+print "}\n\n";
+
+# The debug method code.
+print "static void\ninit_debug_target (struct target_ops *ops)\n{\n";
+for $iter (@delegators) {
+ print " ops->" . $iter . " = " . $debug_names{$iter} . ";\n";
+}
print "}\n";
diff --git a/gdb/target-debug.h b/gdb/target-debug.h
new file mode 100644
index 0000000..3dd705c
--- /dev/null
+++ b/gdb/target-debug.h
@@ -0,0 +1,188 @@
+/* GDB target debugging macros
+
+ Copyright (C) 2014 Free Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef TARGET_DEBUG_H
+#define TARGET_DEBUG_H
+
+/* Printers for the debug target. Each prints an object of a given
+ type to a string that needn't be freed. Most printers are macros,
+ for brevity, but a few are static functions where more complicated
+ behavior is needed.
+
+ References to these printers are automatically generated by
+ make-target-delegates. See the generated file target-delegates.c.
+
+ In a couple cases, a special printing function is defined and then
+ used via the TARGET_DEBUG_PRINTER macro. See target.h.
+
+ A few methods still have some explicit targetdebug code in
+ target.c. In most cases this is because target delegation hasn't
+ been done for the method; but individual cases vary. For instance,
+ target_store_registers does some special register printing that is
+ more simply done there, and target_xfer_partial additionally
+ bypasses the debug target. */
+
+
+/* Helper macro. */
+
+#define target_debug_do_print(E) \
+ fputs_unfiltered ((E), gdb_stdlog);
+
+#define target_debug_print_struct_target_ops_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_enum_target_object(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_CORE_ADDR(X) \
+ target_debug_do_print (core_addr_to_string (X))
+#define target_debug_print_const_char_p(X) \
+ target_debug_do_print (((X) ? (X) : "(null)"))
+#define target_debug_print_char_p(X) \
+ target_debug_do_print (((X) ? (X) : "(null)"))
+#define target_debug_print_int(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_long(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_target_xfer_status(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_exec_direction_kind(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_trace_find_type(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_btrace_read_type(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_btrace_error(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_ptid_t(X) \
+ target_debug_do_print (plongest (ptid_get_pid (X)))
+#define target_debug_print_struct_gdbarch_p(X) \
+ target_debug_do_print (gdbarch_bfd_arch_info (X)->printable_name)
+#define target_debug_print_const_gdb_byte_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_gdb_byte_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_gdb_byte_pp(X) \
+ target_debug_do_print (host_address_to_string (*(X)))
+#define target_debug_print_enum_gdb_signal(X) \
+ target_debug_do_print (gdb_signal_to_name (X))
+#define target_debug_print_ULONGEST(X) \
+ target_debug_do_print (hex_string (X))
+#define target_debug_print_ULONGEST_p(X) \
+ target_debug_do_print (hex_string (*(X)))
+#define target_debug_print_LONGEST(X) \
+ target_debug_do_print (phex (X, 0))
+#define target_debug_print_LONGEST_p(X) \
+ target_debug_do_print (phex (*(X), 0))
+#define target_debug_print_struct_address_space_p(X) \
+ target_debug_do_print (plongest (address_space_num (X)))
+#define target_debug_print_struct_bp_target_info_p(X) \
+ target_debug_do_print (core_addr_to_string ((X)->placed_address))
+#define target_debug_print_struct_expression_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_CORE_ADDR_p(X) \
+ target_debug_do_print (core_addr_to_string (*(X)))
+#define target_debug_print_int_p(X) \
+ target_debug_do_print (plongest (*(X)))
+#define target_debug_print_struct_regcache_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_thread_info_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_ui_file_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_target_section_table_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_async_callback_ftype_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_void_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_find_memory_region_ftype(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_bfd_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC_mem_region_s__p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC_static_tracepoint_marker_p__p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_const_struct_target_desc_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_bp_location_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_trace_state_variable_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_trace_status_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_breakpoint_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tp_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tp_pp(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tsv_pp(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_static_tracepoint_marker_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_traceframe_info_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_btrace_target_info_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC__btrace_block_s__pp(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_const_struct_frame_unwind_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+
+static void
+target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
+{
+ char *str = target_waitstatus_to_string (status);
+
+ fputs_unfiltered (str, gdb_stdlog);
+ xfree (str);
+}
+
+\f
+
+/* Macros or functions that are used via TARGET_DEBUG_PRINTER. */
+
+#define target_debug_print_step(X) \
+ target_debug_do_print ((X) ? "step" : "continue")
+
+static void
+target_debug_print_options (int options)
+{
+ char *str = target_options_to_string (options);
+
+ fputs_unfiltered (str, gdb_stdlog);
+ xfree (str);
+}
+
+static void
+target_debug_print_signals (unsigned char *sigs)
+{
+ fputs_unfiltered ("{", gdb_stdlog);
+ if (sigs != NULL)
+ {
+ int i;
+
+ for (i = 0; i < GDB_SIGNAL_LAST; i++)
+ if (sigs[i])
+ fprintf_unfiltered (gdb_stdlog, " %s", gdb_signal_to_name (i));
+ }
+ fputs_unfiltered (" }", gdb_stdlog);
+}
+
+#endif /* TARGET_DEBUG_H */
diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c
index 8c81672..e8ff3cf 100644
--- a/gdb/target-delegates.c
+++ b/gdb/target-delegates.c
@@ -3,6 +3,7 @@
/* To regenerate this file, run:*/
/* make-target-delegates target.h > target-delegates.c */
+#define TARGET_DEBUG_PRINTER(FUNC)
static void
delegate_post_attach (struct target_ops *self, int arg1)
{
@@ -16,6 +17,18 @@ tdefault_post_attach (struct target_ops *self, int arg1)
}
static void
+debug_post_attach (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", debug_target.to_shortname);
+ debug_target.to_post_attach (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_detach (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -28,6 +41,20 @@ tdefault_detach (struct target_ops *self, const char *arg1, int arg2)
}
static void
+debug_detach (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", debug_target.to_shortname);
+ debug_target.to_detach (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_disconnect (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -41,31 +68,81 @@ tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
}
static void
-delegate_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
+debug_disconnect (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", debug_target.to_shortname);
+ debug_target.to_disconnect (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
+delegate_resume (struct target_ops *self, ptid_t arg1, int TARGET_DEBUG_PRINTER (target_debug_print_step) arg2, enum gdb_signal arg3)
{
self = self->beneath;
self->to_resume (self, arg1, arg2, arg3);
}
static void
-tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
+tdefault_resume (struct target_ops *self, ptid_t arg1, int TARGET_DEBUG_PRINTER (target_debug_print_step) arg2, enum gdb_signal arg3)
{
noprocess ();
}
+static void
+debug_resume (struct target_ops *self, ptid_t arg1, int TARGET_DEBUG_PRINTER (target_debug_print_step) arg2, enum gdb_signal arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", debug_target.to_shortname);
+ debug_target.to_resume (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_step (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_gdb_signal (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static ptid_t
-delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
+delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int TARGET_DEBUG_PRINTER (target_debug_print_options) arg3)
{
self = self->beneath;
return self->to_wait (self, arg1, arg2, arg3);
}
static ptid_t
-tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
+tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int TARGET_DEBUG_PRINTER (target_debug_print_options) arg3)
{
noprocess ();
}
+static ptid_t
+debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int TARGET_DEBUG_PRINTER (target_debug_print_options) arg3)
+{
+ ptid_t result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", debug_target.to_shortname);
+ result = debug_target.to_wait (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_target_waitstatus_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_options (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_ptid_t (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
@@ -79,6 +156,20 @@ tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int ar
}
static void
+debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname);
+ debug_target.to_fetch_registers (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_regcache_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
self = self->beneath;
@@ -92,6 +183,20 @@ tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int ar
}
static void
+debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
+ debug_target.to_store_registers (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_regcache_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
{
self = self->beneath;
@@ -105,6 +210,18 @@ tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
}
static void
+debug_prepare_to_store (struct target_ops *self, struct regcache *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", debug_target.to_shortname);
+ debug_target.to_prepare_to_store (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_regcache_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_files_info (struct target_ops *self)
{
self = self->beneath;
@@ -116,6 +233,16 @@ tdefault_files_info (struct target_ops *self)
{
}
+static void
+debug_files_info (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_files_info (...)\n", debug_target.to_shortname);
+ debug_target.to_files_info (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_files_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
@@ -124,6 +251,24 @@ delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struc
}
static int
+debug_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
@@ -131,6 +276,24 @@ delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struc
}
static int
+debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
{
self = self->beneath;
@@ -144,6 +307,26 @@ tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int
}
static int
+debug_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_use_hw_breakpoint (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_ranged_break_num_registers (struct target_ops *self)
{
self = self->beneath;
@@ -157,6 +340,20 @@ tdefault_ranged_break_num_registers (struct target_ops *self)
}
static int
+debug_ranged_break_num_registers (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_ranged_break_num_registers (...)\n", debug_target.to_shortname);
+ result = debug_target.to_ranged_break_num_registers (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_ranged_break_num_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
@@ -170,6 +367,24 @@ tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, st
}
static int
+debug_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_hw_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_hw_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_hw_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
@@ -183,6 +398,24 @@ tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, st
}
static int
+debug_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_hw_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_hw_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_hw_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
@@ -196,6 +429,28 @@ tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, i
}
static int
+debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_expression_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
@@ -209,6 +464,28 @@ tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, i
}
static int
+debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_expression_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
@@ -222,6 +499,26 @@ tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_A
}
static int
+debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_mask_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_mask_watchpoint (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_mask_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
@@ -235,6 +532,26 @@ tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_A
}
static int
+debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_mask_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_mask_watchpoint (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_mask_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_stopped_by_watchpoint (struct target_ops *self)
{
self = self->beneath;
@@ -248,6 +565,20 @@ tdefault_stopped_by_watchpoint (struct target_ops *self)
}
static int
+debug_stopped_by_watchpoint (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_stopped_by_watchpoint (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
{
self = self->beneath;
@@ -261,6 +592,22 @@ tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
}
static int
+debug_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_data_address (...)\n", debug_target.to_shortname);
+ result = debug_target.to_stopped_data_address (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_data_address (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
@@ -268,6 +615,26 @@ delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1,
}
static int
+debug_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_watchpoint_addr_within_range (...)\n", debug_target.to_shortname);
+ result = debug_target.to_watchpoint_addr_within_range (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_watchpoint_addr_within_range (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
{
self = self->beneath;
@@ -275,6 +642,24 @@ delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, i
}
static int
+debug_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_region_ok_for_hw_watchpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_region_ok_for_hw_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
@@ -288,6 +673,28 @@ tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1
}
static int
+debug_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_accel_watchpoint_condition (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_accel_watchpoint_condition (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_accel_watchpoint_condition (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_expression_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
{
self = self->beneath;
@@ -300,6 +707,24 @@ tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CO
return -1;
}
+static int
+debug_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_masked_watch_num_registers (...)\n", debug_target.to_shortname);
+ result = debug_target.to_masked_watch_num_registers (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_masked_watch_num_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_terminal_init (struct target_ops *self)
{
@@ -313,6 +738,16 @@ tdefault_terminal_init (struct target_ops *self)
}
static void
+debug_terminal_init (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_init (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_init (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_init (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_inferior (struct target_ops *self)
{
self = self->beneath;
@@ -325,6 +760,16 @@ tdefault_terminal_inferior (struct target_ops *self)
}
static void
+debug_terminal_inferior (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_inferior (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_ours_for_output (struct target_ops *self)
{
self = self->beneath;
@@ -337,6 +782,16 @@ tdefault_terminal_ours_for_output (struct target_ops *self)
}
static void
+debug_terminal_ours_for_output (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours_for_output (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_ours_for_output (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours_for_output (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_ours (struct target_ops *self)
{
self = self->beneath;
@@ -349,6 +804,16 @@ tdefault_terminal_ours (struct target_ops *self)
}
static void
+debug_terminal_ours (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_ours (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_save_ours (struct target_ops *self)
{
self = self->beneath;
@@ -361,6 +826,16 @@ tdefault_terminal_save_ours (struct target_ops *self)
}
static void
+debug_terminal_save_ours (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_save_ours (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_save_ours (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_save_ours (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -368,6 +843,20 @@ delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
}
static void
+debug_terminal_info (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_info (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_info (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_kill (struct target_ops *self)
{
self = self->beneath;
@@ -381,6 +870,16 @@ tdefault_kill (struct target_ops *self)
}
static void
+debug_kill (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_kill (...)\n", debug_target.to_shortname);
+ debug_target.to_kill (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_kill (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_load (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -394,6 +893,20 @@ tdefault_load (struct target_ops *self, const char *arg1, int arg2)
}
static void
+debug_load (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_load (...)\n", debug_target.to_shortname);
+ debug_target.to_load (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_load (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
@@ -405,6 +918,18 @@ tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
{
}
+static void
+debug_post_startup_inferior (struct target_ops *self, ptid_t arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_startup_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_post_startup_inferior (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_startup_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_insert_fork_catchpoint (struct target_ops *self, int arg1)
{
@@ -419,6 +944,22 @@ tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_insert_fork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_fork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_fork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_fork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_fork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -432,6 +973,22 @@ tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_remove_fork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_fork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_fork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_fork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -445,6 +1002,22 @@ tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_insert_vfork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_vfork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_vfork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_vfork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -458,6 +1031,22 @@ tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_remove_vfork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_vfork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_vfork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_vfork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
@@ -465,6 +1054,24 @@ delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
}
static int
+debug_follow_fork (struct target_ops *self, int arg1, int arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_fork (...)\n", debug_target.to_shortname);
+ result = debug_target.to_follow_fork (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_fork (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_exec_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -478,6 +1085,22 @@ tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_insert_exec_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_exec_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_exec_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_exec_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_exec_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -491,6 +1114,22 @@ tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_remove_exec_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_exec_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_exec_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_exec_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
{
self = self->beneath;
@@ -504,6 +1143,30 @@ tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, in
}
static int
+debug_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg5);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
{
self = self->beneath;
@@ -516,6 +1179,26 @@ tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
return 0;
}
+static int
+debug_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_has_exited (...)\n", debug_target.to_shortname);
+ result = debug_target.to_has_exited (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_has_exited (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_mourn_inferior (struct target_ops *self)
{
@@ -523,6 +1206,16 @@ delegate_mourn_inferior (struct target_ops *self)
self->to_mourn_inferior (self);
}
+static void
+debug_mourn_inferior (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_mourn_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_mourn_inferior (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_mourn_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_can_run (struct target_ops *self)
{
@@ -536,28 +1229,70 @@ tdefault_can_run (struct target_ops *self)
return 0;
}
+static int
+debug_can_run (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_run (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
-delegate_pass_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+delegate_pass_signals (struct target_ops *self, int arg1, unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals) arg2)
{
self = self->beneath;
self->to_pass_signals (self, arg1, arg2);
}
static void
-tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals) arg2)
+{
+}
+
+static void
+debug_pass_signals (struct target_ops *self, int arg1, unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals) arg2)
{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", debug_target.to_shortname);
+ debug_target.to_pass_signals (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_signals (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
}
static void
-delegate_program_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+delegate_program_signals (struct target_ops *self, int arg1, unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals) arg2)
{
self = self->beneath;
self->to_program_signals (self, arg1, arg2);
}
static void
-tdefault_program_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+tdefault_program_signals (struct target_ops *self, int arg1, unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals) arg2)
+{
+}
+
+static void
+debug_program_signals (struct target_ops *self, int arg1, unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals) arg2)
{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", debug_target.to_shortname);
+ debug_target.to_program_signals (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_signals (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
}
static int
@@ -573,6 +1308,22 @@ tdefault_thread_alive (struct target_ops *self, ptid_t arg1)
return 0;
}
+static int
+debug_thread_alive (struct target_ops *self, ptid_t arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_alive (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_alive (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_alive (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_find_new_threads (struct target_ops *self)
{
@@ -585,6 +1336,16 @@ tdefault_find_new_threads (struct target_ops *self)
{
}
+static void
+debug_find_new_threads (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_new_threads (...)\n", debug_target.to_shortname);
+ debug_target.to_find_new_threads (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_new_threads (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static char *
delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
{
@@ -593,6 +1354,22 @@ delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
}
static char *
+debug_pid_to_str (struct target_ops *self, ptid_t arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_str (...)\n", debug_target.to_shortname);
+ result = debug_target.to_pid_to_str (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_str (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static char *
delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
{
self = self->beneath;
@@ -606,6 +1383,22 @@ tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
}
static char *
+debug_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_extra_thread_info (...)\n", debug_target.to_shortname);
+ result = debug_target.to_extra_thread_info (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_extra_thread_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_thread_info_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static char *
delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
{
self = self->beneath;
@@ -618,6 +1411,22 @@ tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
return NULL;
}
+static char *
+debug_thread_name (struct target_ops *self, struct thread_info *arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_name (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_name (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_name (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_thread_info_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_stop (struct target_ops *self, ptid_t arg1)
{
@@ -631,12 +1440,38 @@ tdefault_stop (struct target_ops *self, ptid_t arg1)
}
static void
+debug_stop (struct target_ops *self, ptid_t arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop (...)\n", debug_target.to_shortname);
+ debug_target.to_stop (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
{
self = self->beneath;
self->to_rcmd (self, arg1, arg2);
}
+static void
+debug_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_rcmd (...)\n", debug_target.to_shortname);
+ debug_target.to_rcmd (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_rcmd (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_ui_file_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static char *
delegate_pid_to_exec_file (struct target_ops *self, int arg1)
{
@@ -650,6 +1485,22 @@ tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
return NULL;
}
+static char *
+debug_pid_to_exec_file (struct target_ops *self, int arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_exec_file (...)\n", debug_target.to_shortname);
+ result = debug_target.to_pid_to_exec_file (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_exec_file (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_log_command (struct target_ops *self, const char *arg1)
{
@@ -662,6 +1513,18 @@ tdefault_log_command (struct target_ops *self, const char *arg1)
{
}
+static void
+debug_log_command (struct target_ops *self, const char *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_log_command (...)\n", debug_target.to_shortname);
+ debug_target.to_log_command (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_log_command (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static struct target_section_table *
delegate_get_section_table (struct target_ops *self)
{
@@ -675,6 +1538,20 @@ tdefault_get_section_table (struct target_ops *self)
return NULL;
}
+static struct target_section_table *
+debug_get_section_table (struct target_ops *self)
+{
+ struct target_section_table * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_section_table (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_section_table (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_section_table (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_target_section_table_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_can_async_p (struct target_ops *self)
{
@@ -689,6 +1566,20 @@ tdefault_can_async_p (struct target_ops *self)
}
static int
+debug_can_async_p (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_async_p (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_async_p (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_async_p (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_is_async_p (struct target_ops *self)
{
self = self->beneath;
@@ -701,6 +1592,20 @@ tdefault_is_async_p (struct target_ops *self)
return 0;
}
+static int
+debug_is_async_p (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_is_async_p (...)\n", debug_target.to_shortname);
+ result = debug_target.to_is_async_p (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_is_async_p (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
{
@@ -714,6 +1619,20 @@ tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
tcomplain ();
}
+static void
+debug_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname);
+ debug_target.to_async (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_async_callback_ftype_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_void_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_supports_non_stop (struct target_ops *self)
{
@@ -728,12 +1647,44 @@ tdefault_supports_non_stop (struct target_ops *self)
}
static int
+debug_supports_non_stop (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_non_stop (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
{
self = self->beneath;
return self->to_find_memory_regions (self, arg1, arg2);
}
+static int
+debug_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", debug_target.to_shortname);
+ result = debug_target.to_find_memory_regions (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_find_memory_region_ftype (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_void_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static char *
delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
{
@@ -741,6 +1692,24 @@ delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
return self->to_make_corefile_notes (self, arg1, arg2);
}
+static char *
+debug_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", debug_target.to_shortname);
+ result = debug_target.to_make_corefile_notes (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_bfd_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static gdb_byte *
delegate_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
{
@@ -754,6 +1723,24 @@ tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
tcomplain ();
}
+static gdb_byte *
+debug_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
+{
+ gdb_byte * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_bookmark (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
{
@@ -767,6 +1754,20 @@ tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
tcomplain ();
}
+static void
+debug_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_bookmark (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static CORE_ADDR
delegate_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
{
@@ -780,6 +1781,26 @@ tdefault_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_AD
generic_tls_error ();
}
+static CORE_ADDR
+debug_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
+{
+ CORE_ADDR result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_thread_local_address (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_thread_local_address (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_thread_local_address (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static enum target_xfer_status
delegate_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
{
@@ -793,6 +1814,34 @@ tdefault_xfer_partial (struct target_ops *self, enum target_object arg1, const c
return TARGET_XFER_E_IO;
}
+static enum target_xfer_status
+debug_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
+{
+ enum target_xfer_status result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", debug_target.to_shortname);
+ result = debug_target.to_xfer_partial (&debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_target_object (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg5);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg6);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST_p (arg7);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_target_xfer_status (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static VEC(mem_region_s) *
delegate_memory_map (struct target_ops *self)
{
@@ -806,6 +1855,20 @@ tdefault_memory_map (struct target_ops *self)
return NULL;
}
+static VEC(mem_region_s) *
+debug_memory_map (struct target_ops *self)
+{
+ VEC(mem_region_s) * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", debug_target.to_shortname);
+ result = debug_target.to_memory_map (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_VEC_mem_region_s__p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
{
@@ -820,6 +1883,20 @@ tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
}
static void
+debug_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", debug_target.to_shortname);
+ debug_target.to_flash_erase (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_flash_done (struct target_ops *self)
{
self = self->beneath;
@@ -832,6 +1909,16 @@ tdefault_flash_done (struct target_ops *self)
tcomplain ();
}
+static void
+debug_flash_done (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", debug_target.to_shortname);
+ debug_target.to_flash_done (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static const struct target_desc *
delegate_read_description (struct target_ops *self)
{
@@ -845,6 +1932,20 @@ tdefault_read_description (struct target_ops *self)
return NULL;
}
+static const struct target_desc *
+debug_read_description (struct target_ops *self)
+{
+ const struct target_desc * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", debug_target.to_shortname);
+ result = debug_target.to_read_description (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_const_struct_target_desc_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static ptid_t
delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
{
@@ -852,6 +1953,24 @@ delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
return self->to_get_ada_task_ptid (self, arg1, arg2);
}
+static ptid_t
+debug_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
+{
+ ptid_t result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_ada_task_ptid (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_long (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_long (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_ptid_t (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
{
@@ -860,6 +1979,28 @@ delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, C
}
static int
+debug_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", debug_target.to_shortname);
+ result = debug_target.to_auxv_parse (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_pp (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
{
self = self->beneath;
@@ -867,6 +2008,30 @@ delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2,
}
static int
+debug_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", debug_target.to_shortname);
+ result = debug_target.to_search_memory (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg5);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_execute_reverse (struct target_ops *self)
{
self = self->beneath;
@@ -879,6 +2044,20 @@ tdefault_can_execute_reverse (struct target_ops *self)
return 0;
}
+static int
+debug_can_execute_reverse (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_execute_reverse (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static enum exec_direction_kind
delegate_execution_direction (struct target_ops *self)
{
@@ -886,6 +2065,20 @@ delegate_execution_direction (struct target_ops *self)
return self->to_execution_direction (self);
}
+static enum exec_direction_kind
+debug_execution_direction (struct target_ops *self)
+{
+ enum exec_direction_kind result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", debug_target.to_shortname);
+ result = debug_target.to_execution_direction (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_exec_direction_kind (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_supports_multi_process (struct target_ops *self)
{
@@ -900,6 +2093,20 @@ tdefault_supports_multi_process (struct target_ops *self)
}
static int
+debug_supports_multi_process (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_multi_process (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_enable_disable_tracepoint (struct target_ops *self)
{
self = self->beneath;
@@ -913,6 +2120,20 @@ tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
}
static int
+debug_supports_enable_disable_tracepoint (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_enable_disable_tracepoint (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_string_tracing (struct target_ops *self)
{
self = self->beneath;
@@ -926,6 +2147,20 @@ tdefault_supports_string_tracing (struct target_ops *self)
}
static int
+debug_supports_string_tracing (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_string_tracing (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
{
self = self->beneath;
@@ -939,6 +2174,20 @@ tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
}
static int
+debug_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_evaluation_of_breakpoint_conditions (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_run_breakpoint_commands (struct target_ops *self)
{
self = self->beneath;
@@ -951,6 +2200,20 @@ tdefault_can_run_breakpoint_commands (struct target_ops *self)
return 0;
}
+static int
+debug_can_run_breakpoint_commands (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_run_breakpoint_commands (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct gdbarch *
delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
{
@@ -958,6 +2221,22 @@ delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
return self->to_thread_architecture (self, arg1);
}
+static struct gdbarch *
+debug_thread_architecture (struct target_ops *self, ptid_t arg1)
+{
+ struct gdbarch * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_architecture (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct address_space *
delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
{
@@ -965,6 +2244,22 @@ delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
return self->to_thread_address_space (self, arg1);
}
+static struct address_space *
+debug_thread_address_space (struct target_ops *self, ptid_t arg1)
+{
+ struct address_space * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_address_space (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_address_space_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_trace_init (struct target_ops *self)
{
@@ -979,6 +2274,16 @@ tdefault_trace_init (struct target_ops *self)
}
static void
+debug_trace_init (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_init (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
@@ -991,6 +2296,18 @@ tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
tcomplain ();
}
+static void
+debug_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", debug_target.to_shortname);
+ debug_target.to_download_tracepoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_location_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_can_download_tracepoint (struct target_ops *self)
{
@@ -1004,6 +2321,20 @@ tdefault_can_download_tracepoint (struct target_ops *self)
return 0;
}
+static int
+debug_can_download_tracepoint (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_download_tracepoint (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
{
@@ -1018,6 +2349,18 @@ tdefault_download_trace_state_variable (struct target_ops *self, struct trace_st
}
static void
+debug_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", debug_target.to_shortname);
+ debug_target.to_download_trace_state_variable (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_trace_state_variable_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
@@ -1031,6 +2374,18 @@ tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
}
static void
+debug_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", debug_target.to_shortname);
+ debug_target.to_enable_tracepoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_location_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
@@ -1044,6 +2399,18 @@ tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
}
static void
+debug_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", debug_target.to_shortname);
+ debug_target.to_disable_tracepoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_location_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_trace_set_readonly_regions (struct target_ops *self)
{
self = self->beneath;
@@ -1057,6 +2424,16 @@ tdefault_trace_set_readonly_regions (struct target_ops *self)
}
static void
+debug_trace_set_readonly_regions (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_set_readonly_regions (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_trace_start (struct target_ops *self)
{
self = self->beneath;
@@ -1069,6 +2446,16 @@ tdefault_trace_start (struct target_ops *self)
tcomplain ();
}
+static void
+debug_trace_start (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_start (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
{
@@ -1082,6 +2469,22 @@ tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
return -1;
}
+static int
+debug_get_trace_status (struct target_ops *self, struct trace_status *arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_trace_status (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_trace_status_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
{
@@ -1096,6 +2499,20 @@ tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1
}
static void
+debug_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", debug_target.to_shortname);
+ debug_target.to_get_tracepoint_status (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_breakpoint_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_uploaded_tp_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_trace_stop (struct target_ops *self)
{
self = self->beneath;
@@ -1108,6 +2525,16 @@ tdefault_trace_stop (struct target_ops *self)
tcomplain ();
}
+static void
+debug_trace_stop (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_stop (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
{
@@ -1122,6 +2549,30 @@ tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg
}
static int
+debug_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", debug_target.to_shortname);
+ result = debug_target.to_trace_find (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_trace_find_type (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg5);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
{
self = self->beneath;
@@ -1135,6 +2586,24 @@ tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONG
}
static int
+debug_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_trace_state_variable_value (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_save_trace_data (struct target_ops *self, const char *arg1)
{
self = self->beneath;
@@ -1148,6 +2617,22 @@ tdefault_save_trace_data (struct target_ops *self, const char *arg1)
}
static int
+debug_save_trace_data (struct target_ops *self, const char *arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", debug_target.to_shortname);
+ result = debug_target.to_save_trace_data (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
{
self = self->beneath;
@@ -1161,6 +2646,22 @@ tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
}
static int
+debug_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", debug_target.to_shortname);
+ result = debug_target.to_upload_tracepoints (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_uploaded_tp_pp (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
{
self = self->beneath;
@@ -1173,6 +2674,22 @@ tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_
return 0;
}
+static int
+debug_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", debug_target.to_shortname);
+ result = debug_target.to_upload_trace_state_variables (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_uploaded_tsv_pp (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static LONGEST
delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
{
@@ -1186,6 +2703,26 @@ tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST a
tcomplain ();
}
+static LONGEST
+debug_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
+{
+ LONGEST result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_raw_trace_data (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_LONGEST (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
{
@@ -1199,6 +2736,20 @@ tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
return -1;
}
+static int
+debug_get_min_fast_tracepoint_insn_len (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_min_fast_tracepoint_insn_len (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
{
@@ -1212,6 +2763,18 @@ tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
}
static void
+debug_set_disconnected_tracing (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", debug_target.to_shortname);
+ debug_target.to_set_disconnected_tracing (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -1224,6 +2787,18 @@ tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
}
static void
+debug_set_circular_trace_buffer (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", debug_target.to_shortname);
+ debug_target.to_set_circular_trace_buffer (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
{
self = self->beneath;
@@ -1235,6 +2810,18 @@ tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
{
}
+static void
+debug_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", debug_target.to_shortname);
+ debug_target.to_set_trace_buffer_size (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
{
@@ -1249,6 +2836,26 @@ tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char
}
static int
+debug_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", debug_target.to_shortname);
+ result = debug_target.to_set_trace_notes (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
@@ -1262,6 +2869,22 @@ tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
}
static int
+debug_core_of_thread (struct target_ops *self, ptid_t arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", debug_target.to_shortname);
+ result = debug_target.to_core_of_thread (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
{
self = self->beneath;
@@ -1269,6 +2892,26 @@ delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR
}
static int
+debug_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", debug_target.to_shortname);
+ result = debug_target.to_verify_memory (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
{
self = self->beneath;
@@ -1281,6 +2924,24 @@ tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
tcomplain ();
}
+static int
+debug_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_tib_address (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_address (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_set_permissions (struct target_ops *self)
{
@@ -1293,6 +2954,16 @@ tdefault_set_permissions (struct target_ops *self)
{
}
+static void
+debug_set_permissions (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", debug_target.to_shortname);
+ debug_target.to_set_permissions (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
{
@@ -1306,6 +2977,24 @@ tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, s
return 0;
}
+static int
+debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", debug_target.to_shortname);
+ result = debug_target.to_static_tracepoint_marker_at (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_static_tracepoint_marker_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static VEC(static_tracepoint_marker_p) *
delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
{
@@ -1319,6 +3008,22 @@ tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char
tcomplain ();
}
+static VEC(static_tracepoint_marker_p) *
+debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
+{
+ VEC(static_tracepoint_marker_p) * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", debug_target.to_shortname);
+ result = debug_target.to_static_tracepoint_markers_by_strid (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_VEC_static_tracepoint_marker_p__p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct traceframe_info *
delegate_traceframe_info (struct target_ops *self)
{
@@ -1332,6 +3037,20 @@ tdefault_traceframe_info (struct target_ops *self)
tcomplain ();
}
+static struct traceframe_info *
+debug_traceframe_info (struct target_ops *self)
+{
+ struct traceframe_info * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", debug_target.to_shortname);
+ result = debug_target.to_traceframe_info (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_traceframe_info_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_use_agent (struct target_ops *self, int arg1)
{
@@ -1346,6 +3065,22 @@ tdefault_use_agent (struct target_ops *self, int arg1)
}
static int
+debug_use_agent (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", debug_target.to_shortname);
+ result = debug_target.to_use_agent (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_use_agent (struct target_ops *self)
{
self = self->beneath;
@@ -1359,6 +3094,20 @@ tdefault_can_use_agent (struct target_ops *self)
}
static int
+debug_can_use_agent (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_use_agent (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_btrace (struct target_ops *self)
{
self = self->beneath;
@@ -1371,6 +3120,20 @@ tdefault_supports_btrace (struct target_ops *self)
return 0;
}
+static int
+debug_supports_btrace (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_btrace (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct btrace_target_info *
delegate_enable_btrace (struct target_ops *self, ptid_t arg1)
{
@@ -1384,6 +3147,22 @@ tdefault_enable_btrace (struct target_ops *self, ptid_t arg1)
tcomplain ();
}
+static struct btrace_target_info *
+debug_enable_btrace (struct target_ops *self, ptid_t arg1)
+{
+ struct btrace_target_info * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname);
+ result = debug_target.to_enable_btrace (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
{
@@ -1398,6 +3177,18 @@ tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg
}
static void
+debug_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname);
+ debug_target.to_disable_btrace (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
{
self = self->beneath;
@@ -1410,6 +3201,18 @@ tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *ar
tcomplain ();
}
+static void
+debug_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname);
+ debug_target.to_teardown_btrace (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static enum btrace_error
delegate_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
{
@@ -1423,6 +3226,26 @@ tdefault_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, stru
tcomplain ();
}
+static enum btrace_error
+debug_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
+{
+ enum btrace_error result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname);
+ result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_VEC__btrace_block_s__pp (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_btrace_read_type (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_btrace_error (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_stop_recording (struct target_ops *self)
{
@@ -1436,6 +3259,16 @@ tdefault_stop_recording (struct target_ops *self)
}
static void
+debug_stop_recording (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname);
+ debug_target.to_stop_recording (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_info_record (struct target_ops *self)
{
self = self->beneath;
@@ -1448,6 +3281,16 @@ tdefault_info_record (struct target_ops *self)
}
static void
+debug_info_record (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", debug_target.to_shortname);
+ debug_target.to_info_record (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_save_record (struct target_ops *self, const char *arg1)
{
self = self->beneath;
@@ -1461,6 +3304,18 @@ tdefault_save_record (struct target_ops *self, const char *arg1)
}
static void
+debug_save_record (struct target_ops *self, const char *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname);
+ debug_target.to_save_record (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_delete_record (struct target_ops *self)
{
self = self->beneath;
@@ -1473,6 +3328,16 @@ tdefault_delete_record (struct target_ops *self)
tcomplain ();
}
+static void
+debug_delete_record (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname);
+ debug_target.to_delete_record (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_record_is_replaying (struct target_ops *self)
{
@@ -1486,6 +3351,20 @@ tdefault_record_is_replaying (struct target_ops *self)
return 0;
}
+static int
+debug_record_is_replaying (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
+ result = debug_target.to_record_is_replaying (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_goto_record_begin (struct target_ops *self)
{
@@ -1500,6 +3379,16 @@ tdefault_goto_record_begin (struct target_ops *self)
}
static void
+debug_goto_record_begin (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_record_begin (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_goto_record_end (struct target_ops *self)
{
self = self->beneath;
@@ -1513,6 +3402,16 @@ tdefault_goto_record_end (struct target_ops *self)
}
static void
+debug_goto_record_end (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_record_end (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_goto_record (struct target_ops *self, ULONGEST arg1)
{
self = self->beneath;
@@ -1526,6 +3425,18 @@ tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
}
static void
+debug_goto_record (struct target_ops *self, ULONGEST arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_record (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_insn_history (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
@@ -1539,6 +3450,20 @@ tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
}
static void
+debug_insn_history (struct target_ops *self, int arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
+ debug_target.to_insn_history (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
{
self = self->beneath;
@@ -1552,6 +3477,22 @@ tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, in
}
static void
+debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname);
+ debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
{
self = self->beneath;
@@ -1565,6 +3506,22 @@ tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST ar
}
static void
+debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname);
+ debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_call_history (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
@@ -1578,6 +3535,20 @@ tdefault_call_history (struct target_ops *self, int arg1, int arg2)
}
static void
+debug_call_history (struct target_ops *self, int arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
+ debug_target.to_call_history (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
{
self = self->beneath;
@@ -1591,6 +3562,22 @@ tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, in
}
static void
+debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname);
+ debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
{
self = self->beneath;
@@ -1603,6 +3590,22 @@ tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST ar
tcomplain ();
}
+static void
+debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname);
+ debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_augmented_libraries_svr4_read (struct target_ops *self)
{
@@ -1616,6 +3619,20 @@ tdefault_augmented_libraries_svr4_read (struct target_ops *self)
return 0;
}
+static int
+debug_augmented_libraries_svr4_read (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname);
+ result = debug_target.to_augmented_libraries_svr4_read (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static const struct frame_unwind *
delegate_get_unwinder (struct target_ops *self)
{
@@ -1630,6 +3647,20 @@ tdefault_get_unwinder (struct target_ops *self)
}
static const struct frame_unwind *
+debug_get_unwinder (struct target_ops *self)
+{
+ const struct frame_unwind * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_unwinder (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_const_struct_frame_unwind_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static const struct frame_unwind *
delegate_get_tailcall_unwinder (struct target_ops *self)
{
self = self->beneath;
@@ -1642,6 +3673,20 @@ tdefault_get_tailcall_unwinder (struct target_ops *self)
return NULL;
}
+static const struct frame_unwind *
+debug_get_tailcall_unwinder (struct target_ops *self)
+{
+ const struct frame_unwind * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_tailcall_unwinder (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_const_struct_frame_unwind_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static CORE_ADDR
delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
{
@@ -1649,6 +3694,22 @@ delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
return self->to_decr_pc_after_break (self, arg1);
}
+static CORE_ADDR
+debug_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
+{
+ CORE_ADDR result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_decr_pc_after_break (...)\n", debug_target.to_shortname);
+ result = debug_target.to_decr_pc_after_break (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_decr_pc_after_break (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_prepare_to_generate_core (struct target_ops *self)
{
@@ -1662,6 +3723,16 @@ tdefault_prepare_to_generate_core (struct target_ops *self)
}
static void
+debug_prepare_to_generate_core (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", debug_target.to_shortname);
+ debug_target.to_prepare_to_generate_core (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_done_generating_core (struct target_ops *self)
{
self = self->beneath;
@@ -1674,6 +3745,16 @@ tdefault_done_generating_core (struct target_ops *self)
}
static void
+debug_done_generating_core (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", debug_target.to_shortname);
+ debug_target.to_done_generating_core (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
install_delegators (struct target_ops *ops)
{
if (ops->to_post_attach == NULL)
@@ -2099,3 +4180,147 @@ install_dummy_methods (struct target_ops *ops)
ops->to_prepare_to_generate_core = tdefault_prepare_to_generate_core;
ops->to_done_generating_core = tdefault_done_generating_core;
}
+
+static void
+init_debug_target (struct target_ops *ops)
+{
+ ops->to_post_attach = debug_post_attach;
+ ops->to_detach = debug_detach;
+ ops->to_disconnect = debug_disconnect;
+ ops->to_resume = debug_resume;
+ ops->to_wait = debug_wait;
+ ops->to_fetch_registers = debug_fetch_registers;
+ ops->to_store_registers = debug_store_registers;
+ ops->to_prepare_to_store = debug_prepare_to_store;
+ ops->to_files_info = debug_files_info;
+ ops->to_insert_breakpoint = debug_insert_breakpoint;
+ ops->to_remove_breakpoint = debug_remove_breakpoint;
+ ops->to_can_use_hw_breakpoint = debug_can_use_hw_breakpoint;
+ ops->to_ranged_break_num_registers = debug_ranged_break_num_registers;
+ ops->to_insert_hw_breakpoint = debug_insert_hw_breakpoint;
+ ops->to_remove_hw_breakpoint = debug_remove_hw_breakpoint;
+ ops->to_remove_watchpoint = debug_remove_watchpoint;
+ ops->to_insert_watchpoint = debug_insert_watchpoint;
+ ops->to_insert_mask_watchpoint = debug_insert_mask_watchpoint;
+ ops->to_remove_mask_watchpoint = debug_remove_mask_watchpoint;
+ ops->to_stopped_by_watchpoint = debug_stopped_by_watchpoint;
+ ops->to_stopped_data_address = debug_stopped_data_address;
+ ops->to_watchpoint_addr_within_range = debug_watchpoint_addr_within_range;
+ ops->to_region_ok_for_hw_watchpoint = debug_region_ok_for_hw_watchpoint;
+ ops->to_can_accel_watchpoint_condition = debug_can_accel_watchpoint_condition;
+ ops->to_masked_watch_num_registers = debug_masked_watch_num_registers;
+ ops->to_terminal_init = debug_terminal_init;
+ ops->to_terminal_inferior = debug_terminal_inferior;
+ ops->to_terminal_ours_for_output = debug_terminal_ours_for_output;
+ ops->to_terminal_ours = debug_terminal_ours;
+ ops->to_terminal_save_ours = debug_terminal_save_ours;
+ ops->to_terminal_info = debug_terminal_info;
+ ops->to_kill = debug_kill;
+ ops->to_load = debug_load;
+ ops->to_post_startup_inferior = debug_post_startup_inferior;
+ ops->to_insert_fork_catchpoint = debug_insert_fork_catchpoint;
+ ops->to_remove_fork_catchpoint = debug_remove_fork_catchpoint;
+ ops->to_insert_vfork_catchpoint = debug_insert_vfork_catchpoint;
+ ops->to_remove_vfork_catchpoint = debug_remove_vfork_catchpoint;
+ ops->to_follow_fork = debug_follow_fork;
+ ops->to_insert_exec_catchpoint = debug_insert_exec_catchpoint;
+ ops->to_remove_exec_catchpoint = debug_remove_exec_catchpoint;
+ ops->to_set_syscall_catchpoint = debug_set_syscall_catchpoint;
+ ops->to_has_exited = debug_has_exited;
+ ops->to_mourn_inferior = debug_mourn_inferior;
+ ops->to_can_run = debug_can_run;
+ ops->to_pass_signals = debug_pass_signals;
+ ops->to_program_signals = debug_program_signals;
+ ops->to_thread_alive = debug_thread_alive;
+ ops->to_find_new_threads = debug_find_new_threads;
+ ops->to_pid_to_str = debug_pid_to_str;
+ ops->to_extra_thread_info = debug_extra_thread_info;
+ ops->to_thread_name = debug_thread_name;
+ ops->to_stop = debug_stop;
+ ops->to_rcmd = debug_rcmd;
+ ops->to_pid_to_exec_file = debug_pid_to_exec_file;
+ ops->to_log_command = debug_log_command;
+ ops->to_get_section_table = debug_get_section_table;
+ ops->to_can_async_p = debug_can_async_p;
+ ops->to_is_async_p = debug_is_async_p;
+ ops->to_async = debug_async;
+ ops->to_supports_non_stop = debug_supports_non_stop;
+ ops->to_find_memory_regions = debug_find_memory_regions;
+ ops->to_make_corefile_notes = debug_make_corefile_notes;
+ ops->to_get_bookmark = debug_get_bookmark;
+ ops->to_goto_bookmark = debug_goto_bookmark;
+ ops->to_get_thread_local_address = debug_get_thread_local_address;
+ ops->to_xfer_partial = debug_xfer_partial;
+ ops->to_memory_map = debug_memory_map;
+ ops->to_flash_erase = debug_flash_erase;
+ ops->to_flash_done = debug_flash_done;
+ ops->to_read_description = debug_read_description;
+ ops->to_get_ada_task_ptid = debug_get_ada_task_ptid;
+ ops->to_auxv_parse = debug_auxv_parse;
+ ops->to_search_memory = debug_search_memory;
+ ops->to_can_execute_reverse = debug_can_execute_reverse;
+ ops->to_execution_direction = debug_execution_direction;
+ ops->to_supports_multi_process = debug_supports_multi_process;
+ ops->to_supports_enable_disable_tracepoint = debug_supports_enable_disable_tracepoint;
+ ops->to_supports_string_tracing = debug_supports_string_tracing;
+ ops->to_supports_evaluation_of_breakpoint_conditions = debug_supports_evaluation_of_breakpoint_conditions;
+ ops->to_can_run_breakpoint_commands = debug_can_run_breakpoint_commands;
+ ops->to_thread_architecture = debug_thread_architecture;
+ ops->to_thread_address_space = debug_thread_address_space;
+ ops->to_trace_init = debug_trace_init;
+ ops->to_download_tracepoint = debug_download_tracepoint;
+ ops->to_can_download_tracepoint = debug_can_download_tracepoint;
+ ops->to_download_trace_state_variable = debug_download_trace_state_variable;
+ ops->to_enable_tracepoint = debug_enable_tracepoint;
+ ops->to_disable_tracepoint = debug_disable_tracepoint;
+ ops->to_trace_set_readonly_regions = debug_trace_set_readonly_regions;
+ ops->to_trace_start = debug_trace_start;
+ ops->to_get_trace_status = debug_get_trace_status;
+ ops->to_get_tracepoint_status = debug_get_tracepoint_status;
+ ops->to_trace_stop = debug_trace_stop;
+ ops->to_trace_find = debug_trace_find;
+ ops->to_get_trace_state_variable_value = debug_get_trace_state_variable_value;
+ ops->to_save_trace_data = debug_save_trace_data;
+ ops->to_upload_tracepoints = debug_upload_tracepoints;
+ ops->to_upload_trace_state_variables = debug_upload_trace_state_variables;
+ ops->to_get_raw_trace_data = debug_get_raw_trace_data;
+ ops->to_get_min_fast_tracepoint_insn_len = debug_get_min_fast_tracepoint_insn_len;
+ ops->to_set_disconnected_tracing = debug_set_disconnected_tracing;
+ ops->to_set_circular_trace_buffer = debug_set_circular_trace_buffer;
+ ops->to_set_trace_buffer_size = debug_set_trace_buffer_size;
+ ops->to_set_trace_notes = debug_set_trace_notes;
+ ops->to_core_of_thread = debug_core_of_thread;
+ ops->to_verify_memory = debug_verify_memory;
+ ops->to_get_tib_address = debug_get_tib_address;
+ ops->to_set_permissions = debug_set_permissions;
+ ops->to_static_tracepoint_marker_at = debug_static_tracepoint_marker_at;
+ ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid;
+ ops->to_traceframe_info = debug_traceframe_info;
+ ops->to_use_agent = debug_use_agent;
+ ops->to_can_use_agent = debug_can_use_agent;
+ ops->to_supports_btrace = debug_supports_btrace;
+ ops->to_enable_btrace = debug_enable_btrace;
+ ops->to_disable_btrace = debug_disable_btrace;
+ ops->to_teardown_btrace = debug_teardown_btrace;
+ ops->to_read_btrace = debug_read_btrace;
+ ops->to_stop_recording = debug_stop_recording;
+ ops->to_info_record = debug_info_record;
+ ops->to_save_record = debug_save_record;
+ ops->to_delete_record = debug_delete_record;
+ ops->to_record_is_replaying = debug_record_is_replaying;
+ ops->to_goto_record_begin = debug_goto_record_begin;
+ ops->to_goto_record_end = debug_goto_record_end;
+ ops->to_goto_record = debug_goto_record;
+ ops->to_insn_history = debug_insn_history;
+ ops->to_insn_history_from = debug_insn_history_from;
+ ops->to_insn_history_range = debug_insn_history_range;
+ ops->to_call_history = debug_call_history;
+ ops->to_call_history_from = debug_call_history_from;
+ ops->to_call_history_range = debug_call_history_range;
+ ops->to_augmented_libraries_svr4_read = debug_augmented_libraries_svr4_read;
+ ops->to_get_unwinder = debug_get_unwinder;
+ ops->to_get_tailcall_unwinder = debug_get_tailcall_unwinder;
+ ops->to_decr_pc_after_break = debug_decr_pc_after_break;
+ ops->to_prepare_to_generate_core = debug_prepare_to_generate_core;
+ ops->to_done_generating_core = debug_done_generating_core;
+}
diff --git a/gdb/target.c b/gdb/target.c
index 07d029a..b9310cf 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -46,6 +46,7 @@
#include "gdb/fileio.h"
#include "agent.h"
#include "auxv.h"
+#include "target-debug.h"
static void target_info (char *, int);
@@ -111,72 +112,14 @@ static enum exec_direction_kind default_execution_direction
static CORE_ADDR default_target_decr_pc_after_break (struct target_ops *ops,
struct gdbarch *gdbarch);
+static struct target_ops debug_target;
+
#include "target-delegates.c"
static void init_dummy_target (void);
-static struct target_ops debug_target;
-
static void debug_to_open (char *, int);
-static void debug_to_prepare_to_store (struct target_ops *self,
- struct regcache *);
-
-static void debug_to_files_info (struct target_ops *);
-
-static int debug_to_insert_breakpoint (struct target_ops *, struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_can_use_hw_breakpoint (struct target_ops *self,
- int, int, int);
-
-static int debug_to_insert_hw_breakpoint (struct target_ops *self,
- struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_remove_hw_breakpoint (struct target_ops *self,
- struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_insert_watchpoint (struct target_ops *self,
- CORE_ADDR, int, int,
- struct expression *);
-
-static int debug_to_remove_watchpoint (struct target_ops *self,
- CORE_ADDR, int, int,
- struct expression *);
-
-static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
-
-static int debug_to_watchpoint_addr_within_range (struct target_ops *,
- CORE_ADDR, CORE_ADDR, int);
-
-static int debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
- CORE_ADDR, int);
-
-static int debug_to_can_accel_watchpoint_condition (struct target_ops *self,
- CORE_ADDR, int, int,
- struct expression *);
-
-static void debug_to_terminal_init (struct target_ops *self);
-
-static void debug_to_terminal_inferior (struct target_ops *self);
-
-static void debug_to_terminal_ours_for_output (struct target_ops *self);
-
-static void debug_to_terminal_save_ours (struct target_ops *self);
-
-static void debug_to_terminal_ours (struct target_ops *self);
-
-static void debug_to_load (struct target_ops *self, const char *, int);
-
-static int debug_to_can_run (struct target_ops *self);
-
-static void debug_to_stop (struct target_ops *self, ptid_t);
-
/* Pointer to array of target architecture structures; the size of the
array; the current index into the array; the allocated size of the
array. */
@@ -471,9 +414,6 @@ add_deprecated_target_alias (struct target_ops *t, char *alias)
void
target_kill (void)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
-
current_target.to_kill (¤t_target);
}
@@ -921,9 +861,6 @@ done:
struct target_section_table *
target_get_section_table (struct target_ops *target)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
-
return (*target->to_get_section_table) (target);
}
@@ -1398,9 +1335,6 @@ target_memory_map (void)
int ix;
struct target_ops *t;
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
-
result = current_target.to_memory_map (¤t_target);
if (result == NULL)
return NULL;
@@ -1432,17 +1366,12 @@ target_memory_map (void)
void
target_flash_erase (ULONGEST address, LONGEST length)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
- hex_string (address), phex (length, 0));
current_target.to_flash_erase (¤t_target, address, length);
}
void
target_flash_done (void)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
current_target.to_flash_done (¤t_target);
}
@@ -2083,9 +2012,6 @@ target_detach (const char *args, int from_tty)
prepare_for_detach ();
current_target.to_detach (¤t_target, args, from_tty);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
- args, from_tty);
}
void
@@ -2096,36 +2022,13 @@ target_disconnect (const char *args, int from_tty)
disconnecting. */
remove_breakpoints ();
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
- args, from_tty);
current_target.to_disconnect (¤t_target, args, from_tty);
}
ptid_t
target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
{
- struct target_ops *t;
- ptid_t retval = (current_target.to_wait) (¤t_target, ptid,
- status, options);
-
- if (targetdebug)
- {
- char *status_string;
- char *options_string;
-
- status_string = target_waitstatus_to_string (status);
- options_string = target_options_to_string (options);
- fprintf_unfiltered (gdb_stdlog,
- "target_wait (%d, status, options={%s})"
- " = %d, %s\n",
- ptid_get_pid (ptid), options_string,
- ptid_get_pid (retval), status_string);
- xfree (status_string);
- xfree (options_string);
- }
-
- return retval;
+ return (current_target.to_wait) (¤t_target, ptid, status, options);
}
char *
@@ -2148,11 +2051,6 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal)
target_dcache_invalidate ();
current_target.to_resume (¤t_target, ptid, step, signal);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
- ptid_get_pid (ptid),
- step ? "step" : "continue",
- gdb_signal_to_name (signal));
registers_changed_ptid (ptid);
/* We only set the internal executing state here. The user/frontend
@@ -2164,42 +2062,12 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal)
void
target_pass_signals (int numsigs, unsigned char *pass_signals)
{
- if (targetdebug)
- {
- int i;
-
- fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
- numsigs);
-
- for (i = 0; i < numsigs; i++)
- if (pass_signals[i])
- fprintf_unfiltered (gdb_stdlog, " %s",
- gdb_signal_to_name (i));
-
- fprintf_unfiltered (gdb_stdlog, " })\n");
- }
-
(*current_target.to_pass_signals) (¤t_target, numsigs, pass_signals);
}
void
target_program_signals (int numsigs, unsigned char *program_signals)
{
- if (targetdebug)
- {
- int i;
-
- fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
- numsigs);
-
- for (i = 0; i < numsigs; i++)
- if (program_signals[i])
- fprintf_unfiltered (gdb_stdlog, " %s",
- gdb_signal_to_name (i));
-
- fprintf_unfiltered (gdb_stdlog, " })\n");
- }
-
(*current_target.to_program_signals) (¤t_target,
numsigs, program_signals);
}
@@ -2219,14 +2087,8 @@ default_follow_fork (struct target_ops *self, int follow_child,
int
target_follow_fork (int follow_child, int detach_fork)
{
- int retval = current_target.to_follow_fork (¤t_target,
- follow_child, detach_fork);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_follow_fork (%d, %d) = %d\n",
- follow_child, detach_fork, retval);
- return retval;
+ return current_target.to_follow_fork (¤t_target,
+ follow_child, detach_fork);
}
static void
@@ -2240,8 +2102,6 @@ void
target_mourn_inferior (void)
{
current_target.to_mourn_inferior (¤t_target);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
/* We no longer need to keep handles on any of the object files.
Make sure to release them to avoid unnecessarily locking any
@@ -2391,20 +2251,9 @@ target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp)
{
- int found;
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
- hex_string (start_addr));
-
- found = current_target.to_search_memory (¤t_target, start_addr,
- search_space_len,
- pattern, pattern_len, found_addrp);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
-
- return found;
+ return current_target.to_search_memory (¤t_target, start_addr,
+ search_space_len,
+ pattern, pattern_len, found_addrp);
}
/* Look through the currently pushed targets. If none of them will
@@ -2643,12 +2492,6 @@ target_thread_address_space (ptid_t ptid)
aspace = current_target.to_thread_address_space (¤t_target, ptid);
gdb_assert (aspace != NULL);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_thread_address_space (%s) = %d\n",
- target_pid_to_str (ptid),
- address_space_num (aspace));
-
return aspace;
}
@@ -3128,22 +2971,13 @@ target_close (struct target_ops *targ)
int
target_thread_alive (ptid_t ptid)
{
- int retval;
-
- retval = current_target.to_thread_alive (¤t_target, ptid);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
- ptid_get_pid (ptid), retval);
-
- return retval;
+ return current_target.to_thread_alive (¤t_target, ptid);
}
void
target_find_new_threads (void)
{
current_target.to_find_new_threads (¤t_target);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
}
void
@@ -3158,14 +2992,6 @@ target_stop (ptid_t ptid)
(*current_target.to_stop) (¤t_target, ptid);
}
-static void
-debug_to_post_attach (struct target_ops *self, int pid)
-{
- debug_target.to_post_attach (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
-}
-
/* Concatenate ELEM to LIST, a comma separate list, and return the
result. The LIST incoming argument is released. */
@@ -3277,13 +3103,7 @@ target_store_registers (struct regcache *regcache, int regno)
int
target_core_of_thread (ptid_t ptid)
{
- int retval = current_target.to_core_of_thread (¤t_target, ptid);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_core_of_thread (%d) = %d\n",
- ptid_get_pid (ptid), retval);
- return retval;
+ return current_target.to_core_of_thread (¤t_target, ptid);
}
int
@@ -3328,16 +3148,8 @@ default_verify_memory (struct target_ops *self,
int
target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
{
- int retval = current_target.to_verify_memory (¤t_target,
- data, memaddr, size);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_verify_memory (%s, %s) = %d\n",
- paddress (target_gdbarch (), memaddr),
- pulongest (size),
- retval);
- return retval;
+ return current_target.to_verify_memory (¤t_target,
+ data, memaddr, size);
}
/* The documentation for this function is in its prototype declaration in
@@ -3346,18 +3158,8 @@ target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
int
target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
{
- int ret;
-
- ret = current_target.to_insert_mask_watchpoint (¤t_target,
- addr, mask, rw);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "\
-target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
- core_addr_to_string (addr),
- core_addr_to_string (mask), rw, ret);
-
- return ret;
+ return current_target.to_insert_mask_watchpoint (¤t_target,
+ addr, mask, rw);
}
/* The documentation for this function is in its prototype declaration in
@@ -3366,18 +3168,8 @@ target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
int
target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
{
- int ret;
-
- ret = current_target.to_remove_mask_watchpoint (¤t_target,
- addr, mask, rw);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "\
-target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
- core_addr_to_string (addr),
- core_addr_to_string (mask), rw, ret);
-
- return ret;
+ return current_target.to_remove_mask_watchpoint (¤t_target,
+ addr, mask, rw);
}
/* The documentation for this function is in its prototype declaration
@@ -3551,14 +3343,6 @@ target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
current_target.to_call_history_range (¤t_target, begin, end, flags);
}
-static void
-debug_to_prepare_to_store (struct target_ops *self, struct regcache *regcache)
-{
- debug_target.to_prepare_to_store (&debug_target, regcache);
-
- fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
-}
-
/* See target.h. */
const struct frame_unwind *
@@ -3609,470 +3393,12 @@ target_done_generating_core (void)
}
static void
-debug_to_files_info (struct target_ops *target)
-{
- debug_target.to_files_info (target);
-
- fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
-}
-
-static int
-debug_to_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_insert_breakpoint (&debug_target, gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_insert_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_remove_breakpoint (&debug_target, gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_remove_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_can_use_hw_breakpoint (struct target_ops *self,
- int type, int cnt, int from_tty)
-{
- int retval;
-
- retval = debug_target.to_can_use_hw_breakpoint (&debug_target,
- type, cnt, from_tty);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
- (unsigned long) type,
- (unsigned long) cnt,
- (unsigned long) from_tty,
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len)
-{
- CORE_ADDR retval;
-
- retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target,
- addr, len);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
- core_addr_to_string (addr), (unsigned long) len,
- core_addr_to_string (retval));
- return retval;
-}
-
-static int
-debug_to_can_accel_watchpoint_condition (struct target_ops *self,
- CORE_ADDR addr, int len, int rw,
- struct expression *cond)
-{
- int retval;
-
- retval = debug_target.to_can_accel_watchpoint_condition (&debug_target,
- addr, len,
- rw, cond);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_can_accel_watchpoint_condition "
- "(%s, %d, %d, %s) = %ld\n",
- core_addr_to_string (addr), len, rw,
- host_address_to_string (cond), (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_stopped_by_watchpoint (struct target_ops *ops)
-{
- int retval;
-
- retval = debug_target.to_stopped_by_watchpoint (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_stopped_by_watchpoint () = %ld\n",
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
-{
- int retval;
-
- retval = debug_target.to_stopped_data_address (target, addr);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_stopped_data_address ([%s]) = %ld\n",
- core_addr_to_string (*addr),
- (unsigned long)retval);
- return retval;
-}
-
-static int
-debug_to_watchpoint_addr_within_range (struct target_ops *target,
- CORE_ADDR addr,
- CORE_ADDR start, int length)
-{
- int retval;
-
- retval = debug_target.to_watchpoint_addr_within_range (target, addr,
- start, length);
-
- fprintf_filtered (gdb_stdlog,
- "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
- core_addr_to_string (addr), core_addr_to_string (start),
- length, retval);
- return retval;
-}
-
-static int
-debug_to_insert_hw_breakpoint (struct target_ops *self,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_insert_hw_breakpoint (&debug_target,
- gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_remove_hw_breakpoint (struct target_ops *self,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_remove_hw_breakpoint (&debug_target,
- gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_insert_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
- struct expression *cond)
-{
- int retval;
-
- retval = debug_target.to_insert_watchpoint (&debug_target,
- addr, len, type, cond);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
- core_addr_to_string (addr), len, type,
- host_address_to_string (cond), (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_remove_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
- struct expression *cond)
-{
- int retval;
-
- retval = debug_target.to_remove_watchpoint (&debug_target,
- addr, len, type, cond);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
- core_addr_to_string (addr), len, type,
- host_address_to_string (cond), (unsigned long) retval);
- return retval;
-}
-
-static void
-debug_to_terminal_init (struct target_ops *self)
-{
- debug_target.to_terminal_init (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
-}
-
-static void
-debug_to_terminal_inferior (struct target_ops *self)
-{
- debug_target.to_terminal_inferior (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
-}
-
-static void
-debug_to_terminal_ours_for_output (struct target_ops *self)
-{
- debug_target.to_terminal_ours_for_output (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
-}
-
-static void
-debug_to_terminal_ours (struct target_ops *self)
-{
- debug_target.to_terminal_ours (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
-}
-
-static void
-debug_to_terminal_save_ours (struct target_ops *self)
-{
- debug_target.to_terminal_save_ours (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
-}
-
-static void
-debug_to_terminal_info (struct target_ops *self,
- const char *arg, int from_tty)
-{
- debug_target.to_terminal_info (&debug_target, arg, from_tty);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
- from_tty);
-}
-
-static void
-debug_to_load (struct target_ops *self, const char *args, int from_tty)
-{
- debug_target.to_load (&debug_target, args, from_tty);
-
- fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
-}
-
-static void
-debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid)
-{
- debug_target.to_post_startup_inferior (&debug_target, ptid);
-
- fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
- ptid_get_pid (ptid));
-}
-
-static int
-debug_to_insert_fork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_remove_fork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_insert_exec_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_remove_exec_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_has_exited (struct target_ops *self,
- int pid, int wait_status, int *exit_status)
-{
- int has_exited;
-
- has_exited = debug_target.to_has_exited (&debug_target,
- pid, wait_status, exit_status);
-
- fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
- pid, wait_status, *exit_status, has_exited);
-
- return has_exited;
-}
-
-static int
-debug_to_can_run (struct target_ops *self)
-{
- int retval;
-
- retval = debug_target.to_can_run (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
-
- return retval;
-}
-
-static struct gdbarch *
-debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
-{
- struct gdbarch *retval;
-
- retval = debug_target.to_thread_architecture (ops, ptid);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_thread_architecture (%s) = %s [%s]\n",
- target_pid_to_str (ptid),
- host_address_to_string (retval),
- gdbarch_bfd_arch_info (retval)->printable_name);
- return retval;
-}
-
-static void
-debug_to_stop (struct target_ops *self, ptid_t ptid)
-{
- debug_target.to_stop (&debug_target, ptid);
-
- fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
- target_pid_to_str (ptid));
-}
-
-static void
-debug_to_rcmd (struct target_ops *self, const char *command,
- struct ui_file *outbuf)
-{
- debug_target.to_rcmd (&debug_target, command, outbuf);
- fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
-}
-
-static char *
-debug_to_pid_to_exec_file (struct target_ops *self, int pid)
-{
- char *exec_file;
-
- exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
- pid, exec_file);
-
- return exec_file;
-}
-
-static void
setup_target_debug (void)
{
memcpy (&debug_target, ¤t_target, sizeof debug_target);
current_target.to_open = debug_to_open;
- current_target.to_post_attach = debug_to_post_attach;
- current_target.to_prepare_to_store = debug_to_prepare_to_store;
- current_target.to_files_info = debug_to_files_info;
- current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
- current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
- current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
- current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
- current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
- current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
- current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
- current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
- current_target.to_stopped_data_address = debug_to_stopped_data_address;
- current_target.to_watchpoint_addr_within_range
- = debug_to_watchpoint_addr_within_range;
- current_target.to_region_ok_for_hw_watchpoint
- = debug_to_region_ok_for_hw_watchpoint;
- current_target.to_can_accel_watchpoint_condition
- = debug_to_can_accel_watchpoint_condition;
- current_target.to_terminal_init = debug_to_terminal_init;
- current_target.to_terminal_inferior = debug_to_terminal_inferior;
- current_target.to_terminal_ours_for_output
- = debug_to_terminal_ours_for_output;
- current_target.to_terminal_ours = debug_to_terminal_ours;
- current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
- current_target.to_terminal_info = debug_to_terminal_info;
- current_target.to_load = debug_to_load;
- current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
- current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
- current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
- current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
- current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
- current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
- current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
- current_target.to_has_exited = debug_to_has_exited;
- current_target.to_can_run = debug_to_can_run;
- current_target.to_stop = debug_to_stop;
- current_target.to_rcmd = debug_to_rcmd;
- current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
- current_target.to_thread_architecture = debug_to_thread_architecture;
+ init_debug_target (¤t_target);
}
\f
diff --git a/gdb/target.h b/gdb/target.h
index 8c8ce00..92572ff 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -357,6 +357,16 @@ struct thread_info; /* fwd decl for parameter list below: */
typedef void async_callback_ftype (enum inferior_event_type event_type,
void *context);
+/* Normally target debug printing is purely type-based. However,
+ sometimes it is necessary to override the debug printing on a
+ per-argument basis. This macro can be used, attribute-style, to
+ name the target debug printing function for a particular method
+ argument. FUNC is the name of the function. The macro's
+ definition is empty because it is only used by the
+ make-target-delegates script. */
+
+#define TARGET_DEBUG_PRINTER(FUNC)
+
/* These defines are used to mark target_ops methods. The script
make-target-delegates scans these and auto-generates the base
method implementations. There are four macros that can be used:
@@ -416,10 +426,13 @@ struct target_ops
TARGET_DEFAULT_IGNORE ();
void (*to_disconnect) (struct target_ops *, const char *, int)
TARGET_DEFAULT_NORETURN (tcomplain ());
- void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal)
+ void (*to_resume) (struct target_ops *, ptid_t,
+ int TARGET_DEBUG_PRINTER (target_debug_print_step),
+ enum gdb_signal)
TARGET_DEFAULT_NORETURN (noprocess ());
ptid_t (*to_wait) (struct target_ops *,
- ptid_t, struct target_waitstatus *, int)
+ ptid_t, struct target_waitstatus *,
+ int TARGET_DEBUG_PRINTER (target_debug_print_options))
TARGET_DEFAULT_NORETURN (noprocess ());
void (*to_fetch_registers) (struct target_ops *, struct regcache *, int)
TARGET_DEFAULT_IGNORE ();
@@ -539,12 +552,14 @@ struct target_ops
/* Documentation of this routine is provided with the corresponding
target_* macro. */
- void (*to_pass_signals) (struct target_ops *, int, unsigned char *)
+ void (*to_pass_signals) (struct target_ops *, int,
+ unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals))
TARGET_DEFAULT_IGNORE ();
/* Documentation of this routine is provided with the
corresponding target_* function. */
- void (*to_program_signals) (struct target_ops *, int, unsigned char *)
+ void (*to_program_signals) (struct target_ops *, int,
+ unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals))
TARGET_DEFAULT_IGNORE ();
int (*to_thread_alive) (struct target_ops *, ptid_t ptid)
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-16 15:46 ` Tom Tromey
@ 2014-07-17 14:50 ` Pedro Alves
2014-07-17 16:12 ` Tom Tromey
2014-07-17 16:49 ` Tom Tromey
0 siblings, 2 replies; 14+ messages in thread
From: Pedro Alves @ 2014-07-17 14:50 UTC (permalink / raw)
To: Tom Tromey; +Cc: gdb-patches
On 07/16/2014 03:56 PM, Tom Tromey wrote:
> Pedro> I like the idea of this patch a lot.
> [...]
> Pedro> Did you try an __attribute__(())-like approach? Something like:
>
> Appended is a patch that works this way.
This looks great to me.
> static void
> +debug_post_attach (struct target_ops *self, int arg1)
> +{
> + fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", debug_target.to_shortname);
> + debug_target.to_post_attach (&debug_target, arg1);
> + fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", debug_target.to_shortname);
> + target_debug_print_struct_target_ops_p (&debug_target);
> + fputs_unfiltered (", ", gdb_stdlog);
> + target_debug_print_int (arg1);
> + fputs_unfiltered (")\n", gdb_stdlog);
I think it'll end up being useful to print the arguments before
the call too, but I don't think we do that today, so this way
looks fine to me.
> +static void
> +delegate_resume (struct target_ops *self, ptid_t arg1, int TARGET_DEBUG_PRINTER (target_debug_print_step) arg2, enum gdb_signal arg3)
Doesn't really matter much, but would it be trivial to strip
out the TARGET_DEBUG_PRINTER part in these generated methods?
Thanks!
I wonder about generating the target_foo() entry point methods too...
--
Pedro Alves
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-17 14:50 ` Pedro Alves
@ 2014-07-17 16:12 ` Tom Tromey
2014-07-17 16:35 ` Pedro Alves
2014-07-17 16:49 ` Tom Tromey
1 sibling, 1 reply; 14+ messages in thread
From: Tom Tromey @ 2014-07-17 16:12 UTC (permalink / raw)
To: Pedro Alves; +Cc: gdb-patches
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:
Pedro> I think it'll end up being useful to print the arguments before
Pedro> the call too, but I don't think we do that today, so this way
Pedro> looks fine to me.
Doing this means marking "out" parameters so they can be skipped.
This is why I didn't do it, but that was due to using a purely
type-based approach -- with the new machinery it ought to be a bit more
doable, provided we don't mind a ton of macros in target_ops.
>> +static void
>> +delegate_resume (struct target_ops *self, ptid_t arg1, int
>> TARGET_DEBUG_PRINTER (target_debug_print_step) arg2, enum gdb_signal
>> arg3)
Pedro> Doesn't really matter much, but would it be trivial to strip
Pedro> out the TARGET_DEBUG_PRINTER part in these generated methods?
Probably easy.
Pedro> I wonder about generating the target_foo() entry point methods too...
FWIW I hadn't thought of it. Looking a little, there seems to be a bit
less uniformity here. Some of the entry points do extra work, and some
have extra arguments (I happened to see target_get_section_table).
Of course anything's doable with either some refactoring or more macro
annotations.
I think the question I would start with is what we would expect to get
from the transform. For the delegation series I think we got a pretty
big reduction in confusion. And for this patch I think we get not just
more uniform and useful debug output, but also simpler maintenance.
One possible benefit from automating the target_* entry points is
simpler maintenance as well. However this has to be weighed against the
loss of readability that comes from having the top-level API disappear
behind a veil of macros and/or generator scripts.
Tom
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-17 16:12 ` Tom Tromey
@ 2014-07-17 16:35 ` Pedro Alves
2014-07-17 16:41 ` Tom Tromey
0 siblings, 1 reply; 14+ messages in thread
From: Pedro Alves @ 2014-07-17 16:35 UTC (permalink / raw)
To: Tom Tromey; +Cc: gdb-patches
On 07/17/2014 05:03 PM, Tom Tromey wrote:
> Pedro> I wonder about generating the target_foo() entry point methods too...
>
> FWIW I hadn't thought of it. Looking a little, there seems to be a bit
> less uniformity here. Some of the entry points do extra work, and some
> have extra arguments (I happened to see target_get_section_table).
Hmm, I think you might have looked at some other method. That one's
arguments seem to match.
But yeah, there's some missing uniformity here. E.g., target_terminal_inferior
is currently horrible for actually bypassing calling the target method
in some cases. target_detach is another case that does extra work.
> Of course anything's doable with either some refactoring or more macro
> annotations.
Yeah.
> I think the question I would start with is what we would expect to get
> from the transform. For the delegation series I think we got a pretty
> big reduction in confusion. And for this patch I think we get not just
> more uniform and useful debug output, but also simpler maintenance.
I was thinking simpler maintenance and clearer resulting code, by enforcing
the rule that the entry point does nothing more than calling the
target_ops method, to avoid surprises like target_terminal_inferior.
> One possible benefit from automating the target_* entry points is
> simpler maintenance as well. However this has to be weighed against the
> loss of readability that comes from having the top-level API disappear
> behind a veil of macros and/or generator scripts.
Definitely.
--
Pedro Alves
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-17 16:35 ` Pedro Alves
@ 2014-07-17 16:41 ` Tom Tromey
2014-07-17 16:52 ` Pedro Alves
0 siblings, 1 reply; 14+ messages in thread
From: Tom Tromey @ 2014-07-17 16:41 UTC (permalink / raw)
To: Pedro Alves; +Cc: gdb-patches
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:
>> have extra arguments (I happened to see target_get_section_table).
Pedro> Hmm, I think you might have looked at some other method. That
Pedro> one's arguments seem to match.
Sorry, I wasn't totally clear.
That particular function takes a target_ops parameter -- but generally
the target_* entry points do not.
Pedro> But yeah, there's some missing uniformity here. E.g.,
Pedro> target_terminal_inferior is currently horrible for actually
Pedro> bypassing calling the target method in some cases. target_detach
Pedro> is another case that does extra work.
Another somewhat related oddity in the current code is that some spots
bypass these entry points, or at least seem to. Search for
"current_target.beneath" outside of target.[ch] to see.
Pedro> I was thinking simpler maintenance and clearer resulting code, by
Pedro> enforcing the rule that the entry point does nothing more than
Pedro> calling the target_ops method, to avoid surprises like
Pedro> target_terminal_inferior.
Yeah, ok. Well, that makes sense, it's just unclear to me if the
cost/benefit ratio is in our favor here, given the apparent amount of
inconsistency already in-tree.
Tom
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-17 14:50 ` Pedro Alves
2014-07-17 16:12 ` Tom Tromey
@ 2014-07-17 16:49 ` Tom Tromey
2014-07-17 16:51 ` Pedro Alves
2014-07-24 13:59 ` Tom Tromey
1 sibling, 2 replies; 14+ messages in thread
From: Tom Tromey @ 2014-07-17 16:49 UTC (permalink / raw)
To: Pedro Alves; +Cc: gdb-patches
Pedro> Doesn't really matter much, but would it be trivial to strip
Pedro> out the TARGET_DEBUG_PRINTER part in these generated methods?
FWIW I did this. New patch appended.
I think I forgot to mention it yesterday but this is now based on my
earlier patch to change the make-target-delegates processing approach.
However, there's no deep reason this must be so.
Tom
2014-07-15 Tom Tromey <tromey@redhat.com>
* make-target-delegates (munge_type, write_debugmethod): New
functions.
(debug_names): New global.
($TARGET_DEBUG_PRINTER): New global.
(write_function_header): Strip TARGET_DEBUG_PRINTER from the type
name.
Write debug methods. Generate init_debug_target.
* target-debug.h: New file.
* target-delegates.c: Rebuild.
* target.c: Include target-debug.h.
(debug_target): Hoist definition.
(target_kill, target_get_section_table, target_memory_map)
(target_flash_erase, target_flash_done, target_detach)
(target_disconnect, target_wait, target_resume)
(target_pass_signals, target_program_signals, target_follow_fork)
(target_mourn_inferior, target_search_memory)
(target_thread_address_space, target_close)
(target_find_new_threads, target_core_of_thread)
(target_verify_memory, target_insert_mask_watchpoint)
(target_remove_mask_watchpoint): Remove targetdebug code.
(debug_to_post_attach, debug_to_prepare_to_store)
(debug_to_files_info, debug_to_insert_breakpoint)
(debug_to_remove_breakpoint, debug_to_can_use_hw_breakpoint)
(debug_to_region_ok_for_hw_watchpoint)
(debug_to_can_accel_watchpoint_condition)
(debug_to_stopped_by_watchpoint, debug_to_stopped_data_address)
(debug_to_watchpoint_addr_within_range)
(debug_to_insert_hw_breakpoint, debug_to_remove_hw_breakpoint)
(debug_to_insert_watchpoint, debug_to_remove_watchpoint)
(debug_to_terminal_init, debug_to_terminal_inferior)
(debug_to_terminal_ours_for_output, debug_to_terminal_ours)
(debug_to_terminal_save_ours, debug_to_terminal_info)
(debug_to_load, debug_to_post_startup_inferior)
(debug_to_insert_fork_catchpoint)
(debug_to_remove_fork_catchpoint)
(debug_to_insert_vfork_catchpoint)
(debug_to_remove_vfork_catchpoint)
(debug_to_insert_exec_catchpoint)
(debug_to_remove_exec_catchpoint, debug_to_has_exited)
(debug_to_can_run, debug_to_thread_architecture, debug_to_stop)
(debug_to_rcmd, debug_to_pid_to_exec_file): Remove.
(setup_target_debug): Call init_debug_target.
* target.h (TARGET_DEBUG_PRINTER): New macro.
(struct target_ops) <to_resume, to_wait, to_pass_signals,
to_program_signals>: Use TARGET_DEBUG_PRINTER.
diff --git a/gdb/make-target-delegates b/gdb/make-target-delegates
index 28db447..085c8bc 100755
--- a/gdb/make-target-delegates
+++ b/gdb/make-target-delegates
@@ -54,6 +54,11 @@ $METHOD = ($INTRO_PART . "(?<return_type>" . $SIMPLE_RETURN_PART
. $NAME_PART . $ARGS_PART
. $METHOD_TRAILER);
+# Match TARGET_DEBUG_PRINTER in an argument type.
+# This must match the whole "sub-expression" including the parens.
+# Reference $1 must refer to the function argument.
+$TARGET_DEBUG_PRINTER = qr,\s*TARGET_DEBUG_PRINTER\s*\(([^)]*)\)\s*,;
+
sub trim($) {
my ($result) = @_;
@@ -144,6 +149,8 @@ sub write_function_header($$@) {
foreach $iter (@argtypes) {
my $val = $iter;
+ $val =~ s/$TARGET_DEBUG_PRINTER//;
+
if ($iter !~ m,\*$,) {
$val .= ' ';
}
@@ -217,6 +224,75 @@ sub write_tdefault($$$$@) {
return tdname ($name);
}
+sub munge_type($) {
+ my ($typename) = @_;
+ my ($result);
+
+ if ($typename =~ m/$TARGET_DEBUG_PRINTER/) {
+ $result = $1;
+ } else {
+ ($result = $typename) =~ s/\s+$//;
+ $result =~ s/[ ()]/_/g;
+ $result =~ s/[*]/p/g;
+ $result = 'target_debug_print_' . $result;
+ }
+
+ return $result;
+}
+
+# Write out a debug method.
+sub write_debugmethod($$$$@) {
+ my ($content, $style, $name, $return_type, @argtypes) = @_;
+
+ my ($debugname) = $name;
+ $debugname =~ s/to_/debug_/;
+ my ($targetname) = $name;
+ $targetname =~ s/to_/target_/;
+
+ my (@names) = write_function_header ($debugname, $return_type, @argtypes);
+
+ if ($return_type ne 'void') {
+ print " $return_type result;\n";
+ }
+
+ print " fprintf_unfiltered (gdb_stdlog, \"-> %s->$name (...)\\n\", debug_target.to_shortname);\n";
+
+ # Delegate to the beneath target.
+ print " ";
+ if ($return_type ne 'void') {
+ print "result = ";
+ }
+ print "debug_target." . $name . " (";
+ my @names2 = @names;
+ @names2[0] = "&debug_target";
+ print join (', ', @names2);
+ print ");\n";
+
+ # Now print the arguments.
+ print " fprintf_unfiltered (gdb_stdlog, \"<- %s->$name (\", debug_target.to_shortname);\n";
+ for my $i (0 .. $#argtypes) {
+ print " fputs_unfiltered (\", \", gdb_stdlog);\n" if $i > 0;
+ my $printer = munge_type ($argtypes[$i]);
+ print " $printer ($names2[$i]);\n";
+ }
+ if ($return_type ne 'void') {
+ print " fputs_unfiltered (\") = \", gdb_stdlog);\n";
+ my $printer = munge_type ($return_type);
+ print " $printer (result);\n";
+ print " fputs_unfiltered (\"\\n\", gdb_stdlog);\n";
+ } else {
+ print " fputs_unfiltered (\")\\n\", gdb_stdlog);\n";
+ }
+
+ if ($return_type ne 'void') {
+ print " return result;\n";
+ }
+
+ print "}\n\n";
+
+ return $debugname;
+}
+
print "/* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */\n";
print "/* vi:set ro: */\n\n";
print "/* To regenerate this file, run:*/\n";
@@ -226,6 +302,7 @@ print "/* make-target-delegates target.h > target-delegates.c */\n";
%tdefault_names = ();
+%debug_names = ();
@delegators = ();
foreach $current_line (@lines) {
next unless $current_line =~ m/$METHOD/;
@@ -248,6 +325,10 @@ foreach $current_line (@lines) {
$tdefault_names{$name} = write_tdefault ($tdefault, $style,
$name, $return_type,
@argtypes);
+
+ $debug_names{$name} = write_debugmethod ($tdefault, $style,
+ $name, $return_type,
+ @argtypes);
}
}
@@ -266,4 +347,11 @@ print "static void\ninstall_dummy_methods (struct target_ops *ops)\n{\n";
for $iter (@delegators) {
print " ops->" . $iter . " = " . $tdefault_names{$iter} . ";\n";
}
+print "}\n\n";
+
+# The debug method code.
+print "static void\ninit_debug_target (struct target_ops *ops)\n{\n";
+for $iter (@delegators) {
+ print " ops->" . $iter . " = " . $debug_names{$iter} . ";\n";
+}
print "}\n";
diff --git a/gdb/target-debug.h b/gdb/target-debug.h
new file mode 100644
index 0000000..3dd705c
--- /dev/null
+++ b/gdb/target-debug.h
@@ -0,0 +1,188 @@
+/* GDB target debugging macros
+
+ Copyright (C) 2014 Free Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef TARGET_DEBUG_H
+#define TARGET_DEBUG_H
+
+/* Printers for the debug target. Each prints an object of a given
+ type to a string that needn't be freed. Most printers are macros,
+ for brevity, but a few are static functions where more complicated
+ behavior is needed.
+
+ References to these printers are automatically generated by
+ make-target-delegates. See the generated file target-delegates.c.
+
+ In a couple cases, a special printing function is defined and then
+ used via the TARGET_DEBUG_PRINTER macro. See target.h.
+
+ A few methods still have some explicit targetdebug code in
+ target.c. In most cases this is because target delegation hasn't
+ been done for the method; but individual cases vary. For instance,
+ target_store_registers does some special register printing that is
+ more simply done there, and target_xfer_partial additionally
+ bypasses the debug target. */
+
+
+/* Helper macro. */
+
+#define target_debug_do_print(E) \
+ fputs_unfiltered ((E), gdb_stdlog);
+
+#define target_debug_print_struct_target_ops_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_enum_target_object(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_CORE_ADDR(X) \
+ target_debug_do_print (core_addr_to_string (X))
+#define target_debug_print_const_char_p(X) \
+ target_debug_do_print (((X) ? (X) : "(null)"))
+#define target_debug_print_char_p(X) \
+ target_debug_do_print (((X) ? (X) : "(null)"))
+#define target_debug_print_int(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_long(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_target_xfer_status(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_exec_direction_kind(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_trace_find_type(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_btrace_read_type(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_enum_btrace_error(X) \
+ target_debug_do_print (plongest (X))
+#define target_debug_print_ptid_t(X) \
+ target_debug_do_print (plongest (ptid_get_pid (X)))
+#define target_debug_print_struct_gdbarch_p(X) \
+ target_debug_do_print (gdbarch_bfd_arch_info (X)->printable_name)
+#define target_debug_print_const_gdb_byte_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_gdb_byte_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_gdb_byte_pp(X) \
+ target_debug_do_print (host_address_to_string (*(X)))
+#define target_debug_print_enum_gdb_signal(X) \
+ target_debug_do_print (gdb_signal_to_name (X))
+#define target_debug_print_ULONGEST(X) \
+ target_debug_do_print (hex_string (X))
+#define target_debug_print_ULONGEST_p(X) \
+ target_debug_do_print (hex_string (*(X)))
+#define target_debug_print_LONGEST(X) \
+ target_debug_do_print (phex (X, 0))
+#define target_debug_print_LONGEST_p(X) \
+ target_debug_do_print (phex (*(X), 0))
+#define target_debug_print_struct_address_space_p(X) \
+ target_debug_do_print (plongest (address_space_num (X)))
+#define target_debug_print_struct_bp_target_info_p(X) \
+ target_debug_do_print (core_addr_to_string ((X)->placed_address))
+#define target_debug_print_struct_expression_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_CORE_ADDR_p(X) \
+ target_debug_do_print (core_addr_to_string (*(X)))
+#define target_debug_print_int_p(X) \
+ target_debug_do_print (plongest (*(X)))
+#define target_debug_print_struct_regcache_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_thread_info_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_ui_file_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_target_section_table_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_async_callback_ftype_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_void_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_find_memory_region_ftype(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_bfd_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC_mem_region_s__p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC_static_tracepoint_marker_p__p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_const_struct_target_desc_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_bp_location_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_trace_state_variable_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_trace_status_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_breakpoint_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tp_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tp_pp(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_uploaded_tsv_pp(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_static_tracepoint_marker_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_traceframe_info_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_struct_btrace_target_info_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_VEC__btrace_block_s__pp(X) \
+ target_debug_do_print (host_address_to_string (X))
+#define target_debug_print_const_struct_frame_unwind_p(X) \
+ target_debug_do_print (host_address_to_string (X))
+
+static void
+target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
+{
+ char *str = target_waitstatus_to_string (status);
+
+ fputs_unfiltered (str, gdb_stdlog);
+ xfree (str);
+}
+
+\f
+
+/* Macros or functions that are used via TARGET_DEBUG_PRINTER. */
+
+#define target_debug_print_step(X) \
+ target_debug_do_print ((X) ? "step" : "continue")
+
+static void
+target_debug_print_options (int options)
+{
+ char *str = target_options_to_string (options);
+
+ fputs_unfiltered (str, gdb_stdlog);
+ xfree (str);
+}
+
+static void
+target_debug_print_signals (unsigned char *sigs)
+{
+ fputs_unfiltered ("{", gdb_stdlog);
+ if (sigs != NULL)
+ {
+ int i;
+
+ for (i = 0; i < GDB_SIGNAL_LAST; i++)
+ if (sigs[i])
+ fprintf_unfiltered (gdb_stdlog, " %s", gdb_signal_to_name (i));
+ }
+ fputs_unfiltered (" }", gdb_stdlog);
+}
+
+#endif /* TARGET_DEBUG_H */
diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c
index 8c81672..9171e79 100644
--- a/gdb/target-delegates.c
+++ b/gdb/target-delegates.c
@@ -3,6 +3,7 @@
/* To regenerate this file, run:*/
/* make-target-delegates target.h > target-delegates.c */
+#define TARGET_DEBUG_PRINTER(FUNC)
static void
delegate_post_attach (struct target_ops *self, int arg1)
{
@@ -16,6 +17,18 @@ tdefault_post_attach (struct target_ops *self, int arg1)
}
static void
+debug_post_attach (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", debug_target.to_shortname);
+ debug_target.to_post_attach (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_detach (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -28,6 +41,20 @@ tdefault_detach (struct target_ops *self, const char *arg1, int arg2)
}
static void
+debug_detach (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", debug_target.to_shortname);
+ debug_target.to_detach (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_disconnect (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -41,6 +68,20 @@ tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
}
static void
+debug_disconnect (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", debug_target.to_shortname);
+ debug_target.to_disconnect (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
{
self = self->beneath;
@@ -53,6 +94,22 @@ tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal
noprocess ();
}
+static void
+debug_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", debug_target.to_shortname);
+ debug_target.to_resume (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_step (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_gdb_signal (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static ptid_t
delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
{
@@ -66,6 +123,26 @@ tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *a
noprocess ();
}
+static ptid_t
+debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
+{
+ ptid_t result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", debug_target.to_shortname);
+ result = debug_target.to_wait (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_target_waitstatus_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_options (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_ptid_t (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
@@ -79,6 +156,20 @@ tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int ar
}
static void
+debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname);
+ debug_target.to_fetch_registers (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_regcache_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
{
self = self->beneath;
@@ -92,6 +183,20 @@ tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int ar
}
static void
+debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
+ debug_target.to_store_registers (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_regcache_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
{
self = self->beneath;
@@ -105,6 +210,18 @@ tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
}
static void
+debug_prepare_to_store (struct target_ops *self, struct regcache *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", debug_target.to_shortname);
+ debug_target.to_prepare_to_store (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_regcache_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_files_info (struct target_ops *self)
{
self = self->beneath;
@@ -116,6 +233,16 @@ tdefault_files_info (struct target_ops *self)
{
}
+static void
+debug_files_info (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_files_info (...)\n", debug_target.to_shortname);
+ debug_target.to_files_info (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_files_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
@@ -124,6 +251,24 @@ delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struc
}
static int
+debug_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
@@ -131,6 +276,24 @@ delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struc
}
static int
+debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
{
self = self->beneath;
@@ -144,6 +307,26 @@ tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int
}
static int
+debug_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_use_hw_breakpoint (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_ranged_break_num_registers (struct target_ops *self)
{
self = self->beneath;
@@ -157,6 +340,20 @@ tdefault_ranged_break_num_registers (struct target_ops *self)
}
static int
+debug_ranged_break_num_registers (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_ranged_break_num_registers (...)\n", debug_target.to_shortname);
+ result = debug_target.to_ranged_break_num_registers (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_ranged_break_num_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
@@ -170,6 +367,24 @@ tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, st
}
static int
+debug_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_hw_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_hw_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_hw_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
{
self = self->beneath;
@@ -183,6 +398,24 @@ tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, st
}
static int
+debug_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_hw_breakpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_hw_breakpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_hw_breakpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_target_info_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
@@ -196,6 +429,28 @@ tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, i
}
static int
+debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_expression_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
@@ -209,6 +464,28 @@ tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, i
}
static int
+debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_expression_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
@@ -222,6 +499,26 @@ tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_A
}
static int
+debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_mask_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_mask_watchpoint (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_mask_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
@@ -235,6 +532,26 @@ tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_A
}
static int
+debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_mask_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_mask_watchpoint (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_mask_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_stopped_by_watchpoint (struct target_ops *self)
{
self = self->beneath;
@@ -248,6 +565,20 @@ tdefault_stopped_by_watchpoint (struct target_ops *self)
}
static int
+debug_stopped_by_watchpoint (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_stopped_by_watchpoint (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
{
self = self->beneath;
@@ -261,6 +592,22 @@ tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
}
static int
+debug_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_data_address (...)\n", debug_target.to_shortname);
+ result = debug_target.to_stopped_data_address (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_data_address (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
{
self = self->beneath;
@@ -268,6 +615,26 @@ delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1,
}
static int
+debug_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_watchpoint_addr_within_range (...)\n", debug_target.to_shortname);
+ result = debug_target.to_watchpoint_addr_within_range (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_watchpoint_addr_within_range (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
{
self = self->beneath;
@@ -275,6 +642,24 @@ delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, i
}
static int
+debug_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_region_ok_for_hw_watchpoint (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_region_ok_for_hw_watchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
{
self = self->beneath;
@@ -288,6 +673,28 @@ tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1
}
static int
+debug_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_accel_watchpoint_condition (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_accel_watchpoint_condition (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_accel_watchpoint_condition (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_expression_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
{
self = self->beneath;
@@ -300,6 +707,24 @@ tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CO
return -1;
}
+static int
+debug_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_masked_watch_num_registers (...)\n", debug_target.to_shortname);
+ result = debug_target.to_masked_watch_num_registers (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_masked_watch_num_registers (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_terminal_init (struct target_ops *self)
{
@@ -313,6 +738,16 @@ tdefault_terminal_init (struct target_ops *self)
}
static void
+debug_terminal_init (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_init (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_init (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_init (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_inferior (struct target_ops *self)
{
self = self->beneath;
@@ -325,6 +760,16 @@ tdefault_terminal_inferior (struct target_ops *self)
}
static void
+debug_terminal_inferior (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_inferior (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_ours_for_output (struct target_ops *self)
{
self = self->beneath;
@@ -337,6 +782,16 @@ tdefault_terminal_ours_for_output (struct target_ops *self)
}
static void
+debug_terminal_ours_for_output (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours_for_output (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_ours_for_output (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours_for_output (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_ours (struct target_ops *self)
{
self = self->beneath;
@@ -349,6 +804,16 @@ tdefault_terminal_ours (struct target_ops *self)
}
static void
+debug_terminal_ours (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_ours (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_save_ours (struct target_ops *self)
{
self = self->beneath;
@@ -361,6 +826,16 @@ tdefault_terminal_save_ours (struct target_ops *self)
}
static void
+debug_terminal_save_ours (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_save_ours (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_save_ours (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_save_ours (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -368,6 +843,20 @@ delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
}
static void
+debug_terminal_info (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_info (...)\n", debug_target.to_shortname);
+ debug_target.to_terminal_info (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_kill (struct target_ops *self)
{
self = self->beneath;
@@ -381,6 +870,16 @@ tdefault_kill (struct target_ops *self)
}
static void
+debug_kill (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_kill (...)\n", debug_target.to_shortname);
+ debug_target.to_kill (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_kill (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_load (struct target_ops *self, const char *arg1, int arg2)
{
self = self->beneath;
@@ -394,6 +893,20 @@ tdefault_load (struct target_ops *self, const char *arg1, int arg2)
}
static void
+debug_load (struct target_ops *self, const char *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_load (...)\n", debug_target.to_shortname);
+ debug_target.to_load (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_load (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
@@ -405,6 +918,18 @@ tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
{
}
+static void
+debug_post_startup_inferior (struct target_ops *self, ptid_t arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_startup_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_post_startup_inferior (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_startup_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_insert_fork_catchpoint (struct target_ops *self, int arg1)
{
@@ -419,6 +944,22 @@ tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_insert_fork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_fork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_fork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_fork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_fork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -432,6 +973,22 @@ tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_remove_fork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_fork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_fork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_fork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -445,6 +1002,22 @@ tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_insert_vfork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_vfork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_vfork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_vfork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -458,6 +1031,22 @@ tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_remove_vfork_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_vfork_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_vfork_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_vfork_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
@@ -465,6 +1054,24 @@ delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
}
static int
+debug_follow_fork (struct target_ops *self, int arg1, int arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_fork (...)\n", debug_target.to_shortname);
+ result = debug_target.to_follow_fork (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_fork (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_insert_exec_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -478,6 +1085,22 @@ tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_insert_exec_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_exec_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_insert_exec_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_exec_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_remove_exec_catchpoint (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -491,6 +1114,22 @@ tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
}
static int
+debug_remove_exec_catchpoint (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_exec_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_remove_exec_catchpoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_exec_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
{
self = self->beneath;
@@ -504,6 +1143,30 @@ tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, in
}
static int
+debug_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg5);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
{
self = self->beneath;
@@ -516,6 +1179,26 @@ tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
return 0;
}
+static int
+debug_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_has_exited (...)\n", debug_target.to_shortname);
+ result = debug_target.to_has_exited (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_has_exited (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_mourn_inferior (struct target_ops *self)
{
@@ -523,6 +1206,16 @@ delegate_mourn_inferior (struct target_ops *self)
self->to_mourn_inferior (self);
}
+static void
+debug_mourn_inferior (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_mourn_inferior (...)\n", debug_target.to_shortname);
+ debug_target.to_mourn_inferior (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_mourn_inferior (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_can_run (struct target_ops *self)
{
@@ -536,28 +1229,70 @@ tdefault_can_run (struct target_ops *self)
return 0;
}
+static int
+debug_can_run (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_run (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
-delegate_pass_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+delegate_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
self = self->beneath;
self->to_pass_signals (self, arg1, arg2);
}
static void
-tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
+{
+}
+
+static void
+debug_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", debug_target.to_shortname);
+ debug_target.to_pass_signals (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_signals (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
}
static void
-delegate_program_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+delegate_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
self = self->beneath;
self->to_program_signals (self, arg1, arg2);
}
static void
-tdefault_program_signals (struct target_ops *self, int arg1, unsigned char *arg2)
+tdefault_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
+{
+}
+
+static void
+debug_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", debug_target.to_shortname);
+ debug_target.to_program_signals (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_signals (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
}
static int
@@ -573,6 +1308,22 @@ tdefault_thread_alive (struct target_ops *self, ptid_t arg1)
return 0;
}
+static int
+debug_thread_alive (struct target_ops *self, ptid_t arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_alive (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_alive (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_alive (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_find_new_threads (struct target_ops *self)
{
@@ -585,6 +1336,16 @@ tdefault_find_new_threads (struct target_ops *self)
{
}
+static void
+debug_find_new_threads (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_new_threads (...)\n", debug_target.to_shortname);
+ debug_target.to_find_new_threads (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_new_threads (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static char *
delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
{
@@ -593,6 +1354,22 @@ delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
}
static char *
+debug_pid_to_str (struct target_ops *self, ptid_t arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_str (...)\n", debug_target.to_shortname);
+ result = debug_target.to_pid_to_str (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_str (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static char *
delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
{
self = self->beneath;
@@ -606,6 +1383,22 @@ tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
}
static char *
+debug_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_extra_thread_info (...)\n", debug_target.to_shortname);
+ result = debug_target.to_extra_thread_info (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_extra_thread_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_thread_info_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static char *
delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
{
self = self->beneath;
@@ -618,6 +1411,22 @@ tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
return NULL;
}
+static char *
+debug_thread_name (struct target_ops *self, struct thread_info *arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_name (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_name (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_name (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_thread_info_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_stop (struct target_ops *self, ptid_t arg1)
{
@@ -631,12 +1440,38 @@ tdefault_stop (struct target_ops *self, ptid_t arg1)
}
static void
+debug_stop (struct target_ops *self, ptid_t arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop (...)\n", debug_target.to_shortname);
+ debug_target.to_stop (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
{
self = self->beneath;
self->to_rcmd (self, arg1, arg2);
}
+static void
+debug_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_rcmd (...)\n", debug_target.to_shortname);
+ debug_target.to_rcmd (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_rcmd (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_ui_file_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static char *
delegate_pid_to_exec_file (struct target_ops *self, int arg1)
{
@@ -650,6 +1485,22 @@ tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
return NULL;
}
+static char *
+debug_pid_to_exec_file (struct target_ops *self, int arg1)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_exec_file (...)\n", debug_target.to_shortname);
+ result = debug_target.to_pid_to_exec_file (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_exec_file (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_log_command (struct target_ops *self, const char *arg1)
{
@@ -662,6 +1513,18 @@ tdefault_log_command (struct target_ops *self, const char *arg1)
{
}
+static void
+debug_log_command (struct target_ops *self, const char *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_log_command (...)\n", debug_target.to_shortname);
+ debug_target.to_log_command (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_log_command (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static struct target_section_table *
delegate_get_section_table (struct target_ops *self)
{
@@ -675,6 +1538,20 @@ tdefault_get_section_table (struct target_ops *self)
return NULL;
}
+static struct target_section_table *
+debug_get_section_table (struct target_ops *self)
+{
+ struct target_section_table * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_section_table (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_section_table (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_section_table (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_target_section_table_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_can_async_p (struct target_ops *self)
{
@@ -689,6 +1566,20 @@ tdefault_can_async_p (struct target_ops *self)
}
static int
+debug_can_async_p (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_async_p (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_async_p (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_async_p (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_is_async_p (struct target_ops *self)
{
self = self->beneath;
@@ -701,6 +1592,20 @@ tdefault_is_async_p (struct target_ops *self)
return 0;
}
+static int
+debug_is_async_p (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_is_async_p (...)\n", debug_target.to_shortname);
+ result = debug_target.to_is_async_p (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_is_async_p (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
{
@@ -714,6 +1619,20 @@ tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
tcomplain ();
}
+static void
+debug_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname);
+ debug_target.to_async (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_async_callback_ftype_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_void_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_supports_non_stop (struct target_ops *self)
{
@@ -728,12 +1647,44 @@ tdefault_supports_non_stop (struct target_ops *self)
}
static int
+debug_supports_non_stop (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_non_stop (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
{
self = self->beneath;
return self->to_find_memory_regions (self, arg1, arg2);
}
+static int
+debug_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", debug_target.to_shortname);
+ result = debug_target.to_find_memory_regions (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_find_memory_region_ftype (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_void_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static char *
delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
{
@@ -741,6 +1692,24 @@ delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
return self->to_make_corefile_notes (self, arg1, arg2);
}
+static char *
+debug_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
+{
+ char * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", debug_target.to_shortname);
+ result = debug_target.to_make_corefile_notes (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_bfd_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_char_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static gdb_byte *
delegate_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
{
@@ -754,6 +1723,24 @@ tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
tcomplain ();
}
+static gdb_byte *
+debug_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
+{
+ gdb_byte * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_bookmark (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
{
@@ -767,6 +1754,20 @@ tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
tcomplain ();
}
+static void
+debug_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_bookmark (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static CORE_ADDR
delegate_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
{
@@ -780,6 +1781,26 @@ tdefault_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_AD
generic_tls_error ();
}
+static CORE_ADDR
+debug_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
+{
+ CORE_ADDR result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_thread_local_address (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_thread_local_address (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_thread_local_address (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static enum target_xfer_status
delegate_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
{
@@ -793,6 +1814,34 @@ tdefault_xfer_partial (struct target_ops *self, enum target_object arg1, const c
return TARGET_XFER_E_IO;
}
+static enum target_xfer_status
+debug_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
+{
+ enum target_xfer_status result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", debug_target.to_shortname);
+ result = debug_target.to_xfer_partial (&debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_target_object (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg5);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg6);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST_p (arg7);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_target_xfer_status (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static VEC(mem_region_s) *
delegate_memory_map (struct target_ops *self)
{
@@ -806,6 +1855,20 @@ tdefault_memory_map (struct target_ops *self)
return NULL;
}
+static VEC(mem_region_s) *
+debug_memory_map (struct target_ops *self)
+{
+ VEC(mem_region_s) * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", debug_target.to_shortname);
+ result = debug_target.to_memory_map (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_VEC_mem_region_s__p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
{
@@ -820,6 +1883,20 @@ tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
}
static void
+debug_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", debug_target.to_shortname);
+ debug_target.to_flash_erase (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_flash_done (struct target_ops *self)
{
self = self->beneath;
@@ -832,6 +1909,16 @@ tdefault_flash_done (struct target_ops *self)
tcomplain ();
}
+static void
+debug_flash_done (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", debug_target.to_shortname);
+ debug_target.to_flash_done (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static const struct target_desc *
delegate_read_description (struct target_ops *self)
{
@@ -845,6 +1932,20 @@ tdefault_read_description (struct target_ops *self)
return NULL;
}
+static const struct target_desc *
+debug_read_description (struct target_ops *self)
+{
+ const struct target_desc * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", debug_target.to_shortname);
+ result = debug_target.to_read_description (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_const_struct_target_desc_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static ptid_t
delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
{
@@ -852,6 +1953,24 @@ delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
return self->to_get_ada_task_ptid (self, arg1, arg2);
}
+static ptid_t
+debug_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
+{
+ ptid_t result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_ada_task_ptid (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_long (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_long (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_ptid_t (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
{
@@ -860,6 +1979,28 @@ delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, C
}
static int
+debug_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", debug_target.to_shortname);
+ result = debug_target.to_auxv_parse (&debug_target, arg1, arg2, arg3, arg4);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_pp (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg4);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
{
self = self->beneath;
@@ -867,6 +2008,30 @@ delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2,
}
static int
+debug_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", debug_target.to_shortname);
+ result = debug_target.to_search_memory (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg5);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_execute_reverse (struct target_ops *self)
{
self = self->beneath;
@@ -879,6 +2044,20 @@ tdefault_can_execute_reverse (struct target_ops *self)
return 0;
}
+static int
+debug_can_execute_reverse (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_execute_reverse (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static enum exec_direction_kind
delegate_execution_direction (struct target_ops *self)
{
@@ -886,6 +2065,20 @@ delegate_execution_direction (struct target_ops *self)
return self->to_execution_direction (self);
}
+static enum exec_direction_kind
+debug_execution_direction (struct target_ops *self)
+{
+ enum exec_direction_kind result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", debug_target.to_shortname);
+ result = debug_target.to_execution_direction (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_exec_direction_kind (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_supports_multi_process (struct target_ops *self)
{
@@ -900,6 +2093,20 @@ tdefault_supports_multi_process (struct target_ops *self)
}
static int
+debug_supports_multi_process (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_multi_process (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_enable_disable_tracepoint (struct target_ops *self)
{
self = self->beneath;
@@ -913,6 +2120,20 @@ tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
}
static int
+debug_supports_enable_disable_tracepoint (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_enable_disable_tracepoint (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_string_tracing (struct target_ops *self)
{
self = self->beneath;
@@ -926,6 +2147,20 @@ tdefault_supports_string_tracing (struct target_ops *self)
}
static int
+debug_supports_string_tracing (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_string_tracing (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
{
self = self->beneath;
@@ -939,6 +2174,20 @@ tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
}
static int
+debug_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_evaluation_of_breakpoint_conditions (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_run_breakpoint_commands (struct target_ops *self)
{
self = self->beneath;
@@ -951,6 +2200,20 @@ tdefault_can_run_breakpoint_commands (struct target_ops *self)
return 0;
}
+static int
+debug_can_run_breakpoint_commands (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_run_breakpoint_commands (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct gdbarch *
delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
{
@@ -958,6 +2221,22 @@ delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
return self->to_thread_architecture (self, arg1);
}
+static struct gdbarch *
+debug_thread_architecture (struct target_ops *self, ptid_t arg1)
+{
+ struct gdbarch * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_architecture (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct address_space *
delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
{
@@ -965,6 +2244,22 @@ delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
return self->to_thread_address_space (self, arg1);
}
+static struct address_space *
+debug_thread_address_space (struct target_ops *self, ptid_t arg1)
+{
+ struct address_space * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", debug_target.to_shortname);
+ result = debug_target.to_thread_address_space (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_address_space_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_trace_init (struct target_ops *self)
{
@@ -979,6 +2274,16 @@ tdefault_trace_init (struct target_ops *self)
}
static void
+debug_trace_init (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_init (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
@@ -991,6 +2296,18 @@ tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
tcomplain ();
}
+static void
+debug_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", debug_target.to_shortname);
+ debug_target.to_download_tracepoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_location_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_can_download_tracepoint (struct target_ops *self)
{
@@ -1004,6 +2321,20 @@ tdefault_can_download_tracepoint (struct target_ops *self)
return 0;
}
+static int
+debug_can_download_tracepoint (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_download_tracepoint (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
{
@@ -1018,6 +2349,18 @@ tdefault_download_trace_state_variable (struct target_ops *self, struct trace_st
}
static void
+debug_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", debug_target.to_shortname);
+ debug_target.to_download_trace_state_variable (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_trace_state_variable_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
@@ -1031,6 +2374,18 @@ tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
}
static void
+debug_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", debug_target.to_shortname);
+ debug_target.to_enable_tracepoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_location_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
{
self = self->beneath;
@@ -1044,6 +2399,18 @@ tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
}
static void
+debug_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", debug_target.to_shortname);
+ debug_target.to_disable_tracepoint (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_bp_location_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_trace_set_readonly_regions (struct target_ops *self)
{
self = self->beneath;
@@ -1057,6 +2424,16 @@ tdefault_trace_set_readonly_regions (struct target_ops *self)
}
static void
+debug_trace_set_readonly_regions (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_set_readonly_regions (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_trace_start (struct target_ops *self)
{
self = self->beneath;
@@ -1069,6 +2446,16 @@ tdefault_trace_start (struct target_ops *self)
tcomplain ();
}
+static void
+debug_trace_start (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_start (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
{
@@ -1082,6 +2469,22 @@ tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
return -1;
}
+static int
+debug_get_trace_status (struct target_ops *self, struct trace_status *arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_trace_status (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_trace_status_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
{
@@ -1096,6 +2499,20 @@ tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1
}
static void
+debug_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", debug_target.to_shortname);
+ debug_target.to_get_tracepoint_status (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_breakpoint_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_uploaded_tp_p (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_trace_stop (struct target_ops *self)
{
self = self->beneath;
@@ -1108,6 +2525,16 @@ tdefault_trace_stop (struct target_ops *self)
tcomplain ();
}
+static void
+debug_trace_stop (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", debug_target.to_shortname);
+ debug_target.to_trace_stop (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
{
@@ -1122,6 +2549,30 @@ tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg
}
static int
+debug_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", debug_target.to_shortname);
+ result = debug_target.to_trace_find (&debug_target, arg1, arg2, arg3, arg4, arg5);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_trace_find_type (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg3);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg4);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int_p (arg5);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
{
self = self->beneath;
@@ -1135,6 +2586,24 @@ tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONG
}
static int
+debug_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_trace_state_variable_value (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_save_trace_data (struct target_ops *self, const char *arg1)
{
self = self->beneath;
@@ -1148,6 +2617,22 @@ tdefault_save_trace_data (struct target_ops *self, const char *arg1)
}
static int
+debug_save_trace_data (struct target_ops *self, const char *arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", debug_target.to_shortname);
+ result = debug_target.to_save_trace_data (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
{
self = self->beneath;
@@ -1161,6 +2646,22 @@ tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
}
static int
+debug_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", debug_target.to_shortname);
+ result = debug_target.to_upload_tracepoints (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_uploaded_tp_pp (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
{
self = self->beneath;
@@ -1173,6 +2674,22 @@ tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_
return 0;
}
+static int
+debug_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", debug_target.to_shortname);
+ result = debug_target.to_upload_trace_state_variables (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_uploaded_tsv_pp (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static LONGEST
delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
{
@@ -1186,6 +2703,26 @@ tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST a
tcomplain ();
}
+static LONGEST
+debug_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
+{
+ LONGEST result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_raw_trace_data (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_LONGEST (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
{
@@ -1199,6 +2736,20 @@ tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
return -1;
}
+static int
+debug_get_min_fast_tracepoint_insn_len (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_min_fast_tracepoint_insn_len (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
{
@@ -1212,6 +2763,18 @@ tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
}
static void
+debug_set_disconnected_tracing (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", debug_target.to_shortname);
+ debug_target.to_set_disconnected_tracing (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
{
self = self->beneath;
@@ -1224,6 +2787,18 @@ tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
}
static void
+debug_set_circular_trace_buffer (struct target_ops *self, int arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", debug_target.to_shortname);
+ debug_target.to_set_circular_trace_buffer (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
{
self = self->beneath;
@@ -1235,6 +2810,18 @@ tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
{
}
+static void
+debug_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", debug_target.to_shortname);
+ debug_target.to_set_trace_buffer_size (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_LONGEST (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
{
@@ -1249,6 +2836,26 @@ tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char
}
static int
+debug_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", debug_target.to_shortname);
+ result = debug_target.to_set_trace_notes (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
{
self = self->beneath;
@@ -1262,6 +2869,22 @@ tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
}
static int
+debug_core_of_thread (struct target_ops *self, ptid_t arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", debug_target.to_shortname);
+ result = debug_target.to_core_of_thread (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
{
self = self->beneath;
@@ -1269,6 +2892,26 @@ delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR
}
static int
+debug_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", debug_target.to_shortname);
+ result = debug_target.to_verify_memory (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_gdb_byte_p (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
{
self = self->beneath;
@@ -1281,6 +2924,24 @@ tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
tcomplain ();
}
+static int
+debug_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_tib_address (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_address (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_set_permissions (struct target_ops *self)
{
@@ -1293,6 +2954,16 @@ tdefault_set_permissions (struct target_ops *self)
{
}
+static void
+debug_set_permissions (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", debug_target.to_shortname);
+ debug_target.to_set_permissions (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
{
@@ -1306,6 +2977,24 @@ tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, s
return 0;
}
+static int
+debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", debug_target.to_shortname);
+ result = debug_target.to_static_tracepoint_marker_at (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_static_tracepoint_marker_p (arg2);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static VEC(static_tracepoint_marker_p) *
delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
{
@@ -1319,6 +3008,22 @@ tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char
tcomplain ();
}
+static VEC(static_tracepoint_marker_p) *
+debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
+{
+ VEC(static_tracepoint_marker_p) * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", debug_target.to_shortname);
+ result = debug_target.to_static_tracepoint_markers_by_strid (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_VEC_static_tracepoint_marker_p__p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct traceframe_info *
delegate_traceframe_info (struct target_ops *self)
{
@@ -1332,6 +3037,20 @@ tdefault_traceframe_info (struct target_ops *self)
tcomplain ();
}
+static struct traceframe_info *
+debug_traceframe_info (struct target_ops *self)
+{
+ struct traceframe_info * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", debug_target.to_shortname);
+ result = debug_target.to_traceframe_info (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_traceframe_info_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static int
delegate_use_agent (struct target_ops *self, int arg1)
{
@@ -1346,6 +3065,22 @@ tdefault_use_agent (struct target_ops *self, int arg1)
}
static int
+debug_use_agent (struct target_ops *self, int arg1)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", debug_target.to_shortname);
+ result = debug_target.to_use_agent (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_can_use_agent (struct target_ops *self)
{
self = self->beneath;
@@ -1359,6 +3094,20 @@ tdefault_can_use_agent (struct target_ops *self)
}
static int
+debug_can_use_agent (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", debug_target.to_shortname);
+ result = debug_target.to_can_use_agent (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static int
delegate_supports_btrace (struct target_ops *self)
{
self = self->beneath;
@@ -1371,6 +3120,20 @@ tdefault_supports_btrace (struct target_ops *self)
return 0;
}
+static int
+debug_supports_btrace (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
+ result = debug_target.to_supports_btrace (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static struct btrace_target_info *
delegate_enable_btrace (struct target_ops *self, ptid_t arg1)
{
@@ -1384,6 +3147,22 @@ tdefault_enable_btrace (struct target_ops *self, ptid_t arg1)
tcomplain ();
}
+static struct btrace_target_info *
+debug_enable_btrace (struct target_ops *self, ptid_t arg1)
+{
+ struct btrace_target_info * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname);
+ result = debug_target.to_enable_btrace (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ptid_t (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
{
@@ -1398,6 +3177,18 @@ tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg
}
static void
+debug_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname);
+ debug_target.to_disable_btrace (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
{
self = self->beneath;
@@ -1410,6 +3201,18 @@ tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *ar
tcomplain ();
}
+static void
+debug_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname);
+ debug_target.to_teardown_btrace (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static enum btrace_error
delegate_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
{
@@ -1423,6 +3226,26 @@ tdefault_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, stru
tcomplain ();
}
+static enum btrace_error
+debug_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
+{
+ enum btrace_error result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname);
+ result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_VEC__btrace_block_s__pp (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_btrace_target_info_p (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_enum_btrace_read_type (arg3);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_enum_btrace_error (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_stop_recording (struct target_ops *self)
{
@@ -1436,6 +3259,16 @@ tdefault_stop_recording (struct target_ops *self)
}
static void
+debug_stop_recording (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname);
+ debug_target.to_stop_recording (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_info_record (struct target_ops *self)
{
self = self->beneath;
@@ -1448,6 +3281,16 @@ tdefault_info_record (struct target_ops *self)
}
static void
+debug_info_record (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", debug_target.to_shortname);
+ debug_target.to_info_record (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_save_record (struct target_ops *self, const char *arg1)
{
self = self->beneath;
@@ -1461,6 +3304,18 @@ tdefault_save_record (struct target_ops *self, const char *arg1)
}
static void
+debug_save_record (struct target_ops *self, const char *arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname);
+ debug_target.to_save_record (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_const_char_p (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_delete_record (struct target_ops *self)
{
self = self->beneath;
@@ -1473,6 +3328,16 @@ tdefault_delete_record (struct target_ops *self)
tcomplain ();
}
+static void
+debug_delete_record (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname);
+ debug_target.to_delete_record (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_record_is_replaying (struct target_ops *self)
{
@@ -1486,6 +3351,20 @@ tdefault_record_is_replaying (struct target_ops *self)
return 0;
}
+static int
+debug_record_is_replaying (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
+ result = debug_target.to_record_is_replaying (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_goto_record_begin (struct target_ops *self)
{
@@ -1500,6 +3379,16 @@ tdefault_goto_record_begin (struct target_ops *self)
}
static void
+debug_goto_record_begin (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_record_begin (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_goto_record_end (struct target_ops *self)
{
self = self->beneath;
@@ -1513,6 +3402,16 @@ tdefault_goto_record_end (struct target_ops *self)
}
static void
+debug_goto_record_end (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_record_end (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_goto_record (struct target_ops *self, ULONGEST arg1)
{
self = self->beneath;
@@ -1526,6 +3425,18 @@ tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
}
static void
+debug_goto_record (struct target_ops *self, ULONGEST arg1)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname);
+ debug_target.to_goto_record (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_insn_history (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
@@ -1539,6 +3450,20 @@ tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
}
static void
+debug_insn_history (struct target_ops *self, int arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
+ debug_target.to_insn_history (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
{
self = self->beneath;
@@ -1552,6 +3477,22 @@ tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, in
}
static void
+debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname);
+ debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
{
self = self->beneath;
@@ -1565,6 +3506,22 @@ tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST ar
}
static void
+debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname);
+ debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_call_history (struct target_ops *self, int arg1, int arg2)
{
self = self->beneath;
@@ -1578,6 +3535,20 @@ tdefault_call_history (struct target_ops *self, int arg1, int arg2)
}
static void
+debug_call_history (struct target_ops *self, int arg1, int arg2)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
+ debug_target.to_call_history (&debug_target, arg1, arg2);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
{
self = self->beneath;
@@ -1591,6 +3562,22 @@ tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, in
}
static void
+debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname);
+ debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
{
self = self->beneath;
@@ -1603,6 +3590,22 @@ tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST ar
tcomplain ();
}
+static void
+debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname);
+ debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg1);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_ULONGEST (arg2);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_int (arg3);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
static int
delegate_augmented_libraries_svr4_read (struct target_ops *self)
{
@@ -1616,6 +3619,20 @@ tdefault_augmented_libraries_svr4_read (struct target_ops *self)
return 0;
}
+static int
+debug_augmented_libraries_svr4_read (struct target_ops *self)
+{
+ int result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname);
+ result = debug_target.to_augmented_libraries_svr4_read (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_int (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static const struct frame_unwind *
delegate_get_unwinder (struct target_ops *self)
{
@@ -1630,6 +3647,20 @@ tdefault_get_unwinder (struct target_ops *self)
}
static const struct frame_unwind *
+debug_get_unwinder (struct target_ops *self)
+{
+ const struct frame_unwind * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_unwinder (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_const_struct_frame_unwind_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
+static const struct frame_unwind *
delegate_get_tailcall_unwinder (struct target_ops *self)
{
self = self->beneath;
@@ -1642,6 +3673,20 @@ tdefault_get_tailcall_unwinder (struct target_ops *self)
return NULL;
}
+static const struct frame_unwind *
+debug_get_tailcall_unwinder (struct target_ops *self)
+{
+ const struct frame_unwind * result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname);
+ result = debug_target.to_get_tailcall_unwinder (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_const_struct_frame_unwind_p (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static CORE_ADDR
delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
{
@@ -1649,6 +3694,22 @@ delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
return self->to_decr_pc_after_break (self, arg1);
}
+static CORE_ADDR
+debug_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
+{
+ CORE_ADDR result;
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_decr_pc_after_break (...)\n", debug_target.to_shortname);
+ result = debug_target.to_decr_pc_after_break (&debug_target, arg1);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_decr_pc_after_break (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (", ", gdb_stdlog);
+ target_debug_print_struct_gdbarch_p (arg1);
+ fputs_unfiltered (") = ", gdb_stdlog);
+ target_debug_print_CORE_ADDR (result);
+ fputs_unfiltered ("\n", gdb_stdlog);
+ return result;
+}
+
static void
delegate_prepare_to_generate_core (struct target_ops *self)
{
@@ -1662,6 +3723,16 @@ tdefault_prepare_to_generate_core (struct target_ops *self)
}
static void
+debug_prepare_to_generate_core (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", debug_target.to_shortname);
+ debug_target.to_prepare_to_generate_core (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
delegate_done_generating_core (struct target_ops *self)
{
self = self->beneath;
@@ -1674,6 +3745,16 @@ tdefault_done_generating_core (struct target_ops *self)
}
static void
+debug_done_generating_core (struct target_ops *self)
+{
+ fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", debug_target.to_shortname);
+ debug_target.to_done_generating_core (&debug_target);
+ fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", debug_target.to_shortname);
+ target_debug_print_struct_target_ops_p (&debug_target);
+ fputs_unfiltered (")\n", gdb_stdlog);
+}
+
+static void
install_delegators (struct target_ops *ops)
{
if (ops->to_post_attach == NULL)
@@ -2099,3 +4180,147 @@ install_dummy_methods (struct target_ops *ops)
ops->to_prepare_to_generate_core = tdefault_prepare_to_generate_core;
ops->to_done_generating_core = tdefault_done_generating_core;
}
+
+static void
+init_debug_target (struct target_ops *ops)
+{
+ ops->to_post_attach = debug_post_attach;
+ ops->to_detach = debug_detach;
+ ops->to_disconnect = debug_disconnect;
+ ops->to_resume = debug_resume;
+ ops->to_wait = debug_wait;
+ ops->to_fetch_registers = debug_fetch_registers;
+ ops->to_store_registers = debug_store_registers;
+ ops->to_prepare_to_store = debug_prepare_to_store;
+ ops->to_files_info = debug_files_info;
+ ops->to_insert_breakpoint = debug_insert_breakpoint;
+ ops->to_remove_breakpoint = debug_remove_breakpoint;
+ ops->to_can_use_hw_breakpoint = debug_can_use_hw_breakpoint;
+ ops->to_ranged_break_num_registers = debug_ranged_break_num_registers;
+ ops->to_insert_hw_breakpoint = debug_insert_hw_breakpoint;
+ ops->to_remove_hw_breakpoint = debug_remove_hw_breakpoint;
+ ops->to_remove_watchpoint = debug_remove_watchpoint;
+ ops->to_insert_watchpoint = debug_insert_watchpoint;
+ ops->to_insert_mask_watchpoint = debug_insert_mask_watchpoint;
+ ops->to_remove_mask_watchpoint = debug_remove_mask_watchpoint;
+ ops->to_stopped_by_watchpoint = debug_stopped_by_watchpoint;
+ ops->to_stopped_data_address = debug_stopped_data_address;
+ ops->to_watchpoint_addr_within_range = debug_watchpoint_addr_within_range;
+ ops->to_region_ok_for_hw_watchpoint = debug_region_ok_for_hw_watchpoint;
+ ops->to_can_accel_watchpoint_condition = debug_can_accel_watchpoint_condition;
+ ops->to_masked_watch_num_registers = debug_masked_watch_num_registers;
+ ops->to_terminal_init = debug_terminal_init;
+ ops->to_terminal_inferior = debug_terminal_inferior;
+ ops->to_terminal_ours_for_output = debug_terminal_ours_for_output;
+ ops->to_terminal_ours = debug_terminal_ours;
+ ops->to_terminal_save_ours = debug_terminal_save_ours;
+ ops->to_terminal_info = debug_terminal_info;
+ ops->to_kill = debug_kill;
+ ops->to_load = debug_load;
+ ops->to_post_startup_inferior = debug_post_startup_inferior;
+ ops->to_insert_fork_catchpoint = debug_insert_fork_catchpoint;
+ ops->to_remove_fork_catchpoint = debug_remove_fork_catchpoint;
+ ops->to_insert_vfork_catchpoint = debug_insert_vfork_catchpoint;
+ ops->to_remove_vfork_catchpoint = debug_remove_vfork_catchpoint;
+ ops->to_follow_fork = debug_follow_fork;
+ ops->to_insert_exec_catchpoint = debug_insert_exec_catchpoint;
+ ops->to_remove_exec_catchpoint = debug_remove_exec_catchpoint;
+ ops->to_set_syscall_catchpoint = debug_set_syscall_catchpoint;
+ ops->to_has_exited = debug_has_exited;
+ ops->to_mourn_inferior = debug_mourn_inferior;
+ ops->to_can_run = debug_can_run;
+ ops->to_pass_signals = debug_pass_signals;
+ ops->to_program_signals = debug_program_signals;
+ ops->to_thread_alive = debug_thread_alive;
+ ops->to_find_new_threads = debug_find_new_threads;
+ ops->to_pid_to_str = debug_pid_to_str;
+ ops->to_extra_thread_info = debug_extra_thread_info;
+ ops->to_thread_name = debug_thread_name;
+ ops->to_stop = debug_stop;
+ ops->to_rcmd = debug_rcmd;
+ ops->to_pid_to_exec_file = debug_pid_to_exec_file;
+ ops->to_log_command = debug_log_command;
+ ops->to_get_section_table = debug_get_section_table;
+ ops->to_can_async_p = debug_can_async_p;
+ ops->to_is_async_p = debug_is_async_p;
+ ops->to_async = debug_async;
+ ops->to_supports_non_stop = debug_supports_non_stop;
+ ops->to_find_memory_regions = debug_find_memory_regions;
+ ops->to_make_corefile_notes = debug_make_corefile_notes;
+ ops->to_get_bookmark = debug_get_bookmark;
+ ops->to_goto_bookmark = debug_goto_bookmark;
+ ops->to_get_thread_local_address = debug_get_thread_local_address;
+ ops->to_xfer_partial = debug_xfer_partial;
+ ops->to_memory_map = debug_memory_map;
+ ops->to_flash_erase = debug_flash_erase;
+ ops->to_flash_done = debug_flash_done;
+ ops->to_read_description = debug_read_description;
+ ops->to_get_ada_task_ptid = debug_get_ada_task_ptid;
+ ops->to_auxv_parse = debug_auxv_parse;
+ ops->to_search_memory = debug_search_memory;
+ ops->to_can_execute_reverse = debug_can_execute_reverse;
+ ops->to_execution_direction = debug_execution_direction;
+ ops->to_supports_multi_process = debug_supports_multi_process;
+ ops->to_supports_enable_disable_tracepoint = debug_supports_enable_disable_tracepoint;
+ ops->to_supports_string_tracing = debug_supports_string_tracing;
+ ops->to_supports_evaluation_of_breakpoint_conditions = debug_supports_evaluation_of_breakpoint_conditions;
+ ops->to_can_run_breakpoint_commands = debug_can_run_breakpoint_commands;
+ ops->to_thread_architecture = debug_thread_architecture;
+ ops->to_thread_address_space = debug_thread_address_space;
+ ops->to_trace_init = debug_trace_init;
+ ops->to_download_tracepoint = debug_download_tracepoint;
+ ops->to_can_download_tracepoint = debug_can_download_tracepoint;
+ ops->to_download_trace_state_variable = debug_download_trace_state_variable;
+ ops->to_enable_tracepoint = debug_enable_tracepoint;
+ ops->to_disable_tracepoint = debug_disable_tracepoint;
+ ops->to_trace_set_readonly_regions = debug_trace_set_readonly_regions;
+ ops->to_trace_start = debug_trace_start;
+ ops->to_get_trace_status = debug_get_trace_status;
+ ops->to_get_tracepoint_status = debug_get_tracepoint_status;
+ ops->to_trace_stop = debug_trace_stop;
+ ops->to_trace_find = debug_trace_find;
+ ops->to_get_trace_state_variable_value = debug_get_trace_state_variable_value;
+ ops->to_save_trace_data = debug_save_trace_data;
+ ops->to_upload_tracepoints = debug_upload_tracepoints;
+ ops->to_upload_trace_state_variables = debug_upload_trace_state_variables;
+ ops->to_get_raw_trace_data = debug_get_raw_trace_data;
+ ops->to_get_min_fast_tracepoint_insn_len = debug_get_min_fast_tracepoint_insn_len;
+ ops->to_set_disconnected_tracing = debug_set_disconnected_tracing;
+ ops->to_set_circular_trace_buffer = debug_set_circular_trace_buffer;
+ ops->to_set_trace_buffer_size = debug_set_trace_buffer_size;
+ ops->to_set_trace_notes = debug_set_trace_notes;
+ ops->to_core_of_thread = debug_core_of_thread;
+ ops->to_verify_memory = debug_verify_memory;
+ ops->to_get_tib_address = debug_get_tib_address;
+ ops->to_set_permissions = debug_set_permissions;
+ ops->to_static_tracepoint_marker_at = debug_static_tracepoint_marker_at;
+ ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid;
+ ops->to_traceframe_info = debug_traceframe_info;
+ ops->to_use_agent = debug_use_agent;
+ ops->to_can_use_agent = debug_can_use_agent;
+ ops->to_supports_btrace = debug_supports_btrace;
+ ops->to_enable_btrace = debug_enable_btrace;
+ ops->to_disable_btrace = debug_disable_btrace;
+ ops->to_teardown_btrace = debug_teardown_btrace;
+ ops->to_read_btrace = debug_read_btrace;
+ ops->to_stop_recording = debug_stop_recording;
+ ops->to_info_record = debug_info_record;
+ ops->to_save_record = debug_save_record;
+ ops->to_delete_record = debug_delete_record;
+ ops->to_record_is_replaying = debug_record_is_replaying;
+ ops->to_goto_record_begin = debug_goto_record_begin;
+ ops->to_goto_record_end = debug_goto_record_end;
+ ops->to_goto_record = debug_goto_record;
+ ops->to_insn_history = debug_insn_history;
+ ops->to_insn_history_from = debug_insn_history_from;
+ ops->to_insn_history_range = debug_insn_history_range;
+ ops->to_call_history = debug_call_history;
+ ops->to_call_history_from = debug_call_history_from;
+ ops->to_call_history_range = debug_call_history_range;
+ ops->to_augmented_libraries_svr4_read = debug_augmented_libraries_svr4_read;
+ ops->to_get_unwinder = debug_get_unwinder;
+ ops->to_get_tailcall_unwinder = debug_get_tailcall_unwinder;
+ ops->to_decr_pc_after_break = debug_decr_pc_after_break;
+ ops->to_prepare_to_generate_core = debug_prepare_to_generate_core;
+ ops->to_done_generating_core = debug_done_generating_core;
+}
diff --git a/gdb/target.c b/gdb/target.c
index 07d029a..b9310cf 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -46,6 +46,7 @@
#include "gdb/fileio.h"
#include "agent.h"
#include "auxv.h"
+#include "target-debug.h"
static void target_info (char *, int);
@@ -111,72 +112,14 @@ static enum exec_direction_kind default_execution_direction
static CORE_ADDR default_target_decr_pc_after_break (struct target_ops *ops,
struct gdbarch *gdbarch);
+static struct target_ops debug_target;
+
#include "target-delegates.c"
static void init_dummy_target (void);
-static struct target_ops debug_target;
-
static void debug_to_open (char *, int);
-static void debug_to_prepare_to_store (struct target_ops *self,
- struct regcache *);
-
-static void debug_to_files_info (struct target_ops *);
-
-static int debug_to_insert_breakpoint (struct target_ops *, struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_can_use_hw_breakpoint (struct target_ops *self,
- int, int, int);
-
-static int debug_to_insert_hw_breakpoint (struct target_ops *self,
- struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_remove_hw_breakpoint (struct target_ops *self,
- struct gdbarch *,
- struct bp_target_info *);
-
-static int debug_to_insert_watchpoint (struct target_ops *self,
- CORE_ADDR, int, int,
- struct expression *);
-
-static int debug_to_remove_watchpoint (struct target_ops *self,
- CORE_ADDR, int, int,
- struct expression *);
-
-static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
-
-static int debug_to_watchpoint_addr_within_range (struct target_ops *,
- CORE_ADDR, CORE_ADDR, int);
-
-static int debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
- CORE_ADDR, int);
-
-static int debug_to_can_accel_watchpoint_condition (struct target_ops *self,
- CORE_ADDR, int, int,
- struct expression *);
-
-static void debug_to_terminal_init (struct target_ops *self);
-
-static void debug_to_terminal_inferior (struct target_ops *self);
-
-static void debug_to_terminal_ours_for_output (struct target_ops *self);
-
-static void debug_to_terminal_save_ours (struct target_ops *self);
-
-static void debug_to_terminal_ours (struct target_ops *self);
-
-static void debug_to_load (struct target_ops *self, const char *, int);
-
-static int debug_to_can_run (struct target_ops *self);
-
-static void debug_to_stop (struct target_ops *self, ptid_t);
-
/* Pointer to array of target architecture structures; the size of the
array; the current index into the array; the allocated size of the
array. */
@@ -471,9 +414,6 @@ add_deprecated_target_alias (struct target_ops *t, char *alias)
void
target_kill (void)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
-
current_target.to_kill (¤t_target);
}
@@ -921,9 +861,6 @@ done:
struct target_section_table *
target_get_section_table (struct target_ops *target)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
-
return (*target->to_get_section_table) (target);
}
@@ -1398,9 +1335,6 @@ target_memory_map (void)
int ix;
struct target_ops *t;
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
-
result = current_target.to_memory_map (¤t_target);
if (result == NULL)
return NULL;
@@ -1432,17 +1366,12 @@ target_memory_map (void)
void
target_flash_erase (ULONGEST address, LONGEST length)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
- hex_string (address), phex (length, 0));
current_target.to_flash_erase (¤t_target, address, length);
}
void
target_flash_done (void)
{
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
current_target.to_flash_done (¤t_target);
}
@@ -2083,9 +2012,6 @@ target_detach (const char *args, int from_tty)
prepare_for_detach ();
current_target.to_detach (¤t_target, args, from_tty);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
- args, from_tty);
}
void
@@ -2096,36 +2022,13 @@ target_disconnect (const char *args, int from_tty)
disconnecting. */
remove_breakpoints ();
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
- args, from_tty);
current_target.to_disconnect (¤t_target, args, from_tty);
}
ptid_t
target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
{
- struct target_ops *t;
- ptid_t retval = (current_target.to_wait) (¤t_target, ptid,
- status, options);
-
- if (targetdebug)
- {
- char *status_string;
- char *options_string;
-
- status_string = target_waitstatus_to_string (status);
- options_string = target_options_to_string (options);
- fprintf_unfiltered (gdb_stdlog,
- "target_wait (%d, status, options={%s})"
- " = %d, %s\n",
- ptid_get_pid (ptid), options_string,
- ptid_get_pid (retval), status_string);
- xfree (status_string);
- xfree (options_string);
- }
-
- return retval;
+ return (current_target.to_wait) (¤t_target, ptid, status, options);
}
char *
@@ -2148,11 +2051,6 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal)
target_dcache_invalidate ();
current_target.to_resume (¤t_target, ptid, step, signal);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
- ptid_get_pid (ptid),
- step ? "step" : "continue",
- gdb_signal_to_name (signal));
registers_changed_ptid (ptid);
/* We only set the internal executing state here. The user/frontend
@@ -2164,42 +2062,12 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal)
void
target_pass_signals (int numsigs, unsigned char *pass_signals)
{
- if (targetdebug)
- {
- int i;
-
- fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
- numsigs);
-
- for (i = 0; i < numsigs; i++)
- if (pass_signals[i])
- fprintf_unfiltered (gdb_stdlog, " %s",
- gdb_signal_to_name (i));
-
- fprintf_unfiltered (gdb_stdlog, " })\n");
- }
-
(*current_target.to_pass_signals) (¤t_target, numsigs, pass_signals);
}
void
target_program_signals (int numsigs, unsigned char *program_signals)
{
- if (targetdebug)
- {
- int i;
-
- fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
- numsigs);
-
- for (i = 0; i < numsigs; i++)
- if (program_signals[i])
- fprintf_unfiltered (gdb_stdlog, " %s",
- gdb_signal_to_name (i));
-
- fprintf_unfiltered (gdb_stdlog, " })\n");
- }
-
(*current_target.to_program_signals) (¤t_target,
numsigs, program_signals);
}
@@ -2219,14 +2087,8 @@ default_follow_fork (struct target_ops *self, int follow_child,
int
target_follow_fork (int follow_child, int detach_fork)
{
- int retval = current_target.to_follow_fork (¤t_target,
- follow_child, detach_fork);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_follow_fork (%d, %d) = %d\n",
- follow_child, detach_fork, retval);
- return retval;
+ return current_target.to_follow_fork (¤t_target,
+ follow_child, detach_fork);
}
static void
@@ -2240,8 +2102,6 @@ void
target_mourn_inferior (void)
{
current_target.to_mourn_inferior (¤t_target);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
/* We no longer need to keep handles on any of the object files.
Make sure to release them to avoid unnecessarily locking any
@@ -2391,20 +2251,9 @@ target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp)
{
- int found;
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
- hex_string (start_addr));
-
- found = current_target.to_search_memory (¤t_target, start_addr,
- search_space_len,
- pattern, pattern_len, found_addrp);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
-
- return found;
+ return current_target.to_search_memory (¤t_target, start_addr,
+ search_space_len,
+ pattern, pattern_len, found_addrp);
}
/* Look through the currently pushed targets. If none of them will
@@ -2643,12 +2492,6 @@ target_thread_address_space (ptid_t ptid)
aspace = current_target.to_thread_address_space (¤t_target, ptid);
gdb_assert (aspace != NULL);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_thread_address_space (%s) = %d\n",
- target_pid_to_str (ptid),
- address_space_num (aspace));
-
return aspace;
}
@@ -3128,22 +2971,13 @@ target_close (struct target_ops *targ)
int
target_thread_alive (ptid_t ptid)
{
- int retval;
-
- retval = current_target.to_thread_alive (¤t_target, ptid);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
- ptid_get_pid (ptid), retval);
-
- return retval;
+ return current_target.to_thread_alive (¤t_target, ptid);
}
void
target_find_new_threads (void)
{
current_target.to_find_new_threads (¤t_target);
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
}
void
@@ -3158,14 +2992,6 @@ target_stop (ptid_t ptid)
(*current_target.to_stop) (¤t_target, ptid);
}
-static void
-debug_to_post_attach (struct target_ops *self, int pid)
-{
- debug_target.to_post_attach (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
-}
-
/* Concatenate ELEM to LIST, a comma separate list, and return the
result. The LIST incoming argument is released. */
@@ -3277,13 +3103,7 @@ target_store_registers (struct regcache *regcache, int regno)
int
target_core_of_thread (ptid_t ptid)
{
- int retval = current_target.to_core_of_thread (¤t_target, ptid);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_core_of_thread (%d) = %d\n",
- ptid_get_pid (ptid), retval);
- return retval;
+ return current_target.to_core_of_thread (¤t_target, ptid);
}
int
@@ -3328,16 +3148,8 @@ default_verify_memory (struct target_ops *self,
int
target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
{
- int retval = current_target.to_verify_memory (¤t_target,
- data, memaddr, size);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog,
- "target_verify_memory (%s, %s) = %d\n",
- paddress (target_gdbarch (), memaddr),
- pulongest (size),
- retval);
- return retval;
+ return current_target.to_verify_memory (¤t_target,
+ data, memaddr, size);
}
/* The documentation for this function is in its prototype declaration in
@@ -3346,18 +3158,8 @@ target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
int
target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
{
- int ret;
-
- ret = current_target.to_insert_mask_watchpoint (¤t_target,
- addr, mask, rw);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "\
-target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
- core_addr_to_string (addr),
- core_addr_to_string (mask), rw, ret);
-
- return ret;
+ return current_target.to_insert_mask_watchpoint (¤t_target,
+ addr, mask, rw);
}
/* The documentation for this function is in its prototype declaration in
@@ -3366,18 +3168,8 @@ target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
int
target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
{
- int ret;
-
- ret = current_target.to_remove_mask_watchpoint (¤t_target,
- addr, mask, rw);
-
- if (targetdebug)
- fprintf_unfiltered (gdb_stdlog, "\
-target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
- core_addr_to_string (addr),
- core_addr_to_string (mask), rw, ret);
-
- return ret;
+ return current_target.to_remove_mask_watchpoint (¤t_target,
+ addr, mask, rw);
}
/* The documentation for this function is in its prototype declaration
@@ -3551,14 +3343,6 @@ target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
current_target.to_call_history_range (¤t_target, begin, end, flags);
}
-static void
-debug_to_prepare_to_store (struct target_ops *self, struct regcache *regcache)
-{
- debug_target.to_prepare_to_store (&debug_target, regcache);
-
- fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
-}
-
/* See target.h. */
const struct frame_unwind *
@@ -3609,470 +3393,12 @@ target_done_generating_core (void)
}
static void
-debug_to_files_info (struct target_ops *target)
-{
- debug_target.to_files_info (target);
-
- fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
-}
-
-static int
-debug_to_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_insert_breakpoint (&debug_target, gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_insert_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_remove_breakpoint (&debug_target, gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_remove_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_can_use_hw_breakpoint (struct target_ops *self,
- int type, int cnt, int from_tty)
-{
- int retval;
-
- retval = debug_target.to_can_use_hw_breakpoint (&debug_target,
- type, cnt, from_tty);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
- (unsigned long) type,
- (unsigned long) cnt,
- (unsigned long) from_tty,
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len)
-{
- CORE_ADDR retval;
-
- retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target,
- addr, len);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
- core_addr_to_string (addr), (unsigned long) len,
- core_addr_to_string (retval));
- return retval;
-}
-
-static int
-debug_to_can_accel_watchpoint_condition (struct target_ops *self,
- CORE_ADDR addr, int len, int rw,
- struct expression *cond)
-{
- int retval;
-
- retval = debug_target.to_can_accel_watchpoint_condition (&debug_target,
- addr, len,
- rw, cond);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_can_accel_watchpoint_condition "
- "(%s, %d, %d, %s) = %ld\n",
- core_addr_to_string (addr), len, rw,
- host_address_to_string (cond), (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_stopped_by_watchpoint (struct target_ops *ops)
-{
- int retval;
-
- retval = debug_target.to_stopped_by_watchpoint (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_stopped_by_watchpoint () = %ld\n",
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
-{
- int retval;
-
- retval = debug_target.to_stopped_data_address (target, addr);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_stopped_data_address ([%s]) = %ld\n",
- core_addr_to_string (*addr),
- (unsigned long)retval);
- return retval;
-}
-
-static int
-debug_to_watchpoint_addr_within_range (struct target_ops *target,
- CORE_ADDR addr,
- CORE_ADDR start, int length)
-{
- int retval;
-
- retval = debug_target.to_watchpoint_addr_within_range (target, addr,
- start, length);
-
- fprintf_filtered (gdb_stdlog,
- "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
- core_addr_to_string (addr), core_addr_to_string (start),
- length, retval);
- return retval;
-}
-
-static int
-debug_to_insert_hw_breakpoint (struct target_ops *self,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_insert_hw_breakpoint (&debug_target,
- gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_remove_hw_breakpoint (struct target_ops *self,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- int retval;
-
- retval = debug_target.to_remove_hw_breakpoint (&debug_target,
- gdbarch, bp_tgt);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
- core_addr_to_string (bp_tgt->placed_address),
- (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_insert_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
- struct expression *cond)
-{
- int retval;
-
- retval = debug_target.to_insert_watchpoint (&debug_target,
- addr, len, type, cond);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
- core_addr_to_string (addr), len, type,
- host_address_to_string (cond), (unsigned long) retval);
- return retval;
-}
-
-static int
-debug_to_remove_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
- struct expression *cond)
-{
- int retval;
-
- retval = debug_target.to_remove_watchpoint (&debug_target,
- addr, len, type, cond);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
- core_addr_to_string (addr), len, type,
- host_address_to_string (cond), (unsigned long) retval);
- return retval;
-}
-
-static void
-debug_to_terminal_init (struct target_ops *self)
-{
- debug_target.to_terminal_init (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
-}
-
-static void
-debug_to_terminal_inferior (struct target_ops *self)
-{
- debug_target.to_terminal_inferior (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
-}
-
-static void
-debug_to_terminal_ours_for_output (struct target_ops *self)
-{
- debug_target.to_terminal_ours_for_output (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
-}
-
-static void
-debug_to_terminal_ours (struct target_ops *self)
-{
- debug_target.to_terminal_ours (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
-}
-
-static void
-debug_to_terminal_save_ours (struct target_ops *self)
-{
- debug_target.to_terminal_save_ours (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
-}
-
-static void
-debug_to_terminal_info (struct target_ops *self,
- const char *arg, int from_tty)
-{
- debug_target.to_terminal_info (&debug_target, arg, from_tty);
-
- fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
- from_tty);
-}
-
-static void
-debug_to_load (struct target_ops *self, const char *args, int from_tty)
-{
- debug_target.to_load (&debug_target, args, from_tty);
-
- fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
-}
-
-static void
-debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid)
-{
- debug_target.to_post_startup_inferior (&debug_target, ptid);
-
- fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
- ptid_get_pid (ptid));
-}
-
-static int
-debug_to_insert_fork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_remove_fork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_insert_exec_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_remove_exec_catchpoint (struct target_ops *self, int pid)
-{
- int retval;
-
- retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
- pid, retval);
-
- return retval;
-}
-
-static int
-debug_to_has_exited (struct target_ops *self,
- int pid, int wait_status, int *exit_status)
-{
- int has_exited;
-
- has_exited = debug_target.to_has_exited (&debug_target,
- pid, wait_status, exit_status);
-
- fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
- pid, wait_status, *exit_status, has_exited);
-
- return has_exited;
-}
-
-static int
-debug_to_can_run (struct target_ops *self)
-{
- int retval;
-
- retval = debug_target.to_can_run (&debug_target);
-
- fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
-
- return retval;
-}
-
-static struct gdbarch *
-debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
-{
- struct gdbarch *retval;
-
- retval = debug_target.to_thread_architecture (ops, ptid);
-
- fprintf_unfiltered (gdb_stdlog,
- "target_thread_architecture (%s) = %s [%s]\n",
- target_pid_to_str (ptid),
- host_address_to_string (retval),
- gdbarch_bfd_arch_info (retval)->printable_name);
- return retval;
-}
-
-static void
-debug_to_stop (struct target_ops *self, ptid_t ptid)
-{
- debug_target.to_stop (&debug_target, ptid);
-
- fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
- target_pid_to_str (ptid));
-}
-
-static void
-debug_to_rcmd (struct target_ops *self, const char *command,
- struct ui_file *outbuf)
-{
- debug_target.to_rcmd (&debug_target, command, outbuf);
- fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
-}
-
-static char *
-debug_to_pid_to_exec_file (struct target_ops *self, int pid)
-{
- char *exec_file;
-
- exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid);
-
- fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
- pid, exec_file);
-
- return exec_file;
-}
-
-static void
setup_target_debug (void)
{
memcpy (&debug_target, ¤t_target, sizeof debug_target);
current_target.to_open = debug_to_open;
- current_target.to_post_attach = debug_to_post_attach;
- current_target.to_prepare_to_store = debug_to_prepare_to_store;
- current_target.to_files_info = debug_to_files_info;
- current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
- current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
- current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
- current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
- current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
- current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
- current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
- current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
- current_target.to_stopped_data_address = debug_to_stopped_data_address;
- current_target.to_watchpoint_addr_within_range
- = debug_to_watchpoint_addr_within_range;
- current_target.to_region_ok_for_hw_watchpoint
- = debug_to_region_ok_for_hw_watchpoint;
- current_target.to_can_accel_watchpoint_condition
- = debug_to_can_accel_watchpoint_condition;
- current_target.to_terminal_init = debug_to_terminal_init;
- current_target.to_terminal_inferior = debug_to_terminal_inferior;
- current_target.to_terminal_ours_for_output
- = debug_to_terminal_ours_for_output;
- current_target.to_terminal_ours = debug_to_terminal_ours;
- current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
- current_target.to_terminal_info = debug_to_terminal_info;
- current_target.to_load = debug_to_load;
- current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
- current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
- current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
- current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
- current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
- current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
- current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
- current_target.to_has_exited = debug_to_has_exited;
- current_target.to_can_run = debug_to_can_run;
- current_target.to_stop = debug_to_stop;
- current_target.to_rcmd = debug_to_rcmd;
- current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
- current_target.to_thread_architecture = debug_to_thread_architecture;
+ init_debug_target (¤t_target);
}
\f
diff --git a/gdb/target.h b/gdb/target.h
index 8c8ce00..92572ff 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -357,6 +357,16 @@ struct thread_info; /* fwd decl for parameter list below: */
typedef void async_callback_ftype (enum inferior_event_type event_type,
void *context);
+/* Normally target debug printing is purely type-based. However,
+ sometimes it is necessary to override the debug printing on a
+ per-argument basis. This macro can be used, attribute-style, to
+ name the target debug printing function for a particular method
+ argument. FUNC is the name of the function. The macro's
+ definition is empty because it is only used by the
+ make-target-delegates script. */
+
+#define TARGET_DEBUG_PRINTER(FUNC)
+
/* These defines are used to mark target_ops methods. The script
make-target-delegates scans these and auto-generates the base
method implementations. There are four macros that can be used:
@@ -416,10 +426,13 @@ struct target_ops
TARGET_DEFAULT_IGNORE ();
void (*to_disconnect) (struct target_ops *, const char *, int)
TARGET_DEFAULT_NORETURN (tcomplain ());
- void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal)
+ void (*to_resume) (struct target_ops *, ptid_t,
+ int TARGET_DEBUG_PRINTER (target_debug_print_step),
+ enum gdb_signal)
TARGET_DEFAULT_NORETURN (noprocess ());
ptid_t (*to_wait) (struct target_ops *,
- ptid_t, struct target_waitstatus *, int)
+ ptid_t, struct target_waitstatus *,
+ int TARGET_DEBUG_PRINTER (target_debug_print_options))
TARGET_DEFAULT_NORETURN (noprocess ());
void (*to_fetch_registers) (struct target_ops *, struct regcache *, int)
TARGET_DEFAULT_IGNORE ();
@@ -539,12 +552,14 @@ struct target_ops
/* Documentation of this routine is provided with the corresponding
target_* macro. */
- void (*to_pass_signals) (struct target_ops *, int, unsigned char *)
+ void (*to_pass_signals) (struct target_ops *, int,
+ unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals))
TARGET_DEFAULT_IGNORE ();
/* Documentation of this routine is provided with the
corresponding target_* function. */
- void (*to_program_signals) (struct target_ops *, int, unsigned char *)
+ void (*to_program_signals) (struct target_ops *, int,
+ unsigned char * TARGET_DEBUG_PRINTER (target_debug_print_signals))
TARGET_DEFAULT_IGNORE ();
int (*to_thread_alive) (struct target_ops *, ptid_t ptid)
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-17 16:49 ` Tom Tromey
@ 2014-07-17 16:51 ` Pedro Alves
2014-07-24 13:59 ` Tom Tromey
1 sibling, 0 replies; 14+ messages in thread
From: Pedro Alves @ 2014-07-17 16:51 UTC (permalink / raw)
To: Tom Tromey; +Cc: gdb-patches
On 07/17/2014 05:41 PM, Tom Tromey wrote:
> Pedro> Doesn't really matter much, but would it be trivial to strip
> Pedro> out the TARGET_DEBUG_PRINTER part in these generated methods?
>
> FWIW I did this. New patch appended.
>
Thanks!
> I think I forgot to mention it yesterday but this is now based on my
> earlier patch to change the make-target-delegates processing approach.
> However, there's no deep reason this must be so.
Yeah, I had assumed so. :-)
This looks good to me.
--
Pedro Alves
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-17 16:41 ` Tom Tromey
@ 2014-07-17 16:52 ` Pedro Alves
0 siblings, 0 replies; 14+ messages in thread
From: Pedro Alves @ 2014-07-17 16:52 UTC (permalink / raw)
To: Tom Tromey; +Cc: gdb-patches
On 07/17/2014 05:40 PM, Tom Tromey wrote:
>>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:
>
>>> have extra arguments (I happened to see target_get_section_table).
>
> Pedro> Hmm, I think you might have looked at some other method. That
> Pedro> one's arguments seem to match.
>
> Sorry, I wasn't totally clear.
> That particular function takes a target_ops parameter -- but generally
> the target_* entry points do not.
Ah.
>
> Pedro> But yeah, there's some missing uniformity here. E.g.,
> Pedro> target_terminal_inferior is currently horrible for actually
> Pedro> bypassing calling the target method in some cases. target_detach
> Pedro> is another case that does extra work.
>
> Another somewhat related oddity in the current code is that some spots
> bypass these entry points, or at least seem to. Search for
> "current_target.beneath" outside of target.[ch] to see.
Yeah, most of those are related to xfer_partial. I wrote somewhere
that I thought we can actually make that one a regular delegated
method now, but I don't have the pointer handy, nor do I off hand
recall why. But I can look it up if you want me to.
>
> Pedro> I was thinking simpler maintenance and clearer resulting code, by
> Pedro> enforcing the rule that the entry point does nothing more than
> Pedro> calling the target_ops method, to avoid surprises like
> Pedro> target_terminal_inferior.
>
> Yeah, ok. Well, that makes sense, it's just unclear to me if the
> cost/benefit ratio is in our favor here, given the apparent amount of
> inconsistency already in-tree.
Yeah, agreed. It was just a thought, brainstorming material.
I'm definitely not going to jump right into attempting it.
--
Pedro Alves
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [RFC] auto-generate most target debug methods
2014-07-17 16:49 ` Tom Tromey
2014-07-17 16:51 ` Pedro Alves
@ 2014-07-24 13:59 ` Tom Tromey
1 sibling, 0 replies; 14+ messages in thread
From: Tom Tromey @ 2014-07-24 13:59 UTC (permalink / raw)
To: Pedro Alves; +Cc: gdb-patches
>>>>> "Tom" == Tom Tromey <tromey@redhat.com> writes:
Pedro> Doesn't really matter much, but would it be trivial to strip
Pedro> out the TARGET_DEBUG_PRINTER part in these generated methods?
Tom> FWIW I did this. New patch appended.
I'm checking this in now.
Tom
^ permalink raw reply [flat|nested] 14+ messages in thread
end of thread, other threads:[~2014-07-24 13:36 UTC | newest]
Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-06-19 20:04 [RFC] auto-generate most target debug methods Tom Tromey
2014-06-20 8:00 ` Yao Qi
2014-06-20 14:04 ` Tom Tromey
2014-07-15 11:17 ` Pedro Alves
2014-07-15 15:20 ` Tom Tromey
2014-07-16 15:46 ` Tom Tromey
2014-07-17 14:50 ` Pedro Alves
2014-07-17 16:12 ` Tom Tromey
2014-07-17 16:35 ` Pedro Alves
2014-07-17 16:41 ` Tom Tromey
2014-07-17 16:52 ` Pedro Alves
2014-07-17 16:49 ` Tom Tromey
2014-07-17 16:51 ` Pedro Alves
2014-07-24 13:59 ` Tom Tromey
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).