mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-09 04:21:49 +08:00
f6ac5f3d63
I.e., use C++ virtual methods and inheritance instead of tables of
function pointers.
Unfortunately, there's no way to do a smooth transition. ALL native
targets in the tree must be converted at the same time. I've tested
all I could with cross compilers and with help from GCC compile farm,
but naturally I haven't been able to test many of the ports. Still, I
made a best effort to port everything over, and while I expect some
build problems due to typos and such, which should be trivial to fix,
I don't expect any design problems.
* Implementation notes:
- The flattened current_target is gone. References to current_target
or current_target.beneath are replaced with references to
target_stack (the top of the stack) directly.
- To keep "set debug target" working, this adds a new debug_stratum
layer that sits on top of the stack, prints the debug, and delegates
to the target beneath.
In addition, this makes the shortname and longname properties of
target_ops be virtual methods instead of data fields, and makes the
debug target defer those to the target beneath. This is so that
debug code sprinkled around that does "if (debugtarget) ..." can
transparently print the name of the target beneath.
A patch later in the series actually splits out the
shortname/longname methods to a separate structure, but I preferred
to keep that chance separate as it is associated with changing a bit
the design of how targets are registered and open.
- Since you can't check whether a C++ virtual method is overridden,
the old method of checking whether a target_ops implements a method
by comparing the function pointer must be replaced with something
else.
Some cases are fixed by adding a parallel "can_do_foo" target_ops
methods. E.g.,:
+ for (t = target_stack; t != NULL; t = t->beneath)
{
- if (t->to_create_inferior != NULL)
+ if (t->can_create_inferior ())
break;
}
Others are fixed by changing void return type to bool or int return
type, and have the default implementation return false or -1, to
indicate lack of support.
- make-target-delegates was adjusted to generate C++ classes and
methods.
It needed tweaks to grok "virtual" in front of the target method
name, and for the fact that methods are no longer function pointers.
(In particular, the current code parsing the return type was simple
because it could simply parse up until the '(' in '(*to_foo)'.
It now generates a couple C++ classes that inherit target_ops:
dummy_target and debug_target.
Since we need to generate the class declarations as well, i.e., we
need to emit methods twice, we now generate the code in two passes.
- The core_target global is renamed to avoid conflict with the
"core_target" class.
- ctf/tfile targets
init_tracefile_ops is replaced by a base class that is inherited by
both ctf and tfile.
- bsd-uthread
The bsd_uthread_ops_hack hack is gone. It's not needed because
nothing was extending a target created by bsd_uthread_target.
- remote/extended-remote targets
This is a first pass, just enough to C++ify target_ops.
A later pass will convert more free functions to methods, and make
remote_state be truly per remote instance, allowing multiple
simultaneous instances of remote targets.
- inf-child/"native" is converted to an actual base class
(inf_child_target), that is inherited by all native targets.
- GNU/Linux
The old weird double-target linux_ops mechanism in linux-nat.c, is
gone, replaced by adding a few virtual methods to linux-nat.h's
target_ops, called low_XXX, that the concrete linux-nat
implementations override. Sort of like gdbserver's
linux_target_ops, but simpler, for requiring only one
target_ops-like hierarchy, which spares implementing the same method
twice when we need to forward the method to a low implementation.
The low target simply reimplements the target_ops method directly in
that case.
There are a few remaining linux-nat.c hooks that would be better
converted to low_ methods like above too. E.g.:
linux_nat_set_new_thread (t, x86_linux_new_thread);
linux_nat_set_new_fork (t, x86_linux_new_fork);
linux_nat_set_forget_process
That'll be done in a follow up patch.
- We can no longer use functions like x86_use_watchpoints to install
custom methods on an arbitrary base target.
The patch replaces instances of such a pattern with template mixins.
For example memory_breakpoint_target defined in target.h, or
x86_nat_target in x86-nat.h.
- linux_trad_target, MIPS and Alpha GNU/Linux
The code in the new linux-nat-trad.h/c files which was split off of
inf-ptrace.h/c recently, is converted to a C++ base class, and used
by the MIPS and Alpha GNU/Linux ports.
- BSD targets
The
$architecture x NetBSD/OpenBSD/FreeBSD
support matrix complicates things a bit. There's common BSD target
code, and there's common architecture-specific code shared between
the different BSDs. Currently, all that is stiched together to form
a final target, via the i386bsd_target, x86bsd_target,
fbsd_nat_add_target functions etc.
This introduces new fbsd_nat_target, obsd_nat_target and
nbsd_nat_target classes that serve as base/prototype target for the
corresponding BSD variant.
And introduces generic i386/AMD64 BSD targets, to be used as
template mixin to build a final target. Similarly, a generic SPARC
target is added, used by both BSD and Linux ports.
- bsd_kvm_add_target, BSD libkvm target
I considered making bsd_kvm_supply_pcb a virtual method, and then
have each port inherit bsd_kvm_target and override that method, but
that was resulting in lots of unjustified churn, so I left the
function pointer mechanism alone.
gdb/ChangeLog:
2018-05-02 Pedro Alves <palves@redhat.com>
John Baldwin <jhb@freebsd.org>
* target.h (enum strata) <debug_stratum>: New.
(struct target_ops) <all delegation methods>: Replace by C++
virtual methods, and drop "to_" prefix. All references updated
throughout.
<to_shortname, to_longname, to_doc, to_data,
to_have_steppable_watchpoint, to_have_continuable_watchpoint,
to_has_thread_control, to_attach_no_wait>: Delete, replaced by
virtual methods. All references updated throughout.
<can_attach, supports_terminal_ours, can_create_inferior,
get_thread_control_capabilities, attach_no_wait>: New
virtual methods.
<insert_breakpoint, remove_breakpoint>: Now
TARGET_DEFAULT_NORETURN methods.
<info_proc>: Now returns bool.
<to_magic>: Delete.
(OPS_MAGIC): Delete.
(current_target): Delete. All references replaced by references
to ...
(target_stack): ... this. New.
(target_shortname, target_longname): Adjust.
(target_can_run): Now a function declaration.
(default_child_has_all_memory, default_child_has_memory)
(default_child_has_stack, default_child_has_registers)
(default_child_has_execution): Remove target_ops parameter.
(complete_target_initialization): Delete.
(memory_breakpoint_target): New template class.
(test_target_ops): Refactor as a C++ class with virtual methods.
* make-target-delegates (NAME_PART): Tighten.
(POINTER_PART, CP_SYMBOL): New.
(SIMPLE_RETURN_PART): Reimplement.
(VEC_RETURN_PART): Expect less.
(RETURN_PART, VIRTUAL_PART): New.
(METHOD): Adjust to C++ virtual methods.
(scan_target_h): Remove reference to C99.
(dname): Output "target_ops::" prefix.
(write_function_header): Adjust to output a C++ class method.
(write_declaration): New.
(write_delegator): Adjust to output a C++ class method.
(tdname): Output "dummy_target::" prefix.
(write_tdefault, write_debugmethod): Adjust to output a C++ class
method.
(tdefault_names, debug_names): Delete.
(return_types, tdefaults, styles, argtypes_array): New.
(top level): All methods are delegators.
(print_class): New.
(top level): Print dummy_target and debug_target classes.
* target-delegates.c: Regenerate.
* target-debug.h (target_debug_print_enum_info_proc_what)
(target_debug_print_thread_control_capabilities)
(target_debug_print_thread_info_p): New.
* target.c (dummy_target): Delete.
(the_dummy_target, the_debug_target): New.
(target_stack): Now extern.
(set_targetdebug): Push/unpush debug target.
(default_child_has_all_memory, default_child_has_memory)
(default_child_has_stack, default_child_has_registers)
(default_child_has_execution): Remove target_ops parameter.
(complete_target_initialization): Delete.
(add_target_with_completer): No longer call
complete_target_initialization.
(target_supports_terminal_ours): Use regular delegation.
(update_current_target): Delete.
(push_target): No longer check magic number. Don't call
update_current_target.
(unpush_target): Don't call update_current_target.
(target_is_pushed): No longer check magic number.
(target_require_runnable): Skip for all stratums over
process_stratum.
(target_ops::info_proc): New.
(target_info_proc): Use find_target_at and
find_default_run_target.
(target_supports_disable_randomization): Use regular delegation.
(target_get_osdata): Use find_target_at.
(target_ops::open, target_ops::close, target_ops::can_attach)
(target_ops::attach, target_ops::can_create_inferior)
(target_ops::create_inferior, target_ops::can_run)
(target_can_run): New.
(default_fileio_target): Use regular delegation.
(target_ops::fileio_open, target_ops::fileio_pwrite)
(target_ops::fileio_pread, target_ops::fileio_fstat)
(target_ops::fileio_close, target_ops::fileio_unlink)
(target_ops::fileio_readlink): New.
(target_fileio_open_1, target_fileio_unlink)
(target_fileio_readlink): Always call the target method. Handle
FILEIO_ENOSYS.
(return_zero, return_zero_has_execution): Delete.
(init_dummy_target): Delete.
(dummy_target::dummy_target, dummy_target::shortname)
(dummy_target::longname, dummy_target::doc)
(debug_target::debug_target, debug_target::shortname)
(debug_target::longname, debug_target::doc): New.
(target_supports_delete_record): Use regular delegation.
(setup_target_debug): Delete.
(maintenance_print_target_stack): Skip debug_stratum.
(initialize_targets): Instantiate the_dummy_target and
the_debug_target.
* auxv.c (target_auxv_parse): Remove 'ops' parameter. Adjust to
use target_stack.
(target_auxv_search, fprint_target_auxv): Adjust.
(info_auxv_command): Adjust to use target_stack.
* auxv.h (target_auxv_parse): Remove 'ops' parameter.
* exceptions.c (print_flush): Handle a NULL target_stack.
* regcache.c (target_ops_no_register): Refactor as class with
virtual methods.
* exec.c (exec_target): New class.
(exec_ops): Now an exec_target.
(exec_open, exec_close_1, exec_get_section_table)
(exec_xfer_partial, exec_files_info, exec_has_memory)
(exec_make_note_section): Refactor as exec_target methods.
(exec_file_clear, ignore, exec_remove_breakpoint, init_exec_ops):
Delete.
(exec_target::find_memory_regions): New.
(_initialize_exec): Don't call init_exec_ops.
* gdbcore.h (exec_file_clear): Delete.
* corefile.c (core_target): Delete.
(core_file_command): Adjust.
* corelow.c (core_target): New class.
(the_core_target): New.
(core_close): Remove target_ops parameter.
(core_close_cleanup): Adjust.
(core_target::close): New.
(core_open, core_detach, get_core_registers, core_files_info)
(core_xfer_partial, core_thread_alive, core_read_description)
(core_pid_to_str, core_thread_name, core_has_memory)
(core_has_stack, core_has_registers, core_info_proc): Rework as
core_target methods.
(ignore, core_remove_breakpoint, init_core_ops): Delete.
(_initialize_corelow): Initialize the_core_target.
* gdbcore.h (core_target): Delete.
(the_core_target): New.
* ctf.c: (ctf_target): New class.
(ctf_ops): Now a ctf_target.
(ctf_open, ctf_close, ctf_files_info, ctf_fetch_registers)
(ctf_xfer_partial, ctf_get_trace_state_variable_value)
(ctf_trace_find, ctf_traceframe_info): Refactor as ctf_target
methods.
(init_ctf_ops): Delete.
(_initialize_ctf): Don't call it.
* tracefile-tfile.c (tfile_target): New class.
(tfile_ops): Now a tfile_target.
(tfile_open, tfile_close, tfile_files_info)
(tfile_get_tracepoint_status, tfile_trace_find)
(tfile_fetch_registers, tfile_xfer_partial)
(tfile_get_trace_state_variable_value, tfile_traceframe_info):
Refactor as tfile_target methods.
(tfile_xfer_partial_features): Remove target_ops parameter.
(init_tfile_ops): Delete.
(_initialize_tracefile_tfile): Don't call it.
* tracefile.c (tracefile_has_all_memory, tracefile_has_memory)
(tracefile_has_stack, tracefile_has_registers)
(tracefile_thread_alive, tracefile_get_trace_status): Refactor as
tracefile_target methods.
(init_tracefile_ops): Delete.
(tracefile_target::tracefile_target): New.
* tracefile.h: Include "target.h".
(tracefile_target): New class.
(init_tracefile_ops): Delete.
* spu-multiarch.c (spu_multiarch_target): New class.
(spu_ops): Now a spu_multiarch_target.
(spu_thread_architecture, spu_region_ok_for_hw_watchpoint)
(spu_fetch_registers, spu_store_registers, spu_xfer_partial)
(spu_search_memory, spu_mourn_inferior): Refactor as
spu_multiarch_target methods.
(init_spu_ops): Delete.
(_initialize_spu_multiarch): Remove references to init_spu_ops,
complete_target_initialization.
* ravenscar-thread.c (ravenscar_thread_target): New class.
(ravenscar_ops): Now a ravenscar_thread_target.
(ravenscar_resume, ravenscar_wait, ravenscar_update_thread_list)
(ravenscar_thread_alive, ravenscar_pid_to_str)
(ravenscar_fetch_registers, ravenscar_store_registers)
(ravenscar_prepare_to_store, ravenscar_stopped_by_sw_breakpoint)
(ravenscar_stopped_by_hw_breakpoint)
(ravenscar_stopped_by_watchpoint, ravenscar_stopped_data_address)
(ravenscar_mourn_inferior, ravenscar_core_of_thread)
(ravenscar_get_ada_task_ptid): Refactor as ravenscar_thread_target
methods.
(init_ravenscar_thread_ops): Delete.
(_initialize_ravenscar): Remove references to
init_ravenscar_thread_ops and complete_target_initialization.
* bsd-uthread.c (bsd_uthread_ops_hack): Delete.
(bsd_uthread_target): New class.
(bsd_uthread_ops): Now a bsd_uthread_target.
(bsd_uthread_activate): Adjust to refer to bsd_uthread_ops.
(bsd_uthread_close, bsd_uthread_mourn_inferior)
(bsd_uthread_fetch_registers, bsd_uthread_store_registers)
(bsd_uthread_wait, bsd_uthread_resume, bsd_uthread_thread_alive)
(bsd_uthread_update_thread_list, bsd_uthread_extra_thread_info)
(bsd_uthread_pid_to_str): Refactor as bsd_uthread_target methods.
(bsd_uthread_target): Delete function.
(_initialize_bsd_uthread): Remove reference to
complete_target_initialization.
* bfd-target.c (target_bfd_data): Delete. Fields folded into ...
(target_bfd): ... this new class.
(target_bfd_xfer_partial, target_bfd_get_section_table)
(target_bfd_close): Refactor as target_bfd methods.
(target_bfd::~target_bfd): New.
(target_bfd_reopen): Adjust.
(target_bfd::close): New.
* record-btrace.c (record_btrace_target): New class.
(record_btrace_ops): Now a record_btrace_target.
(record_btrace_open, record_btrace_stop_recording)
(record_btrace_disconnect, record_btrace_close)
(record_btrace_async, record_btrace_info)
(record_btrace_insn_history, record_btrace_insn_history_range)
(record_btrace_insn_history_from, record_btrace_call_history)
(record_btrace_call_history_range)
(record_btrace_call_history_from, record_btrace_record_method)
(record_btrace_is_replaying, record_btrace_will_replay)
(record_btrace_xfer_partial, record_btrace_insert_breakpoint)
(record_btrace_remove_breakpoint, record_btrace_fetch_registers)
(record_btrace_store_registers, record_btrace_prepare_to_store)
(record_btrace_to_get_unwinder)
(record_btrace_to_get_tailcall_unwinder, record_btrace_resume)
(record_btrace_commit_resume, record_btrace_wait)
(record_btrace_stop, record_btrace_can_execute_reverse)
(record_btrace_stopped_by_sw_breakpoint)
(record_btrace_supports_stopped_by_sw_breakpoint)
(record_btrace_stopped_by_hw_breakpoint)
(record_btrace_supports_stopped_by_hw_breakpoint)
(record_btrace_update_thread_list, record_btrace_thread_alive)
(record_btrace_goto_begin, record_btrace_goto_end)
(record_btrace_goto, record_btrace_stop_replaying_all)
(record_btrace_execution_direction)
(record_btrace_prepare_to_generate_core)
(record_btrace_done_generating_core): Refactor as
record_btrace_target methods.
(init_record_btrace_ops): Delete.
(_initialize_record_btrace): Remove reference to
init_record_btrace_ops.
* record-full.c (RECORD_FULL_IS_REPLAY): Adjust to always refer to
the execution_direction global.
(record_full_base_target, record_full_target)
(record_full_core_target): New classes.
(record_full_ops): Now a record_full_target.
(record_full_core_ops): Now a record_full_core_target.
(record_full_target::detach, record_full_target::disconnect)
(record_full_core_target::disconnect)
(record_full_target::mourn_inferior, record_full_target::kill):
New.
(record_full_open, record_full_close, record_full_async): Refactor
as methods of the record_full_base_target class.
(record_full_resume, record_full_commit_resume): Refactor
as methods of the record_full_target class.
(record_full_wait, record_full_stopped_by_watchpoint)
(record_full_stopped_data_address)
(record_full_stopped_by_sw_breakpoint)
(record_full_supports_stopped_by_sw_breakpoint)
(record_full_stopped_by_hw_breakpoint)
(record_full_supports_stopped_by_hw_breakpoint): Refactor as
methods of the record_full_base_target class.
(record_full_store_registers, record_full_xfer_partial)
(record_full_insert_breakpoint, record_full_remove_breakpoint):
Refactor as methods of the record_full_target class.
(record_full_can_execute_reverse, record_full_get_bookmark)
(record_full_goto_bookmark, record_full_execution_direction)
(record_full_record_method, record_full_info, record_full_delete)
(record_full_is_replaying, record_full_will_replay)
(record_full_goto_begin, record_full_goto_end, record_full_goto)
(record_full_stop_replaying): Refactor as methods of the
record_full_base_target class.
(record_full_core_resume, record_full_core_kill)
(record_full_core_fetch_registers)
(record_full_core_prepare_to_store)
(record_full_core_store_registers, record_full_core_xfer_partial)
(record_full_core_insert_breakpoint)
(record_full_core_remove_breakpoint)
(record_full_core_has_execution): Refactor
as methods of the record_full_core_target class.
(record_full_base_target::supports_delete_record): New.
(init_record_full_ops): Delete.
(init_record_full_core_ops): Delete.
(record_full_save): Refactor as method of the
record_full_base_target class.
(_initialize_record_full): Remove references to
init_record_full_ops and init_record_full_core_ops.
* remote.c (remote_target, extended_remote_target): New classes.
(remote_ops): Now a remote_target.
(extended_remote_ops): Now an extended_remote_target.
(remote_insert_fork_catchpoint, remote_remove_fork_catchpoint)
(remote_insert_vfork_catchpoint, remote_remove_vfork_catchpoint)
(remote_insert_exec_catchpoint, remote_remove_exec_catchpoint)
(remote_pass_signals, remote_set_syscall_catchpoint)
(remote_program_signals, )
(remote_thread_always_alive): Remove target_ops parameter.
(remote_thread_alive, remote_thread_name)
(remote_update_thread_list, remote_threads_extra_info)
(remote_static_tracepoint_marker_at)
(remote_static_tracepoint_markers_by_strid)
(remote_get_ada_task_ptid, remote_close, remote_start_remote)
(remote_open): Refactor as methods of remote_target.
(extended_remote_open, extended_remote_detach)
(extended_remote_attach, extended_remote_post_attach):
(extended_remote_supports_disable_randomization)
(extended_remote_create_inferior): : Refactor as method of
extended_remote_target.
(remote_set_permissions, remote_open_1, remote_detach)
(remote_follow_fork, remote_follow_exec, remote_disconnect)
(remote_resume, remote_commit_resume, remote_stop)
(remote_interrupt, remote_pass_ctrlc, remote_terminal_inferior)
(remote_terminal_ours, remote_wait, remote_fetch_registers)
(remote_prepare_to_store, remote_store_registers)
(remote_flash_erase, remote_flash_done, remote_files_info)
(remote_kill, remote_mourn, remote_insert_breakpoint)
(remote_remove_breakpoint, remote_insert_watchpoint)
(remote_watchpoint_addr_within_range)
(remote_remove_watchpoint, remote_region_ok_for_hw_watchpoint)
(remote_check_watch_resources, remote_stopped_by_sw_breakpoint)
(remote_supports_stopped_by_sw_breakpoint)
(remote_stopped_by_hw_breakpoint)
(remote_supports_stopped_by_hw_breakpoint)
(remote_stopped_by_watchpoint, remote_stopped_data_address)
(remote_insert_hw_breakpoint, remote_remove_hw_breakpoint)
(remote_verify_memory): Refactor as methods of remote_target.
(remote_write_qxfer, remote_read_qxfer): Remove target_ops
parameter.
(remote_xfer_partial, remote_get_memory_xfer_limit)
(remote_search_memory, remote_rcmd, remote_memory_map)
(remote_pid_to_str, remote_get_thread_local_address)
(remote_get_tib_address, remote_read_description): Refactor as
methods of remote_target.
(remote_target::fileio_open, remote_target::fileio_pwrite)
(remote_target::fileio_pread, remote_target::fileio_close): New.
(remote_hostio_readlink, remote_hostio_fstat)
(remote_filesystem_is_local, remote_can_execute_reverse)
(remote_supports_non_stop, remote_supports_disable_randomization)
(remote_supports_multi_process, remote_supports_cond_breakpoints)
(remote_supports_enable_disable_tracepoint)
(remote_supports_string_tracing)
(remote_can_run_breakpoint_commands, remote_trace_init)
(remote_download_tracepoint, remote_can_download_tracepoint)
(remote_download_trace_state_variable, remote_enable_tracepoint)
(remote_disable_tracepoint, remote_trace_set_readonly_regions)
(remote_trace_start, remote_get_trace_status)
(remote_get_tracepoint_status, remote_trace_stop)
(remote_trace_find, remote_get_trace_state_variable_value)
(remote_save_trace_data, remote_get_raw_trace_data)
(remote_set_disconnected_tracing, remote_core_of_thread)
(remote_set_circular_trace_buffer, remote_traceframe_info)
(remote_get_min_fast_tracepoint_insn_len)
(remote_set_trace_buffer_size, remote_set_trace_notes)
(remote_use_agent, remote_can_use_agent, remote_enable_btrace)
(remote_disable_btrace, remote_teardown_btrace)
(remote_read_btrace, remote_btrace_conf)
(remote_augmented_libraries_svr4_read, remote_load)
(remote_pid_to_exec_file, remote_can_do_single_step)
(remote_execution_direction, remote_thread_handle_to_thread_info):
Refactor as methods of remote_target.
(init_remote_ops, init_extended_remote_ops): Delete.
(remote_can_async_p, remote_is_async_p, remote_async)
(remote_thread_events, remote_upload_tracepoints)
(remote_upload_trace_state_variables): Refactor as methods of
remote_target.
(_initialize_remote): Remove references to init_remote_ops and
init_extended_remote_ops.
* remote-sim.c (gdbsim_target): New class.
(gdbsim_fetch_register, gdbsim_store_register, gdbsim_kill)
(gdbsim_load, gdbsim_create_inferior, gdbsim_open, gdbsim_close)
(gdbsim_detach, gdbsim_resume, gdbsim_interrupt)
(gdbsim_wait, gdbsim_prepare_to_store, gdbsim_xfer_partial)
(gdbsim_files_info, gdbsim_mourn_inferior, gdbsim_thread_alive)
(gdbsim_pid_to_str, gdbsim_has_all_memory, gdbsim_has_memory):
Refactor as methods of gdbsim_target.
(gdbsim_ops): Now a gdbsim_target.
(init_gdbsim_ops): Delete.
(gdbsim_cntrl_c): Adjust.
(_initialize_remote_sim): Remove reference to init_gdbsim_ops.
* amd64-linux-nat.c (amd64_linux_nat_target): New class.
(the_amd64_linux_nat_target): New.
(amd64_linux_fetch_inferior_registers)
(amd64_linux_store_inferior_registers): Refactor as methods of
amd64_linux_nat_target.
(_initialize_amd64_linux_nat): Adjust. Set linux_target.
* i386-linux-nat.c: Don't include "linux-nat.h".
(i386_linux_nat_target): New class.
(the_i386_linux_nat_target): New.
(i386_linux_fetch_inferior_registers)
(i386_linux_store_inferior_registers, i386_linux_resume): Refactor
as methods of i386_linux_nat_target.
(_initialize_i386_linux_nat): Adjust. Set linux_target.
* inf-child.c (inf_child_ops): Delete.
(inf_child_fetch_inferior_registers)
(inf_child_store_inferior_registers): Delete.
(inf_child_post_attach, inf_child_prepare_to_store): Refactor as
methods of inf_child_target.
(inf_child_target::supports_terminal_ours)
(inf_child_target::terminal_init)
(inf_child_target::terminal_inferior)
(inf_child_target::terminal_ours_for_output)
(inf_child_target::terminal_ours, inf_child_target::interrupt)
(inf_child_target::pass_ctrlc, inf_child_target::terminal_info):
New.
(inf_child_open, inf_child_disconnect, inf_child_close)
(inf_child_mourn_inferior, inf_child_maybe_unpush_target)
(inf_child_post_startup_inferior, inf_child_can_run)
(inf_child_pid_to_exec_file): Refactor as methods of
inf_child_target.
(inf_child_follow_fork): Delete.
(inf_child_target::can_create_inferior)
(inf_child_target::can_attach): New.
(inf_child_target::has_all_memory, inf_child_target::has_memory)
(inf_child_target::has_stack, inf_child_target::has_registers)
(inf_child_target::has_execution): New.
(inf_child_fileio_open, inf_child_fileio_pwrite)
(inf_child_fileio_pread, inf_child_fileio_fstat)
(inf_child_fileio_close, inf_child_fileio_unlink)
(inf_child_fileio_readlink, inf_child_use_agent)
(inf_child_can_use_agent): Refactor as methods of
inf_child_target.
(return_zero, inf_child_target): Delete.
(inf_child_target::inf_child_target): New.
* inf-child.h: Include "target.h".
(inf_child_target): Delete function prototype.
(inf_child_target): New class.
(inf_child_open_target, inf_child_mourn_inferior)
(inf_child_maybe_unpush_target): Delete.
* inf-ptrace.c (inf_ptrace_target::~inf_ptrace_target): New.
(inf_ptrace_follow_fork, inf_ptrace_insert_fork_catchpoint)
(inf_ptrace_remove_fork_catchpoint, inf_ptrace_create_inferior)
(inf_ptrace_post_startup_inferior, inf_ptrace_mourn_inferior)
(inf_ptrace_attach, inf_ptrace_post_attach, inf_ptrace_detach)
(inf_ptrace_detach_success, inf_ptrace_kill, inf_ptrace_resume)
(inf_ptrace_wait, inf_ptrace_xfer_partial)
(inf_ptrace_thread_alive, inf_ptrace_files_info)
(inf_ptrace_pid_to_str, inf_ptrace_auxv_parse): Refactor as
methods of inf_ptrace_target.
(inf_ptrace_target): Delete function.
* inf-ptrace.h: Include "inf-child.h".
(inf_ptrace_target): Delete function declaration.
(inf_ptrace_target): New class.
(inf_ptrace_trad_target, inf_ptrace_detach_success): Delete.
* linux-nat.c (linux_target): New.
(linux_ops, linux_ops_saved, super_xfer_partial): Delete.
(linux_nat_target::~linux_nat_target): New.
(linux_child_post_attach, linux_child_post_startup_inferior)
(linux_child_follow_fork, linux_child_insert_fork_catchpoint)
(linux_child_remove_fork_catchpoint)
(linux_child_insert_vfork_catchpoint)
(linux_child_remove_vfork_catchpoint)
(linux_child_insert_exec_catchpoint)
(linux_child_remove_exec_catchpoint)
(linux_child_set_syscall_catchpoint, linux_nat_pass_signals)
(linux_nat_create_inferior, linux_nat_attach, linux_nat_detach)
(linux_nat_resume, linux_nat_stopped_by_watchpoint)
(linux_nat_stopped_data_address)
(linux_nat_stopped_by_sw_breakpoint)
(linux_nat_supports_stopped_by_sw_breakpoint)
(linux_nat_stopped_by_hw_breakpoint)
(linux_nat_supports_stopped_by_hw_breakpoint, linux_nat_wait)
(linux_nat_kill, linux_nat_mourn_inferior)
(linux_nat_xfer_partial, linux_nat_thread_alive)
(linux_nat_update_thread_list, linux_nat_pid_to_str)
(linux_nat_thread_name, linux_child_pid_to_exec_file)
(linux_child_static_tracepoint_markers_by_strid)
(linux_nat_is_async_p, linux_nat_can_async_p)
(linux_nat_supports_non_stop, linux_nat_always_non_stop_p)
(linux_nat_supports_multi_process)
(linux_nat_supports_disable_randomization, linux_nat_async)
(linux_nat_stop, linux_nat_close, linux_nat_thread_address_space)
(linux_nat_core_of_thread, linux_nat_filesystem_is_local)
(linux_nat_fileio_open, linux_nat_fileio_readlink)
(linux_nat_fileio_unlink, linux_nat_thread_events): Refactor as
methods of linux_nat_target.
(linux_nat_wait_1, linux_xfer_siginfo, linux_proc_xfer_partial)
(linux_proc_xfer_spu, linux_nat_xfer_osdata): Remove target_ops
parameter.
(check_stopped_by_watchpoint): Adjust.
(linux_xfer_partial): Delete.
(linux_target_install_ops, linux_target, linux_nat_add_target):
Delete.
(linux_nat_target::linux_nat_target): New.
* linux-nat.h: Include "inf-ptrace.h".
(linux_nat_target): New.
(linux_target, linux_target_install_ops, linux_nat_add_target):
Delete function declarations.
(linux_target): Declare global.
* linux-thread-db.c (thread_db_target): New.
(thread_db_target::thread_db_target): New.
(thread_db_ops): Delete.
(the_thread_db_target): New.
(thread_db_detach, thread_db_wait, thread_db_mourn_inferior)
(thread_db_update_thread_list, thread_db_pid_to_str)
(thread_db_extra_thread_info)
(thread_db_thread_handle_to_thread_info)
(thread_db_get_thread_local_address, thread_db_get_ada_task_ptid)
(thread_db_resume): Refactor as methods of thread_db_target.
(init_thread_db_ops): Delete.
(_initialize_thread_db): Remove reference to init_thread_db_ops.
* x86-linux-nat.c: Don't include "linux-nat.h".
(super_post_startup_inferior): Delete.
(x86_linux_nat_target::~x86_linux_nat_target): New.
(x86_linux_child_post_startup_inferior)
(x86_linux_read_description, x86_linux_enable_btrace)
(x86_linux_disable_btrace, x86_linux_teardown_btrace)
(x86_linux_read_btrace, x86_linux_btrace_conf): Refactor as
methods of x86_linux_nat_target.
(x86_linux_create_target): Delete. Bits folded ...
(x86_linux_add_target): ... here. Now takes a linux_nat_target
pointer.
* x86-linux-nat.h: Include "linux-nat.h" and "x86-nat.h".
(x86_linux_nat_target): New class.
(x86_linux_create_target): Delete.
(x86_linux_add_target): Now takes a linux_nat_target pointer.
* x86-nat.c (x86_insert_watchpoint, x86_remove_watchpoint)
(x86_region_ok_for_watchpoint, x86_stopped_data_address)
(x86_stopped_by_watchpoint, x86_insert_hw_breakpoint)
(x86_remove_hw_breakpoint, x86_can_use_hw_breakpoint)
(x86_stopped_by_hw_breakpoint): Remove target_ops parameter and
make extern.
(x86_use_watchpoints): Delete.
* x86-nat.h: Include "breakpoint.h" and "target.h".
(x86_use_watchpoints): Delete.
(x86_can_use_hw_breakpoint, x86_region_ok_for_hw_watchpoint)
(x86_stopped_by_watchpoint, x86_stopped_data_address)
(x86_insert_watchpoint, x86_remove_watchpoint)
(x86_insert_hw_breakpoint, x86_remove_hw_breakpoint)
(x86_stopped_by_hw_breakpoint): New declarations.
(x86_nat_target): New template class.
* ppc-linux-nat.c (ppc_linux_nat_target): New class.
(the_ppc_linux_nat_target): New.
(ppc_linux_fetch_inferior_registers)
(ppc_linux_can_use_hw_breakpoint)
(ppc_linux_region_ok_for_hw_watchpoint)
(ppc_linux_ranged_break_num_registers)
(ppc_linux_insert_hw_breakpoint, ppc_linux_remove_hw_breakpoint)
(ppc_linux_insert_mask_watchpoint)
(ppc_linux_remove_mask_watchpoint)
(ppc_linux_can_accel_watchpoint_condition)
(ppc_linux_insert_watchpoint, ppc_linux_remove_watchpoint)
(ppc_linux_stopped_data_address, ppc_linux_stopped_by_watchpoint)
(ppc_linux_watchpoint_addr_within_range)
(ppc_linux_masked_watch_num_registers)
(ppc_linux_store_inferior_registers, ppc_linux_auxv_parse)
(ppc_linux_read_description): Refactor as methods of
ppc_linux_nat_target.
(_initialize_ppc_linux_nat): Adjust. Set linux_target.
* procfs.c (procfs_xfer_partial): Delete forward declaration.
(procfs_target): New class.
(the_procfs_target): New.
(procfs_target): Delete function.
(procfs_auxv_parse, procfs_attach, procfs_detach)
(procfs_fetch_registers, procfs_store_registers, procfs_wait)
(procfs_xfer_partial, procfs_resume, procfs_pass_signals)
(procfs_files_info, procfs_kill_inferior, procfs_mourn_inferior)
(procfs_create_inferior, procfs_update_thread_list)
(procfs_thread_alive, procfs_pid_to_str)
(procfs_can_use_hw_breakpoint, procfs_stopped_by_watchpoint)
(procfs_stopped_data_address, procfs_insert_watchpoint)
(procfs_remove_watchpoint, procfs_region_ok_for_hw_watchpoint)
(proc_find_memory_regions, procfs_info_proc)
(procfs_make_note_section): Refactor as methods of procfs_target.
(_initialize_procfs): Adjust.
* sol-thread.c (sol_thread_target): New class.
(sol_thread_ops): Now a sol_thread_target.
(sol_thread_detach, sol_thread_resume, sol_thread_wait)
(sol_thread_fetch_registers, sol_thread_store_registers)
(sol_thread_xfer_partial, sol_thread_mourn_inferior)
(sol_thread_alive, solaris_pid_to_str, sol_update_thread_list)
(sol_get_ada_task_ptid): Refactor as methods of sol_thread_target.
(init_sol_thread_ops): Delete.
(_initialize_sol_thread): Adjust. Remove references to
init_sol_thread_ops and complete_target_initialization.
* windows-nat.c (windows_nat_target): New class.
(windows_fetch_inferior_registers)
(windows_store_inferior_registers, windows_resume, windows_wait)
(windows_attach, windows_detach, windows_pid_to_exec_file)
(windows_files_info, windows_create_inferior)
(windows_mourn_inferior, windows_interrupt, windows_kill_inferior)
(windows_close, windows_pid_to_str, windows_xfer_partial)
(windows_get_tib_address, windows_get_ada_task_ptid)
(windows_thread_name, windows_thread_alive): Refactor as
windows_nat_target methods.
(do_initial_windows_stuff): Adjust.
(windows_target): Delete function.
(_initialize_windows_nat): Adjust.
* darwin-nat.c (darwin_resume, darwin_wait_to, darwin_interrupt)
(darwin_mourn_inferior, darwin_kill_inferior)
(darwin_create_inferior, darwin_attach, darwin_detach)
(darwin_pid_to_str, darwin_thread_alive, darwin_xfer_partial)
(darwin_pid_to_exec_file, darwin_get_ada_task_ptid)
(darwin_supports_multi_process): Refactor as darwin_nat_target
methods.
(darwin_resume_to, darwin_files_info): Delete.
(_initialize_darwin_inferior): Rename to ...
(_initialize_darwin_nat): ... this. Adjust to C++ification.
* darwin-nat.h: Include "inf-child.h".
(darwin_nat_target): New class.
(darwin_complete_target): Delete.
* i386-darwin-nat.c (i386_darwin_nat_target): New class.
(darwin_target): New.
(i386_darwin_fetch_inferior_registers)
(i386_darwin_store_inferior_registers): Refactor as methods of
darwin_nat_target.
(darwin_complete_target): Delete, with ...
(_initialize_i386_darwin_nat): ... bits factored out here.
* alpha-linux-nat.c (alpha_linux_nat_target): New class.
(the_alpha_linux_nat_target): New.
(alpha_linux_register_u_offset): Refactor as
alpha_linux_nat_target method.
(_initialize_alpha_linux_nat): Adjust.
* linux-nat-trad.c (inf_ptrace_register_u_offset): Delete.
(inf_ptrace_fetch_register, inf_ptrace_fetch_registers)
(inf_ptrace_store_register, inf_ptrace_store_registers): Refact as
methods of linux_nat_trad_target.
(linux_trad_target): Delete.
* linux-nat-trad.h (linux_trad_target): Delete function.
(linux_nat_trad_target): New class.
* mips-linux-nat.c (mips_linux_nat_target): New class.
(super_fetch_registers, super_store_registers, super_close):
Delete.
(the_mips_linux_nat_target): New.
(mips64_linux_regsets_fetch_registers)
(mips64_linux_regsets_store_registers)
(mips64_linux_fetch_registers, mips64_linux_store_registers)
(mips_linux_register_u_offset, mips_linux_read_description)
(mips_linux_can_use_hw_breakpoint)
(mips_linux_stopped_by_watchpoint)
(mips_linux_stopped_data_address)
(mips_linux_region_ok_for_hw_watchpoint)
(mips_linux_insert_watchpoint, mips_linux_remove_watchpoint)
(mips_linux_close): Refactor as methods of mips_linux_nat.
(_initialize_mips_linux_nat): Adjust to C++ification.
* aix-thread.c (aix_thread_target): New class.
(aix_thread_ops): Now an aix_thread_target.
(aix_thread_detach, aix_thread_resume, aix_thread_wait)
(aix_thread_fetch_registers, aix_thread_store_registers)
(aix_thread_xfer_partial, aix_thread_mourn_inferior)
(aix_thread_thread_alive, aix_thread_pid_to_str)
(aix_thread_extra_thread_info, aix_thread_get_ada_task_ptid):
Refactor as methods of aix_thread_target.
(init_aix_thread_ops): Delete.
(_initialize_aix_thread): Remove references to init_aix_thread_ops
and complete_target_initialization.
* rs6000-nat.c (rs6000_xfer_shared_libraries): Delete.
(rs6000_nat_target): New class.
(the_rs6000_nat_target): New.
(rs6000_fetch_inferior_registers, rs6000_store_inferior_registers)
(rs6000_xfer_partial, rs6000_wait, rs6000_create_inferior)
(rs6000_xfer_shared_libraries): Refactor as rs6000_nat_target methods.
(super_create_inferior): Delete.
(_initialize_rs6000_nat): Adjust to C++ification.
* arm-linux-nat.c (arm_linux_nat_target): New class.
(the_arm_linux_nat_target): New.
(arm_linux_fetch_inferior_registers)
(arm_linux_store_inferior_registers, arm_linux_read_description)
(arm_linux_can_use_hw_breakpoint, arm_linux_insert_hw_breakpoint)
(arm_linux_remove_hw_breakpoint)
(arm_linux_region_ok_for_hw_watchpoint)
(arm_linux_insert_watchpoint, arm_linux_remove_watchpoint)
(arm_linux_stopped_data_address, arm_linux_stopped_by_watchpoint)
(arm_linux_watchpoint_addr_within_range): Refactor as methods of
arm_linux_nat_target.
(_initialize_arm_linux_nat): Adjust to C++ification.
* aarch64-linux-nat.c (aarch64_linux_nat_target): New class.
(the_aarch64_linux_nat_target): New.
(aarch64_linux_fetch_inferior_registers)
(aarch64_linux_store_inferior_registers)
(aarch64_linux_child_post_startup_inferior)
(aarch64_linux_read_description)
(aarch64_linux_can_use_hw_breakpoint)
(aarch64_linux_insert_hw_breakpoint)
(aarch64_linux_remove_hw_breakpoint)
(aarch64_linux_insert_watchpoint, aarch64_linux_remove_watchpoint)
(aarch64_linux_region_ok_for_hw_watchpoint)
(aarch64_linux_stopped_data_address)
(aarch64_linux_stopped_by_watchpoint)
(aarch64_linux_watchpoint_addr_within_range)
(aarch64_linux_can_do_single_step): Refactor as methods of
aarch64_linux_nat_target.
(super_post_startup_inferior): Delete.
(_initialize_aarch64_linux_nat): Adjust to C++ification.
* hppa-linux-nat.c (hppa_linux_nat_target): New class.
(the_hppa_linux_nat_target): New.
(hppa_linux_fetch_inferior_registers)
(hppa_linux_store_inferior_registers): Refactor as methods of
hppa_linux_nat_target.
(_initialize_hppa_linux_nat): Adjust to C++ification.
* ia64-linux-nat.c (ia64_linux_nat_target): New class.
(the_ia64_linux_nat_target): New.
(ia64_linux_insert_watchpoint, ia64_linux_remove_watchpoint)
(ia64_linux_stopped_data_address)
(ia64_linux_stopped_by_watchpoint, ia64_linux_fetch_registers)
(ia64_linux_store_registers, ia64_linux_xfer_partial): Refactor as
ia64_linux_nat_target methods.
(super_xfer_partial): Delete.
(_initialize_ia64_linux_nat): Adjust to C++ification.
* m32r-linux-nat.c (m32r_linux_nat_target): New class.
(the_m32r_linux_nat_target): New.
(m32r_linux_fetch_inferior_registers)
(m32r_linux_store_inferior_registers): Refactor as
m32r_linux_nat_target methods.
(_initialize_m32r_linux_nat): Adjust to C++ification.
* m68k-linux-nat.c (m68k_linux_nat_target): New class.
(the_m68k_linux_nat_target): New.
(m68k_linux_fetch_inferior_registers)
(m68k_linux_store_inferior_registers): Refactor as
m68k_linux_nat_target methods.
(_initialize_m68k_linux_nat): Adjust to C++ification.
* s390-linux-nat.c (s390_linux_nat_target): New class.
(the_s390_linux_nat_target): New.
(s390_linux_fetch_inferior_registers)
(s390_linux_store_inferior_registers, s390_stopped_by_watchpoint)
(s390_insert_watchpoint, s390_remove_watchpoint)
(s390_can_use_hw_breakpoint, s390_insert_hw_breakpoint)
(s390_remove_hw_breakpoint, s390_region_ok_for_hw_watchpoint)
(s390_auxv_parse, s390_read_description): Refactor as methods of
s390_linux_nat_target.
(_initialize_s390_nat): Adjust to C++ification.
* sparc-linux-nat.c (sparc_linux_nat_target): New class.
(the_sparc_linux_nat_target): New.
(_initialize_sparc_linux_nat): Adjust to C++ification.
* sparc-nat.c (sparc_fetch_inferior_registers)
(sparc_store_inferior_registers): Remove target_ops parameter.
* sparc-nat.h (sparc_fetch_inferior_registers)
(sparc_store_inferior_registers): Remove target_ops parameter.
* sparc64-linux-nat.c (sparc64_linux_nat_target): New class.
(the_sparc64_linux_nat_target): New.
(_initialize_sparc64_linux_nat): Adjust to C++ification.
* spu-linux-nat.c (spu_linux_nat_target): New class.
(the_spu_linux_nat_target): New.
(spu_child_post_startup_inferior, spu_child_post_attach)
(spu_child_wait, spu_fetch_inferior_registers)
(spu_store_inferior_registers, spu_xfer_partial)
(spu_can_use_hw_breakpoint): Refactor as spu_linux_nat_target
methods.
(_initialize_spu_nat): Adjust to C++ification.
* tilegx-linux-nat.c (tilegx_linux_nat_target): New class.
(the_tilegx_linux_nat_target): New.
(fetch_inferior_registers, store_inferior_registers):
Refactor as methods.
(_initialize_tile_linux_nat): Adjust to C++ification.
* xtensa-linux-nat.c (xtensa_linux_nat_target): New class.
(the_xtensa_linux_nat_target): New.
(xtensa_linux_fetch_inferior_registers)
(xtensa_linux_store_inferior_registers): Refactor as
xtensa_linux_nat_target methods.
(_initialize_xtensa_linux_nat): Adjust to C++ification.
* fbsd-nat.c (USE_SIGTRAP_SIGINFO): Delete.
(fbsd_pid_to_exec_file, fbsd_find_memory_regions)
(fbsd_find_memory_regions, fbsd_info_proc, fbsd_xfer_partial)
(fbsd_thread_alive, fbsd_pid_to_str, fbsd_thread_name)
(fbsd_update_thread_list, fbsd_resume, fbsd_wait)
(fbsd_stopped_by_sw_breakpoint)
(fbsd_supports_stopped_by_sw_breakpoint, fbsd_follow_fork)
(fbsd_insert_fork_catchpoint, fbsd_remove_fork_catchpoint)
(fbsd_insert_vfork_catchpoint, fbsd_remove_vfork_catchpoint)
(fbsd_post_startup_inferior, fbsd_post_attach)
(fbsd_insert_exec_catchpoint, fbsd_remove_exec_catchpoint)
(fbsd_set_syscall_catchpoint)
(super_xfer_partial, super_resume, super_wait)
(fbsd_supports_stopped_by_hw_breakpoint): Delete.
(fbsd_handle_debug_trap): Remove target_ops parameter.
(fbsd_nat_add_target): Delete.
* fbsd-nat.h: Include "inf-ptrace.h".
(fbsd_nat_add_target): Delete.
(USE_SIGTRAP_SIGINFO): Define.
(fbsd_nat_target): New class.
* amd64-bsd-nat.c (amd64bsd_fetch_inferior_registers)
(amd64bsd_store_inferior_registers): Remove target_ops parameter.
(amd64bsd_target): Delete.
* amd64-bsd-nat.h: New file.
* amd64-fbsd-nat.c: Include "amd64-bsd-nat.h" instead of
"x86-bsd-nat.h".
(amd64_fbsd_nat_target): New class.
(the_amd64_fbsd_nat_target): New.
(amd64fbsd_read_description): Refactor as method of
amd64_fbsd_nat_target.
(amd64_fbsd_nat_target::supports_stopped_by_hw_breakpoint): New.
(_initialize_amd64fbsd_nat): Adjust to C++ification.
* amd64-nat.h (amd64bsd_target): Delete function declaration.
* i386-bsd-nat.c (i386bsd_fetch_inferior_registers)
(i386bsd_store_inferior_registers): Remove target_ops parameter.
(i386bsd_target): Delete.
* i386-bsd-nat.h (i386bsd_target): Delete function declaration.
(i386bsd_fetch_inferior_registers)
(i386bsd_store_inferior_registers): Declare.
(i386_bsd_nat_target): New class.
* i386-fbsd-nat.c (i386_fbsd_nat_target): New class.
(the_i386_fbsd_nat_target): New.
(i386fbsd_resume, i386fbsd_read_description): Refactor as
i386_fbsd_nat_target methods.
(i386_fbsd_nat_target::supports_stopped_by_hw_breakpoint): New.
(_initialize_i386fbsd_nat): Adjust to C++ification.
* x86-bsd-nat.c (super_mourn_inferior): Delete.
(x86bsd_mourn_inferior, x86bsd_target): Delete.
(_initialize_x86_bsd_nat): Adjust to C++ification.
* x86-bsd-nat.h: Include "x86-nat.h".
(x86bsd_target): Delete declaration.
(x86bsd_nat_target): New class.
* aarch64-fbsd-nat.c (aarch64_fbsd_nat_target): New class.
(the_aarch64_fbsd_nat_target): New.
(aarch64_fbsd_fetch_inferior_registers)
(aarch64_fbsd_store_inferior_registers): Refactor as methods of
aarch64_fbsd_nat_target.
(_initialize_aarch64_fbsd_nat): Adjust to C++ification.
* alpha-bsd-nat.c (alpha_bsd_nat_target): New class.
(the_alpha_bsd_nat_target): New.
(alphabsd_fetch_inferior_registers)
(alphabsd_store_inferior_registers): Refactor as
alpha_bsd_nat_target methods.
(_initialize_alphabsd_nat): Refactor as methods of
alpha_bsd_nat_target.
* amd64-nbsd-nat.c: Include "amd64-bsd-nat.h".
(the_amd64_nbsd_nat_target): New.
(_initialize_amd64nbsd_nat): Adjust to C++ification.
* amd64-obsd-nat.c: Include "amd64-bsd-nat.h".
(the_amd64_obsd_nat_target): New.
(_initialize_amd64obsd_nat): Adjust to C++ification.
* arm-fbsd-nat.c (arm_fbsd_nat_target): New.
(the_arm_fbsd_nat_target): New.
(arm_fbsd_fetch_inferior_registers)
(arm_fbsd_store_inferior_registers, arm_fbsd_read_description):
(_initialize_arm_fbsd_nat): Refactor as methods of
arm_fbsd_nat_target.
(_initialize_arm_fbsd_nat): Adjust to C++ification.
* arm-nbsd-nat.c (arm_netbsd_nat_target): New class.
(the_arm_netbsd_nat_target): New.
(armnbsd_fetch_registers, armnbsd_store_registers): Refactor as
arm_netbsd_nat_target.
(_initialize_arm_netbsd_nat): Adjust to C++ification.
* hppa-nbsd-nat.c (hppa_nbsd_nat_target): New class.
(the_hppa_nbsd_nat_target): New.
(hppanbsd_fetch_registers, hppanbsd_store_registers): Refactor as
hppa_nbsd_nat_target methods.
(_initialize_hppanbsd_nat): Adjust to C++ification.
* hppa-obsd-nat.c (hppa_obsd_nat_target): New class.
(the_hppa_obsd_nat_target): New.
(hppaobsd_fetch_registers, hppaobsd_store_registers): Refactor as
methods of hppa_obsd_nat_target.
(_initialize_hppaobsd_nat): Adjust to C++ification. Use
add_target.
* i386-nbsd-nat.c (the_i386_nbsd_nat_target): New.
(_initialize_i386nbsd_nat): Adjust to C++ification. Use
add_target.
* i386-obsd-nat.c (the_i386_obsd_nat_target): New.
(_initialize_i386obsd_nat): Use add_target.
* m68k-bsd-nat.c (m68k_bsd_nat_target): New class.
(the_m68k_bsd_nat_target): New.
(m68kbsd_fetch_inferior_registers)
(m68kbsd_store_inferior_registers): Refactor as methods of
m68k_bsd_nat_target.
(_initialize_m68kbsd_nat): Adjust to C++ification.
* mips-fbsd-nat.c (mips_fbsd_nat_target): New class.
(the_mips_fbsd_nat_target): New.
(mips_fbsd_fetch_inferior_registers)
(mips_fbsd_store_inferior_registers): Refactor as methods of
mips_fbsd_nat_target.
(_initialize_mips_fbsd_nat): Adjust to C++ification. Use
add_target.
* mips-nbsd-nat.c (mips_nbsd_nat_target): New class.
(the_mips_nbsd_nat_target): New.
(mipsnbsd_fetch_inferior_registers)
(mipsnbsd_store_inferior_registers): Refactor as methods of
mips_nbsd_nat_target.
(_initialize_mipsnbsd_nat): Adjust to C++ification.
* mips64-obsd-nat.c (mips64_obsd_nat_target): New class.
(the_mips64_obsd_nat_target): New.
(mips64obsd_fetch_inferior_registers)
(mips64obsd_store_inferior_registers): Refactor as methods of
mips64_obsd_nat_target.
(_initialize_mips64obsd_nat): Adjust to C++ification. Use
add_target.
* nbsd-nat.c (nbsd_pid_to_exec_file): Refactor as method of
nbsd_nat_target.
* nbsd-nat.h: Include "inf-ptrace.h".
(nbsd_nat_target): New class.
* obsd-nat.c (obsd_pid_to_str, obsd_update_thread_list)
(obsd_wait): Refactor as methods of obsd_nat_target.
(obsd_add_target): Delete.
* obsd-nat.h: Include "inf-ptrace.h".
(obsd_nat_target): New class.
* ppc-fbsd-nat.c (ppc_fbsd_nat_target): New class.
(the_ppc_fbsd_nat_target): New.
(ppcfbsd_fetch_inferior_registers)
(ppcfbsd_store_inferior_registers): Refactor as methods of
ppc_fbsd_nat_target.
(_initialize_ppcfbsd_nat): Adjust to C++ification. Use
add_target.
* ppc-nbsd-nat.c (ppc_nbsd_nat_target): New class.
(the_ppc_nbsd_nat_target): New.
(ppcnbsd_fetch_inferior_registers)
(ppcnbsd_store_inferior_registers): Refactor as methods of
ppc_nbsd_nat_target.
(_initialize_ppcnbsd_nat): Adjust to C++ification.
* ppc-obsd-nat.c (ppc_obsd_nat_target): New class.
(the_ppc_obsd_nat_target): New.
(ppcobsd_fetch_registers, ppcobsd_store_registers): Refactor as
methods of ppc_obsd_nat_target.
(_initialize_ppcobsd_nat): Adjust to C++ification. Use
add_target.
* sh-nbsd-nat.c (sh_nbsd_nat_target): New class.
(the_sh_nbsd_nat_target): New.
(shnbsd_fetch_inferior_registers)
(shnbsd_store_inferior_registers): Refactor as methods of
sh_nbsd_nat_target.
(_initialize_shnbsd_nat): Adjust to C++ification.
* sparc-nat.c (sparc_xfer_wcookie): Make extern.
(inf_ptrace_xfer_partial): Delete.
(sparc_xfer_partial, sparc_target): Delete.
* sparc-nat.h (sparc_fetch_inferior_registers)
(sparc_store_inferior_registers, sparc_xfer_wcookie): Declare.
(sparc_target): Delete function declaration.
(sparc_target): New template class.
* sparc-nbsd-nat.c (the_sparc_nbsd_nat_target): New.
(_initialize_sparcnbsd_nat): Adjust to C++ification.
* sparc64-fbsd-nat.c (the_sparc64_fbsd_nat_target): New.
(_initialize_sparc64fbsd_nat): Adjust to C++ification. Use
add_target.
* sparc64-nbsd-nat.c (the_sparc64_nbsd_nat_target): New.
(_initialize_sparc64nbsd_nat): Adjust to C++ification.
* sparc64-obsd-nat.c (the_sparc64_obsd_nat_target): New.
(_initialize_sparc64obsd_nat): Adjust to C++ification. Use
add_target.
* vax-bsd-nat.c (vax_bsd_nat_target): New class.
(the_vax_bsd_nat_target): New.
(vaxbsd_fetch_inferior_registers)
(vaxbsd_store_inferior_registers): Refactor as vax_bsd_nat_target
methods.
(_initialize_vaxbsd_nat): Adjust to C++ification.
* bsd-kvm.c (bsd_kvm_target): New class.
(bsd_kvm_ops): Now a bsd_kvm_target.
(bsd_kvm_open, bsd_kvm_close, bsd_kvm_xfer_partial)
(bsd_kvm_files_info, bsd_kvm_fetch_registers)
(bsd_kvm_thread_alive, bsd_kvm_pid_to_str): Refactor as methods of
bsd_kvm_target.
(bsd_kvm_return_one): Delete.
(bsd_kvm_add_target): Adjust to C++ification.
* nto-procfs.c (nto_procfs_target, nto_procfs_target_native)
(nto_procfs_target_procfs): New classes.
(procfs_open_1, procfs_thread_alive, procfs_update_thread_list)
(procfs_files_info, procfs_pid_to_exec_file, procfs_attach)
(procfs_post_attach, procfs_wait, procfs_fetch_registers)
(procfs_xfer_partial, procfs_detach, procfs_insert_breakpoint)
(procfs_remove_breakpoint, procfs_insert_hw_breakpoint)
(procfs_remove_hw_breakpoint, procfs_resume)
(procfs_mourn_inferior, procfs_create_inferior, procfs_interrupt)
(procfs_kill_inferior, procfs_store_registers)
(procfs_pass_signals, procfs_pid_to_str, procfs_can_run): Refactor
as methods of nto_procfs_target.
(nto_procfs_ops): Now an nto_procfs_target_procfs.
(nto_native_ops): Delete.
(procfs_open, procfs_native_open): Delete.
(nto_native_ops): Now an nto_procfs_target_native.
(init_procfs_targets): Adjust to C++ification.
(procfs_can_use_hw_breakpoint, procfs_remove_hw_watchpoint)
(procfs_insert_hw_watchpoint, procfs_stopped_by_watchpoint):
Refactor as methods of nto_procfs_target.
* go32-nat.c (go32_nat_target): New class.
(the_go32_nat_target): New.
(go32_attach, go32_resume, go32_wait, go32_fetch_registers)
(go32_store_registers, go32_xfer_partial, go32_files_info)
(go32_kill_inferior, go32_create_inferior, go32_mourn_inferior)
(go32_terminal_init, go32_terminal_info, go32_terminal_inferior)
(go32_terminal_ours, go32_pass_ctrlc, go32_thread_alive)
(go32_pid_to_str): Refactor as methods of go32_nat_target.
(go32_target): Delete.
(_initialize_go32_nat): Adjust to C++ification.
* gnu-nat.c (gnu_wait, gnu_resume, gnu_kill_inferior)
(gnu_mourn_inferior, gnu_create_inferior, gnu_attach, gnu_detach)
(gnu_stop, gnu_thread_alive, gnu_xfer_partial)
(gnu_find_memory_regions, gnu_pid_to_str): Refactor as methods of
gnu_nat_target.
(gnu_target): Delete.
* gnu-nat.h (gnu_target): Delete.
(gnu_nat_target): New class.
* i386-gnu-nat.c (gnu_base_target): New.
(i386_gnu_nat_target): New class.
(the_i386_gnu_nat_target): New.
(_initialize_i386gnu_nat): Adjust to C++ification.
gdb/testsuite/ChangeLog:
2018-05-02 Pedro Alves <palves@redhat.com>
* gdb.base/breakpoint-in-ro-region.exp: Adjust to to_resume and
to_log_command renames.
* gdb.base/sss-bp-on-user-bp-2.exp: Likewise.
1370 lines
44 KiB
C
1370 lines
44 KiB
C
/* Abstraction of GNU v3 abi.
|
|
Contributed by Jim Blandy <jimb@redhat.com>
|
|
|
|
Copyright (C) 2001-2018 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "value.h"
|
|
#include "cp-abi.h"
|
|
#include "cp-support.h"
|
|
#include "demangle.h"
|
|
#include "objfiles.h"
|
|
#include "valprint.h"
|
|
#include "c-lang.h"
|
|
#include "typeprint.h"
|
|
#include <algorithm>
|
|
|
|
static struct cp_abi_ops gnu_v3_abi_ops;
|
|
|
|
/* A gdbarch key for std::type_info, in the event that it can't be
|
|
found in the debug info. */
|
|
|
|
static struct gdbarch_data *std_type_info_gdbarch_data;
|
|
|
|
|
|
static int
|
|
gnuv3_is_vtable_name (const char *name)
|
|
{
|
|
return startswith (name, "_ZTV");
|
|
}
|
|
|
|
static int
|
|
gnuv3_is_operator_name (const char *name)
|
|
{
|
|
return startswith (name, CP_OPERATOR_STR);
|
|
}
|
|
|
|
|
|
/* To help us find the components of a vtable, we build ourselves a
|
|
GDB type object representing the vtable structure. Following the
|
|
V3 ABI, it goes something like this:
|
|
|
|
struct gdb_gnu_v3_abi_vtable {
|
|
|
|
/ * An array of virtual call and virtual base offsets. The real
|
|
length of this array depends on the class hierarchy; we use
|
|
negative subscripts to access the elements. Yucky, but
|
|
better than the alternatives. * /
|
|
ptrdiff_t vcall_and_vbase_offsets[0];
|
|
|
|
/ * The offset from a virtual pointer referring to this table
|
|
to the top of the complete object. * /
|
|
ptrdiff_t offset_to_top;
|
|
|
|
/ * The type_info pointer for this class. This is really a
|
|
std::type_info *, but GDB doesn't really look at the
|
|
type_info object itself, so we don't bother to get the type
|
|
exactly right. * /
|
|
void *type_info;
|
|
|
|
/ * Virtual table pointers in objects point here. * /
|
|
|
|
/ * Virtual function pointers. Like the vcall/vbase array, the
|
|
real length of this table depends on the class hierarchy. * /
|
|
void (*virtual_functions[0]) ();
|
|
|
|
};
|
|
|
|
The catch, of course, is that the exact layout of this table
|
|
depends on the ABI --- word size, endianness, alignment, etc. So
|
|
the GDB type object is actually a per-architecture kind of thing.
|
|
|
|
vtable_type_gdbarch_data is a gdbarch per-architecture data pointer
|
|
which refers to the struct type * for this structure, laid out
|
|
appropriately for the architecture. */
|
|
static struct gdbarch_data *vtable_type_gdbarch_data;
|
|
|
|
|
|
/* Human-readable names for the numbers of the fields above. */
|
|
enum {
|
|
vtable_field_vcall_and_vbase_offsets,
|
|
vtable_field_offset_to_top,
|
|
vtable_field_type_info,
|
|
vtable_field_virtual_functions
|
|
};
|
|
|
|
|
|
/* Return a GDB type representing `struct gdb_gnu_v3_abi_vtable',
|
|
described above, laid out appropriately for ARCH.
|
|
|
|
We use this function as the gdbarch per-architecture data
|
|
initialization function. */
|
|
static void *
|
|
build_gdb_vtable_type (struct gdbarch *arch)
|
|
{
|
|
struct type *t;
|
|
struct field *field_list, *field;
|
|
int offset;
|
|
|
|
struct type *void_ptr_type
|
|
= builtin_type (arch)->builtin_data_ptr;
|
|
struct type *ptr_to_void_fn_type
|
|
= builtin_type (arch)->builtin_func_ptr;
|
|
|
|
/* ARCH can't give us the true ptrdiff_t type, so we guess. */
|
|
struct type *ptrdiff_type
|
|
= arch_integer_type (arch, gdbarch_ptr_bit (arch), 0, "ptrdiff_t");
|
|
|
|
/* We assume no padding is necessary, since GDB doesn't know
|
|
anything about alignment at the moment. If this assumption bites
|
|
us, we should add a gdbarch method which, given a type, returns
|
|
the alignment that type requires, and then use that here. */
|
|
|
|
/* Build the field list. */
|
|
field_list = XCNEWVEC (struct field, 4);
|
|
field = &field_list[0];
|
|
offset = 0;
|
|
|
|
/* ptrdiff_t vcall_and_vbase_offsets[0]; */
|
|
FIELD_NAME (*field) = "vcall_and_vbase_offsets";
|
|
FIELD_TYPE (*field) = lookup_array_range_type (ptrdiff_type, 0, -1);
|
|
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
|
|
offset += TYPE_LENGTH (FIELD_TYPE (*field));
|
|
field++;
|
|
|
|
/* ptrdiff_t offset_to_top; */
|
|
FIELD_NAME (*field) = "offset_to_top";
|
|
FIELD_TYPE (*field) = ptrdiff_type;
|
|
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
|
|
offset += TYPE_LENGTH (FIELD_TYPE (*field));
|
|
field++;
|
|
|
|
/* void *type_info; */
|
|
FIELD_NAME (*field) = "type_info";
|
|
FIELD_TYPE (*field) = void_ptr_type;
|
|
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
|
|
offset += TYPE_LENGTH (FIELD_TYPE (*field));
|
|
field++;
|
|
|
|
/* void (*virtual_functions[0]) (); */
|
|
FIELD_NAME (*field) = "virtual_functions";
|
|
FIELD_TYPE (*field) = lookup_array_range_type (ptr_to_void_fn_type, 0, -1);
|
|
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
|
|
offset += TYPE_LENGTH (FIELD_TYPE (*field));
|
|
field++;
|
|
|
|
/* We assumed in the allocation above that there were four fields. */
|
|
gdb_assert (field == (field_list + 4));
|
|
|
|
t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
|
|
TYPE_NFIELDS (t) = field - field_list;
|
|
TYPE_FIELDS (t) = field_list;
|
|
TYPE_TAG_NAME (t) = "gdb_gnu_v3_abi_vtable";
|
|
INIT_CPLUS_SPECIFIC (t);
|
|
|
|
return make_type_with_address_space (t, TYPE_INSTANCE_FLAG_CODE_SPACE);
|
|
}
|
|
|
|
|
|
/* Return the ptrdiff_t type used in the vtable type. */
|
|
static struct type *
|
|
vtable_ptrdiff_type (struct gdbarch *gdbarch)
|
|
{
|
|
struct type *vtable_type
|
|
= (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
|
|
|
|
/* The "offset_to_top" field has the appropriate (ptrdiff_t) type. */
|
|
return TYPE_FIELD_TYPE (vtable_type, vtable_field_offset_to_top);
|
|
}
|
|
|
|
/* Return the offset from the start of the imaginary `struct
|
|
gdb_gnu_v3_abi_vtable' object to the vtable's "address point"
|
|
(i.e., where objects' virtual table pointers point). */
|
|
static int
|
|
vtable_address_point_offset (struct gdbarch *gdbarch)
|
|
{
|
|
struct type *vtable_type
|
|
= (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
|
|
|
|
return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
|
|
/ TARGET_CHAR_BIT);
|
|
}
|
|
|
|
|
|
/* Determine whether structure TYPE is a dynamic class. Cache the
|
|
result. */
|
|
|
|
static int
|
|
gnuv3_dynamic_class (struct type *type)
|
|
{
|
|
int fieldnum, fieldelem;
|
|
|
|
type = check_typedef (type);
|
|
gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
|
|
|| TYPE_CODE (type) == TYPE_CODE_UNION);
|
|
|
|
if (TYPE_CODE (type) == TYPE_CODE_UNION)
|
|
return 0;
|
|
|
|
if (TYPE_CPLUS_DYNAMIC (type))
|
|
return TYPE_CPLUS_DYNAMIC (type) == 1;
|
|
|
|
ALLOCATE_CPLUS_STRUCT_TYPE (type);
|
|
|
|
for (fieldnum = 0; fieldnum < TYPE_N_BASECLASSES (type); fieldnum++)
|
|
if (BASETYPE_VIA_VIRTUAL (type, fieldnum)
|
|
|| gnuv3_dynamic_class (TYPE_FIELD_TYPE (type, fieldnum)))
|
|
{
|
|
TYPE_CPLUS_DYNAMIC (type) = 1;
|
|
return 1;
|
|
}
|
|
|
|
for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
|
|
for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
|
|
fieldelem++)
|
|
{
|
|
struct fn_field *f = TYPE_FN_FIELDLIST1 (type, fieldnum);
|
|
|
|
if (TYPE_FN_FIELD_VIRTUAL_P (f, fieldelem))
|
|
{
|
|
TYPE_CPLUS_DYNAMIC (type) = 1;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
TYPE_CPLUS_DYNAMIC (type) = -1;
|
|
return 0;
|
|
}
|
|
|
|
/* Find the vtable for a value of CONTAINER_TYPE located at
|
|
CONTAINER_ADDR. Return a value of the correct vtable type for this
|
|
architecture, or NULL if CONTAINER does not have a vtable. */
|
|
|
|
static struct value *
|
|
gnuv3_get_vtable (struct gdbarch *gdbarch,
|
|
struct type *container_type, CORE_ADDR container_addr)
|
|
{
|
|
struct type *vtable_type
|
|
= (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
|
|
struct type *vtable_pointer_type;
|
|
struct value *vtable_pointer;
|
|
CORE_ADDR vtable_address;
|
|
|
|
container_type = check_typedef (container_type);
|
|
gdb_assert (TYPE_CODE (container_type) == TYPE_CODE_STRUCT);
|
|
|
|
/* If this type does not have a virtual table, don't read the first
|
|
field. */
|
|
if (!gnuv3_dynamic_class (container_type))
|
|
return NULL;
|
|
|
|
/* We do not consult the debug information to find the virtual table.
|
|
The ABI specifies that it is always at offset zero in any class,
|
|
and debug information may not represent it.
|
|
|
|
We avoid using value_contents on principle, because the object might
|
|
be large. */
|
|
|
|
/* Find the type "pointer to virtual table". */
|
|
vtable_pointer_type = lookup_pointer_type (vtable_type);
|
|
|
|
/* Load it from the start of the class. */
|
|
vtable_pointer = value_at (vtable_pointer_type, container_addr);
|
|
vtable_address = value_as_address (vtable_pointer);
|
|
|
|
/* Correct it to point at the start of the virtual table, rather
|
|
than the address point. */
|
|
return value_at_lazy (vtable_type,
|
|
vtable_address
|
|
- vtable_address_point_offset (gdbarch));
|
|
}
|
|
|
|
|
|
static struct type *
|
|
gnuv3_rtti_type (struct value *value,
|
|
int *full_p, LONGEST *top_p, int *using_enc_p)
|
|
{
|
|
struct gdbarch *gdbarch;
|
|
struct type *values_type = check_typedef (value_type (value));
|
|
struct value *vtable;
|
|
struct minimal_symbol *vtable_symbol;
|
|
const char *vtable_symbol_name;
|
|
const char *class_name;
|
|
struct type *run_time_type;
|
|
LONGEST offset_to_top;
|
|
const char *atsign;
|
|
|
|
/* We only have RTTI for dynamic class objects. */
|
|
if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT
|
|
|| !gnuv3_dynamic_class (values_type))
|
|
return NULL;
|
|
|
|
/* Determine architecture. */
|
|
gdbarch = get_type_arch (values_type);
|
|
|
|
if (using_enc_p)
|
|
*using_enc_p = 0;
|
|
|
|
vtable = gnuv3_get_vtable (gdbarch, values_type,
|
|
value_as_address (value_addr (value)));
|
|
if (vtable == NULL)
|
|
return NULL;
|
|
|
|
/* Find the linker symbol for this vtable. */
|
|
vtable_symbol
|
|
= lookup_minimal_symbol_by_pc (value_address (vtable)
|
|
+ value_embedded_offset (vtable)).minsym;
|
|
if (! vtable_symbol)
|
|
return NULL;
|
|
|
|
/* The symbol's demangled name should be something like "vtable for
|
|
CLASS", where CLASS is the name of the run-time type of VALUE.
|
|
If we didn't like this approach, we could instead look in the
|
|
type_info object itself to get the class name. But this way
|
|
should work just as well, and doesn't read target memory. */
|
|
vtable_symbol_name = MSYMBOL_DEMANGLED_NAME (vtable_symbol);
|
|
if (vtable_symbol_name == NULL
|
|
|| !startswith (vtable_symbol_name, "vtable for "))
|
|
{
|
|
warning (_("can't find linker symbol for virtual table for `%s' value"),
|
|
TYPE_SAFE_NAME (values_type));
|
|
if (vtable_symbol_name)
|
|
warning (_(" found `%s' instead"), vtable_symbol_name);
|
|
return NULL;
|
|
}
|
|
class_name = vtable_symbol_name + 11;
|
|
|
|
/* Strip off @plt and version suffixes. */
|
|
atsign = strchr (class_name, '@');
|
|
if (atsign != NULL)
|
|
{
|
|
char *copy;
|
|
|
|
copy = (char *) alloca (atsign - class_name + 1);
|
|
memcpy (copy, class_name, atsign - class_name);
|
|
copy[atsign - class_name] = '\0';
|
|
class_name = copy;
|
|
}
|
|
|
|
/* Try to look up the class name as a type name. */
|
|
/* FIXME: chastain/2003-11-26: block=NULL is bogus. See pr gdb/1465. */
|
|
run_time_type = cp_lookup_rtti_type (class_name, NULL);
|
|
if (run_time_type == NULL)
|
|
return NULL;
|
|
|
|
/* Get the offset from VALUE to the top of the complete object.
|
|
NOTE: this is the reverse of the meaning of *TOP_P. */
|
|
offset_to_top
|
|
= value_as_long (value_field (vtable, vtable_field_offset_to_top));
|
|
|
|
if (full_p)
|
|
*full_p = (- offset_to_top == value_embedded_offset (value)
|
|
&& (TYPE_LENGTH (value_enclosing_type (value))
|
|
>= TYPE_LENGTH (run_time_type)));
|
|
if (top_p)
|
|
*top_p = - offset_to_top;
|
|
return run_time_type;
|
|
}
|
|
|
|
/* Return a function pointer for CONTAINER's VTABLE_INDEX'th virtual
|
|
function, of type FNTYPE. */
|
|
|
|
static struct value *
|
|
gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
|
|
struct type *fntype, int vtable_index)
|
|
{
|
|
struct value *vtable, *vfn;
|
|
|
|
/* Every class with virtual functions must have a vtable. */
|
|
vtable = gnuv3_get_vtable (gdbarch, value_type (container),
|
|
value_as_address (value_addr (container)));
|
|
gdb_assert (vtable != NULL);
|
|
|
|
/* Fetch the appropriate function pointer from the vtable. */
|
|
vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
|
|
vtable_index);
|
|
|
|
/* If this architecture uses function descriptors directly in the vtable,
|
|
then the address of the vtable entry is actually a "function pointer"
|
|
(i.e. points to the descriptor). We don't need to scale the index
|
|
by the size of a function descriptor; GCC does that before outputing
|
|
debug information. */
|
|
if (gdbarch_vtable_function_descriptors (gdbarch))
|
|
vfn = value_addr (vfn);
|
|
|
|
/* Cast the function pointer to the appropriate type. */
|
|
vfn = value_cast (lookup_pointer_type (fntype), vfn);
|
|
|
|
return vfn;
|
|
}
|
|
|
|
/* GNU v3 implementation of value_virtual_fn_field. See cp-abi.h
|
|
for a description of the arguments. */
|
|
|
|
static struct value *
|
|
gnuv3_virtual_fn_field (struct value **value_p,
|
|
struct fn_field *f, int j,
|
|
struct type *vfn_base, int offset)
|
|
{
|
|
struct type *values_type = check_typedef (value_type (*value_p));
|
|
struct gdbarch *gdbarch;
|
|
|
|
/* Some simple sanity checks. */
|
|
if (TYPE_CODE (values_type) != TYPE_CODE_STRUCT)
|
|
error (_("Only classes can have virtual functions."));
|
|
|
|
/* Determine architecture. */
|
|
gdbarch = get_type_arch (values_type);
|
|
|
|
/* Cast our value to the base class which defines this virtual
|
|
function. This takes care of any necessary `this'
|
|
adjustments. */
|
|
if (vfn_base != values_type)
|
|
*value_p = value_cast (vfn_base, *value_p);
|
|
|
|
return gnuv3_get_virtual_fn (gdbarch, *value_p, TYPE_FN_FIELD_TYPE (f, j),
|
|
TYPE_FN_FIELD_VOFFSET (f, j));
|
|
}
|
|
|
|
/* Compute the offset of the baseclass which is
|
|
the INDEXth baseclass of class TYPE,
|
|
for value at VALADDR (in host) at ADDRESS (in target).
|
|
The result is the offset of the baseclass value relative
|
|
to (the address of)(ARG) + OFFSET.
|
|
|
|
-1 is returned on error. */
|
|
|
|
static int
|
|
gnuv3_baseclass_offset (struct type *type, int index,
|
|
const bfd_byte *valaddr, LONGEST embedded_offset,
|
|
CORE_ADDR address, const struct value *val)
|
|
{
|
|
struct gdbarch *gdbarch;
|
|
struct type *ptr_type;
|
|
struct value *vtable;
|
|
struct value *vbase_array;
|
|
long int cur_base_offset, base_offset;
|
|
|
|
/* Determine architecture. */
|
|
gdbarch = get_type_arch (type);
|
|
ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
|
|
|
|
/* If it isn't a virtual base, this is easy. The offset is in the
|
|
type definition. */
|
|
if (!BASETYPE_VIA_VIRTUAL (type, index))
|
|
return TYPE_BASECLASS_BITPOS (type, index) / 8;
|
|
|
|
/* To access a virtual base, we need to use the vbase offset stored in
|
|
our vtable. Recent GCC versions provide this information. If it isn't
|
|
available, we could get what we needed from RTTI, or from drawing the
|
|
complete inheritance graph based on the debug info. Neither is
|
|
worthwhile. */
|
|
cur_base_offset = TYPE_BASECLASS_BITPOS (type, index) / 8;
|
|
if (cur_base_offset >= - vtable_address_point_offset (gdbarch))
|
|
error (_("Expected a negative vbase offset (old compiler?)"));
|
|
|
|
cur_base_offset = cur_base_offset + vtable_address_point_offset (gdbarch);
|
|
if ((- cur_base_offset) % TYPE_LENGTH (ptr_type) != 0)
|
|
error (_("Misaligned vbase offset."));
|
|
cur_base_offset = cur_base_offset / ((int) TYPE_LENGTH (ptr_type));
|
|
|
|
vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
|
|
gdb_assert (vtable != NULL);
|
|
vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
|
|
base_offset = value_as_long (value_subscript (vbase_array, cur_base_offset));
|
|
return base_offset;
|
|
}
|
|
|
|
/* Locate a virtual method in DOMAIN or its non-virtual base classes
|
|
which has virtual table index VOFFSET. The method has an associated
|
|
"this" adjustment of ADJUSTMENT bytes. */
|
|
|
|
static const char *
|
|
gnuv3_find_method_in (struct type *domain, CORE_ADDR voffset,
|
|
LONGEST adjustment)
|
|
{
|
|
int i;
|
|
|
|
/* Search this class first. */
|
|
if (adjustment == 0)
|
|
{
|
|
int len;
|
|
|
|
len = TYPE_NFN_FIELDS (domain);
|
|
for (i = 0; i < len; i++)
|
|
{
|
|
int len2, j;
|
|
struct fn_field *f;
|
|
|
|
f = TYPE_FN_FIELDLIST1 (domain, i);
|
|
len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
|
|
|
|
check_stub_method_group (domain, i);
|
|
for (j = 0; j < len2; j++)
|
|
if (TYPE_FN_FIELD_VOFFSET (f, j) == voffset)
|
|
return TYPE_FN_FIELD_PHYSNAME (f, j);
|
|
}
|
|
}
|
|
|
|
/* Next search non-virtual bases. If it's in a virtual base,
|
|
we're out of luck. */
|
|
for (i = 0; i < TYPE_N_BASECLASSES (domain); i++)
|
|
{
|
|
int pos;
|
|
struct type *basetype;
|
|
|
|
if (BASETYPE_VIA_VIRTUAL (domain, i))
|
|
continue;
|
|
|
|
pos = TYPE_BASECLASS_BITPOS (domain, i) / 8;
|
|
basetype = TYPE_FIELD_TYPE (domain, i);
|
|
/* Recurse with a modified adjustment. We don't need to adjust
|
|
voffset. */
|
|
if (adjustment >= pos && adjustment < pos + TYPE_LENGTH (basetype))
|
|
return gnuv3_find_method_in (basetype, voffset, adjustment - pos);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Decode GNU v3 method pointer. */
|
|
|
|
static int
|
|
gnuv3_decode_method_ptr (struct gdbarch *gdbarch,
|
|
const gdb_byte *contents,
|
|
CORE_ADDR *value_p,
|
|
LONGEST *adjustment_p)
|
|
{
|
|
struct type *funcptr_type = builtin_type (gdbarch)->builtin_func_ptr;
|
|
struct type *offset_type = vtable_ptrdiff_type (gdbarch);
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
CORE_ADDR ptr_value;
|
|
LONGEST voffset, adjustment;
|
|
int vbit;
|
|
|
|
/* Extract the pointer to member. The first element is either a pointer
|
|
or a vtable offset. For pointers, we need to use extract_typed_address
|
|
to allow the back-end to convert the pointer to a GDB address -- but
|
|
vtable offsets we must handle as integers. At this point, we do not
|
|
yet know which case we have, so we extract the value under both
|
|
interpretations and choose the right one later on. */
|
|
ptr_value = extract_typed_address (contents, funcptr_type);
|
|
voffset = extract_signed_integer (contents,
|
|
TYPE_LENGTH (funcptr_type), byte_order);
|
|
contents += TYPE_LENGTH (funcptr_type);
|
|
adjustment = extract_signed_integer (contents,
|
|
TYPE_LENGTH (offset_type), byte_order);
|
|
|
|
if (!gdbarch_vbit_in_delta (gdbarch))
|
|
{
|
|
vbit = voffset & 1;
|
|
voffset = voffset ^ vbit;
|
|
}
|
|
else
|
|
{
|
|
vbit = adjustment & 1;
|
|
adjustment = adjustment >> 1;
|
|
}
|
|
|
|
*value_p = vbit? voffset : ptr_value;
|
|
*adjustment_p = adjustment;
|
|
return vbit;
|
|
}
|
|
|
|
/* GNU v3 implementation of cplus_print_method_ptr. */
|
|
|
|
static void
|
|
gnuv3_print_method_ptr (const gdb_byte *contents,
|
|
struct type *type,
|
|
struct ui_file *stream)
|
|
{
|
|
struct type *self_type = TYPE_SELF_TYPE (type);
|
|
struct gdbarch *gdbarch = get_type_arch (self_type);
|
|
CORE_ADDR ptr_value;
|
|
LONGEST adjustment;
|
|
int vbit;
|
|
|
|
/* Extract the pointer to member. */
|
|
vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
|
|
|
|
/* Check for NULL. */
|
|
if (ptr_value == 0 && vbit == 0)
|
|
{
|
|
fprintf_filtered (stream, "NULL");
|
|
return;
|
|
}
|
|
|
|
/* Search for a virtual method. */
|
|
if (vbit)
|
|
{
|
|
CORE_ADDR voffset;
|
|
const char *physname;
|
|
|
|
/* It's a virtual table offset, maybe in this class. Search
|
|
for a field with the correct vtable offset. First convert it
|
|
to an index, as used in TYPE_FN_FIELD_VOFFSET. */
|
|
voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
|
|
|
|
physname = gnuv3_find_method_in (self_type, voffset, adjustment);
|
|
|
|
/* If we found a method, print that. We don't bother to disambiguate
|
|
possible paths to the method based on the adjustment. */
|
|
if (physname)
|
|
{
|
|
char *demangled_name = gdb_demangle (physname,
|
|
DMGL_ANSI | DMGL_PARAMS);
|
|
|
|
fprintf_filtered (stream, "&virtual ");
|
|
if (demangled_name == NULL)
|
|
fputs_filtered (physname, stream);
|
|
else
|
|
{
|
|
fputs_filtered (demangled_name, stream);
|
|
xfree (demangled_name);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else if (ptr_value != 0)
|
|
{
|
|
/* Found a non-virtual function: print out the type. */
|
|
fputs_filtered ("(", stream);
|
|
c_print_type (type, "", stream, -1, 0, &type_print_raw_options);
|
|
fputs_filtered (") ", stream);
|
|
}
|
|
|
|
/* We didn't find it; print the raw data. */
|
|
if (vbit)
|
|
{
|
|
fprintf_filtered (stream, "&virtual table offset ");
|
|
print_longest (stream, 'd', 1, ptr_value);
|
|
}
|
|
else
|
|
{
|
|
struct value_print_options opts;
|
|
|
|
get_user_print_options (&opts);
|
|
print_address_demangle (&opts, gdbarch, ptr_value, stream, demangle);
|
|
}
|
|
|
|
if (adjustment)
|
|
{
|
|
fprintf_filtered (stream, ", this adjustment ");
|
|
print_longest (stream, 'd', 1, adjustment);
|
|
}
|
|
}
|
|
|
|
/* GNU v3 implementation of cplus_method_ptr_size. */
|
|
|
|
static int
|
|
gnuv3_method_ptr_size (struct type *type)
|
|
{
|
|
struct gdbarch *gdbarch = get_type_arch (type);
|
|
|
|
return 2 * TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
|
|
}
|
|
|
|
/* GNU v3 implementation of cplus_make_method_ptr. */
|
|
|
|
static void
|
|
gnuv3_make_method_ptr (struct type *type, gdb_byte *contents,
|
|
CORE_ADDR value, int is_virtual)
|
|
{
|
|
struct gdbarch *gdbarch = get_type_arch (type);
|
|
int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr);
|
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
|
|
|
/* FIXME drow/2006-12-24: The adjustment of "this" is currently
|
|
always zero, since the method pointer is of the correct type.
|
|
But if the method pointer came from a base class, this is
|
|
incorrect - it should be the offset to the base. The best
|
|
fix might be to create the pointer to member pointing at the
|
|
base class and cast it to the derived class, but that requires
|
|
support for adjusting pointers to members when casting them -
|
|
not currently supported by GDB. */
|
|
|
|
if (!gdbarch_vbit_in_delta (gdbarch))
|
|
{
|
|
store_unsigned_integer (contents, size, byte_order, value | is_virtual);
|
|
store_unsigned_integer (contents + size, size, byte_order, 0);
|
|
}
|
|
else
|
|
{
|
|
store_unsigned_integer (contents, size, byte_order, value);
|
|
store_unsigned_integer (contents + size, size, byte_order, is_virtual);
|
|
}
|
|
}
|
|
|
|
/* GNU v3 implementation of cplus_method_ptr_to_value. */
|
|
|
|
static struct value *
|
|
gnuv3_method_ptr_to_value (struct value **this_p, struct value *method_ptr)
|
|
{
|
|
struct gdbarch *gdbarch;
|
|
const gdb_byte *contents = value_contents (method_ptr);
|
|
CORE_ADDR ptr_value;
|
|
struct type *self_type, *final_type, *method_type;
|
|
LONGEST adjustment;
|
|
int vbit;
|
|
|
|
self_type = TYPE_SELF_TYPE (check_typedef (value_type (method_ptr)));
|
|
final_type = lookup_pointer_type (self_type);
|
|
|
|
method_type = TYPE_TARGET_TYPE (check_typedef (value_type (method_ptr)));
|
|
|
|
/* Extract the pointer to member. */
|
|
gdbarch = get_type_arch (self_type);
|
|
vbit = gnuv3_decode_method_ptr (gdbarch, contents, &ptr_value, &adjustment);
|
|
|
|
/* First convert THIS to match the containing type of the pointer to
|
|
member. This cast may adjust the value of THIS. */
|
|
*this_p = value_cast (final_type, *this_p);
|
|
|
|
/* Then apply whatever adjustment is necessary. This creates a somewhat
|
|
strange pointer: it claims to have type FINAL_TYPE, but in fact it
|
|
might not be a valid FINAL_TYPE. For instance, it might be a
|
|
base class of FINAL_TYPE. And if it's not the primary base class,
|
|
then printing it out as a FINAL_TYPE object would produce some pretty
|
|
garbage.
|
|
|
|
But we don't really know the type of the first argument in
|
|
METHOD_TYPE either, which is why this happens. We can't
|
|
dereference this later as a FINAL_TYPE, but once we arrive in the
|
|
called method we'll have debugging information for the type of
|
|
"this" - and that'll match the value we produce here.
|
|
|
|
You can provoke this case by casting a Base::* to a Derived::*, for
|
|
instance. */
|
|
*this_p = value_cast (builtin_type (gdbarch)->builtin_data_ptr, *this_p);
|
|
*this_p = value_ptradd (*this_p, adjustment);
|
|
*this_p = value_cast (final_type, *this_p);
|
|
|
|
if (vbit)
|
|
{
|
|
LONGEST voffset;
|
|
|
|
voffset = ptr_value / TYPE_LENGTH (vtable_ptrdiff_type (gdbarch));
|
|
return gnuv3_get_virtual_fn (gdbarch, value_ind (*this_p),
|
|
method_type, voffset);
|
|
}
|
|
else
|
|
return value_from_pointer (lookup_pointer_type (method_type), ptr_value);
|
|
}
|
|
|
|
/* Objects of this type are stored in a hash table and a vector when
|
|
printing the vtables for a class. */
|
|
|
|
struct value_and_voffset
|
|
{
|
|
/* The value representing the object. */
|
|
struct value *value;
|
|
|
|
/* The maximum vtable offset we've found for any object at this
|
|
offset in the outermost object. */
|
|
int max_voffset;
|
|
};
|
|
|
|
/* Hash function for value_and_voffset. */
|
|
|
|
static hashval_t
|
|
hash_value_and_voffset (const void *p)
|
|
{
|
|
const struct value_and_voffset *o = (const struct value_and_voffset *) p;
|
|
|
|
return value_address (o->value) + value_embedded_offset (o->value);
|
|
}
|
|
|
|
/* Equality function for value_and_voffset. */
|
|
|
|
static int
|
|
eq_value_and_voffset (const void *a, const void *b)
|
|
{
|
|
const struct value_and_voffset *ova = (const struct value_and_voffset *) a;
|
|
const struct value_and_voffset *ovb = (const struct value_and_voffset *) b;
|
|
|
|
return (value_address (ova->value) + value_embedded_offset (ova->value)
|
|
== value_address (ovb->value) + value_embedded_offset (ovb->value));
|
|
}
|
|
|
|
/* Comparison function for value_and_voffset. */
|
|
|
|
static bool
|
|
compare_value_and_voffset (const struct value_and_voffset *va,
|
|
const struct value_and_voffset *vb)
|
|
{
|
|
CORE_ADDR addra = (value_address (va->value)
|
|
+ value_embedded_offset (va->value));
|
|
CORE_ADDR addrb = (value_address (vb->value)
|
|
+ value_embedded_offset (vb->value));
|
|
|
|
return addra < addrb;
|
|
}
|
|
|
|
/* A helper function used when printing vtables. This determines the
|
|
key (most derived) sub-object at each address and also computes the
|
|
maximum vtable offset seen for the corresponding vtable. Updates
|
|
OFFSET_HASH and OFFSET_VEC with a new value_and_voffset object, if
|
|
needed. VALUE is the object to examine. */
|
|
|
|
static void
|
|
compute_vtable_size (htab_t offset_hash,
|
|
std::vector<value_and_voffset *> *offset_vec,
|
|
struct value *value)
|
|
{
|
|
int i;
|
|
struct type *type = check_typedef (value_type (value));
|
|
void **slot;
|
|
struct value_and_voffset search_vo, *current_vo;
|
|
|
|
gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT);
|
|
|
|
/* If the object is not dynamic, then we are done; as it cannot have
|
|
dynamic base types either. */
|
|
if (!gnuv3_dynamic_class (type))
|
|
return;
|
|
|
|
/* Update the hash and the vec, if needed. */
|
|
search_vo.value = value;
|
|
slot = htab_find_slot (offset_hash, &search_vo, INSERT);
|
|
if (*slot)
|
|
current_vo = (struct value_and_voffset *) *slot;
|
|
else
|
|
{
|
|
current_vo = XNEW (struct value_and_voffset);
|
|
current_vo->value = value;
|
|
current_vo->max_voffset = -1;
|
|
*slot = current_vo;
|
|
offset_vec->push_back (current_vo);
|
|
}
|
|
|
|
/* Update the value_and_voffset object with the highest vtable
|
|
offset from this class. */
|
|
for (i = 0; i < TYPE_NFN_FIELDS (type); ++i)
|
|
{
|
|
int j;
|
|
struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, i);
|
|
|
|
for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (type, i); ++j)
|
|
{
|
|
if (TYPE_FN_FIELD_VIRTUAL_P (fn, j))
|
|
{
|
|
int voffset = TYPE_FN_FIELD_VOFFSET (fn, j);
|
|
|
|
if (voffset > current_vo->max_voffset)
|
|
current_vo->max_voffset = voffset;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Recurse into base classes. */
|
|
for (i = 0; i < TYPE_N_BASECLASSES (type); ++i)
|
|
compute_vtable_size (offset_hash, offset_vec, value_field (value, i));
|
|
}
|
|
|
|
/* Helper for gnuv3_print_vtable that prints a single vtable. */
|
|
|
|
static void
|
|
print_one_vtable (struct gdbarch *gdbarch, struct value *value,
|
|
int max_voffset,
|
|
struct value_print_options *opts)
|
|
{
|
|
int i;
|
|
struct type *type = check_typedef (value_type (value));
|
|
struct value *vtable;
|
|
CORE_ADDR vt_addr;
|
|
|
|
vtable = gnuv3_get_vtable (gdbarch, type,
|
|
value_address (value)
|
|
+ value_embedded_offset (value));
|
|
vt_addr = value_address (value_field (vtable,
|
|
vtable_field_virtual_functions));
|
|
|
|
printf_filtered (_("vtable for '%s' @ %s (subobject @ %s):\n"),
|
|
TYPE_SAFE_NAME (type),
|
|
paddress (gdbarch, vt_addr),
|
|
paddress (gdbarch, (value_address (value)
|
|
+ value_embedded_offset (value))));
|
|
|
|
for (i = 0; i <= max_voffset; ++i)
|
|
{
|
|
/* Initialize it just to avoid a GCC false warning. */
|
|
CORE_ADDR addr = 0;
|
|
int got_error = 0;
|
|
struct value *vfn;
|
|
|
|
printf_filtered ("[%d]: ", i);
|
|
|
|
vfn = value_subscript (value_field (vtable,
|
|
vtable_field_virtual_functions),
|
|
i);
|
|
|
|
if (gdbarch_vtable_function_descriptors (gdbarch))
|
|
vfn = value_addr (vfn);
|
|
|
|
TRY
|
|
{
|
|
addr = value_as_address (vfn);
|
|
}
|
|
CATCH (ex, RETURN_MASK_ERROR)
|
|
{
|
|
printf_filtered (_("<error: %s>"), ex.message);
|
|
got_error = 1;
|
|
}
|
|
END_CATCH
|
|
|
|
if (!got_error)
|
|
print_function_pointer_address (opts, gdbarch, addr, gdb_stdout);
|
|
printf_filtered ("\n");
|
|
}
|
|
}
|
|
|
|
/* Implementation of the print_vtable method. */
|
|
|
|
static void
|
|
gnuv3_print_vtable (struct value *value)
|
|
{
|
|
struct gdbarch *gdbarch;
|
|
struct type *type;
|
|
struct value *vtable;
|
|
struct value_print_options opts;
|
|
int count;
|
|
|
|
value = coerce_ref (value);
|
|
type = check_typedef (value_type (value));
|
|
if (TYPE_CODE (type) == TYPE_CODE_PTR)
|
|
{
|
|
value = value_ind (value);
|
|
type = check_typedef (value_type (value));
|
|
}
|
|
|
|
get_user_print_options (&opts);
|
|
|
|
/* Respect 'set print object'. */
|
|
if (opts.objectprint)
|
|
{
|
|
value = value_full_object (value, NULL, 0, 0, 0);
|
|
type = check_typedef (value_type (value));
|
|
}
|
|
|
|
gdbarch = get_type_arch (type);
|
|
|
|
vtable = NULL;
|
|
if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
|
|
vtable = gnuv3_get_vtable (gdbarch, type,
|
|
value_as_address (value_addr (value)));
|
|
|
|
if (!vtable)
|
|
{
|
|
printf_filtered (_("This object does not have a virtual function table\n"));
|
|
return;
|
|
}
|
|
|
|
htab_up offset_hash (htab_create_alloc (1, hash_value_and_voffset,
|
|
eq_value_and_voffset,
|
|
xfree, xcalloc, xfree));
|
|
std::vector<value_and_voffset *> result_vec;
|
|
|
|
compute_vtable_size (offset_hash.get (), &result_vec, value);
|
|
std::sort (result_vec.begin (), result_vec.end (),
|
|
compare_value_and_voffset);
|
|
|
|
count = 0;
|
|
for (value_and_voffset *iter : result_vec)
|
|
{
|
|
if (iter->max_voffset >= 0)
|
|
{
|
|
if (count > 0)
|
|
printf_filtered ("\n");
|
|
print_one_vtable (gdbarch, iter->value, iter->max_voffset, &opts);
|
|
++count;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Return a GDB type representing `struct std::type_info', laid out
|
|
appropriately for ARCH.
|
|
|
|
We use this function as the gdbarch per-architecture data
|
|
initialization function. */
|
|
|
|
static void *
|
|
build_std_type_info_type (struct gdbarch *arch)
|
|
{
|
|
struct type *t;
|
|
struct field *field_list, *field;
|
|
int offset;
|
|
struct type *void_ptr_type
|
|
= builtin_type (arch)->builtin_data_ptr;
|
|
struct type *char_type
|
|
= builtin_type (arch)->builtin_char;
|
|
struct type *char_ptr_type
|
|
= make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL);
|
|
|
|
field_list = XCNEWVEC (struct field, 2);
|
|
field = &field_list[0];
|
|
offset = 0;
|
|
|
|
/* The vtable. */
|
|
FIELD_NAME (*field) = "_vptr.type_info";
|
|
FIELD_TYPE (*field) = void_ptr_type;
|
|
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
|
|
offset += TYPE_LENGTH (FIELD_TYPE (*field));
|
|
field++;
|
|
|
|
/* The name. */
|
|
FIELD_NAME (*field) = "__name";
|
|
FIELD_TYPE (*field) = char_ptr_type;
|
|
SET_FIELD_BITPOS (*field, offset * TARGET_CHAR_BIT);
|
|
offset += TYPE_LENGTH (FIELD_TYPE (*field));
|
|
field++;
|
|
|
|
gdb_assert (field == (field_list + 2));
|
|
|
|
t = arch_type (arch, TYPE_CODE_STRUCT, offset * TARGET_CHAR_BIT, NULL);
|
|
TYPE_NFIELDS (t) = field - field_list;
|
|
TYPE_FIELDS (t) = field_list;
|
|
TYPE_TAG_NAME (t) = "gdb_gnu_v3_type_info";
|
|
INIT_CPLUS_SPECIFIC (t);
|
|
|
|
return t;
|
|
}
|
|
|
|
/* Implement the 'get_typeid_type' method. */
|
|
|
|
static struct type *
|
|
gnuv3_get_typeid_type (struct gdbarch *gdbarch)
|
|
{
|
|
struct symbol *typeinfo;
|
|
struct type *typeinfo_type;
|
|
|
|
typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
|
|
NULL).symbol;
|
|
if (typeinfo == NULL)
|
|
typeinfo_type
|
|
= (struct type *) gdbarch_data (gdbarch, std_type_info_gdbarch_data);
|
|
else
|
|
typeinfo_type = SYMBOL_TYPE (typeinfo);
|
|
|
|
return typeinfo_type;
|
|
}
|
|
|
|
/* Implement the 'get_typeid' method. */
|
|
|
|
static struct value *
|
|
gnuv3_get_typeid (struct value *value)
|
|
{
|
|
struct type *typeinfo_type;
|
|
struct type *type;
|
|
struct gdbarch *gdbarch;
|
|
struct value *result;
|
|
std::string type_name, canonical;
|
|
|
|
/* We have to handle values a bit trickily here, to allow this code
|
|
to work properly with non_lvalue values that are really just
|
|
disguised types. */
|
|
if (value_lval_const (value) == lval_memory)
|
|
value = coerce_ref (value);
|
|
|
|
type = check_typedef (value_type (value));
|
|
|
|
/* In the non_lvalue case, a reference might have slipped through
|
|
here. */
|
|
if (TYPE_CODE (type) == TYPE_CODE_REF)
|
|
type = check_typedef (TYPE_TARGET_TYPE (type));
|
|
|
|
/* Ignore top-level cv-qualifiers. */
|
|
type = make_cv_type (0, 0, type, NULL);
|
|
gdbarch = get_type_arch (type);
|
|
|
|
type_name = type_to_string (type);
|
|
if (type_name.empty ())
|
|
error (_("cannot find typeinfo for unnamed type"));
|
|
|
|
/* We need to canonicalize the type name here, because we do lookups
|
|
using the demangled name, and so we must match the format it
|
|
uses. E.g., GDB tends to use "const char *" as a type name, but
|
|
the demangler uses "char const *". */
|
|
canonical = cp_canonicalize_string (type_name.c_str ());
|
|
if (!canonical.empty ())
|
|
type_name = canonical;
|
|
|
|
typeinfo_type = gnuv3_get_typeid_type (gdbarch);
|
|
|
|
/* We check for lval_memory because in the "typeid (type-id)" case,
|
|
the type is passed via a not_lval value object. */
|
|
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
|
|
&& value_lval_const (value) == lval_memory
|
|
&& gnuv3_dynamic_class (type))
|
|
{
|
|
struct value *vtable, *typeinfo_value;
|
|
CORE_ADDR address = value_address (value) + value_embedded_offset (value);
|
|
|
|
vtable = gnuv3_get_vtable (gdbarch, type, address);
|
|
if (vtable == NULL)
|
|
error (_("cannot find typeinfo for object of type '%s'"),
|
|
type_name.c_str ());
|
|
typeinfo_value = value_field (vtable, vtable_field_type_info);
|
|
result = value_ind (value_cast (make_pointer_type (typeinfo_type, NULL),
|
|
typeinfo_value));
|
|
}
|
|
else
|
|
{
|
|
std::string sym_name = std::string ("typeinfo for ") + type_name;
|
|
bound_minimal_symbol minsym
|
|
= lookup_minimal_symbol (sym_name.c_str (), NULL, NULL);
|
|
|
|
if (minsym.minsym == NULL)
|
|
error (_("could not find typeinfo symbol for '%s'"), type_name.c_str ());
|
|
|
|
result = value_at_lazy (typeinfo_type, BMSYMBOL_VALUE_ADDRESS (minsym));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Implement the 'get_typename_from_type_info' method. */
|
|
|
|
static std::string
|
|
gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
|
|
{
|
|
struct gdbarch *gdbarch = get_type_arch (value_type (type_info_ptr));
|
|
struct bound_minimal_symbol typeinfo_sym;
|
|
CORE_ADDR addr;
|
|
const char *symname;
|
|
const char *class_name;
|
|
const char *atsign;
|
|
|
|
addr = value_as_address (type_info_ptr);
|
|
typeinfo_sym = lookup_minimal_symbol_by_pc (addr);
|
|
if (typeinfo_sym.minsym == NULL)
|
|
error (_("could not find minimal symbol for typeinfo address %s"),
|
|
paddress (gdbarch, addr));
|
|
|
|
#define TYPEINFO_PREFIX "typeinfo for "
|
|
#define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
|
|
symname = MSYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
|
|
if (symname == NULL || strncmp (symname, TYPEINFO_PREFIX,
|
|
TYPEINFO_PREFIX_LEN))
|
|
error (_("typeinfo symbol '%s' has unexpected name"),
|
|
MSYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
|
|
class_name = symname + TYPEINFO_PREFIX_LEN;
|
|
|
|
/* Strip off @plt and version suffixes. */
|
|
atsign = strchr (class_name, '@');
|
|
if (atsign != NULL)
|
|
return std::string (class_name, atsign - class_name);
|
|
return class_name;
|
|
}
|
|
|
|
/* Implement the 'get_type_from_type_info' method. */
|
|
|
|
static struct type *
|
|
gnuv3_get_type_from_type_info (struct value *type_info_ptr)
|
|
{
|
|
/* We have to parse the type name, since in general there is not a
|
|
symbol for a type. This is somewhat bogus since there may be a
|
|
mis-parse. Another approach might be to re-use the demangler's
|
|
internal form to reconstruct the type somehow. */
|
|
std::string type_name = gnuv3_get_typename_from_type_info (type_info_ptr);
|
|
expression_up expr (parse_expression (type_name.c_str ()));
|
|
struct value *type_val = evaluate_type (expr.get ());
|
|
return value_type (type_val);
|
|
}
|
|
|
|
/* Determine if we are currently in a C++ thunk. If so, get the address
|
|
of the routine we are thunking to and continue to there instead. */
|
|
|
|
static CORE_ADDR
|
|
gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
|
|
{
|
|
CORE_ADDR real_stop_pc, method_stop_pc, func_addr;
|
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
|
struct bound_minimal_symbol thunk_sym, fn_sym;
|
|
struct obj_section *section;
|
|
const char *thunk_name, *fn_name;
|
|
|
|
real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
|
|
if (real_stop_pc == 0)
|
|
real_stop_pc = stop_pc;
|
|
|
|
/* Find the linker symbol for this potential thunk. */
|
|
thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
|
|
section = find_pc_section (real_stop_pc);
|
|
if (thunk_sym.minsym == NULL || section == NULL)
|
|
return 0;
|
|
|
|
/* The symbol's demangled name should be something like "virtual
|
|
thunk to FUNCTION", where FUNCTION is the name of the function
|
|
being thunked to. */
|
|
thunk_name = MSYMBOL_DEMANGLED_NAME (thunk_sym.minsym);
|
|
if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
|
|
return 0;
|
|
|
|
fn_name = strstr (thunk_name, " thunk to ") + strlen (" thunk to ");
|
|
fn_sym = lookup_minimal_symbol (fn_name, NULL, section->objfile);
|
|
if (fn_sym.minsym == NULL)
|
|
return 0;
|
|
|
|
method_stop_pc = BMSYMBOL_VALUE_ADDRESS (fn_sym);
|
|
|
|
/* Some targets have minimal symbols pointing to function descriptors
|
|
(powerpc 64 for example). Make sure to retrieve the address
|
|
of the real function from the function descriptor before passing on
|
|
the address to other layers of GDB. */
|
|
func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, method_stop_pc,
|
|
target_stack);
|
|
if (func_addr != 0)
|
|
method_stop_pc = func_addr;
|
|
|
|
real_stop_pc = gdbarch_skip_trampoline_code
|
|
(gdbarch, frame, method_stop_pc);
|
|
if (real_stop_pc == 0)
|
|
real_stop_pc = method_stop_pc;
|
|
|
|
return real_stop_pc;
|
|
}
|
|
|
|
/* Return nonzero if a type should be passed by reference.
|
|
|
|
The rule in the v3 ABI document comes from section 3.1.1. If the
|
|
type has a non-trivial copy constructor or destructor, then the
|
|
caller must make a copy (by calling the copy constructor if there
|
|
is one or perform the copy itself otherwise), pass the address of
|
|
the copy, and then destroy the temporary (if necessary).
|
|
|
|
For return values with non-trivial copy constructors or
|
|
destructors, space will be allocated in the caller, and a pointer
|
|
will be passed as the first argument (preceding "this").
|
|
|
|
We don't have a bulletproof mechanism for determining whether a
|
|
constructor or destructor is trivial. For GCC and DWARF2 debug
|
|
information, we can check the artificial flag.
|
|
|
|
We don't do anything with the constructors or destructors,
|
|
but we have to get the argument passing right anyway. */
|
|
static int
|
|
gnuv3_pass_by_reference (struct type *type)
|
|
{
|
|
int fieldnum, fieldelem;
|
|
|
|
type = check_typedef (type);
|
|
|
|
/* We're only interested in things that can have methods. */
|
|
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
|
|
&& TYPE_CODE (type) != TYPE_CODE_UNION)
|
|
return 0;
|
|
|
|
/* A dynamic class has a non-trivial copy constructor.
|
|
See c++98 section 12.8 Copying class objects [class.copy]. */
|
|
if (gnuv3_dynamic_class (type))
|
|
return 1;
|
|
|
|
for (fieldnum = 0; fieldnum < TYPE_NFN_FIELDS (type); fieldnum++)
|
|
for (fieldelem = 0; fieldelem < TYPE_FN_FIELDLIST_LENGTH (type, fieldnum);
|
|
fieldelem++)
|
|
{
|
|
struct fn_field *fn = TYPE_FN_FIELDLIST1 (type, fieldnum);
|
|
const char *name = TYPE_FN_FIELDLIST_NAME (type, fieldnum);
|
|
struct type *fieldtype = TYPE_FN_FIELD_TYPE (fn, fieldelem);
|
|
|
|
/* If this function is marked as artificial, it is compiler-generated,
|
|
and we assume it is trivial. */
|
|
if (TYPE_FN_FIELD_ARTIFICIAL (fn, fieldelem))
|
|
continue;
|
|
|
|
/* If we've found a destructor, we must pass this by reference. */
|
|
if (name[0] == '~')
|
|
return 1;
|
|
|
|
/* If the mangled name of this method doesn't indicate that it
|
|
is a constructor, we're not interested.
|
|
|
|
FIXME drow/2007-09-23: We could do this using the name of
|
|
the method and the name of the class instead of dealing
|
|
with the mangled name. We don't have a convenient function
|
|
to strip off both leading scope qualifiers and trailing
|
|
template arguments yet. */
|
|
if (!is_constructor_name (TYPE_FN_FIELD_PHYSNAME (fn, fieldelem))
|
|
&& !TYPE_FN_FIELD_CONSTRUCTOR (fn, fieldelem))
|
|
continue;
|
|
|
|
/* If this method takes two arguments, and the second argument is
|
|
a reference to this class, then it is a copy constructor. */
|
|
if (TYPE_NFIELDS (fieldtype) == 2)
|
|
{
|
|
struct type *arg_type = TYPE_FIELD_TYPE (fieldtype, 1);
|
|
|
|
if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
|
|
{
|
|
struct type *arg_target_type;
|
|
|
|
arg_target_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
|
|
if (class_types_same_p (arg_target_type, type))
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Even if all the constructors and destructors were artificial, one
|
|
of them may have invoked a non-artificial constructor or
|
|
destructor in a base class. If any base class needs to be passed
|
|
by reference, so does this class. Similarly for members, which
|
|
are constructed whenever this class is. We do not need to worry
|
|
about recursive loops here, since we are only looking at members
|
|
of complete class type. Also ignore any static members. */
|
|
for (fieldnum = 0; fieldnum < TYPE_NFIELDS (type); fieldnum++)
|
|
if (! field_is_static (&TYPE_FIELD (type, fieldnum))
|
|
&& gnuv3_pass_by_reference (TYPE_FIELD_TYPE (type, fieldnum)))
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
init_gnuv3_ops (void)
|
|
{
|
|
vtable_type_gdbarch_data
|
|
= gdbarch_data_register_post_init (build_gdb_vtable_type);
|
|
std_type_info_gdbarch_data
|
|
= gdbarch_data_register_post_init (build_std_type_info_type);
|
|
|
|
gnu_v3_abi_ops.shortname = "gnu-v3";
|
|
gnu_v3_abi_ops.longname = "GNU G++ Version 3 ABI";
|
|
gnu_v3_abi_ops.doc = "G++ Version 3 ABI";
|
|
gnu_v3_abi_ops.is_destructor_name =
|
|
(enum dtor_kinds (*) (const char *))is_gnu_v3_mangled_dtor;
|
|
gnu_v3_abi_ops.is_constructor_name =
|
|
(enum ctor_kinds (*) (const char *))is_gnu_v3_mangled_ctor;
|
|
gnu_v3_abi_ops.is_vtable_name = gnuv3_is_vtable_name;
|
|
gnu_v3_abi_ops.is_operator_name = gnuv3_is_operator_name;
|
|
gnu_v3_abi_ops.rtti_type = gnuv3_rtti_type;
|
|
gnu_v3_abi_ops.virtual_fn_field = gnuv3_virtual_fn_field;
|
|
gnu_v3_abi_ops.baseclass_offset = gnuv3_baseclass_offset;
|
|
gnu_v3_abi_ops.print_method_ptr = gnuv3_print_method_ptr;
|
|
gnu_v3_abi_ops.method_ptr_size = gnuv3_method_ptr_size;
|
|
gnu_v3_abi_ops.make_method_ptr = gnuv3_make_method_ptr;
|
|
gnu_v3_abi_ops.method_ptr_to_value = gnuv3_method_ptr_to_value;
|
|
gnu_v3_abi_ops.print_vtable = gnuv3_print_vtable;
|
|
gnu_v3_abi_ops.get_typeid = gnuv3_get_typeid;
|
|
gnu_v3_abi_ops.get_typeid_type = gnuv3_get_typeid_type;
|
|
gnu_v3_abi_ops.get_type_from_type_info = gnuv3_get_type_from_type_info;
|
|
gnu_v3_abi_ops.get_typename_from_type_info
|
|
= gnuv3_get_typename_from_type_info;
|
|
gnu_v3_abi_ops.skip_trampoline = gnuv3_skip_trampoline;
|
|
gnu_v3_abi_ops.pass_by_reference = gnuv3_pass_by_reference;
|
|
}
|
|
|
|
void
|
|
_initialize_gnu_v3_abi (void)
|
|
{
|
|
init_gnuv3_ops ();
|
|
|
|
register_cp_abi (&gnu_v3_abi_ops);
|
|
set_cp_abi_as_auto_default (gnu_v3_abi_ops.shortname);
|
|
}
|