2013-12-19 16:38:11 +00:00
|
|
|
/* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
|
|
|
|
/* vi:set ro: */
|
|
|
|
|
|
|
|
/* To regenerate this file, run:*/
|
|
|
|
/* make-target-delegates target.h > target-delegates.c */
|
2013-12-18 16:42:24 +00:00
|
|
|
static void
|
|
|
|
delegate_post_attach (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_post_attach (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_post_attach (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-13 20:33:08 +00:00
|
|
|
static void
|
|
|
|
delegate_detach (struct target_ops *self, const char *arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_detach (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_detach (struct target_ops *self, const char *arg1, int arg2)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-20 17:30:13 +00:00
|
|
|
static void
|
2014-06-06 19:26:53 +00:00
|
|
|
delegate_disconnect (struct target_ops *self, const char *arg1, int arg2)
|
2013-12-20 17:30:13 +00:00
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_disconnect (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-06-06 19:26:53 +00:00
|
|
|
tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
|
2013-12-20 17:30:13 +00:00
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
static void
|
|
|
|
delegate_resume (struct target_ops *self, ptid_t arg1, int 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)
|
|
|
|
{
|
|
|
|
noprocess ();
|
|
|
|
}
|
|
|
|
|
|
|
|
static ptid_t
|
|
|
|
delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int 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)
|
|
|
|
{
|
|
|
|
noprocess ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:30:22 +00:00
|
|
|
static void
|
|
|
|
delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_fetch_registers (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
static void
|
|
|
|
delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_store_registers (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
|
|
|
|
{
|
|
|
|
noprocess ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 16:47:18 +00:00
|
|
|
static void
|
|
|
|
delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_prepare_to_store (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
|
|
|
|
{
|
|
|
|
noprocess ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 16:51:47 +00:00
|
|
|
static void
|
|
|
|
delegate_files_info (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_files_info (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_files_info (struct target_ops *self)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
static int
|
|
|
|
delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_insert_breakpoint (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_remove_breakpoint (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
2013-12-18 16:58:16 +00:00
|
|
|
static int
|
|
|
|
delegate_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_can_use_hw_breakpoint (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:31:42 +00:00
|
|
|
static int
|
|
|
|
delegate_ranged_break_num_registers (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_ranged_break_num_registers (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_ranged_break_num_registers (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:01:11 +00:00
|
|
|
static int
|
|
|
|
delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_insert_hw_breakpoint (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:05:18 +00:00
|
|
|
static int
|
|
|
|
delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_remove_hw_breakpoint (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:11:49 +00:00
|
|
|
static int
|
|
|
|
delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_remove_watchpoint (self, arg1, arg2, arg3, arg4);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:08:59 +00:00
|
|
|
static int
|
|
|
|
delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_insert_watchpoint (self, arg1, arg2, arg3, arg4);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:32:43 +00:00
|
|
|
static int
|
|
|
|
delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_insert_mask_watchpoint (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:33:28 +00:00
|
|
|
static int
|
|
|
|
delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_remove_mask_watchpoint (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
static int
|
|
|
|
delegate_stopped_by_watchpoint (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_stopped_by_watchpoint (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_stopped_by_watchpoint (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_stopped_data_address (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:15:23 +00:00
|
|
|
static int
|
|
|
|
delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_watchpoint_addr_within_range (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:18:05 +00:00
|
|
|
static int
|
|
|
|
delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_region_ok_for_hw_watchpoint (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:20:48 +00:00
|
|
|
static int
|
|
|
|
delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_can_accel_watchpoint_condition (self, arg1, arg2, arg3, arg4);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:34:15 +00:00
|
|
|
static int
|
|
|
|
delegate_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_masked_watch_num_registers (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:24:07 +00:00
|
|
|
static void
|
|
|
|
delegate_terminal_init (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_terminal_init (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_terminal_init (struct target_ops *self)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:29:01 +00:00
|
|
|
static void
|
|
|
|
delegate_terminal_inferior (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_terminal_inferior (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_terminal_inferior (struct target_ops *self)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:29:46 +00:00
|
|
|
static void
|
|
|
|
delegate_terminal_ours_for_output (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_terminal_ours_for_output (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_terminal_ours_for_output (struct target_ops *self)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:30:16 +00:00
|
|
|
static void
|
|
|
|
delegate_terminal_ours (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_terminal_ours (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_terminal_ours (struct target_ops *self)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:30:41 +00:00
|
|
|
static void
|
|
|
|
delegate_terminal_save_ours (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_terminal_save_ours (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_terminal_save_ours (struct target_ops *self)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:31:10 +00:00
|
|
|
static void
|
|
|
|
delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_terminal_info (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:35:15 +00:00
|
|
|
static void
|
|
|
|
delegate_kill (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_kill (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_kill (struct target_ops *self)
|
|
|
|
{
|
|
|
|
noprocess ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:31:48 +00:00
|
|
|
static void
|
|
|
|
delegate_load (struct target_ops *self, char *arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_load (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_load (struct target_ops *self, char *arg1, int arg2)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:32:56 +00:00
|
|
|
static void
|
|
|
|
delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_post_startup_inferior (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:33:43 +00:00
|
|
|
static int
|
|
|
|
delegate_insert_fork_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_insert_fork_catchpoint (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:34:15 +00:00
|
|
|
static int
|
|
|
|
delegate_remove_fork_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_remove_fork_catchpoint (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:44:22 +00:00
|
|
|
static int
|
|
|
|
delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_insert_vfork_catchpoint (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:44:57 +00:00
|
|
|
static int
|
|
|
|
delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_remove_vfork_catchpoint (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:38:04 +00:00
|
|
|
static int
|
|
|
|
delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_follow_fork (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:45:38 +00:00
|
|
|
static int
|
|
|
|
delegate_insert_exec_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_insert_exec_catchpoint (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:46:02 +00:00
|
|
|
static int
|
|
|
|
delegate_remove_exec_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_remove_exec_catchpoint (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:46:38 +00:00
|
|
|
static int
|
|
|
|
delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4, arg5);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:47:22 +00:00
|
|
|
static int
|
|
|
|
delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_has_exited (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:40:23 +00:00
|
|
|
static void
|
|
|
|
delegate_mourn_inferior (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_mourn_inferior (self);
|
|
|
|
}
|
|
|
|
|
2013-12-20 19:19:37 +00:00
|
|
|
static int
|
|
|
|
delegate_can_run (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_can_run (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_can_run (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:42:10 +00:00
|
|
|
static void
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:42:54 +00:00
|
|
|
static void
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-19 14:21:56 +00:00
|
|
|
static int
|
|
|
|
delegate_thread_alive (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_thread_alive (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_thread_alive (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:44:20 +00:00
|
|
|
static void
|
|
|
|
delegate_find_new_threads (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_find_new_threads (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_find_new_threads (struct target_ops *self)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:46:03 +00:00
|
|
|
static char *
|
|
|
|
delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_pid_to_str (self, arg1);
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:48:36 +00:00
|
|
|
static char *
|
|
|
|
delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_extra_thread_info (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
|
|
|
|
{
|
pass NULL to TARGET_DEFAULT_RETURN when appropriate
This changes instances of TARGET_DEFAULT_RETURN(0) to
TARGET_DEFAULT_RETURN(NULL) when appropriate. The use of "0" was a
relic from an earlier implementation of make-target-delegates; and I
didn't want to go back through the long patch series, fixing up
conflicts, just to change this small detail.
2014-02-19 Tom Tromey <tromey@redhat.com>
* target-delegates.c: Rebuild.
* target.h (struct target_ops) <to_extra_thread_info,
to_thread_name, to_pid_to_exec_file, to_get_section_table,
to_memory_map, to_read_description, to_traceframe_info>: Use NULL,
not 0, in TARGET_DEFAULT_RETURN.
2014-01-15 16:30:05 +00:00
|
|
|
return NULL;
|
2013-12-18 17:48:36 +00:00
|
|
|
}
|
|
|
|
|
2013-12-18 17:49:35 +00:00
|
|
|
static char *
|
|
|
|
delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_thread_name (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
|
|
|
|
{
|
pass NULL to TARGET_DEFAULT_RETURN when appropriate
This changes instances of TARGET_DEFAULT_RETURN(0) to
TARGET_DEFAULT_RETURN(NULL) when appropriate. The use of "0" was a
relic from an earlier implementation of make-target-delegates; and I
didn't want to go back through the long patch series, fixing up
conflicts, just to change this small detail.
2014-02-19 Tom Tromey <tromey@redhat.com>
* target-delegates.c: Rebuild.
* target.h (struct target_ops) <to_extra_thread_info,
to_thread_name, to_pid_to_exec_file, to_get_section_table,
to_memory_map, to_read_description, to_traceframe_info>: Use NULL,
not 0, in TARGET_DEFAULT_RETURN.
2014-01-15 16:30:05 +00:00
|
|
|
return NULL;
|
2013-12-18 17:49:35 +00:00
|
|
|
}
|
|
|
|
|
2013-12-18 21:28:07 +00:00
|
|
|
static void
|
|
|
|
delegate_stop (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_stop (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_stop (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 16:35:21 +00:00
|
|
|
static void
|
2014-06-06 19:19:53 +00:00
|
|
|
delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
|
2013-12-18 16:35:21 +00:00
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_rcmd (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:51:10 +00:00
|
|
|
static char *
|
|
|
|
delegate_pid_to_exec_file (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_pid_to_exec_file (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
|
|
|
|
{
|
pass NULL to TARGET_DEFAULT_RETURN when appropriate
This changes instances of TARGET_DEFAULT_RETURN(0) to
TARGET_DEFAULT_RETURN(NULL) when appropriate. The use of "0" was a
relic from an earlier implementation of make-target-delegates; and I
didn't want to go back through the long patch series, fixing up
conflicts, just to change this small detail.
2014-02-19 Tom Tromey <tromey@redhat.com>
* target-delegates.c: Rebuild.
* target.h (struct target_ops) <to_extra_thread_info,
to_thread_name, to_pid_to_exec_file, to_get_section_table,
to_memory_map, to_read_description, to_traceframe_info>: Use NULL,
not 0, in TARGET_DEFAULT_RETURN.
2014-01-15 16:30:05 +00:00
|
|
|
return NULL;
|
2013-12-18 17:51:10 +00:00
|
|
|
}
|
|
|
|
|
2013-12-18 17:52:58 +00:00
|
|
|
static void
|
|
|
|
delegate_log_command (struct target_ops *self, const char *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_log_command (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_log_command (struct target_ops *self, const char *arg1)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:47:06 +00:00
|
|
|
static struct target_section_table *
|
|
|
|
delegate_get_section_table (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_section_table (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct target_section_table *
|
|
|
|
tdefault_get_section_table (struct target_ops *self)
|
|
|
|
{
|
pass NULL to TARGET_DEFAULT_RETURN when appropriate
This changes instances of TARGET_DEFAULT_RETURN(0) to
TARGET_DEFAULT_RETURN(NULL) when appropriate. The use of "0" was a
relic from an earlier implementation of make-target-delegates; and I
didn't want to go back through the long patch series, fixing up
conflicts, just to change this small detail.
2014-02-19 Tom Tromey <tromey@redhat.com>
* target-delegates.c: Rebuild.
* target.h (struct target_ops) <to_extra_thread_info,
to_thread_name, to_pid_to_exec_file, to_get_section_table,
to_memory_map, to_read_description, to_traceframe_info>: Use NULL,
not 0, in TARGET_DEFAULT_RETURN.
2014-01-15 16:30:05 +00:00
|
|
|
return NULL;
|
2013-12-18 21:47:06 +00:00
|
|
|
}
|
|
|
|
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
static int
|
|
|
|
delegate_can_async_p (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_can_async_p (self);
|
|
|
|
}
|
|
|
|
|
fix regressions with target-async
A patch in the target cleanup series caused a regression when using
record with target-async. Version 4 of the patch is here:
https://sourceware.org/ml/gdb-patches/2014-03/msg00159.html
The immediate problem is that record supplies to_can_async_p and
to_is_async_p methods, but does not supply a to_async method. So,
when target-async is set, record claims to support async -- but if the
underlying target does not support async, then the to_async method
call will end up in that method's default implementation, namely
tcomplain.
This worked previously because the record target used to provide a
to_async method; one that (erroneously, only at push time) checked the
other members of the target stack, and then simply dropped to_async
calls in the "does not implement async" case.
My first thought was to simply drop tcomplain as the default for
to_async. This works, but Pedro pointed out that the only reason
record has to supply to_can_async_p and to_is_async_p is that these
default to using the find_default_run_target machinery -- and these
defaults are only needed by "run" and "attach".
So, a nicer solution presents itself: change run and attach to
explicitly call into the default run target when needed; and change
to_is_async_p and to_can_async_p to default to "return 0". This makes
the target stack simpler to use and lets us remove the method
implementations from record. This is also in harmony with other plans
for the target stack; namely trying to reduce the impact of
find_default_run_target. This approach makes it clear that
find_default_is_async_p is not needed -- it is asking whether a target
that may not even be pushed is actually async, which seems like a
nonsensical question.
While an improvement, this approach proved to introduce the same bug
when using the core target. Looking a bit deeper, the issue is that
code in "attach" and "run" may need to use either the current target
stack or the default run target -- but different calls into the target
API in those functions could wind up querying different targets.
This new patch makes the target to use more explicit in "run" and
"attach". Then these commands explicitly make the needed calls
against that target. This ensures that a single target is used for
all relevant operations. This lets us remove a couple find_default_*
functions from various targets, including the dummy target. I think
this is a decent understandability improvement.
One issue I see with this patch is that the new calls in "run" and
"attach" are not very much like the rest of the target API. I think
fundamentally this is due to bad factoring in the target API, which
may need to be fixed for multi-target. Tackling that seemed ambitious
for a regression fix.
While working on this I noticed that there don't seem to be any test
cases that involve both target-async and record, so this patch changes
break-precsave.exp to add some. It also changes corefile.exp to add
some target-async tests; these pass with current trunk and with this
patch applied, but fail with the v1 patch.
This patch differs from v4 in that it moves initialization of
to_can_async_p and to_supports_non_stop into inf-child, adds some
assertions to complete_target_initialization, and adds some comments
to target.h.
Built and regtested on x86-64 Fedora 20.
2014-03-12 Tom Tromey <tromey@redhat.com>
* inf-child.c (return_zero): New function.
(inf_child_target): Set to_can_async_p, to_supports_non_stop.
* aix-thread.c (aix_thread_inferior_created): New function.
(aix_thread_attach): Remove.
(init_aix_thread_ops): Don't set to_attach.
(_initialize_aix_thread): Register inferior_created observer.
* corelow.c (init_core_ops): Don't set to_attach or
to_create_inferior.
* exec.c (init_exec_ops): Don't set to_attach or
to_create_inferior.
* infcmd.c (run_command_1): Use find_run_target. Make direct
target calls.
(attach_command): Use find_attach_target. Make direct target
calls.
* record-btrace.c (init_record_btrace_ops): Don't set
to_create_inferior.
* record-full.c (record_full_can_async_p, record_full_is_async_p):
Remove.
(init_record_full_ops, init_record_full_core_ops): Update. Don't
set to_create_inferior.
* target.c (complete_target_initialization): Add assertion.
(target_create_inferior): Remove.
(find_default_attach, find_default_create_inferior): Remove.
(find_attach_target, find_run_target): New functions.
(find_default_is_async_p, find_default_can_async_p)
(target_supports_non_stop, target_attach): Remove.
(init_dummy_target): Don't set to_create_inferior or
to_supports_non_stop.
* target.h (struct target_ops) <to_attach>: Add comment. Remove
TARGET_DEFAULT_FUNC.
<to_create_inferior>: Add comment.
<to_can_async_p, to_is_async_p, to_supports_non_stop>: Use
TARGET_DEFAULT_RETURN.
<to_can_async_p, to_supports_non_stop, to_can_run>: Add comments.
(find_attach_target, find_run_target): Declare.
(target_create_inferior): Remove.
(target_has_execution_1): Update comment.
(target_supports_non_stop): Remove.
* target-delegates.c: Rebuild.
2014-03-12 Tom Tromey <tromey@redhat.com>
* gdb.base/corefile.exp (corefile_test_run, corefile_test_attach):
New procs. Add target-async tests.
* gdb.reverse/break-precsave.exp (precsave_tests): New proc.
Add target-async tests.
2014-02-28 16:47:34 +00:00
|
|
|
static int
|
|
|
|
tdefault_can_async_p (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
static int
|
|
|
|
delegate_is_async_p (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_is_async_p (self);
|
|
|
|
}
|
|
|
|
|
fix regressions with target-async
A patch in the target cleanup series caused a regression when using
record with target-async. Version 4 of the patch is here:
https://sourceware.org/ml/gdb-patches/2014-03/msg00159.html
The immediate problem is that record supplies to_can_async_p and
to_is_async_p methods, but does not supply a to_async method. So,
when target-async is set, record claims to support async -- but if the
underlying target does not support async, then the to_async method
call will end up in that method's default implementation, namely
tcomplain.
This worked previously because the record target used to provide a
to_async method; one that (erroneously, only at push time) checked the
other members of the target stack, and then simply dropped to_async
calls in the "does not implement async" case.
My first thought was to simply drop tcomplain as the default for
to_async. This works, but Pedro pointed out that the only reason
record has to supply to_can_async_p and to_is_async_p is that these
default to using the find_default_run_target machinery -- and these
defaults are only needed by "run" and "attach".
So, a nicer solution presents itself: change run and attach to
explicitly call into the default run target when needed; and change
to_is_async_p and to_can_async_p to default to "return 0". This makes
the target stack simpler to use and lets us remove the method
implementations from record. This is also in harmony with other plans
for the target stack; namely trying to reduce the impact of
find_default_run_target. This approach makes it clear that
find_default_is_async_p is not needed -- it is asking whether a target
that may not even be pushed is actually async, which seems like a
nonsensical question.
While an improvement, this approach proved to introduce the same bug
when using the core target. Looking a bit deeper, the issue is that
code in "attach" and "run" may need to use either the current target
stack or the default run target -- but different calls into the target
API in those functions could wind up querying different targets.
This new patch makes the target to use more explicit in "run" and
"attach". Then these commands explicitly make the needed calls
against that target. This ensures that a single target is used for
all relevant operations. This lets us remove a couple find_default_*
functions from various targets, including the dummy target. I think
this is a decent understandability improvement.
One issue I see with this patch is that the new calls in "run" and
"attach" are not very much like the rest of the target API. I think
fundamentally this is due to bad factoring in the target API, which
may need to be fixed for multi-target. Tackling that seemed ambitious
for a regression fix.
While working on this I noticed that there don't seem to be any test
cases that involve both target-async and record, so this patch changes
break-precsave.exp to add some. It also changes corefile.exp to add
some target-async tests; these pass with current trunk and with this
patch applied, but fail with the v1 patch.
This patch differs from v4 in that it moves initialization of
to_can_async_p and to_supports_non_stop into inf-child, adds some
assertions to complete_target_initialization, and adds some comments
to target.h.
Built and regtested on x86-64 Fedora 20.
2014-03-12 Tom Tromey <tromey@redhat.com>
* inf-child.c (return_zero): New function.
(inf_child_target): Set to_can_async_p, to_supports_non_stop.
* aix-thread.c (aix_thread_inferior_created): New function.
(aix_thread_attach): Remove.
(init_aix_thread_ops): Don't set to_attach.
(_initialize_aix_thread): Register inferior_created observer.
* corelow.c (init_core_ops): Don't set to_attach or
to_create_inferior.
* exec.c (init_exec_ops): Don't set to_attach or
to_create_inferior.
* infcmd.c (run_command_1): Use find_run_target. Make direct
target calls.
(attach_command): Use find_attach_target. Make direct target
calls.
* record-btrace.c (init_record_btrace_ops): Don't set
to_create_inferior.
* record-full.c (record_full_can_async_p, record_full_is_async_p):
Remove.
(init_record_full_ops, init_record_full_core_ops): Update. Don't
set to_create_inferior.
* target.c (complete_target_initialization): Add assertion.
(target_create_inferior): Remove.
(find_default_attach, find_default_create_inferior): Remove.
(find_attach_target, find_run_target): New functions.
(find_default_is_async_p, find_default_can_async_p)
(target_supports_non_stop, target_attach): Remove.
(init_dummy_target): Don't set to_create_inferior or
to_supports_non_stop.
* target.h (struct target_ops) <to_attach>: Add comment. Remove
TARGET_DEFAULT_FUNC.
<to_create_inferior>: Add comment.
<to_can_async_p, to_is_async_p, to_supports_non_stop>: Use
TARGET_DEFAULT_RETURN.
<to_can_async_p, to_supports_non_stop, to_can_run>: Add comments.
(find_attach_target, find_run_target): Declare.
(target_create_inferior): Remove.
(target_has_execution_1): Update comment.
(target_supports_non_stop): Remove.
* target-delegates.c: Rebuild.
2014-03-12 Tom Tromey <tromey@redhat.com>
* gdb.base/corefile.exp (corefile_test_run, corefile_test_attach):
New procs. Add target-async tests.
* gdb.reverse/break-precsave.exp (precsave_tests): New proc.
Add target-async tests.
2014-02-28 16:47:34 +00:00
|
|
|
static int
|
|
|
|
tdefault_is_async_p (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
static void
|
|
|
|
delegate_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_async (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
fix regressions with target-async
A patch in the target cleanup series caused a regression when using
record with target-async. Version 4 of the patch is here:
https://sourceware.org/ml/gdb-patches/2014-03/msg00159.html
The immediate problem is that record supplies to_can_async_p and
to_is_async_p methods, but does not supply a to_async method. So,
when target-async is set, record claims to support async -- but if the
underlying target does not support async, then the to_async method
call will end up in that method's default implementation, namely
tcomplain.
This worked previously because the record target used to provide a
to_async method; one that (erroneously, only at push time) checked the
other members of the target stack, and then simply dropped to_async
calls in the "does not implement async" case.
My first thought was to simply drop tcomplain as the default for
to_async. This works, but Pedro pointed out that the only reason
record has to supply to_can_async_p and to_is_async_p is that these
default to using the find_default_run_target machinery -- and these
defaults are only needed by "run" and "attach".
So, a nicer solution presents itself: change run and attach to
explicitly call into the default run target when needed; and change
to_is_async_p and to_can_async_p to default to "return 0". This makes
the target stack simpler to use and lets us remove the method
implementations from record. This is also in harmony with other plans
for the target stack; namely trying to reduce the impact of
find_default_run_target. This approach makes it clear that
find_default_is_async_p is not needed -- it is asking whether a target
that may not even be pushed is actually async, which seems like a
nonsensical question.
While an improvement, this approach proved to introduce the same bug
when using the core target. Looking a bit deeper, the issue is that
code in "attach" and "run" may need to use either the current target
stack or the default run target -- but different calls into the target
API in those functions could wind up querying different targets.
This new patch makes the target to use more explicit in "run" and
"attach". Then these commands explicitly make the needed calls
against that target. This ensures that a single target is used for
all relevant operations. This lets us remove a couple find_default_*
functions from various targets, including the dummy target. I think
this is a decent understandability improvement.
One issue I see with this patch is that the new calls in "run" and
"attach" are not very much like the rest of the target API. I think
fundamentally this is due to bad factoring in the target API, which
may need to be fixed for multi-target. Tackling that seemed ambitious
for a regression fix.
While working on this I noticed that there don't seem to be any test
cases that involve both target-async and record, so this patch changes
break-precsave.exp to add some. It also changes corefile.exp to add
some target-async tests; these pass with current trunk and with this
patch applied, but fail with the v1 patch.
This patch differs from v4 in that it moves initialization of
to_can_async_p and to_supports_non_stop into inf-child, adds some
assertions to complete_target_initialization, and adds some comments
to target.h.
Built and regtested on x86-64 Fedora 20.
2014-03-12 Tom Tromey <tromey@redhat.com>
* inf-child.c (return_zero): New function.
(inf_child_target): Set to_can_async_p, to_supports_non_stop.
* aix-thread.c (aix_thread_inferior_created): New function.
(aix_thread_attach): Remove.
(init_aix_thread_ops): Don't set to_attach.
(_initialize_aix_thread): Register inferior_created observer.
* corelow.c (init_core_ops): Don't set to_attach or
to_create_inferior.
* exec.c (init_exec_ops): Don't set to_attach or
to_create_inferior.
* infcmd.c (run_command_1): Use find_run_target. Make direct
target calls.
(attach_command): Use find_attach_target. Make direct target
calls.
* record-btrace.c (init_record_btrace_ops): Don't set
to_create_inferior.
* record-full.c (record_full_can_async_p, record_full_is_async_p):
Remove.
(init_record_full_ops, init_record_full_core_ops): Update. Don't
set to_create_inferior.
* target.c (complete_target_initialization): Add assertion.
(target_create_inferior): Remove.
(find_default_attach, find_default_create_inferior): Remove.
(find_attach_target, find_run_target): New functions.
(find_default_is_async_p, find_default_can_async_p)
(target_supports_non_stop, target_attach): Remove.
(init_dummy_target): Don't set to_create_inferior or
to_supports_non_stop.
* target.h (struct target_ops) <to_attach>: Add comment. Remove
TARGET_DEFAULT_FUNC.
<to_create_inferior>: Add comment.
<to_can_async_p, to_is_async_p, to_supports_non_stop>: Use
TARGET_DEFAULT_RETURN.
<to_can_async_p, to_supports_non_stop, to_can_run>: Add comments.
(find_attach_target, find_run_target): Declare.
(target_create_inferior): Remove.
(target_has_execution_1): Update comment.
(target_supports_non_stop): Remove.
* target-delegates.c: Rebuild.
2014-03-12 Tom Tromey <tromey@redhat.com>
* gdb.base/corefile.exp (corefile_test_run, corefile_test_attach):
New procs. Add target-async tests.
* gdb.reverse/break-precsave.exp (precsave_tests): New proc.
Add target-async tests.
2014-02-28 16:47:34 +00:00
|
|
|
static int
|
|
|
|
delegate_supports_non_stop (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_supports_non_stop (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_supports_non_stop (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:55:34 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2013-12-18 17:57:18 +00:00
|
|
|
static char *
|
|
|
|
delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_make_corefile_notes (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
2013-12-18 18:10:32 +00:00
|
|
|
static gdb_byte *
|
|
|
|
delegate_get_bookmark (struct target_ops *self, char *arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_bookmark (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static gdb_byte *
|
|
|
|
tdefault_get_bookmark (struct target_ops *self, char *arg1, int arg2)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 18:11:25 +00:00
|
|
|
static void
|
|
|
|
delegate_goto_bookmark (struct target_ops *self, gdb_byte *arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_goto_bookmark (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_goto_bookmark (struct target_ops *self, gdb_byte *arg1, int arg2)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
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)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum target_xfer_status
|
|
|
|
tdefault_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)
|
|
|
|
{
|
|
|
|
return TARGET_XFER_E_IO;
|
|
|
|
}
|
|
|
|
|
2013-12-19 14:47:11 +00:00
|
|
|
static VEC(mem_region_s) *
|
|
|
|
delegate_memory_map (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_memory_map (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VEC(mem_region_s) *
|
|
|
|
tdefault_memory_map (struct target_ops *self)
|
|
|
|
{
|
pass NULL to TARGET_DEFAULT_RETURN when appropriate
This changes instances of TARGET_DEFAULT_RETURN(0) to
TARGET_DEFAULT_RETURN(NULL) when appropriate. The use of "0" was a
relic from an earlier implementation of make-target-delegates; and I
didn't want to go back through the long patch series, fixing up
conflicts, just to change this small detail.
2014-02-19 Tom Tromey <tromey@redhat.com>
* target-delegates.c: Rebuild.
* target.h (struct target_ops) <to_extra_thread_info,
to_thread_name, to_pid_to_exec_file, to_get_section_table,
to_memory_map, to_read_description, to_traceframe_info>: Use NULL,
not 0, in TARGET_DEFAULT_RETURN.
2014-01-15 16:30:05 +00:00
|
|
|
return NULL;
|
2013-12-19 14:47:11 +00:00
|
|
|
}
|
|
|
|
|
2013-12-18 21:50:56 +00:00
|
|
|
static void
|
|
|
|
delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_flash_erase (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:52:02 +00:00
|
|
|
static void
|
|
|
|
delegate_flash_done (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_flash_done (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_flash_done (struct target_ops *self)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2014-01-13 16:30:30 +00:00
|
|
|
static const struct target_desc *
|
|
|
|
delegate_read_description (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_read_description (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct target_desc *
|
|
|
|
tdefault_read_description (struct target_ops *self)
|
|
|
|
{
|
pass NULL to TARGET_DEFAULT_RETURN when appropriate
This changes instances of TARGET_DEFAULT_RETURN(0) to
TARGET_DEFAULT_RETURN(NULL) when appropriate. The use of "0" was a
relic from an earlier implementation of make-target-delegates; and I
didn't want to go back through the long patch series, fixing up
conflicts, just to change this small detail.
2014-02-19 Tom Tromey <tromey@redhat.com>
* target-delegates.c: Rebuild.
* target.h (struct target_ops) <to_extra_thread_info,
to_thread_name, to_pid_to_exec_file, to_get_section_table,
to_memory_map, to_read_description, to_traceframe_info>: Use NULL,
not 0, in TARGET_DEFAULT_RETURN.
2014-01-15 16:30:05 +00:00
|
|
|
return NULL;
|
2014-01-13 16:30:30 +00:00
|
|
|
}
|
|
|
|
|
2013-12-18 20:53:09 +00:00
|
|
|
static ptid_t
|
|
|
|
delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_ada_task_ptid (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
2013-12-19 14:56:20 +00:00
|
|
|
static int
|
|
|
|
delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_auxv_parse (self, arg1, arg2, arg3, arg4);
|
|
|
|
}
|
|
|
|
|
2013-12-19 15:12:26 +00:00
|
|
|
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;
|
|
|
|
return self->to_search_memory (self, arg1, arg2, arg3, arg4, arg5);
|
|
|
|
}
|
|
|
|
|
2013-12-18 18:12:28 +00:00
|
|
|
static int
|
|
|
|
delegate_can_execute_reverse (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_can_execute_reverse (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_can_execute_reverse (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 18:15:21 +00:00
|
|
|
static enum exec_direction_kind
|
|
|
|
delegate_execution_direction (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_execution_direction (self);
|
|
|
|
}
|
|
|
|
|
2013-12-18 20:54:06 +00:00
|
|
|
static int
|
|
|
|
delegate_supports_multi_process (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_supports_multi_process (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_supports_multi_process (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 20:54:59 +00:00
|
|
|
static int
|
|
|
|
delegate_supports_enable_disable_tracepoint (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_supports_enable_disable_tracepoint (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 20:56:04 +00:00
|
|
|
static int
|
|
|
|
delegate_supports_string_tracing (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_supports_string_tracing (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_supports_string_tracing (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:20:06 +00:00
|
|
|
static int
|
|
|
|
delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_supports_evaluation_of_breakpoint_conditions (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:20:36 +00:00
|
|
|
static int
|
|
|
|
delegate_can_run_breakpoint_commands (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_can_run_breakpoint_commands (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_can_run_breakpoint_commands (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 18:16:31 +00:00
|
|
|
static struct gdbarch *
|
|
|
|
delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_thread_architecture (self, arg1);
|
|
|
|
}
|
|
|
|
|
2014-02-21 17:33:42 +00:00
|
|
|
static struct address_space *
|
|
|
|
delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_thread_address_space (self, arg1);
|
|
|
|
}
|
|
|
|
|
2013-12-18 20:57:05 +00:00
|
|
|
static void
|
|
|
|
delegate_trace_init (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_trace_init (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_trace_init (struct target_ops *self)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 20:57:41 +00:00
|
|
|
static void
|
|
|
|
delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_download_tracepoint (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:00:23 +00:00
|
|
|
static int
|
|
|
|
delegate_can_download_tracepoint (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_can_download_tracepoint (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_can_download_tracepoint (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:01:07 +00:00
|
|
|
static void
|
|
|
|
delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_download_trace_state_variable (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:01:51 +00:00
|
|
|
static void
|
|
|
|
delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_enable_tracepoint (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:02:30 +00:00
|
|
|
static void
|
|
|
|
delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_disable_tracepoint (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:03:28 +00:00
|
|
|
static void
|
|
|
|
delegate_trace_set_readonly_regions (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_trace_set_readonly_regions (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_trace_set_readonly_regions (struct target_ops *self)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:04:27 +00:00
|
|
|
static void
|
|
|
|
delegate_trace_start (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_trace_start (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_trace_start (struct target_ops *self)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:06:18 +00:00
|
|
|
static int
|
|
|
|
delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_trace_status (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:06:52 +00:00
|
|
|
static void
|
|
|
|
delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_get_tracepoint_status (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:07:28 +00:00
|
|
|
static void
|
|
|
|
delegate_trace_stop (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_trace_stop (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_trace_stop (struct target_ops *self)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:08:14 +00:00
|
|
|
static int
|
|
|
|
delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:09:04 +00:00
|
|
|
static int
|
|
|
|
delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_trace_state_variable_value (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:09:37 +00:00
|
|
|
static int
|
|
|
|
delegate_save_trace_data (struct target_ops *self, const char *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_save_trace_data (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_save_trace_data (struct target_ops *self, const char *arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:10:14 +00:00
|
|
|
static int
|
|
|
|
delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_upload_tracepoints (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:10:40 +00:00
|
|
|
static int
|
|
|
|
delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_upload_trace_state_variables (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:11:12 +00:00
|
|
|
static LONGEST
|
|
|
|
delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_raw_trace_data (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static LONGEST
|
|
|
|
tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:11:53 +00:00
|
|
|
static int
|
|
|
|
delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_min_fast_tracepoint_insn_len (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:12:29 +00:00
|
|
|
static void
|
|
|
|
delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_set_disconnected_tracing (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:13:09 +00:00
|
|
|
static void
|
|
|
|
delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_set_circular_trace_buffer (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:14:58 +00:00
|
|
|
static void
|
|
|
|
delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_set_trace_buffer_size (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:15:23 +00:00
|
|
|
static int
|
|
|
|
delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_set_trace_notes (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:55:06 +00:00
|
|
|
static int
|
|
|
|
delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_core_of_thread (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:55:44 +00:00
|
|
|
static int
|
|
|
|
delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_verify_memory (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:15:55 +00:00
|
|
|
static int
|
|
|
|
delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_tib_address (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:16:24 +00:00
|
|
|
static void
|
|
|
|
delegate_set_permissions (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_set_permissions (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_set_permissions (struct target_ops *self)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:16:51 +00:00
|
|
|
static int
|
|
|
|
delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_static_tracepoint_marker_at (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:17:35 +00:00
|
|
|
static VEC(static_tracepoint_marker_p) *
|
|
|
|
delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_static_tracepoint_markers_by_strid (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VEC(static_tracepoint_marker_p) *
|
|
|
|
tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:18:10 +00:00
|
|
|
static struct traceframe_info *
|
|
|
|
delegate_traceframe_info (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_traceframe_info (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct traceframe_info *
|
|
|
|
tdefault_traceframe_info (struct target_ops *self)
|
|
|
|
{
|
2014-03-04 09:39:10 +00:00
|
|
|
tcomplain ();
|
2013-12-18 21:18:10 +00:00
|
|
|
}
|
|
|
|
|
2013-12-18 21:18:35 +00:00
|
|
|
static int
|
|
|
|
delegate_use_agent (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_use_agent (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_use_agent (struct target_ops *self, int arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:19:04 +00:00
|
|
|
static int
|
|
|
|
delegate_can_use_agent (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_can_use_agent (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_can_use_agent (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-13 20:26:04 +00:00
|
|
|
static int
|
|
|
|
delegate_supports_btrace (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_supports_btrace (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_supports_btrace (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-19 15:19:41 +00:00
|
|
|
static struct btrace_target_info *
|
|
|
|
delegate_enable_btrace (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_enable_btrace (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct btrace_target_info *
|
|
|
|
tdefault_enable_btrace (struct target_ops *self, ptid_t arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 15:17:16 +00:00
|
|
|
static void
|
|
|
|
delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_disable_btrace (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 15:18:04 +00:00
|
|
|
static void
|
|
|
|
delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_teardown_btrace (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 15:19:02 +00:00
|
|
|
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)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_read_btrace (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum btrace_error
|
|
|
|
tdefault_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 15:21:20 +00:00
|
|
|
static void
|
|
|
|
delegate_stop_recording (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_stop_recording (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_stop_recording (struct target_ops *self)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:26:34 +00:00
|
|
|
static void
|
|
|
|
delegate_save_record (struct target_ops *self, const char *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_save_record (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_save_record (struct target_ops *self, const char *arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:25:47 +00:00
|
|
|
static void
|
|
|
|
delegate_delete_record (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_delete_record (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_delete_record (struct target_ops *self)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:25:01 +00:00
|
|
|
static int
|
|
|
|
delegate_record_is_replaying (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_record_is_replaying (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_record_is_replaying (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:24:04 +00:00
|
|
|
static void
|
|
|
|
delegate_goto_record_begin (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_goto_record_begin (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_goto_record_begin (struct target_ops *self)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:23:23 +00:00
|
|
|
static void
|
|
|
|
delegate_goto_record_end (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_goto_record_end (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_goto_record_end (struct target_ops *self)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:22:36 +00:00
|
|
|
static void
|
|
|
|
delegate_goto_record (struct target_ops *self, ULONGEST arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_goto_record (self, arg1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:18:49 +00:00
|
|
|
static void
|
|
|
|
delegate_insn_history (struct target_ops *self, int arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_insn_history (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:16:56 +00:00
|
|
|
static void
|
|
|
|
delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_insn_history_from (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:15:44 +00:00
|
|
|
static void
|
|
|
|
delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_insn_history_range (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:13:40 +00:00
|
|
|
static void
|
|
|
|
delegate_call_history (struct target_ops *self, int arg1, int arg2)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_call_history (self, arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_call_history (struct target_ops *self, int arg1, int arg2)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:11:49 +00:00
|
|
|
static void
|
|
|
|
delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_call_history_from (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-19 03:10:20 +00:00
|
|
|
static void
|
|
|
|
delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
self->to_call_history_range (self, arg1, arg2, arg3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
|
|
|
|
{
|
|
|
|
tcomplain ();
|
|
|
|
}
|
|
|
|
|
2013-12-18 21:19:33 +00:00
|
|
|
static int
|
|
|
|
delegate_augmented_libraries_svr4_read (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_augmented_libraries_svr4_read (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
tdefault_augmented_libraries_svr4_read (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-01-16 20:00:07 +00:00
|
|
|
static const struct frame_unwind *
|
|
|
|
delegate_get_unwinder (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_unwinder (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct frame_unwind *
|
|
|
|
tdefault_get_unwinder (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct frame_unwind *
|
|
|
|
delegate_get_tailcall_unwinder (struct target_ops *self)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_get_tailcall_unwinder (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct frame_unwind *
|
|
|
|
tdefault_get_tailcall_unwinder (struct target_ops *self)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-01-16 18:39:32 +00:00
|
|
|
static CORE_ADDR
|
|
|
|
delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
|
|
|
|
{
|
|
|
|
self = self->beneath;
|
|
|
|
return self->to_decr_pc_after_break (self, arg1);
|
|
|
|
}
|
|
|
|
|
2013-12-19 16:38:11 +00:00
|
|
|
static void
|
|
|
|
install_delegators (struct target_ops *ops)
|
|
|
|
{
|
2013-12-18 16:42:24 +00:00
|
|
|
if (ops->to_post_attach == NULL)
|
|
|
|
ops->to_post_attach = delegate_post_attach;
|
2013-12-13 20:33:08 +00:00
|
|
|
if (ops->to_detach == NULL)
|
|
|
|
ops->to_detach = delegate_detach;
|
2013-12-20 17:30:13 +00:00
|
|
|
if (ops->to_disconnect == NULL)
|
|
|
|
ops->to_disconnect = delegate_disconnect;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
if (ops->to_resume == NULL)
|
|
|
|
ops->to_resume = delegate_resume;
|
|
|
|
if (ops->to_wait == NULL)
|
|
|
|
ops->to_wait = delegate_wait;
|
2013-12-18 21:30:22 +00:00
|
|
|
if (ops->to_fetch_registers == NULL)
|
|
|
|
ops->to_fetch_registers = delegate_fetch_registers;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
if (ops->to_store_registers == NULL)
|
|
|
|
ops->to_store_registers = delegate_store_registers;
|
2013-12-18 16:47:18 +00:00
|
|
|
if (ops->to_prepare_to_store == NULL)
|
|
|
|
ops->to_prepare_to_store = delegate_prepare_to_store;
|
2013-12-18 16:51:47 +00:00
|
|
|
if (ops->to_files_info == NULL)
|
|
|
|
ops->to_files_info = delegate_files_info;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
if (ops->to_insert_breakpoint == NULL)
|
|
|
|
ops->to_insert_breakpoint = delegate_insert_breakpoint;
|
|
|
|
if (ops->to_remove_breakpoint == NULL)
|
|
|
|
ops->to_remove_breakpoint = delegate_remove_breakpoint;
|
2013-12-18 16:58:16 +00:00
|
|
|
if (ops->to_can_use_hw_breakpoint == NULL)
|
|
|
|
ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint;
|
2013-12-18 21:31:42 +00:00
|
|
|
if (ops->to_ranged_break_num_registers == NULL)
|
|
|
|
ops->to_ranged_break_num_registers = delegate_ranged_break_num_registers;
|
2013-12-18 17:01:11 +00:00
|
|
|
if (ops->to_insert_hw_breakpoint == NULL)
|
|
|
|
ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint;
|
2013-12-18 17:05:18 +00:00
|
|
|
if (ops->to_remove_hw_breakpoint == NULL)
|
|
|
|
ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint;
|
2013-12-18 17:11:49 +00:00
|
|
|
if (ops->to_remove_watchpoint == NULL)
|
|
|
|
ops->to_remove_watchpoint = delegate_remove_watchpoint;
|
2013-12-18 17:08:59 +00:00
|
|
|
if (ops->to_insert_watchpoint == NULL)
|
|
|
|
ops->to_insert_watchpoint = delegate_insert_watchpoint;
|
2013-12-18 21:32:43 +00:00
|
|
|
if (ops->to_insert_mask_watchpoint == NULL)
|
|
|
|
ops->to_insert_mask_watchpoint = delegate_insert_mask_watchpoint;
|
2013-12-18 21:33:28 +00:00
|
|
|
if (ops->to_remove_mask_watchpoint == NULL)
|
|
|
|
ops->to_remove_mask_watchpoint = delegate_remove_mask_watchpoint;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
if (ops->to_stopped_by_watchpoint == NULL)
|
|
|
|
ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint;
|
|
|
|
if (ops->to_stopped_data_address == NULL)
|
|
|
|
ops->to_stopped_data_address = delegate_stopped_data_address;
|
2013-12-18 17:15:23 +00:00
|
|
|
if (ops->to_watchpoint_addr_within_range == NULL)
|
|
|
|
ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range;
|
2013-12-18 17:18:05 +00:00
|
|
|
if (ops->to_region_ok_for_hw_watchpoint == NULL)
|
|
|
|
ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint;
|
2013-12-18 17:20:48 +00:00
|
|
|
if (ops->to_can_accel_watchpoint_condition == NULL)
|
|
|
|
ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
|
2013-12-18 21:34:15 +00:00
|
|
|
if (ops->to_masked_watch_num_registers == NULL)
|
|
|
|
ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers;
|
2013-12-18 17:24:07 +00:00
|
|
|
if (ops->to_terminal_init == NULL)
|
|
|
|
ops->to_terminal_init = delegate_terminal_init;
|
2013-12-18 17:29:01 +00:00
|
|
|
if (ops->to_terminal_inferior == NULL)
|
|
|
|
ops->to_terminal_inferior = delegate_terminal_inferior;
|
2013-12-18 17:29:46 +00:00
|
|
|
if (ops->to_terminal_ours_for_output == NULL)
|
|
|
|
ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
|
2013-12-18 17:30:16 +00:00
|
|
|
if (ops->to_terminal_ours == NULL)
|
|
|
|
ops->to_terminal_ours = delegate_terminal_ours;
|
2013-12-18 17:30:41 +00:00
|
|
|
if (ops->to_terminal_save_ours == NULL)
|
|
|
|
ops->to_terminal_save_ours = delegate_terminal_save_ours;
|
2013-12-18 17:31:10 +00:00
|
|
|
if (ops->to_terminal_info == NULL)
|
|
|
|
ops->to_terminal_info = delegate_terminal_info;
|
2013-12-18 21:35:15 +00:00
|
|
|
if (ops->to_kill == NULL)
|
|
|
|
ops->to_kill = delegate_kill;
|
2013-12-18 17:31:48 +00:00
|
|
|
if (ops->to_load == NULL)
|
|
|
|
ops->to_load = delegate_load;
|
2013-12-18 17:32:56 +00:00
|
|
|
if (ops->to_post_startup_inferior == NULL)
|
|
|
|
ops->to_post_startup_inferior = delegate_post_startup_inferior;
|
2013-12-18 17:33:43 +00:00
|
|
|
if (ops->to_insert_fork_catchpoint == NULL)
|
|
|
|
ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint;
|
2013-12-18 17:34:15 +00:00
|
|
|
if (ops->to_remove_fork_catchpoint == NULL)
|
|
|
|
ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint;
|
2013-12-18 17:44:22 +00:00
|
|
|
if (ops->to_insert_vfork_catchpoint == NULL)
|
|
|
|
ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint;
|
2013-12-18 17:44:57 +00:00
|
|
|
if (ops->to_remove_vfork_catchpoint == NULL)
|
|
|
|
ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint;
|
2013-12-18 21:38:04 +00:00
|
|
|
if (ops->to_follow_fork == NULL)
|
|
|
|
ops->to_follow_fork = delegate_follow_fork;
|
2013-12-18 17:45:38 +00:00
|
|
|
if (ops->to_insert_exec_catchpoint == NULL)
|
|
|
|
ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
|
2013-12-18 17:46:02 +00:00
|
|
|
if (ops->to_remove_exec_catchpoint == NULL)
|
|
|
|
ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
|
2013-12-18 17:46:38 +00:00
|
|
|
if (ops->to_set_syscall_catchpoint == NULL)
|
|
|
|
ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
|
2013-12-18 17:47:22 +00:00
|
|
|
if (ops->to_has_exited == NULL)
|
|
|
|
ops->to_has_exited = delegate_has_exited;
|
2013-12-18 21:40:23 +00:00
|
|
|
if (ops->to_mourn_inferior == NULL)
|
|
|
|
ops->to_mourn_inferior = delegate_mourn_inferior;
|
2013-12-20 19:19:37 +00:00
|
|
|
if (ops->to_can_run == NULL)
|
|
|
|
ops->to_can_run = delegate_can_run;
|
2013-12-18 21:42:10 +00:00
|
|
|
if (ops->to_pass_signals == NULL)
|
|
|
|
ops->to_pass_signals = delegate_pass_signals;
|
2013-12-18 21:42:54 +00:00
|
|
|
if (ops->to_program_signals == NULL)
|
|
|
|
ops->to_program_signals = delegate_program_signals;
|
2013-12-19 14:21:56 +00:00
|
|
|
if (ops->to_thread_alive == NULL)
|
|
|
|
ops->to_thread_alive = delegate_thread_alive;
|
2013-12-18 21:44:20 +00:00
|
|
|
if (ops->to_find_new_threads == NULL)
|
|
|
|
ops->to_find_new_threads = delegate_find_new_threads;
|
2013-12-18 21:46:03 +00:00
|
|
|
if (ops->to_pid_to_str == NULL)
|
|
|
|
ops->to_pid_to_str = delegate_pid_to_str;
|
2013-12-18 17:48:36 +00:00
|
|
|
if (ops->to_extra_thread_info == NULL)
|
|
|
|
ops->to_extra_thread_info = delegate_extra_thread_info;
|
2013-12-18 17:49:35 +00:00
|
|
|
if (ops->to_thread_name == NULL)
|
|
|
|
ops->to_thread_name = delegate_thread_name;
|
2013-12-18 21:28:07 +00:00
|
|
|
if (ops->to_stop == NULL)
|
|
|
|
ops->to_stop = delegate_stop;
|
2013-12-18 16:35:21 +00:00
|
|
|
if (ops->to_rcmd == NULL)
|
|
|
|
ops->to_rcmd = delegate_rcmd;
|
2013-12-18 17:51:10 +00:00
|
|
|
if (ops->to_pid_to_exec_file == NULL)
|
|
|
|
ops->to_pid_to_exec_file = delegate_pid_to_exec_file;
|
2013-12-18 17:52:58 +00:00
|
|
|
if (ops->to_log_command == NULL)
|
|
|
|
ops->to_log_command = delegate_log_command;
|
2013-12-18 21:47:06 +00:00
|
|
|
if (ops->to_get_section_table == NULL)
|
|
|
|
ops->to_get_section_table = delegate_get_section_table;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
if (ops->to_can_async_p == NULL)
|
|
|
|
ops->to_can_async_p = delegate_can_async_p;
|
|
|
|
if (ops->to_is_async_p == NULL)
|
|
|
|
ops->to_is_async_p = delegate_is_async_p;
|
|
|
|
if (ops->to_async == NULL)
|
|
|
|
ops->to_async = delegate_async;
|
fix regressions with target-async
A patch in the target cleanup series caused a regression when using
record with target-async. Version 4 of the patch is here:
https://sourceware.org/ml/gdb-patches/2014-03/msg00159.html
The immediate problem is that record supplies to_can_async_p and
to_is_async_p methods, but does not supply a to_async method. So,
when target-async is set, record claims to support async -- but if the
underlying target does not support async, then the to_async method
call will end up in that method's default implementation, namely
tcomplain.
This worked previously because the record target used to provide a
to_async method; one that (erroneously, only at push time) checked the
other members of the target stack, and then simply dropped to_async
calls in the "does not implement async" case.
My first thought was to simply drop tcomplain as the default for
to_async. This works, but Pedro pointed out that the only reason
record has to supply to_can_async_p and to_is_async_p is that these
default to using the find_default_run_target machinery -- and these
defaults are only needed by "run" and "attach".
So, a nicer solution presents itself: change run and attach to
explicitly call into the default run target when needed; and change
to_is_async_p and to_can_async_p to default to "return 0". This makes
the target stack simpler to use and lets us remove the method
implementations from record. This is also in harmony with other plans
for the target stack; namely trying to reduce the impact of
find_default_run_target. This approach makes it clear that
find_default_is_async_p is not needed -- it is asking whether a target
that may not even be pushed is actually async, which seems like a
nonsensical question.
While an improvement, this approach proved to introduce the same bug
when using the core target. Looking a bit deeper, the issue is that
code in "attach" and "run" may need to use either the current target
stack or the default run target -- but different calls into the target
API in those functions could wind up querying different targets.
This new patch makes the target to use more explicit in "run" and
"attach". Then these commands explicitly make the needed calls
against that target. This ensures that a single target is used for
all relevant operations. This lets us remove a couple find_default_*
functions from various targets, including the dummy target. I think
this is a decent understandability improvement.
One issue I see with this patch is that the new calls in "run" and
"attach" are not very much like the rest of the target API. I think
fundamentally this is due to bad factoring in the target API, which
may need to be fixed for multi-target. Tackling that seemed ambitious
for a regression fix.
While working on this I noticed that there don't seem to be any test
cases that involve both target-async and record, so this patch changes
break-precsave.exp to add some. It also changes corefile.exp to add
some target-async tests; these pass with current trunk and with this
patch applied, but fail with the v1 patch.
This patch differs from v4 in that it moves initialization of
to_can_async_p and to_supports_non_stop into inf-child, adds some
assertions to complete_target_initialization, and adds some comments
to target.h.
Built and regtested on x86-64 Fedora 20.
2014-03-12 Tom Tromey <tromey@redhat.com>
* inf-child.c (return_zero): New function.
(inf_child_target): Set to_can_async_p, to_supports_non_stop.
* aix-thread.c (aix_thread_inferior_created): New function.
(aix_thread_attach): Remove.
(init_aix_thread_ops): Don't set to_attach.
(_initialize_aix_thread): Register inferior_created observer.
* corelow.c (init_core_ops): Don't set to_attach or
to_create_inferior.
* exec.c (init_exec_ops): Don't set to_attach or
to_create_inferior.
* infcmd.c (run_command_1): Use find_run_target. Make direct
target calls.
(attach_command): Use find_attach_target. Make direct target
calls.
* record-btrace.c (init_record_btrace_ops): Don't set
to_create_inferior.
* record-full.c (record_full_can_async_p, record_full_is_async_p):
Remove.
(init_record_full_ops, init_record_full_core_ops): Update. Don't
set to_create_inferior.
* target.c (complete_target_initialization): Add assertion.
(target_create_inferior): Remove.
(find_default_attach, find_default_create_inferior): Remove.
(find_attach_target, find_run_target): New functions.
(find_default_is_async_p, find_default_can_async_p)
(target_supports_non_stop, target_attach): Remove.
(init_dummy_target): Don't set to_create_inferior or
to_supports_non_stop.
* target.h (struct target_ops) <to_attach>: Add comment. Remove
TARGET_DEFAULT_FUNC.
<to_create_inferior>: Add comment.
<to_can_async_p, to_is_async_p, to_supports_non_stop>: Use
TARGET_DEFAULT_RETURN.
<to_can_async_p, to_supports_non_stop, to_can_run>: Add comments.
(find_attach_target, find_run_target): Declare.
(target_create_inferior): Remove.
(target_has_execution_1): Update comment.
(target_supports_non_stop): Remove.
* target-delegates.c: Rebuild.
2014-03-12 Tom Tromey <tromey@redhat.com>
* gdb.base/corefile.exp (corefile_test_run, corefile_test_attach):
New procs. Add target-async tests.
* gdb.reverse/break-precsave.exp (precsave_tests): New proc.
Add target-async tests.
2014-02-28 16:47:34 +00:00
|
|
|
if (ops->to_supports_non_stop == NULL)
|
|
|
|
ops->to_supports_non_stop = delegate_supports_non_stop;
|
2013-12-18 17:55:34 +00:00
|
|
|
if (ops->to_find_memory_regions == NULL)
|
|
|
|
ops->to_find_memory_regions = delegate_find_memory_regions;
|
2013-12-18 17:57:18 +00:00
|
|
|
if (ops->to_make_corefile_notes == NULL)
|
|
|
|
ops->to_make_corefile_notes = delegate_make_corefile_notes;
|
2013-12-18 18:10:32 +00:00
|
|
|
if (ops->to_get_bookmark == NULL)
|
|
|
|
ops->to_get_bookmark = delegate_get_bookmark;
|
2013-12-18 18:11:25 +00:00
|
|
|
if (ops->to_goto_bookmark == NULL)
|
|
|
|
ops->to_goto_bookmark = delegate_goto_bookmark;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
if (ops->to_xfer_partial == NULL)
|
|
|
|
ops->to_xfer_partial = delegate_xfer_partial;
|
2013-12-19 14:47:11 +00:00
|
|
|
if (ops->to_memory_map == NULL)
|
|
|
|
ops->to_memory_map = delegate_memory_map;
|
2013-12-18 21:50:56 +00:00
|
|
|
if (ops->to_flash_erase == NULL)
|
|
|
|
ops->to_flash_erase = delegate_flash_erase;
|
2013-12-18 21:52:02 +00:00
|
|
|
if (ops->to_flash_done == NULL)
|
|
|
|
ops->to_flash_done = delegate_flash_done;
|
2014-01-13 16:30:30 +00:00
|
|
|
if (ops->to_read_description == NULL)
|
|
|
|
ops->to_read_description = delegate_read_description;
|
2013-12-18 20:53:09 +00:00
|
|
|
if (ops->to_get_ada_task_ptid == NULL)
|
|
|
|
ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid;
|
2013-12-19 14:56:20 +00:00
|
|
|
if (ops->to_auxv_parse == NULL)
|
|
|
|
ops->to_auxv_parse = delegate_auxv_parse;
|
2013-12-19 15:12:26 +00:00
|
|
|
if (ops->to_search_memory == NULL)
|
|
|
|
ops->to_search_memory = delegate_search_memory;
|
2013-12-18 18:12:28 +00:00
|
|
|
if (ops->to_can_execute_reverse == NULL)
|
|
|
|
ops->to_can_execute_reverse = delegate_can_execute_reverse;
|
2013-12-18 18:15:21 +00:00
|
|
|
if (ops->to_execution_direction == NULL)
|
|
|
|
ops->to_execution_direction = delegate_execution_direction;
|
2013-12-18 20:54:06 +00:00
|
|
|
if (ops->to_supports_multi_process == NULL)
|
|
|
|
ops->to_supports_multi_process = delegate_supports_multi_process;
|
2013-12-18 20:54:59 +00:00
|
|
|
if (ops->to_supports_enable_disable_tracepoint == NULL)
|
|
|
|
ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint;
|
2013-12-18 20:56:04 +00:00
|
|
|
if (ops->to_supports_string_tracing == NULL)
|
|
|
|
ops->to_supports_string_tracing = delegate_supports_string_tracing;
|
2013-12-18 21:20:06 +00:00
|
|
|
if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL)
|
|
|
|
ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions;
|
2013-12-18 21:20:36 +00:00
|
|
|
if (ops->to_can_run_breakpoint_commands == NULL)
|
|
|
|
ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands;
|
2013-12-18 18:16:31 +00:00
|
|
|
if (ops->to_thread_architecture == NULL)
|
|
|
|
ops->to_thread_architecture = delegate_thread_architecture;
|
2014-02-21 17:33:42 +00:00
|
|
|
if (ops->to_thread_address_space == NULL)
|
|
|
|
ops->to_thread_address_space = delegate_thread_address_space;
|
2013-12-18 20:57:05 +00:00
|
|
|
if (ops->to_trace_init == NULL)
|
|
|
|
ops->to_trace_init = delegate_trace_init;
|
2013-12-18 20:57:41 +00:00
|
|
|
if (ops->to_download_tracepoint == NULL)
|
|
|
|
ops->to_download_tracepoint = delegate_download_tracepoint;
|
2013-12-18 21:00:23 +00:00
|
|
|
if (ops->to_can_download_tracepoint == NULL)
|
|
|
|
ops->to_can_download_tracepoint = delegate_can_download_tracepoint;
|
2013-12-18 21:01:07 +00:00
|
|
|
if (ops->to_download_trace_state_variable == NULL)
|
|
|
|
ops->to_download_trace_state_variable = delegate_download_trace_state_variable;
|
2013-12-18 21:01:51 +00:00
|
|
|
if (ops->to_enable_tracepoint == NULL)
|
|
|
|
ops->to_enable_tracepoint = delegate_enable_tracepoint;
|
2013-12-18 21:02:30 +00:00
|
|
|
if (ops->to_disable_tracepoint == NULL)
|
|
|
|
ops->to_disable_tracepoint = delegate_disable_tracepoint;
|
2013-12-18 21:03:28 +00:00
|
|
|
if (ops->to_trace_set_readonly_regions == NULL)
|
|
|
|
ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions;
|
2013-12-18 21:04:27 +00:00
|
|
|
if (ops->to_trace_start == NULL)
|
|
|
|
ops->to_trace_start = delegate_trace_start;
|
2013-12-18 21:06:18 +00:00
|
|
|
if (ops->to_get_trace_status == NULL)
|
|
|
|
ops->to_get_trace_status = delegate_get_trace_status;
|
2013-12-18 21:06:52 +00:00
|
|
|
if (ops->to_get_tracepoint_status == NULL)
|
|
|
|
ops->to_get_tracepoint_status = delegate_get_tracepoint_status;
|
2013-12-18 21:07:28 +00:00
|
|
|
if (ops->to_trace_stop == NULL)
|
|
|
|
ops->to_trace_stop = delegate_trace_stop;
|
2013-12-18 21:08:14 +00:00
|
|
|
if (ops->to_trace_find == NULL)
|
|
|
|
ops->to_trace_find = delegate_trace_find;
|
2013-12-18 21:09:04 +00:00
|
|
|
if (ops->to_get_trace_state_variable_value == NULL)
|
|
|
|
ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value;
|
2013-12-18 21:09:37 +00:00
|
|
|
if (ops->to_save_trace_data == NULL)
|
|
|
|
ops->to_save_trace_data = delegate_save_trace_data;
|
2013-12-18 21:10:14 +00:00
|
|
|
if (ops->to_upload_tracepoints == NULL)
|
|
|
|
ops->to_upload_tracepoints = delegate_upload_tracepoints;
|
2013-12-18 21:10:40 +00:00
|
|
|
if (ops->to_upload_trace_state_variables == NULL)
|
|
|
|
ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables;
|
2013-12-18 21:11:12 +00:00
|
|
|
if (ops->to_get_raw_trace_data == NULL)
|
|
|
|
ops->to_get_raw_trace_data = delegate_get_raw_trace_data;
|
2013-12-18 21:11:53 +00:00
|
|
|
if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
|
|
|
|
ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len;
|
2013-12-18 21:12:29 +00:00
|
|
|
if (ops->to_set_disconnected_tracing == NULL)
|
|
|
|
ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing;
|
2013-12-18 21:13:09 +00:00
|
|
|
if (ops->to_set_circular_trace_buffer == NULL)
|
|
|
|
ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer;
|
2013-12-18 21:14:58 +00:00
|
|
|
if (ops->to_set_trace_buffer_size == NULL)
|
|
|
|
ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size;
|
2013-12-18 21:15:23 +00:00
|
|
|
if (ops->to_set_trace_notes == NULL)
|
|
|
|
ops->to_set_trace_notes = delegate_set_trace_notes;
|
2013-12-18 21:55:06 +00:00
|
|
|
if (ops->to_core_of_thread == NULL)
|
|
|
|
ops->to_core_of_thread = delegate_core_of_thread;
|
2013-12-18 21:55:44 +00:00
|
|
|
if (ops->to_verify_memory == NULL)
|
|
|
|
ops->to_verify_memory = delegate_verify_memory;
|
2013-12-18 21:15:55 +00:00
|
|
|
if (ops->to_get_tib_address == NULL)
|
|
|
|
ops->to_get_tib_address = delegate_get_tib_address;
|
2013-12-18 21:16:24 +00:00
|
|
|
if (ops->to_set_permissions == NULL)
|
|
|
|
ops->to_set_permissions = delegate_set_permissions;
|
2013-12-18 21:16:51 +00:00
|
|
|
if (ops->to_static_tracepoint_marker_at == NULL)
|
|
|
|
ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at;
|
2013-12-18 21:17:35 +00:00
|
|
|
if (ops->to_static_tracepoint_markers_by_strid == NULL)
|
|
|
|
ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
|
2013-12-18 21:18:10 +00:00
|
|
|
if (ops->to_traceframe_info == NULL)
|
|
|
|
ops->to_traceframe_info = delegate_traceframe_info;
|
2013-12-18 21:18:35 +00:00
|
|
|
if (ops->to_use_agent == NULL)
|
|
|
|
ops->to_use_agent = delegate_use_agent;
|
2013-12-18 21:19:04 +00:00
|
|
|
if (ops->to_can_use_agent == NULL)
|
|
|
|
ops->to_can_use_agent = delegate_can_use_agent;
|
2013-12-13 20:26:04 +00:00
|
|
|
if (ops->to_supports_btrace == NULL)
|
|
|
|
ops->to_supports_btrace = delegate_supports_btrace;
|
2013-12-19 15:19:41 +00:00
|
|
|
if (ops->to_enable_btrace == NULL)
|
|
|
|
ops->to_enable_btrace = delegate_enable_btrace;
|
2013-12-19 15:17:16 +00:00
|
|
|
if (ops->to_disable_btrace == NULL)
|
|
|
|
ops->to_disable_btrace = delegate_disable_btrace;
|
2013-12-19 15:18:04 +00:00
|
|
|
if (ops->to_teardown_btrace == NULL)
|
|
|
|
ops->to_teardown_btrace = delegate_teardown_btrace;
|
2013-12-19 15:19:02 +00:00
|
|
|
if (ops->to_read_btrace == NULL)
|
|
|
|
ops->to_read_btrace = delegate_read_btrace;
|
2013-12-19 15:21:20 +00:00
|
|
|
if (ops->to_stop_recording == NULL)
|
|
|
|
ops->to_stop_recording = delegate_stop_recording;
|
2013-12-19 03:26:34 +00:00
|
|
|
if (ops->to_save_record == NULL)
|
|
|
|
ops->to_save_record = delegate_save_record;
|
2013-12-19 03:25:47 +00:00
|
|
|
if (ops->to_delete_record == NULL)
|
|
|
|
ops->to_delete_record = delegate_delete_record;
|
2013-12-19 03:25:01 +00:00
|
|
|
if (ops->to_record_is_replaying == NULL)
|
|
|
|
ops->to_record_is_replaying = delegate_record_is_replaying;
|
2013-12-19 03:24:04 +00:00
|
|
|
if (ops->to_goto_record_begin == NULL)
|
|
|
|
ops->to_goto_record_begin = delegate_goto_record_begin;
|
2013-12-19 03:23:23 +00:00
|
|
|
if (ops->to_goto_record_end == NULL)
|
|
|
|
ops->to_goto_record_end = delegate_goto_record_end;
|
2013-12-19 03:22:36 +00:00
|
|
|
if (ops->to_goto_record == NULL)
|
|
|
|
ops->to_goto_record = delegate_goto_record;
|
2013-12-19 03:18:49 +00:00
|
|
|
if (ops->to_insn_history == NULL)
|
|
|
|
ops->to_insn_history = delegate_insn_history;
|
2013-12-19 03:16:56 +00:00
|
|
|
if (ops->to_insn_history_from == NULL)
|
|
|
|
ops->to_insn_history_from = delegate_insn_history_from;
|
2013-12-19 03:15:44 +00:00
|
|
|
if (ops->to_insn_history_range == NULL)
|
|
|
|
ops->to_insn_history_range = delegate_insn_history_range;
|
2013-12-19 03:13:40 +00:00
|
|
|
if (ops->to_call_history == NULL)
|
|
|
|
ops->to_call_history = delegate_call_history;
|
2013-12-19 03:11:49 +00:00
|
|
|
if (ops->to_call_history_from == NULL)
|
|
|
|
ops->to_call_history_from = delegate_call_history_from;
|
2013-12-19 03:10:20 +00:00
|
|
|
if (ops->to_call_history_range == NULL)
|
|
|
|
ops->to_call_history_range = delegate_call_history_range;
|
2013-12-18 21:19:33 +00:00
|
|
|
if (ops->to_augmented_libraries_svr4_read == NULL)
|
|
|
|
ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read;
|
2014-01-16 20:00:07 +00:00
|
|
|
if (ops->to_get_unwinder == NULL)
|
|
|
|
ops->to_get_unwinder = delegate_get_unwinder;
|
|
|
|
if (ops->to_get_tailcall_unwinder == NULL)
|
|
|
|
ops->to_get_tailcall_unwinder = delegate_get_tailcall_unwinder;
|
2014-01-16 18:39:32 +00:00
|
|
|
if (ops->to_decr_pc_after_break == NULL)
|
|
|
|
ops->to_decr_pc_after_break = delegate_decr_pc_after_break;
|
2013-12-19 16:38:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
install_dummy_methods (struct target_ops *ops)
|
|
|
|
{
|
2013-12-18 16:42:24 +00:00
|
|
|
ops->to_post_attach = tdefault_post_attach;
|
2013-12-13 20:33:08 +00:00
|
|
|
ops->to_detach = tdefault_detach;
|
2013-12-20 17:30:13 +00:00
|
|
|
ops->to_disconnect = tdefault_disconnect;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
ops->to_resume = tdefault_resume;
|
|
|
|
ops->to_wait = tdefault_wait;
|
2013-12-18 21:30:22 +00:00
|
|
|
ops->to_fetch_registers = tdefault_fetch_registers;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
ops->to_store_registers = tdefault_store_registers;
|
2013-12-18 16:47:18 +00:00
|
|
|
ops->to_prepare_to_store = tdefault_prepare_to_store;
|
2013-12-18 16:51:47 +00:00
|
|
|
ops->to_files_info = tdefault_files_info;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
ops->to_insert_breakpoint = memory_insert_breakpoint;
|
|
|
|
ops->to_remove_breakpoint = memory_remove_breakpoint;
|
2013-12-18 16:58:16 +00:00
|
|
|
ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint;
|
2013-12-18 21:31:42 +00:00
|
|
|
ops->to_ranged_break_num_registers = tdefault_ranged_break_num_registers;
|
2013-12-18 17:01:11 +00:00
|
|
|
ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint;
|
2013-12-18 17:05:18 +00:00
|
|
|
ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint;
|
2013-12-18 17:11:49 +00:00
|
|
|
ops->to_remove_watchpoint = tdefault_remove_watchpoint;
|
2013-12-18 17:08:59 +00:00
|
|
|
ops->to_insert_watchpoint = tdefault_insert_watchpoint;
|
2013-12-18 21:32:43 +00:00
|
|
|
ops->to_insert_mask_watchpoint = tdefault_insert_mask_watchpoint;
|
2013-12-18 21:33:28 +00:00
|
|
|
ops->to_remove_mask_watchpoint = tdefault_remove_mask_watchpoint;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint;
|
|
|
|
ops->to_stopped_data_address = tdefault_stopped_data_address;
|
2013-12-18 17:15:23 +00:00
|
|
|
ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range;
|
2013-12-18 17:18:05 +00:00
|
|
|
ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
|
2013-12-18 17:20:48 +00:00
|
|
|
ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
|
2013-12-18 21:34:15 +00:00
|
|
|
ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers;
|
2013-12-18 17:24:07 +00:00
|
|
|
ops->to_terminal_init = tdefault_terminal_init;
|
2013-12-18 17:29:01 +00:00
|
|
|
ops->to_terminal_inferior = tdefault_terminal_inferior;
|
2013-12-18 17:29:46 +00:00
|
|
|
ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
|
2013-12-18 17:30:16 +00:00
|
|
|
ops->to_terminal_ours = tdefault_terminal_ours;
|
2013-12-18 17:30:41 +00:00
|
|
|
ops->to_terminal_save_ours = tdefault_terminal_save_ours;
|
2013-12-18 17:31:10 +00:00
|
|
|
ops->to_terminal_info = default_terminal_info;
|
2013-12-18 21:35:15 +00:00
|
|
|
ops->to_kill = tdefault_kill;
|
2013-12-18 17:31:48 +00:00
|
|
|
ops->to_load = tdefault_load;
|
2013-12-18 17:32:56 +00:00
|
|
|
ops->to_post_startup_inferior = tdefault_post_startup_inferior;
|
2013-12-18 17:33:43 +00:00
|
|
|
ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint;
|
2013-12-18 17:34:15 +00:00
|
|
|
ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint;
|
2013-12-18 17:44:22 +00:00
|
|
|
ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint;
|
2013-12-18 17:44:57 +00:00
|
|
|
ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint;
|
2013-12-18 21:38:04 +00:00
|
|
|
ops->to_follow_fork = default_follow_fork;
|
2013-12-18 17:45:38 +00:00
|
|
|
ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
|
2013-12-18 17:46:02 +00:00
|
|
|
ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
|
2013-12-18 17:46:38 +00:00
|
|
|
ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
|
2013-12-18 17:47:22 +00:00
|
|
|
ops->to_has_exited = tdefault_has_exited;
|
2013-12-18 21:40:23 +00:00
|
|
|
ops->to_mourn_inferior = default_mourn_inferior;
|
2013-12-20 19:19:37 +00:00
|
|
|
ops->to_can_run = tdefault_can_run;
|
2013-12-18 21:42:10 +00:00
|
|
|
ops->to_pass_signals = tdefault_pass_signals;
|
2013-12-18 21:42:54 +00:00
|
|
|
ops->to_program_signals = tdefault_program_signals;
|
2013-12-19 14:21:56 +00:00
|
|
|
ops->to_thread_alive = tdefault_thread_alive;
|
2013-12-18 21:44:20 +00:00
|
|
|
ops->to_find_new_threads = tdefault_find_new_threads;
|
2013-12-18 21:46:03 +00:00
|
|
|
ops->to_pid_to_str = default_pid_to_str;
|
2013-12-18 17:48:36 +00:00
|
|
|
ops->to_extra_thread_info = tdefault_extra_thread_info;
|
2013-12-18 17:49:35 +00:00
|
|
|
ops->to_thread_name = tdefault_thread_name;
|
2013-12-18 21:28:07 +00:00
|
|
|
ops->to_stop = tdefault_stop;
|
2013-12-18 16:35:21 +00:00
|
|
|
ops->to_rcmd = default_rcmd;
|
2013-12-18 17:51:10 +00:00
|
|
|
ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
|
2013-12-18 17:52:58 +00:00
|
|
|
ops->to_log_command = tdefault_log_command;
|
2013-12-18 21:47:06 +00:00
|
|
|
ops->to_get_section_table = tdefault_get_section_table;
|
fix regressions with target-async
A patch in the target cleanup series caused a regression when using
record with target-async. Version 4 of the patch is here:
https://sourceware.org/ml/gdb-patches/2014-03/msg00159.html
The immediate problem is that record supplies to_can_async_p and
to_is_async_p methods, but does not supply a to_async method. So,
when target-async is set, record claims to support async -- but if the
underlying target does not support async, then the to_async method
call will end up in that method's default implementation, namely
tcomplain.
This worked previously because the record target used to provide a
to_async method; one that (erroneously, only at push time) checked the
other members of the target stack, and then simply dropped to_async
calls in the "does not implement async" case.
My first thought was to simply drop tcomplain as the default for
to_async. This works, but Pedro pointed out that the only reason
record has to supply to_can_async_p and to_is_async_p is that these
default to using the find_default_run_target machinery -- and these
defaults are only needed by "run" and "attach".
So, a nicer solution presents itself: change run and attach to
explicitly call into the default run target when needed; and change
to_is_async_p and to_can_async_p to default to "return 0". This makes
the target stack simpler to use and lets us remove the method
implementations from record. This is also in harmony with other plans
for the target stack; namely trying to reduce the impact of
find_default_run_target. This approach makes it clear that
find_default_is_async_p is not needed -- it is asking whether a target
that may not even be pushed is actually async, which seems like a
nonsensical question.
While an improvement, this approach proved to introduce the same bug
when using the core target. Looking a bit deeper, the issue is that
code in "attach" and "run" may need to use either the current target
stack or the default run target -- but different calls into the target
API in those functions could wind up querying different targets.
This new patch makes the target to use more explicit in "run" and
"attach". Then these commands explicitly make the needed calls
against that target. This ensures that a single target is used for
all relevant operations. This lets us remove a couple find_default_*
functions from various targets, including the dummy target. I think
this is a decent understandability improvement.
One issue I see with this patch is that the new calls in "run" and
"attach" are not very much like the rest of the target API. I think
fundamentally this is due to bad factoring in the target API, which
may need to be fixed for multi-target. Tackling that seemed ambitious
for a regression fix.
While working on this I noticed that there don't seem to be any test
cases that involve both target-async and record, so this patch changes
break-precsave.exp to add some. It also changes corefile.exp to add
some target-async tests; these pass with current trunk and with this
patch applied, but fail with the v1 patch.
This patch differs from v4 in that it moves initialization of
to_can_async_p and to_supports_non_stop into inf-child, adds some
assertions to complete_target_initialization, and adds some comments
to target.h.
Built and regtested on x86-64 Fedora 20.
2014-03-12 Tom Tromey <tromey@redhat.com>
* inf-child.c (return_zero): New function.
(inf_child_target): Set to_can_async_p, to_supports_non_stop.
* aix-thread.c (aix_thread_inferior_created): New function.
(aix_thread_attach): Remove.
(init_aix_thread_ops): Don't set to_attach.
(_initialize_aix_thread): Register inferior_created observer.
* corelow.c (init_core_ops): Don't set to_attach or
to_create_inferior.
* exec.c (init_exec_ops): Don't set to_attach or
to_create_inferior.
* infcmd.c (run_command_1): Use find_run_target. Make direct
target calls.
(attach_command): Use find_attach_target. Make direct target
calls.
* record-btrace.c (init_record_btrace_ops): Don't set
to_create_inferior.
* record-full.c (record_full_can_async_p, record_full_is_async_p):
Remove.
(init_record_full_ops, init_record_full_core_ops): Update. Don't
set to_create_inferior.
* target.c (complete_target_initialization): Add assertion.
(target_create_inferior): Remove.
(find_default_attach, find_default_create_inferior): Remove.
(find_attach_target, find_run_target): New functions.
(find_default_is_async_p, find_default_can_async_p)
(target_supports_non_stop, target_attach): Remove.
(init_dummy_target): Don't set to_create_inferior or
to_supports_non_stop.
* target.h (struct target_ops) <to_attach>: Add comment. Remove
TARGET_DEFAULT_FUNC.
<to_create_inferior>: Add comment.
<to_can_async_p, to_is_async_p, to_supports_non_stop>: Use
TARGET_DEFAULT_RETURN.
<to_can_async_p, to_supports_non_stop, to_can_run>: Add comments.
(find_attach_target, find_run_target): Declare.
(target_create_inferior): Remove.
(target_has_execution_1): Update comment.
(target_supports_non_stop): Remove.
* target-delegates.c: Rebuild.
2014-03-12 Tom Tromey <tromey@redhat.com>
* gdb.base/corefile.exp (corefile_test_run, corefile_test_attach):
New procs. Add target-async tests.
* gdb.reverse/break-precsave.exp (precsave_tests): New proc.
Add target-async tests.
2014-02-28 16:47:34 +00:00
|
|
|
ops->to_can_async_p = tdefault_can_async_p;
|
|
|
|
ops->to_is_async_p = tdefault_is_async_p;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
ops->to_async = tdefault_async;
|
fix regressions with target-async
A patch in the target cleanup series caused a regression when using
record with target-async. Version 4 of the patch is here:
https://sourceware.org/ml/gdb-patches/2014-03/msg00159.html
The immediate problem is that record supplies to_can_async_p and
to_is_async_p methods, but does not supply a to_async method. So,
when target-async is set, record claims to support async -- but if the
underlying target does not support async, then the to_async method
call will end up in that method's default implementation, namely
tcomplain.
This worked previously because the record target used to provide a
to_async method; one that (erroneously, only at push time) checked the
other members of the target stack, and then simply dropped to_async
calls in the "does not implement async" case.
My first thought was to simply drop tcomplain as the default for
to_async. This works, but Pedro pointed out that the only reason
record has to supply to_can_async_p and to_is_async_p is that these
default to using the find_default_run_target machinery -- and these
defaults are only needed by "run" and "attach".
So, a nicer solution presents itself: change run and attach to
explicitly call into the default run target when needed; and change
to_is_async_p and to_can_async_p to default to "return 0". This makes
the target stack simpler to use and lets us remove the method
implementations from record. This is also in harmony with other plans
for the target stack; namely trying to reduce the impact of
find_default_run_target. This approach makes it clear that
find_default_is_async_p is not needed -- it is asking whether a target
that may not even be pushed is actually async, which seems like a
nonsensical question.
While an improvement, this approach proved to introduce the same bug
when using the core target. Looking a bit deeper, the issue is that
code in "attach" and "run" may need to use either the current target
stack or the default run target -- but different calls into the target
API in those functions could wind up querying different targets.
This new patch makes the target to use more explicit in "run" and
"attach". Then these commands explicitly make the needed calls
against that target. This ensures that a single target is used for
all relevant operations. This lets us remove a couple find_default_*
functions from various targets, including the dummy target. I think
this is a decent understandability improvement.
One issue I see with this patch is that the new calls in "run" and
"attach" are not very much like the rest of the target API. I think
fundamentally this is due to bad factoring in the target API, which
may need to be fixed for multi-target. Tackling that seemed ambitious
for a regression fix.
While working on this I noticed that there don't seem to be any test
cases that involve both target-async and record, so this patch changes
break-precsave.exp to add some. It also changes corefile.exp to add
some target-async tests; these pass with current trunk and with this
patch applied, but fail with the v1 patch.
This patch differs from v4 in that it moves initialization of
to_can_async_p and to_supports_non_stop into inf-child, adds some
assertions to complete_target_initialization, and adds some comments
to target.h.
Built and regtested on x86-64 Fedora 20.
2014-03-12 Tom Tromey <tromey@redhat.com>
* inf-child.c (return_zero): New function.
(inf_child_target): Set to_can_async_p, to_supports_non_stop.
* aix-thread.c (aix_thread_inferior_created): New function.
(aix_thread_attach): Remove.
(init_aix_thread_ops): Don't set to_attach.
(_initialize_aix_thread): Register inferior_created observer.
* corelow.c (init_core_ops): Don't set to_attach or
to_create_inferior.
* exec.c (init_exec_ops): Don't set to_attach or
to_create_inferior.
* infcmd.c (run_command_1): Use find_run_target. Make direct
target calls.
(attach_command): Use find_attach_target. Make direct target
calls.
* record-btrace.c (init_record_btrace_ops): Don't set
to_create_inferior.
* record-full.c (record_full_can_async_p, record_full_is_async_p):
Remove.
(init_record_full_ops, init_record_full_core_ops): Update. Don't
set to_create_inferior.
* target.c (complete_target_initialization): Add assertion.
(target_create_inferior): Remove.
(find_default_attach, find_default_create_inferior): Remove.
(find_attach_target, find_run_target): New functions.
(find_default_is_async_p, find_default_can_async_p)
(target_supports_non_stop, target_attach): Remove.
(init_dummy_target): Don't set to_create_inferior or
to_supports_non_stop.
* target.h (struct target_ops) <to_attach>: Add comment. Remove
TARGET_DEFAULT_FUNC.
<to_create_inferior>: Add comment.
<to_can_async_p, to_is_async_p, to_supports_non_stop>: Use
TARGET_DEFAULT_RETURN.
<to_can_async_p, to_supports_non_stop, to_can_run>: Add comments.
(find_attach_target, find_run_target): Declare.
(target_create_inferior): Remove.
(target_has_execution_1): Update comment.
(target_supports_non_stop): Remove.
* target-delegates.c: Rebuild.
2014-03-12 Tom Tromey <tromey@redhat.com>
* gdb.base/corefile.exp (corefile_test_run, corefile_test_attach):
New procs. Add target-async tests.
* gdb.reverse/break-precsave.exp (precsave_tests): New proc.
Add target-async tests.
2014-02-28 16:47:34 +00:00
|
|
|
ops->to_supports_non_stop = tdefault_supports_non_stop;
|
2013-12-18 17:55:34 +00:00
|
|
|
ops->to_find_memory_regions = dummy_find_memory_regions;
|
2013-12-18 17:57:18 +00:00
|
|
|
ops->to_make_corefile_notes = dummy_make_corefile_notes;
|
2013-12-18 18:10:32 +00:00
|
|
|
ops->to_get_bookmark = tdefault_get_bookmark;
|
2013-12-18 18:11:25 +00:00
|
|
|
ops->to_goto_bookmark = tdefault_goto_bookmark;
|
add target method delegation
This patch replaces some code in the record targets with target method
delegation.
record-full.c stores pointers to many target methods when the record
target is pushed. Then it later delegates some calls via these. This
is wrong because it violates the target stack contract. In particular
it is ok to unpush a target at any stratum, but record-full does not
keep track of this, so it could potentially call into an unpushed
target.
This patch fixes the problem by using the newly-introduced generic
approach to target delegation for the methods in question.
2014-02-19 Tom Tromey <tromey@redhat.com>
* record-full.c (record_full_beneath_to_resume_ops)
(record_full_beneath_to_resume, record_full_beneath_to_wait_ops)
(record_full_beneath_to_wait)
(record_full_beneath_to_store_registers_ops)
(record_full_beneath_to_store_registers)
(record_full_beneath_to_xfer_partial_ops)
(record_full_beneath_to_xfer_partial)
(record_full_beneath_to_insert_breakpoint_ops)
(record_full_beneath_to_insert_breakpoint)
(record_full_beneath_to_remove_breakpoint_ops)
(record_full_beneath_to_remove_breakpoint)
(record_full_beneath_to_stopped_by_watchpoint)
(record_full_beneath_to_stopped_data_address)
(record_full_beneath_to_async, tmp_to_resume_ops, tmp_to_resume)
(tmp_to_wait_ops, tmp_to_wait, tmp_to_store_registers_ops)
(tmp_to_store_registers, tmp_to_xfer_partial_ops)
(tmp_to_xfer_partial, tmp_to_instmp_to_insert_breakpoint_ops)
(tmp_to_insert_breakpoint, tmp_to_remove_breakpoint_ops)
(tmp_to_remove_breakpoint, tmp_to_stopped_by_watchpoint)
(tmp_to_stopped_data_address, tmp_to_async): Remove.
(record_full_open_1, record_full_open): Update. Use RECORD_IS_USED.
(record_full_resume, record_full_wait_1)
(record_full_stopped_by_watchpoint, record_full_stopped_data_address)
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint)
(record_full_async, record_full_core_xfer_partial): Use target
delegation.
* target-delegates.c: Rebuild.
* target.c (current_xfer_partial): Remove.
(update_current_target): Do not INHERIT or de_fault
to_insert_breakpoint, to_remove_breakpoint,
to_stopped_data_address, to_stopped_by_watchpoint, to_can_async_p,
to_is_async_p, to_async. Do not set to_xfer_partial field.
(default_xfer_partial): Simplify.
(current_xfer_partial): Remove.
(target_wait, target_resume): Simplify.
(find_default_can_async_p, find_default_is_async_p): Update.
(init_dummy_target): Don't set to_can_async_p, to_is_async_p,
to_xfer_partial, to_stopped_by_watchpoint,
to_stopped_data_address.
(target_store_registers): Simplify.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
(target_remove_breakpoint, target_insert_breakpoint)
(debug_to_insert_breakpoint, debug_to_remove_breakpoint): Update.
* target.h (struct target_ops) <to_resume, to_wait,
to_store_registers, to_insert_breakpoint, to_remove_breakpoint,
to_stopped_by_watchpoint, to_stopped_data_address, to_can_async_p,
to_is_async_p, to_async, to_xfer_partial>: Add TARGET_DEFAULT
markup.
(forward_target_remove_breakpoint)
(forward_target_insert_breakpoint): Remove.
* record-btrace.c (record_btrace_remove_breakpoint): Delegate
directly.
(record_btrace_insert_breakpoint): Delegate directly.
2013-07-12 19:00:34 +00:00
|
|
|
ops->to_xfer_partial = tdefault_xfer_partial;
|
2013-12-19 14:47:11 +00:00
|
|
|
ops->to_memory_map = tdefault_memory_map;
|
2013-12-18 21:50:56 +00:00
|
|
|
ops->to_flash_erase = tdefault_flash_erase;
|
2013-12-18 21:52:02 +00:00
|
|
|
ops->to_flash_done = tdefault_flash_done;
|
2014-01-13 16:30:30 +00:00
|
|
|
ops->to_read_description = tdefault_read_description;
|
2013-12-18 20:53:09 +00:00
|
|
|
ops->to_get_ada_task_ptid = default_get_ada_task_ptid;
|
2013-12-19 14:56:20 +00:00
|
|
|
ops->to_auxv_parse = default_auxv_parse;
|
2013-12-19 15:12:26 +00:00
|
|
|
ops->to_search_memory = default_search_memory;
|
2013-12-18 18:12:28 +00:00
|
|
|
ops->to_can_execute_reverse = tdefault_can_execute_reverse;
|
2013-12-18 18:15:21 +00:00
|
|
|
ops->to_execution_direction = default_execution_direction;
|
2013-12-18 20:54:06 +00:00
|
|
|
ops->to_supports_multi_process = tdefault_supports_multi_process;
|
2013-12-18 20:54:59 +00:00
|
|
|
ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint;
|
2013-12-18 20:56:04 +00:00
|
|
|
ops->to_supports_string_tracing = tdefault_supports_string_tracing;
|
2013-12-18 21:20:06 +00:00
|
|
|
ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions;
|
2013-12-18 21:20:36 +00:00
|
|
|
ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands;
|
2013-12-18 18:16:31 +00:00
|
|
|
ops->to_thread_architecture = default_thread_architecture;
|
2014-02-21 17:33:42 +00:00
|
|
|
ops->to_thread_address_space = default_thread_address_space;
|
2013-12-18 20:57:05 +00:00
|
|
|
ops->to_trace_init = tdefault_trace_init;
|
2013-12-18 20:57:41 +00:00
|
|
|
ops->to_download_tracepoint = tdefault_download_tracepoint;
|
2013-12-18 21:00:23 +00:00
|
|
|
ops->to_can_download_tracepoint = tdefault_can_download_tracepoint;
|
2013-12-18 21:01:07 +00:00
|
|
|
ops->to_download_trace_state_variable = tdefault_download_trace_state_variable;
|
2013-12-18 21:01:51 +00:00
|
|
|
ops->to_enable_tracepoint = tdefault_enable_tracepoint;
|
2013-12-18 21:02:30 +00:00
|
|
|
ops->to_disable_tracepoint = tdefault_disable_tracepoint;
|
2013-12-18 21:03:28 +00:00
|
|
|
ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions;
|
2013-12-18 21:04:27 +00:00
|
|
|
ops->to_trace_start = tdefault_trace_start;
|
2013-12-18 21:06:18 +00:00
|
|
|
ops->to_get_trace_status = tdefault_get_trace_status;
|
2013-12-18 21:06:52 +00:00
|
|
|
ops->to_get_tracepoint_status = tdefault_get_tracepoint_status;
|
2013-12-18 21:07:28 +00:00
|
|
|
ops->to_trace_stop = tdefault_trace_stop;
|
2013-12-18 21:08:14 +00:00
|
|
|
ops->to_trace_find = tdefault_trace_find;
|
2013-12-18 21:09:04 +00:00
|
|
|
ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value;
|
2013-12-18 21:09:37 +00:00
|
|
|
ops->to_save_trace_data = tdefault_save_trace_data;
|
2013-12-18 21:10:14 +00:00
|
|
|
ops->to_upload_tracepoints = tdefault_upload_tracepoints;
|
2013-12-18 21:10:40 +00:00
|
|
|
ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables;
|
2013-12-18 21:11:12 +00:00
|
|
|
ops->to_get_raw_trace_data = tdefault_get_raw_trace_data;
|
2013-12-18 21:11:53 +00:00
|
|
|
ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len;
|
2013-12-18 21:12:29 +00:00
|
|
|
ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing;
|
2013-12-18 21:13:09 +00:00
|
|
|
ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer;
|
2013-12-18 21:14:58 +00:00
|
|
|
ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size;
|
2013-12-18 21:15:23 +00:00
|
|
|
ops->to_set_trace_notes = tdefault_set_trace_notes;
|
2013-12-18 21:55:06 +00:00
|
|
|
ops->to_core_of_thread = tdefault_core_of_thread;
|
Make compare-sections work against all targets; add compare-sections [-r] tests.
This does two things:
1. Adds a test.
Recently compare-sections got a new "-r" switch, but given no test
existed for compare-sections, the patch was allowed in with no
testsuite addition. This now adds a test for both compare-sections
and compare-sections -r.
2. Makes the compare-sections command work against all targets.
Currently, compare-sections only works with remote targets, and only
those that support the qCRC packet. The patch makes it so that if the
target doesn't support accelerating memory verification, then GDB
falls back to comparing memory itself. This is of course slower, but
it's better than nothing, IMO. While testing against extended-remote
GDBserver I noticed that we send the qCRC request to the target if
we're connected, but not yet running a program. That can't work of
course -- the patch fixes that. This all also goes in the direction
of bridging the local/remote parity gap.
I didn't decouple 1. from 2., because that would mean that the test
would need to handle the case of the target not supporting the
command.
Tested on x86_64 Fedora 17, native, remote GDBserver, and
extended-remote GDBserver. I also hack-disabled qCRC support to make
sure the fallback paths in remote.c work.
gdb/doc/
2014-05-20 Pedro Alves <palves@redhat.com>
* gdb.texinfo (Memory) <compare-sections>: Generalize comments to
not be remote specific. Add cross reference to the qCRC packet.
(Separate Debug Files): Update cross reference to the qCRC packet.
(General Query Packets) <qCRC packet>: Add anchor.
gdb/
2014-05-20 Pedro Alves <palves@redhat.com>
* NEWS: Mention that compare-sections now works with all targets.
* remote.c (PACKET_qCRC): New enum value.
(remote_verify_memory): Don't send qCRC if the target has no
execution. Use packet_support/packet_ok. If the target doesn't
support the qCRC packet, fallback to a deep memory copy.
(compare_sections_command): Say "target image" instead of "remote
executable".
(_initialize_remote): Add PACKET_qCRC to the list of config
packets that have no associated command. Extend comment.
* target.c (simple_verify_memory, default_verify_memory): New
function.
* target.h (struct target_ops) <to_verify_memory>: Default to
default_verify_memory.
(simple_verify_memory): New declaration.
* target-delegates.c: Regenerate.
gdb/testsuite/
2014-05-20 Pedro Alves <palves@redhat.com>
* gdb.base/compare-sections.c: New file.
* gdb.base/compare-sections.exp: New file.
2014-05-20 18:11:39 +00:00
|
|
|
ops->to_verify_memory = default_verify_memory;
|
2013-12-18 21:15:55 +00:00
|
|
|
ops->to_get_tib_address = tdefault_get_tib_address;
|
2013-12-18 21:16:24 +00:00
|
|
|
ops->to_set_permissions = tdefault_set_permissions;
|
2013-12-18 21:16:51 +00:00
|
|
|
ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at;
|
2013-12-18 21:17:35 +00:00
|
|
|
ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
|
2013-12-18 21:18:10 +00:00
|
|
|
ops->to_traceframe_info = tdefault_traceframe_info;
|
2013-12-18 21:18:35 +00:00
|
|
|
ops->to_use_agent = tdefault_use_agent;
|
2013-12-18 21:19:04 +00:00
|
|
|
ops->to_can_use_agent = tdefault_can_use_agent;
|
2013-12-13 20:26:04 +00:00
|
|
|
ops->to_supports_btrace = tdefault_supports_btrace;
|
2013-12-19 15:19:41 +00:00
|
|
|
ops->to_enable_btrace = tdefault_enable_btrace;
|
2013-12-19 15:17:16 +00:00
|
|
|
ops->to_disable_btrace = tdefault_disable_btrace;
|
2013-12-19 15:18:04 +00:00
|
|
|
ops->to_teardown_btrace = tdefault_teardown_btrace;
|
2013-12-19 15:19:02 +00:00
|
|
|
ops->to_read_btrace = tdefault_read_btrace;
|
2013-12-19 15:21:20 +00:00
|
|
|
ops->to_stop_recording = tdefault_stop_recording;
|
2013-12-19 03:26:34 +00:00
|
|
|
ops->to_save_record = tdefault_save_record;
|
2013-12-19 03:25:47 +00:00
|
|
|
ops->to_delete_record = tdefault_delete_record;
|
2013-12-19 03:25:01 +00:00
|
|
|
ops->to_record_is_replaying = tdefault_record_is_replaying;
|
2013-12-19 03:24:04 +00:00
|
|
|
ops->to_goto_record_begin = tdefault_goto_record_begin;
|
2013-12-19 03:23:23 +00:00
|
|
|
ops->to_goto_record_end = tdefault_goto_record_end;
|
2013-12-19 03:22:36 +00:00
|
|
|
ops->to_goto_record = tdefault_goto_record;
|
2013-12-19 03:18:49 +00:00
|
|
|
ops->to_insn_history = tdefault_insn_history;
|
2013-12-19 03:16:56 +00:00
|
|
|
ops->to_insn_history_from = tdefault_insn_history_from;
|
2013-12-19 03:15:44 +00:00
|
|
|
ops->to_insn_history_range = tdefault_insn_history_range;
|
2013-12-19 03:13:40 +00:00
|
|
|
ops->to_call_history = tdefault_call_history;
|
2013-12-19 03:11:49 +00:00
|
|
|
ops->to_call_history_from = tdefault_call_history_from;
|
2013-12-19 03:10:20 +00:00
|
|
|
ops->to_call_history_range = tdefault_call_history_range;
|
2013-12-18 21:19:33 +00:00
|
|
|
ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read;
|
2014-01-16 20:00:07 +00:00
|
|
|
ops->to_get_unwinder = tdefault_get_unwinder;
|
|
|
|
ops->to_get_tailcall_unwinder = tdefault_get_tailcall_unwinder;
|
2014-01-16 18:39:32 +00:00
|
|
|
ops->to_decr_pc_after_break = default_target_decr_pc_after_break;
|
2013-12-19 16:38:11 +00:00
|
|
|
}
|