FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

auto-generate most target debug methods

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

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

For example now you'd see:

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

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

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

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

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

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

Regtested on x86-64 Fedora 20.

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

	* make-target-delegates (munge_type, write_debugmethod): New
	functions.
	(debug_names): New global.
	($TARGET_DEBUG_PRINTER): New global.
	(write_function_header): Strip TARGET_DEBUG_PRINTER from the type
	name.
	Write debug methods.  Generate init_debug_target.
	* target-debug.h: New file.
	* target-delegates.c: Rebuild.
	* target.c: Include target-debug.h.
	(debug_target): Hoist definition.
	(target_kill, target_get_section_table, target_memory_map)
	(target_flash_erase, target_flash_done, target_detach)
	(target_disconnect, target_wait, target_resume)
	(target_pass_signals, target_program_signals, target_follow_fork)
	(target_mourn_inferior, target_search_memory)
	(target_thread_address_space, target_close)
	(target_find_new_threads, target_core_of_thread)
	(target_verify_memory, target_insert_mask_watchpoint)
	(target_remove_mask_watchpoint): Remove targetdebug code.
	(debug_to_post_attach, debug_to_prepare_to_store)
	(debug_to_files_info, debug_to_insert_breakpoint)
	(debug_to_remove_breakpoint, debug_to_can_use_hw_breakpoint)
	(debug_to_region_ok_for_hw_watchpoint)
	(debug_to_can_accel_watchpoint_condition)
	(debug_to_stopped_by_watchpoint, debug_to_stopped_data_address)
	(debug_to_watchpoint_addr_within_range)
	(debug_to_insert_hw_breakpoint, debug_to_remove_hw_breakpoint)
	(debug_to_insert_watchpoint, debug_to_remove_watchpoint)
	(debug_to_terminal_init, debug_to_terminal_inferior)
	(debug_to_terminal_ours_for_output, debug_to_terminal_ours)
	(debug_to_terminal_save_ours, debug_to_terminal_info)
	(debug_to_load, debug_to_post_startup_inferior)
	(debug_to_insert_fork_catchpoint)
	(debug_to_remove_fork_catchpoint)
	(debug_to_insert_vfork_catchpoint)
	(debug_to_remove_vfork_catchpoint)
	(debug_to_insert_exec_catchpoint)
	(debug_to_remove_exec_catchpoint, debug_to_has_exited)
	(debug_to_can_run, debug_to_thread_architecture, debug_to_stop)
	(debug_to_rcmd, debug_to_pid_to_exec_file): Remove.
	(setup_target_debug): Call init_debug_target.
	* target.h (TARGET_DEBUG_PRINTER): New macro.
	(struct target_ops) <to_resume, to_wait, to_pass_signals,
	to_program_signals>: Use TARGET_DEBUG_PRINTER.
This commit is contained in:
Tom Tromey 2014-06-15 21:28:57 -06:00
parent 2c51604d3a
commit a7068b6012
6 changed files with 2589 additions and 700 deletions
Download patch file Download diff file Expand all files Collapse all files

48
gdb/ChangeLog
View file

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

88
gdb/make-target-delegates
View file

@ -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";

188
gdb/target-debug.h Normal file
View file

@ -0,0 +1,188 @@
/* GDB target debugging macros
Copyright (C) 2014 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef TARGET_DEBUG_H
#define TARGET_DEBUG_H
/* Printers for the debug target. Each prints an object of a given
type to a string that needn't be freed. Most printers are macros,
for brevity, but a few are static functions where more complicated
behavior is needed.
References to these printers are automatically generated by
make-target-delegates. See the generated file target-delegates.c.
In a couple cases, a special printing function is defined and then
used via the TARGET_DEBUG_PRINTER macro. See target.h.
A few methods still have some explicit targetdebug code in
target.c. In most cases this is because target delegation hasn't
been done for the method; but individual cases vary. For instance,
target_store_registers does some special register printing that is
more simply done there, and target_xfer_partial additionally
bypasses the debug target. */
/* Helper macro. */
#define target_debug_do_print(E) \
fputs_unfiltered ((E), gdb_stdlog);
#define target_debug_print_struct_target_ops_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_enum_target_object(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_CORE_ADDR(X) \
target_debug_do_print (core_addr_to_string (X))
#define target_debug_print_const_char_p(X) \
target_debug_do_print (((X) ? (X) : "(null)"))
#define target_debug_print_char_p(X) \
target_debug_do_print (((X) ? (X) : "(null)"))
#define target_debug_print_int(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_long(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_enum_target_xfer_status(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_enum_exec_direction_kind(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_enum_trace_find_type(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_enum_btrace_read_type(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_enum_btrace_error(X) \
target_debug_do_print (plongest (X))
#define target_debug_print_ptid_t(X) \
target_debug_do_print (plongest (ptid_get_pid (X)))
#define target_debug_print_struct_gdbarch_p(X) \
target_debug_do_print (gdbarch_bfd_arch_info (X)->printable_name)
#define target_debug_print_const_gdb_byte_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_gdb_byte_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_gdb_byte_pp(X) \
target_debug_do_print (host_address_to_string (*(X)))
#define target_debug_print_enum_gdb_signal(X) \
target_debug_do_print (gdb_signal_to_name (X))
#define target_debug_print_ULONGEST(X) \
target_debug_do_print (hex_string (X))
#define target_debug_print_ULONGEST_p(X) \
target_debug_do_print (hex_string (*(X)))
#define target_debug_print_LONGEST(X) \
target_debug_do_print (phex (X, 0))
#define target_debug_print_LONGEST_p(X) \
target_debug_do_print (phex (*(X), 0))
#define target_debug_print_struct_address_space_p(X) \
target_debug_do_print (plongest (address_space_num (X)))
#define target_debug_print_struct_bp_target_info_p(X) \
target_debug_do_print (core_addr_to_string ((X)->placed_address))
#define target_debug_print_struct_expression_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_CORE_ADDR_p(X) \
target_debug_do_print (core_addr_to_string (*(X)))
#define target_debug_print_int_p(X) \
target_debug_do_print (plongest (*(X)))
#define target_debug_print_struct_regcache_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_thread_info_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_ui_file_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_target_section_table_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_async_callback_ftype_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_void_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_find_memory_region_ftype(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_bfd_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_VEC_mem_region_s__p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_VEC_static_tracepoint_marker_p__p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_const_struct_target_desc_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_bp_location_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_trace_state_variable_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_trace_status_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_breakpoint_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_uploaded_tp_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_uploaded_tp_pp(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_uploaded_tsv_pp(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_static_tracepoint_marker_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_traceframe_info_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_struct_btrace_target_info_p(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_VEC__btrace_block_s__pp(X) \
target_debug_do_print (host_address_to_string (X))
#define target_debug_print_const_struct_frame_unwind_p(X) \
target_debug_do_print (host_address_to_string (X))
static void
target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
{
char *str = target_waitstatus_to_string (status);
fputs_unfiltered (str, gdb_stdlog);
xfree (str);
}
/* Macros or functions that are used via TARGET_DEBUG_PRINTER. */
#define target_debug_print_step(X) \
target_debug_do_print ((X) ? "step" : "continue")
static void
target_debug_print_options (int options)
{
char *str = target_options_to_string (options);
fputs_unfiltered (str, gdb_stdlog);
xfree (str);
}
static void
target_debug_print_signals (unsigned char *sigs)
{
fputs_unfiltered ("{", gdb_stdlog);
if (sigs != NULL)
{
int i;
for (i = 0; i < GDB_SIGNAL_LAST; i++)
if (sigs[i])
fprintf_unfiltered (gdb_stdlog, " %s", gdb_signal_to_name (i));
}
fputs_unfiltered (" }", gdb_stdlog);
}
#endif /* TARGET_DEBUG_H */

2224
gdb/target-delegates.c
View file

File diff suppressed because it is too large Load diff

698
gdb/target.c
View file

@ -46,6 +46,7 @@
#include "gdb/fileio.h"
#include "agent.h"
#include "auxv.h"
#include "target-debug.h"
static void target_info (char *, int);
@ -111,72 +112,14 @@ static enum exec_direction_kind default_execution_direction
static CORE_ADDR default_target_decr_pc_after_break (struct target_ops *ops,
struct gdbarch *gdbarch);
static struct target_ops debug_target;
#include "target-delegates.c"
static void init_dummy_target (void);
static struct target_ops debug_target;
static void debug_to_open (char *, int);
static void debug_to_prepare_to_store (struct target_ops *self,
struct regcache *);
static void debug_to_files_info (struct target_ops *);
static int debug_to_insert_breakpoint (struct target_ops *, struct gdbarch *,
struct bp_target_info *);
static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *,
struct bp_target_info *);
static int debug_to_can_use_hw_breakpoint (struct target_ops *self,
int, int, int);
static int debug_to_insert_hw_breakpoint (struct target_ops *self,
struct gdbarch *,
struct bp_target_info *);
static int debug_to_remove_hw_breakpoint (struct target_ops *self,
struct gdbarch *,
struct bp_target_info *);
static int debug_to_insert_watchpoint (struct target_ops *self,
CORE_ADDR, int, int,
struct expression *);
static int debug_to_remove_watchpoint (struct target_ops *self,
CORE_ADDR, int, int,
struct expression *);
static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
static int debug_to_watchpoint_addr_within_range (struct target_ops *,
CORE_ADDR, CORE_ADDR, int);
static int debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
CORE_ADDR, int);
static int debug_to_can_accel_watchpoint_condition (struct target_ops *self,
CORE_ADDR, int, int,
struct expression *);
static void debug_to_terminal_init (struct target_ops *self);
static void debug_to_terminal_inferior (struct target_ops *self);
static void debug_to_terminal_ours_for_output (struct target_ops *self);
static void debug_to_terminal_save_ours (struct target_ops *self);
static void debug_to_terminal_ours (struct target_ops *self);
static void debug_to_load (struct target_ops *self, const char *, int);
static int debug_to_can_run (struct target_ops *self);
static void debug_to_stop (struct target_ops *self, ptid_t);
/* Pointer to array of target architecture structures; the size of the
array; the current index into the array; the allocated size of the
array. */
@ -471,9 +414,6 @@ add_deprecated_target_alias (struct target_ops *t, char *alias)
void
target_kill (void)
{
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
current_target.to_kill (&current_target);
}
@ -938,9 +878,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);
}
@ -1415,9 +1352,6 @@ target_memory_map (void)
int ix;
struct target_ops *t;
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
result = current_target.to_memory_map (&current_target);
if (result == NULL)
return NULL;
@ -1449,17 +1383,12 @@ target_memory_map (void)
void
target_flash_erase (ULONGEST address, LONGEST length)
{
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
hex_string (address), phex (length, 0));
current_target.to_flash_erase (&current_target, address, length);
}
void
target_flash_done (void)
{
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
current_target.to_flash_done (&current_target);
}
@ -2100,9 +2029,6 @@ target_detach (const char *args, int from_tty)
prepare_for_detach ();
current_target.to_detach (&current_target, args, from_tty);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
args, from_tty);
}
void
@ -2113,36 +2039,13 @@ target_disconnect (const char *args, int from_tty)
disconnecting. */
remove_breakpoints ();
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
args, from_tty);
current_target.to_disconnect (&current_target, args, from_tty);
}
ptid_t
target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
{
struct target_ops *t;
ptid_t retval = (current_target.to_wait) (&current_target, ptid,
status, options);
if (targetdebug)
{
char *status_string;
char *options_string;
status_string = target_waitstatus_to_string (status);
options_string = target_options_to_string (options);
fprintf_unfiltered (gdb_stdlog,
"target_wait (%d, status, options={%s})"
" = %d, %s\n",
ptid_get_pid (ptid), options_string,
ptid_get_pid (retval), status_string);
xfree (status_string);
xfree (options_string);
}
return retval;
return (current_target.to_wait) (&current_target, ptid, status, options);
}
char *
@ -2165,11 +2068,6 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal)
target_dcache_invalidate ();
current_target.to_resume (&current_target, ptid, step, signal);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
ptid_get_pid (ptid),
step ? "step" : "continue",
gdb_signal_to_name (signal));
registers_changed_ptid (ptid);
/* We only set the internal executing state here. The user/frontend
@ -2181,42 +2079,12 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal)
void
target_pass_signals (int numsigs, unsigned char *pass_signals)
{
if (targetdebug)
{
int i;
fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
numsigs);
for (i = 0; i < numsigs; i++)
if (pass_signals[i])
fprintf_unfiltered (gdb_stdlog, " %s",
gdb_signal_to_name (i));
fprintf_unfiltered (gdb_stdlog, " })\n");
}
(*current_target.to_pass_signals) (&current_target, numsigs, pass_signals);
}
void
target_program_signals (int numsigs, unsigned char *program_signals)
{
if (targetdebug)
{
int i;
fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
numsigs);
for (i = 0; i < numsigs; i++)
if (program_signals[i])
fprintf_unfiltered (gdb_stdlog, " %s",
gdb_signal_to_name (i));
fprintf_unfiltered (gdb_stdlog, " })\n");
}
(*current_target.to_program_signals) (&current_target,
numsigs, program_signals);
}
@ -2236,14 +2104,8 @@ default_follow_fork (struct target_ops *self, int follow_child,
int
target_follow_fork (int follow_child, int detach_fork)
{
int retval = current_target.to_follow_fork (&current_target,
return current_target.to_follow_fork (&current_target,
follow_child, detach_fork);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
"target_follow_fork (%d, %d) = %d\n",
follow_child, detach_fork, retval);
return retval;
}
static void
@ -2257,8 +2119,6 @@ void
target_mourn_inferior (void)
{
current_target.to_mourn_inferior (&current_target);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
/* We no longer need to keep handles on any of the object files.
Make sure to release them to avoid unnecessarily locking any
@ -2408,20 +2268,9 @@ target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp)
{
int found;
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
hex_string (start_addr));
found = current_target.to_search_memory (&current_target, start_addr,
return current_target.to_search_memory (&current_target, start_addr,
search_space_len,
pattern, pattern_len, found_addrp);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
return found;
}
/* Look through the currently pushed targets. If none of them will
@ -2660,12 +2509,6 @@ target_thread_address_space (ptid_t ptid)
aspace = current_target.to_thread_address_space (&current_target, ptid);
gdb_assert (aspace != NULL);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
"target_thread_address_space (%s) = %d\n",
target_pid_to_str (ptid),
address_space_num (aspace));
return aspace;
}
@ -3145,22 +2988,13 @@ target_close (struct target_ops *targ)
int
target_thread_alive (ptid_t ptid)
{
int retval;
retval = current_target.to_thread_alive (&current_target, ptid);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
ptid_get_pid (ptid), retval);
return retval;
return current_target.to_thread_alive (&current_target, ptid);
}
void
target_find_new_threads (void)
{
current_target.to_find_new_threads (&current_target);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
}
void
@ -3175,14 +3009,6 @@ target_stop (ptid_t ptid)
(*current_target.to_stop) (&current_target, ptid);
}
static void
debug_to_post_attach (struct target_ops *self, int pid)
{
debug_target.to_post_attach (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
}
/* Concatenate ELEM to LIST, a comma separate list, and return the
result. The LIST incoming argument is released. */
@ -3294,13 +3120,7 @@ target_store_registers (struct regcache *regcache, int regno)
int
target_core_of_thread (ptid_t ptid)
{
int retval = current_target.to_core_of_thread (&current_target, ptid);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
"target_core_of_thread (%d) = %d\n",
ptid_get_pid (ptid), retval);
return retval;
return current_target.to_core_of_thread (&current_target, ptid);
}
int
@ -3345,16 +3165,8 @@ default_verify_memory (struct target_ops *self,
int
target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
{
int retval = current_target.to_verify_memory (&current_target,
return current_target.to_verify_memory (&current_target,
data, memaddr, size);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog,
"target_verify_memory (%s, %s) = %d\n",
paddress (target_gdbarch (), memaddr),
pulongest (size),
retval);
return retval;
}
/* The documentation for this function is in its prototype declaration in
@ -3363,18 +3175,8 @@ target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
int
target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
{
int ret;
ret = current_target.to_insert_mask_watchpoint (&current_target,
return current_target.to_insert_mask_watchpoint (&current_target,
addr, mask, rw);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "\
target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
core_addr_to_string (addr),
core_addr_to_string (mask), rw, ret);
return ret;
}
/* The documentation for this function is in its prototype declaration in
@ -3383,18 +3185,8 @@ target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
int
target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
{
int ret;
ret = current_target.to_remove_mask_watchpoint (&current_target,
return current_target.to_remove_mask_watchpoint (&current_target,
addr, mask, rw);
if (targetdebug)
fprintf_unfiltered (gdb_stdlog, "\
target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
core_addr_to_string (addr),
core_addr_to_string (mask), rw, ret);
return ret;
}
/* The documentation for this function is in its prototype declaration
@ -3569,14 +3361,6 @@ target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
current_target.to_call_history_range (&current_target, begin, end, flags);
}
static void
debug_to_prepare_to_store (struct target_ops *self, struct regcache *regcache)
{
debug_target.to_prepare_to_store (&debug_target, regcache);
fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
}
/* See target.h. */
const struct frame_unwind *
@ -3626,471 +3410,13 @@ target_done_generating_core (void)
current_target.to_done_generating_core (&current_target);
}
static void
debug_to_files_info (struct target_ops *target)
{
debug_target.to_files_info (target);
fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
}
static int
debug_to_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
int retval;
retval = debug_target.to_insert_breakpoint (&debug_target, gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_insert_breakpoint (%s, xxx) = %ld\n",
core_addr_to_string (bp_tgt->placed_address),
(unsigned long) retval);
return retval;
}
static int
debug_to_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
int retval;
retval = debug_target.to_remove_breakpoint (&debug_target, gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_remove_breakpoint (%s, xxx) = %ld\n",
core_addr_to_string (bp_tgt->placed_address),
(unsigned long) retval);
return retval;
}
static int
debug_to_can_use_hw_breakpoint (struct target_ops *self,
int type, int cnt, int from_tty)
{
int retval;
retval = debug_target.to_can_use_hw_breakpoint (&debug_target,
type, cnt, from_tty);
fprintf_unfiltered (gdb_stdlog,
"target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
(unsigned long) type,
(unsigned long) cnt,
(unsigned long) from_tty,
(unsigned long) retval);
return retval;
}
static int
debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
CORE_ADDR addr, int len)
{
CORE_ADDR retval;
retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target,
addr, len);
fprintf_unfiltered (gdb_stdlog,
"target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
core_addr_to_string (addr), (unsigned long) len,
core_addr_to_string (retval));
return retval;
}
static int
debug_to_can_accel_watchpoint_condition (struct target_ops *self,
CORE_ADDR addr, int len, int rw,
struct expression *cond)
{
int retval;
retval = debug_target.to_can_accel_watchpoint_condition (&debug_target,
addr, len,
rw, cond);
fprintf_unfiltered (gdb_stdlog,
"target_can_accel_watchpoint_condition "
"(%s, %d, %d, %s) = %ld\n",
core_addr_to_string (addr), len, rw,
host_address_to_string (cond), (unsigned long) retval);
return retval;
}
static int
debug_to_stopped_by_watchpoint (struct target_ops *ops)
{
int retval;
retval = debug_target.to_stopped_by_watchpoint (&debug_target);
fprintf_unfiltered (gdb_stdlog,
"target_stopped_by_watchpoint () = %ld\n",
(unsigned long) retval);
return retval;
}
static int
debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
{
int retval;
retval = debug_target.to_stopped_data_address (target, addr);
fprintf_unfiltered (gdb_stdlog,
"target_stopped_data_address ([%s]) = %ld\n",
core_addr_to_string (*addr),
(unsigned long)retval);
return retval;
}
static int
debug_to_watchpoint_addr_within_range (struct target_ops *target,
CORE_ADDR addr,
CORE_ADDR start, int length)
{
int retval;
retval = debug_target.to_watchpoint_addr_within_range (target, addr,
start, length);
fprintf_filtered (gdb_stdlog,
"target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
core_addr_to_string (addr), core_addr_to_string (start),
length, retval);
return retval;
}
static int
debug_to_insert_hw_breakpoint (struct target_ops *self,
struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
int retval;
retval = debug_target.to_insert_hw_breakpoint (&debug_target,
gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_insert_hw_breakpoint (%s, xxx) = %ld\n",
core_addr_to_string (bp_tgt->placed_address),
(unsigned long) retval);
return retval;
}
static int
debug_to_remove_hw_breakpoint (struct target_ops *self,
struct gdbarch *gdbarch,
struct bp_target_info *bp_tgt)
{
int retval;
retval = debug_target.to_remove_hw_breakpoint (&debug_target,
gdbarch, bp_tgt);
fprintf_unfiltered (gdb_stdlog,
"target_remove_hw_breakpoint (%s, xxx) = %ld\n",
core_addr_to_string (bp_tgt->placed_address),
(unsigned long) retval);
return retval;
}
static int
debug_to_insert_watchpoint (struct target_ops *self,
CORE_ADDR addr, int len, int type,
struct expression *cond)
{
int retval;
retval = debug_target.to_insert_watchpoint (&debug_target,
addr, len, type, cond);
fprintf_unfiltered (gdb_stdlog,
"target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
core_addr_to_string (addr), len, type,
host_address_to_string (cond), (unsigned long) retval);
return retval;
}
static int
debug_to_remove_watchpoint (struct target_ops *self,
CORE_ADDR addr, int len, int type,
struct expression *cond)
{
int retval;
retval = debug_target.to_remove_watchpoint (&debug_target,
addr, len, type, cond);
fprintf_unfiltered (gdb_stdlog,
"target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
core_addr_to_string (addr), len, type,
host_address_to_string (cond), (unsigned long) retval);
return retval;
}
static void
debug_to_terminal_init (struct target_ops *self)
{
debug_target.to_terminal_init (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
}
static void
debug_to_terminal_inferior (struct target_ops *self)
{
debug_target.to_terminal_inferior (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
}
static void
debug_to_terminal_ours_for_output (struct target_ops *self)
{
debug_target.to_terminal_ours_for_output (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
}
static void
debug_to_terminal_ours (struct target_ops *self)
{
debug_target.to_terminal_ours (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
}
static void
debug_to_terminal_save_ours (struct target_ops *self)
{
debug_target.to_terminal_save_ours (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
}
static void
debug_to_terminal_info (struct target_ops *self,
const char *arg, int from_tty)
{
debug_target.to_terminal_info (&debug_target, arg, from_tty);
fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
from_tty);
}
static void
debug_to_load (struct target_ops *self, const char *args, int from_tty)
{
debug_target.to_load (&debug_target, args, from_tty);
fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
}
static void
debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid)
{
debug_target.to_post_startup_inferior (&debug_target, ptid);
fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
ptid_get_pid (ptid));
}
static int
debug_to_insert_fork_catchpoint (struct target_ops *self, int pid)
{
int retval;
retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
pid, retval);
return retval;
}
static int
debug_to_remove_fork_catchpoint (struct target_ops *self, int pid)
{
int retval;
retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
pid, retval);
return retval;
}
static int
debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid)
{
int retval;
retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
pid, retval);
return retval;
}
static int
debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid)
{
int retval;
retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
pid, retval);
return retval;
}
static int
debug_to_insert_exec_catchpoint (struct target_ops *self, int pid)
{
int retval;
retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
pid, retval);
return retval;
}
static int
debug_to_remove_exec_catchpoint (struct target_ops *self, int pid)
{
int retval;
retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
pid, retval);
return retval;
}
static int
debug_to_has_exited (struct target_ops *self,
int pid, int wait_status, int *exit_status)
{
int has_exited;
has_exited = debug_target.to_has_exited (&debug_target,
pid, wait_status, exit_status);
fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
pid, wait_status, *exit_status, has_exited);
return has_exited;
}
static int
debug_to_can_run (struct target_ops *self)
{
int retval;
retval = debug_target.to_can_run (&debug_target);
fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
return retval;
}
static struct gdbarch *
debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
{
struct gdbarch *retval;
retval = debug_target.to_thread_architecture (ops, ptid);
fprintf_unfiltered (gdb_stdlog,
"target_thread_architecture (%s) = %s [%s]\n",
target_pid_to_str (ptid),
host_address_to_string (retval),
gdbarch_bfd_arch_info (retval)->printable_name);
return retval;
}
static void
debug_to_stop (struct target_ops *self, ptid_t ptid)
{
debug_target.to_stop (&debug_target, ptid);
fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
target_pid_to_str (ptid));
}
static void
debug_to_rcmd (struct target_ops *self, const char *command,
struct ui_file *outbuf)
{
debug_target.to_rcmd (&debug_target, command, outbuf);
fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
}
static char *
debug_to_pid_to_exec_file (struct target_ops *self, int pid)
{
char *exec_file;
exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid);
fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
pid, exec_file);
return exec_file;
}
static void
setup_target_debug (void)
{
memcpy (&debug_target, &current_target, sizeof debug_target);
current_target.to_open = debug_to_open;
current_target.to_post_attach = debug_to_post_attach;
current_target.to_prepare_to_store = debug_to_prepare_to_store;
current_target.to_files_info = debug_to_files_info;
current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
current_target.to_stopped_data_address = debug_to_stopped_data_address;
current_target.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range;
current_target.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint;
current_target.to_can_accel_watchpoint_condition
= debug_to_can_accel_watchpoint_condition;
current_target.to_terminal_init = debug_to_terminal_init;
current_target.to_terminal_inferior = debug_to_terminal_inferior;
current_target.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output;
current_target.to_terminal_ours = debug_to_terminal_ours;
current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
current_target.to_terminal_info = debug_to_terminal_info;
current_target.to_load = debug_to_load;
current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
current_target.to_has_exited = debug_to_has_exited;
current_target.to_can_run = debug_to_can_run;
current_target.to_stop = debug_to_stop;
current_target.to_rcmd = debug_to_rcmd;
current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
current_target.to_thread_architecture = debug_to_thread_architecture;
init_debug_target (&current_target);
}

23
gdb/target.h
View file

@ -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)