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.
2185 lines
63 KiB
C
2185 lines
63 KiB
C
/* Target-dependent code for UltraSPARC.
|
||
|
||
Copyright (C) 2003-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 "arch-utils.h"
|
||
#include "dwarf2-frame.h"
|
||
#include "frame.h"
|
||
#include "frame-base.h"
|
||
#include "frame-unwind.h"
|
||
#include "gdbcore.h"
|
||
#include "gdbtypes.h"
|
||
#include "inferior.h"
|
||
#include "symtab.h"
|
||
#include "objfiles.h"
|
||
#include "osabi.h"
|
||
#include "regcache.h"
|
||
#include "target-descriptions.h"
|
||
#include "target.h"
|
||
#include "value.h"
|
||
|
||
#include "sparc64-tdep.h"
|
||
|
||
/* This file implements the SPARC 64-bit ABI as defined by the
|
||
section "Low-Level System Information" of the SPARC Compliance
|
||
Definition (SCD) 2.4.1, which is the 64-bit System V psABI for
|
||
SPARC. */
|
||
|
||
/* Please use the sparc32_-prefix for 32-bit specific code, the
|
||
sparc64_-prefix for 64-bit specific code and the sparc_-prefix for
|
||
code can handle both. */
|
||
|
||
/* The M7 processor supports an Application Data Integrity (ADI) feature
|
||
that detects invalid data accesses. When software allocates memory and
|
||
enables ADI on the allocated memory, it chooses a 4-bit version number,
|
||
sets the version in the upper 4 bits of the 64-bit pointer to that data,
|
||
and stores the 4-bit version in every cacheline of the object. Hardware
|
||
saves the latter in spare bits in the cache and memory hierarchy. On each
|
||
load and store, the processor compares the upper 4 VA (virtual address) bits
|
||
to the cacheline's version. If there is a mismatch, the processor generates
|
||
a version mismatch trap which can be either precise or disrupting.
|
||
The trap is an error condition which the kernel delivers to the process
|
||
as a SIGSEGV signal.
|
||
|
||
The upper 4 bits of the VA represent a version and are not part of the
|
||
true address. The processor clears these bits and sign extends bit 59
|
||
to generate the true address.
|
||
|
||
Note that 32-bit applications cannot use ADI. */
|
||
|
||
|
||
#include <algorithm>
|
||
#include "cli/cli-utils.h"
|
||
#include "gdbcmd.h"
|
||
#include "auxv.h"
|
||
|
||
#define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/9999/adi/lstatus")
|
||
|
||
/* ELF Auxiliary vectors */
|
||
#ifndef AT_ADI_BLKSZ
|
||
#define AT_ADI_BLKSZ 34
|
||
#endif
|
||
#ifndef AT_ADI_NBITS
|
||
#define AT_ADI_NBITS 35
|
||
#endif
|
||
#ifndef AT_ADI_UEONADI
|
||
#define AT_ADI_UEONADI 36
|
||
#endif
|
||
|
||
/* ADI command list. */
|
||
static struct cmd_list_element *sparc64adilist = NULL;
|
||
|
||
/* ADI stat settings. */
|
||
typedef struct
|
||
{
|
||
/* The ADI block size. */
|
||
unsigned long blksize;
|
||
|
||
/* Number of bits used for an ADI version tag which can be
|
||
used together with the shift value for an ADI version tag
|
||
to encode or extract the ADI version value in a pointer. */
|
||
unsigned long nbits;
|
||
|
||
/* The maximum ADI version tag value supported. */
|
||
int max_version;
|
||
|
||
/* ADI version tag file. */
|
||
int tag_fd = 0;
|
||
|
||
/* ADI availability check has been done. */
|
||
bool checked_avail = false;
|
||
|
||
/* ADI is available. */
|
||
bool is_avail = false;
|
||
|
||
} adi_stat_t;
|
||
|
||
/* Per-process ADI stat info. */
|
||
|
||
typedef struct sparc64_adi_info
|
||
{
|
||
sparc64_adi_info (pid_t pid_)
|
||
: pid (pid_)
|
||
{}
|
||
|
||
/* The process identifier. */
|
||
pid_t pid;
|
||
|
||
/* The ADI stat. */
|
||
adi_stat_t stat = {};
|
||
|
||
} sparc64_adi_info;
|
||
|
||
static std::forward_list<sparc64_adi_info> adi_proc_list;
|
||
|
||
|
||
/* Get ADI info for process PID, creating one if it doesn't exist. */
|
||
|
||
static sparc64_adi_info *
|
||
get_adi_info_proc (pid_t pid)
|
||
{
|
||
auto found = std::find_if (adi_proc_list.begin (), adi_proc_list.end (),
|
||
[&pid] (const sparc64_adi_info &info)
|
||
{
|
||
return info.pid == pid;
|
||
});
|
||
|
||
if (found == adi_proc_list.end ())
|
||
{
|
||
adi_proc_list.emplace_front (pid);
|
||
return &adi_proc_list.front ();
|
||
}
|
||
else
|
||
{
|
||
return &(*found);
|
||
}
|
||
}
|
||
|
||
static adi_stat_t
|
||
get_adi_info (pid_t pid)
|
||
{
|
||
sparc64_adi_info *proc;
|
||
|
||
proc = get_adi_info_proc (pid);
|
||
return proc->stat;
|
||
}
|
||
|
||
/* Is called when GDB is no longer debugging process PID. It
|
||
deletes data structure that keeps track of the ADI stat. */
|
||
|
||
void
|
||
sparc64_forget_process (pid_t pid)
|
||
{
|
||
int target_errno;
|
||
|
||
for (auto pit = adi_proc_list.before_begin (),
|
||
it = std::next (pit);
|
||
it != adi_proc_list.end ();
|
||
)
|
||
{
|
||
if ((*it).pid == pid)
|
||
{
|
||
if ((*it).stat.tag_fd > 0)
|
||
target_fileio_close ((*it).stat.tag_fd, &target_errno);
|
||
adi_proc_list.erase_after (pit);
|
||
break;
|
||
}
|
||
else
|
||
pit = it++;
|
||
}
|
||
|
||
}
|
||
|
||
static void
|
||
info_adi_command (const char *args, int from_tty)
|
||
{
|
||
printf_unfiltered ("\"adi\" must be followed by \"examine\" "
|
||
"or \"assign\".\n");
|
||
help_list (sparc64adilist, "adi ", all_commands, gdb_stdout);
|
||
}
|
||
|
||
/* Read attributes of a maps entry in /proc/[pid]/adi/maps. */
|
||
|
||
static void
|
||
read_maps_entry (const char *line,
|
||
ULONGEST *addr, ULONGEST *endaddr)
|
||
{
|
||
const char *p = line;
|
||
|
||
*addr = strtoulst (p, &p, 16);
|
||
if (*p == '-')
|
||
p++;
|
||
|
||
*endaddr = strtoulst (p, &p, 16);
|
||
}
|
||
|
||
/* Check if ADI is available. */
|
||
|
||
static bool
|
||
adi_available (void)
|
||
{
|
||
pid_t pid = ptid_get_pid (inferior_ptid);
|
||
sparc64_adi_info *proc = get_adi_info_proc (pid);
|
||
CORE_ADDR value;
|
||
|
||
if (proc->stat.checked_avail)
|
||
return proc->stat.is_avail;
|
||
|
||
proc->stat.checked_avail = true;
|
||
if (target_auxv_search (target_stack, AT_ADI_BLKSZ, &value) <= 0)
|
||
return false;
|
||
proc->stat.blksize = value;
|
||
target_auxv_search (target_stack, AT_ADI_NBITS, &value);
|
||
proc->stat.nbits = value;
|
||
proc->stat.max_version = (1 << proc->stat.nbits) - 2;
|
||
proc->stat.is_avail = true;
|
||
|
||
return proc->stat.is_avail;
|
||
}
|
||
|
||
/* Normalize a versioned address - a VA with ADI bits (63-60) set. */
|
||
|
||
static CORE_ADDR
|
||
adi_normalize_address (CORE_ADDR addr)
|
||
{
|
||
adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
|
||
|
||
if (ast.nbits)
|
||
{
|
||
/* Clear upper bits. */
|
||
addr &= ((uint64_t) -1) >> ast.nbits;
|
||
|
||
/* Sign extend. */
|
||
CORE_ADDR signbit = (uint64_t) 1 << (64 - ast.nbits - 1);
|
||
return (addr ^ signbit) - signbit;
|
||
}
|
||
return addr;
|
||
}
|
||
|
||
/* Align a normalized address - a VA with bit 59 sign extended into
|
||
ADI bits. */
|
||
|
||
static CORE_ADDR
|
||
adi_align_address (CORE_ADDR naddr)
|
||
{
|
||
adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
|
||
|
||
return (naddr - (naddr % ast.blksize)) / ast.blksize;
|
||
}
|
||
|
||
/* Convert a byte count to count at a ratio of 1:adi_blksz. */
|
||
|
||
static int
|
||
adi_convert_byte_count (CORE_ADDR naddr, int nbytes, CORE_ADDR locl)
|
||
{
|
||
adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
|
||
|
||
return ((naddr + nbytes + ast.blksize - 1) / ast.blksize) - locl;
|
||
}
|
||
|
||
/* The /proc/[pid]/adi/tags file, which allows gdb to get/set ADI
|
||
version in a target process, maps linearly to the address space
|
||
of the target process at a ratio of 1:adi_blksz.
|
||
|
||
A read (or write) at offset K in the file returns (or modifies)
|
||
the ADI version tag stored in the cacheline containing address
|
||
K * adi_blksz, encoded as 1 version tag per byte. The allowed
|
||
version tag values are between 0 and adi_stat.max_version. */
|
||
|
||
static int
|
||
adi_tag_fd (void)
|
||
{
|
||
pid_t pid = ptid_get_pid (inferior_ptid);
|
||
sparc64_adi_info *proc = get_adi_info_proc (pid);
|
||
|
||
if (proc->stat.tag_fd != 0)
|
||
return proc->stat.tag_fd;
|
||
|
||
char cl_name[MAX_PROC_NAME_SIZE];
|
||
snprintf (cl_name, sizeof(cl_name), "/proc/%ld/adi/tags", (long) pid);
|
||
int target_errno;
|
||
proc->stat.tag_fd = target_fileio_open (NULL, cl_name, O_RDWR|O_EXCL,
|
||
0, &target_errno);
|
||
return proc->stat.tag_fd;
|
||
}
|
||
|
||
/* Check if an address set is ADI enabled, using /proc/[pid]/adi/maps
|
||
which was exported by the kernel and contains the currently ADI
|
||
mapped memory regions and their access permissions. */
|
||
|
||
static bool
|
||
adi_is_addr_mapped (CORE_ADDR vaddr, size_t cnt)
|
||
{
|
||
char filename[MAX_PROC_NAME_SIZE];
|
||
size_t i = 0;
|
||
|
||
pid_t pid = ptid_get_pid (inferior_ptid);
|
||
snprintf (filename, sizeof filename, "/proc/%ld/adi/maps", (long) pid);
|
||
gdb::unique_xmalloc_ptr<char> data
|
||
= target_fileio_read_stralloc (NULL, filename);
|
||
if (data)
|
||
{
|
||
adi_stat_t adi_stat = get_adi_info (pid);
|
||
char *line;
|
||
for (line = strtok (data.get (), "\n"); line; line = strtok (NULL, "\n"))
|
||
{
|
||
ULONGEST addr, endaddr;
|
||
|
||
read_maps_entry (line, &addr, &endaddr);
|
||
|
||
while (((vaddr + i) * adi_stat.blksize) >= addr
|
||
&& ((vaddr + i) * adi_stat.blksize) < endaddr)
|
||
{
|
||
if (++i == cnt)
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
warning (_("unable to open /proc file '%s'"), filename);
|
||
|
||
return false;
|
||
}
|
||
|
||
/* Read ADI version tag value for memory locations starting at "VADDR"
|
||
for "SIZE" number of bytes. */
|
||
|
||
static int
|
||
adi_read_versions (CORE_ADDR vaddr, size_t size, gdb_byte *tags)
|
||
{
|
||
int fd = adi_tag_fd ();
|
||
if (fd == -1)
|
||
return -1;
|
||
|
||
if (!adi_is_addr_mapped (vaddr, size))
|
||
{
|
||
adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
|
||
error(_("Address at %s is not in ADI maps"),
|
||
paddress (target_gdbarch (), vaddr * ast.blksize));
|
||
}
|
||
|
||
int target_errno;
|
||
return target_fileio_pread (fd, tags, size, vaddr, &target_errno);
|
||
}
|
||
|
||
/* Write ADI version tag for memory locations starting at "VADDR" for
|
||
"SIZE" number of bytes to "TAGS". */
|
||
|
||
static int
|
||
adi_write_versions (CORE_ADDR vaddr, size_t size, unsigned char *tags)
|
||
{
|
||
int fd = adi_tag_fd ();
|
||
if (fd == -1)
|
||
return -1;
|
||
|
||
if (!adi_is_addr_mapped (vaddr, size))
|
||
{
|
||
adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
|
||
error(_("Address at %s is not in ADI maps"),
|
||
paddress (target_gdbarch (), vaddr * ast.blksize));
|
||
}
|
||
|
||
int target_errno;
|
||
return target_fileio_pwrite (fd, tags, size, vaddr, &target_errno);
|
||
}
|
||
|
||
/* Print ADI version tag value in "TAGS" for memory locations starting
|
||
at "VADDR" with number of "CNT". */
|
||
|
||
static void
|
||
adi_print_versions (CORE_ADDR vaddr, size_t cnt, gdb_byte *tags)
|
||
{
|
||
int v_idx = 0;
|
||
const int maxelts = 8; /* # of elements per line */
|
||
|
||
adi_stat_t adi_stat = get_adi_info (ptid_get_pid (inferior_ptid));
|
||
|
||
while (cnt > 0)
|
||
{
|
||
QUIT;
|
||
printf_filtered ("%s:\t",
|
||
paddress (target_gdbarch (), vaddr * adi_stat.blksize));
|
||
for (int i = maxelts; i > 0 && cnt > 0; i--, cnt--)
|
||
{
|
||
if (tags[v_idx] == 0xff) /* no version tag */
|
||
printf_filtered ("-");
|
||
else
|
||
printf_filtered ("%1X", tags[v_idx]);
|
||
if (cnt > 1)
|
||
printf_filtered (" ");
|
||
++v_idx;
|
||
}
|
||
printf_filtered ("\n");
|
||
gdb_flush (gdb_stdout);
|
||
vaddr += maxelts;
|
||
}
|
||
}
|
||
|
||
static void
|
||
do_examine (CORE_ADDR start, int bcnt)
|
||
{
|
||
CORE_ADDR vaddr = adi_normalize_address (start);
|
||
|
||
CORE_ADDR vstart = adi_align_address (vaddr);
|
||
int cnt = adi_convert_byte_count (vaddr, bcnt, vstart);
|
||
gdb::def_vector<gdb_byte> buf (cnt);
|
||
int read_cnt = adi_read_versions (vstart, cnt, buf.data ());
|
||
if (read_cnt == -1)
|
||
error (_("No ADI information"));
|
||
else if (read_cnt < cnt)
|
||
error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
|
||
|
||
adi_print_versions (vstart, cnt, buf.data ());
|
||
}
|
||
|
||
static void
|
||
do_assign (CORE_ADDR start, size_t bcnt, int version)
|
||
{
|
||
CORE_ADDR vaddr = adi_normalize_address (start);
|
||
|
||
CORE_ADDR vstart = adi_align_address (vaddr);
|
||
int cnt = adi_convert_byte_count (vaddr, bcnt, vstart);
|
||
std::vector<unsigned char> buf (cnt, version);
|
||
int set_cnt = adi_write_versions (vstart, cnt, buf.data ());
|
||
|
||
if (set_cnt == -1)
|
||
error (_("No ADI information"));
|
||
else if (set_cnt < cnt)
|
||
error(_("No ADI information at %s"), paddress (target_gdbarch (), vaddr));
|
||
|
||
}
|
||
|
||
/* ADI examine version tag command.
|
||
|
||
Command syntax:
|
||
|
||
adi (examine|x)/count <addr> */
|
||
|
||
static void
|
||
adi_examine_command (const char *args, int from_tty)
|
||
{
|
||
/* make sure program is active and adi is available */
|
||
if (!target_has_execution)
|
||
error (_("ADI command requires a live process/thread"));
|
||
|
||
if (!adi_available ())
|
||
error (_("No ADI information"));
|
||
|
||
pid_t pid = ptid_get_pid (inferior_ptid);
|
||
sparc64_adi_info *proc = get_adi_info_proc (pid);
|
||
int cnt = 1;
|
||
const char *p = args;
|
||
if (p && *p == '/')
|
||
{
|
||
p++;
|
||
cnt = get_number (&p);
|
||
}
|
||
|
||
CORE_ADDR next_address = 0;
|
||
if (p != 0 && *p != 0)
|
||
next_address = parse_and_eval_address (p);
|
||
if (!cnt || !next_address)
|
||
error (_("Usage: adi examine|x[/count] <addr>"));
|
||
|
||
do_examine (next_address, cnt);
|
||
}
|
||
|
||
/* ADI assign version tag command.
|
||
|
||
Command syntax:
|
||
|
||
adi (assign|a)/count <addr> = <version> */
|
||
|
||
static void
|
||
adi_assign_command (const char *args, int from_tty)
|
||
{
|
||
/* make sure program is active and adi is available */
|
||
if (!target_has_execution)
|
||
error (_("ADI command requires a live process/thread"));
|
||
|
||
if (!adi_available ())
|
||
error (_("No ADI information"));
|
||
|
||
const char *exp = args;
|
||
if (exp == 0)
|
||
error_no_arg (_("Usage: adi assign|a[/count] <addr> = <version>"));
|
||
|
||
char *q = (char *) strchr (exp, '=');
|
||
if (q)
|
||
*q++ = 0;
|
||
else
|
||
error (_("Usage: adi assign|a[/count] <addr> = <version>"));
|
||
|
||
size_t cnt = 1;
|
||
const char *p = args;
|
||
if (exp && *exp == '/')
|
||
{
|
||
p = exp + 1;
|
||
cnt = get_number (&p);
|
||
}
|
||
|
||
CORE_ADDR next_address = 0;
|
||
if (p != 0 && *p != 0)
|
||
next_address = parse_and_eval_address (p);
|
||
else
|
||
error (_("Usage: adi assign|a[/count] <addr> = <version>"));
|
||
|
||
int version = 0;
|
||
if (q != NULL) /* parse version tag */
|
||
{
|
||
adi_stat_t ast = get_adi_info (ptid_get_pid (inferior_ptid));
|
||
version = parse_and_eval_long (q);
|
||
if (version < 0 || version > ast.max_version)
|
||
error (_("Invalid ADI version tag %d"), version);
|
||
}
|
||
|
||
do_assign (next_address, cnt, version);
|
||
}
|
||
|
||
void
|
||
_initialize_sparc64_adi_tdep (void)
|
||
{
|
||
|
||
add_prefix_cmd ("adi", class_support, info_adi_command,
|
||
_("ADI version related commands."),
|
||
&sparc64adilist, "adi ", 0, &cmdlist);
|
||
add_cmd ("examine", class_support, adi_examine_command,
|
||
_("Examine ADI versions."), &sparc64adilist);
|
||
add_alias_cmd ("x", "examine", no_class, 1, &sparc64adilist);
|
||
add_cmd ("assign", class_support, adi_assign_command,
|
||
_("Assign ADI versions."), &sparc64adilist);
|
||
|
||
}
|
||
|
||
|
||
/* The functions on this page are intended to be used to classify
|
||
function arguments. */
|
||
|
||
/* Check whether TYPE is "Integral or Pointer". */
|
||
|
||
static int
|
||
sparc64_integral_or_pointer_p (const struct type *type)
|
||
{
|
||
switch (TYPE_CODE (type))
|
||
{
|
||
case TYPE_CODE_INT:
|
||
case TYPE_CODE_BOOL:
|
||
case TYPE_CODE_CHAR:
|
||
case TYPE_CODE_ENUM:
|
||
case TYPE_CODE_RANGE:
|
||
{
|
||
int len = TYPE_LENGTH (type);
|
||
gdb_assert (len == 1 || len == 2 || len == 4 || len == 8);
|
||
}
|
||
return 1;
|
||
case TYPE_CODE_PTR:
|
||
case TYPE_CODE_REF:
|
||
case TYPE_CODE_RVALUE_REF:
|
||
{
|
||
int len = TYPE_LENGTH (type);
|
||
gdb_assert (len == 8);
|
||
}
|
||
return 1;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Check whether TYPE is "Floating". */
|
||
|
||
static int
|
||
sparc64_floating_p (const struct type *type)
|
||
{
|
||
switch (TYPE_CODE (type))
|
||
{
|
||
case TYPE_CODE_FLT:
|
||
{
|
||
int len = TYPE_LENGTH (type);
|
||
gdb_assert (len == 4 || len == 8 || len == 16);
|
||
}
|
||
return 1;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Check whether TYPE is "Complex Floating". */
|
||
|
||
static int
|
||
sparc64_complex_floating_p (const struct type *type)
|
||
{
|
||
switch (TYPE_CODE (type))
|
||
{
|
||
case TYPE_CODE_COMPLEX:
|
||
{
|
||
int len = TYPE_LENGTH (type);
|
||
gdb_assert (len == 8 || len == 16 || len == 32);
|
||
}
|
||
return 1;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Check whether TYPE is "Structure or Union".
|
||
|
||
In terms of Ada subprogram calls, arrays are treated the same as
|
||
struct and union types. So this function also returns non-zero
|
||
for array types. */
|
||
|
||
static int
|
||
sparc64_structure_or_union_p (const struct type *type)
|
||
{
|
||
switch (TYPE_CODE (type))
|
||
{
|
||
case TYPE_CODE_STRUCT:
|
||
case TYPE_CODE_UNION:
|
||
case TYPE_CODE_ARRAY:
|
||
return 1;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* Construct types for ISA-specific registers. */
|
||
|
||
static struct type *
|
||
sparc64_pstate_type (struct gdbarch *gdbarch)
|
||
{
|
||
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
||
|
||
if (!tdep->sparc64_pstate_type)
|
||
{
|
||
struct type *type;
|
||
|
||
type = arch_flags_type (gdbarch, "builtin_type_sparc64_pstate", 64);
|
||
append_flags_type_flag (type, 0, "AG");
|
||
append_flags_type_flag (type, 1, "IE");
|
||
append_flags_type_flag (type, 2, "PRIV");
|
||
append_flags_type_flag (type, 3, "AM");
|
||
append_flags_type_flag (type, 4, "PEF");
|
||
append_flags_type_flag (type, 5, "RED");
|
||
append_flags_type_flag (type, 8, "TLE");
|
||
append_flags_type_flag (type, 9, "CLE");
|
||
append_flags_type_flag (type, 10, "PID0");
|
||
append_flags_type_flag (type, 11, "PID1");
|
||
|
||
tdep->sparc64_pstate_type = type;
|
||
}
|
||
|
||
return tdep->sparc64_pstate_type;
|
||
}
|
||
|
||
static struct type *
|
||
sparc64_ccr_type (struct gdbarch *gdbarch)
|
||
{
|
||
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
||
|
||
if (tdep->sparc64_ccr_type == NULL)
|
||
{
|
||
struct type *type;
|
||
|
||
type = arch_flags_type (gdbarch, "builtin_type_sparc64_ccr", 64);
|
||
append_flags_type_flag (type, 0, "icc.c");
|
||
append_flags_type_flag (type, 1, "icc.v");
|
||
append_flags_type_flag (type, 2, "icc.z");
|
||
append_flags_type_flag (type, 3, "icc.n");
|
||
append_flags_type_flag (type, 4, "xcc.c");
|
||
append_flags_type_flag (type, 5, "xcc.v");
|
||
append_flags_type_flag (type, 6, "xcc.z");
|
||
append_flags_type_flag (type, 7, "xcc.n");
|
||
|
||
tdep->sparc64_ccr_type = type;
|
||
}
|
||
|
||
return tdep->sparc64_ccr_type;
|
||
}
|
||
|
||
static struct type *
|
||
sparc64_fsr_type (struct gdbarch *gdbarch)
|
||
{
|
||
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
||
|
||
if (!tdep->sparc64_fsr_type)
|
||
{
|
||
struct type *type;
|
||
|
||
type = arch_flags_type (gdbarch, "builtin_type_sparc64_fsr", 64);
|
||
append_flags_type_flag (type, 0, "NXC");
|
||
append_flags_type_flag (type, 1, "DZC");
|
||
append_flags_type_flag (type, 2, "UFC");
|
||
append_flags_type_flag (type, 3, "OFC");
|
||
append_flags_type_flag (type, 4, "NVC");
|
||
append_flags_type_flag (type, 5, "NXA");
|
||
append_flags_type_flag (type, 6, "DZA");
|
||
append_flags_type_flag (type, 7, "UFA");
|
||
append_flags_type_flag (type, 8, "OFA");
|
||
append_flags_type_flag (type, 9, "NVA");
|
||
append_flags_type_flag (type, 22, "NS");
|
||
append_flags_type_flag (type, 23, "NXM");
|
||
append_flags_type_flag (type, 24, "DZM");
|
||
append_flags_type_flag (type, 25, "UFM");
|
||
append_flags_type_flag (type, 26, "OFM");
|
||
append_flags_type_flag (type, 27, "NVM");
|
||
|
||
tdep->sparc64_fsr_type = type;
|
||
}
|
||
|
||
return tdep->sparc64_fsr_type;
|
||
}
|
||
|
||
static struct type *
|
||
sparc64_fprs_type (struct gdbarch *gdbarch)
|
||
{
|
||
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
||
|
||
if (!tdep->sparc64_fprs_type)
|
||
{
|
||
struct type *type;
|
||
|
||
type = arch_flags_type (gdbarch, "builtin_type_sparc64_fprs", 64);
|
||
append_flags_type_flag (type, 0, "DL");
|
||
append_flags_type_flag (type, 1, "DU");
|
||
append_flags_type_flag (type, 2, "FEF");
|
||
|
||
tdep->sparc64_fprs_type = type;
|
||
}
|
||
|
||
return tdep->sparc64_fprs_type;
|
||
}
|
||
|
||
|
||
/* Register information. */
|
||
#define SPARC64_FPU_REGISTERS \
|
||
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
|
||
"f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
|
||
"f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
|
||
"f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \
|
||
"f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \
|
||
"f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62"
|
||
#define SPARC64_CP0_REGISTERS \
|
||
"pc", "npc", \
|
||
/* FIXME: Give "state" a name until we start using register groups. */ \
|
||
"state", \
|
||
"fsr", \
|
||
"fprs", \
|
||
"y"
|
||
|
||
static const char *sparc64_fpu_register_names[] = { SPARC64_FPU_REGISTERS };
|
||
static const char *sparc64_cp0_register_names[] = { SPARC64_CP0_REGISTERS };
|
||
|
||
static const char *sparc64_register_names[] =
|
||
{
|
||
SPARC_CORE_REGISTERS,
|
||
SPARC64_FPU_REGISTERS,
|
||
SPARC64_CP0_REGISTERS
|
||
};
|
||
|
||
/* Total number of registers. */
|
||
#define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
|
||
|
||
/* We provide the aliases %d0..%d62 and %q0..%q60 for the floating
|
||
registers as "psuedo" registers. */
|
||
|
||
static const char *sparc64_pseudo_register_names[] =
|
||
{
|
||
"cwp", "pstate", "asi", "ccr",
|
||
|
||
"d0", "d2", "d4", "d6", "d8", "d10", "d12", "d14",
|
||
"d16", "d18", "d20", "d22", "d24", "d26", "d28", "d30",
|
||
"d32", "d34", "d36", "d38", "d40", "d42", "d44", "d46",
|
||
"d48", "d50", "d52", "d54", "d56", "d58", "d60", "d62",
|
||
|
||
"q0", "q4", "q8", "q12", "q16", "q20", "q24", "q28",
|
||
"q32", "q36", "q40", "q44", "q48", "q52", "q56", "q60",
|
||
};
|
||
|
||
/* Total number of pseudo registers. */
|
||
#define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
|
||
|
||
/* Return the name of pseudo register REGNUM. */
|
||
|
||
static const char *
|
||
sparc64_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
|
||
{
|
||
regnum -= gdbarch_num_regs (gdbarch);
|
||
|
||
if (regnum < SPARC64_NUM_PSEUDO_REGS)
|
||
return sparc64_pseudo_register_names[regnum];
|
||
|
||
internal_error (__FILE__, __LINE__,
|
||
_("sparc64_pseudo_register_name: bad register number %d"),
|
||
regnum);
|
||
}
|
||
|
||
/* Return the name of register REGNUM. */
|
||
|
||
static const char *
|
||
sparc64_register_name (struct gdbarch *gdbarch, int regnum)
|
||
{
|
||
if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
|
||
return tdesc_register_name (gdbarch, regnum);
|
||
|
||
if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
|
||
return sparc64_register_names[regnum];
|
||
|
||
return sparc64_pseudo_register_name (gdbarch, regnum);
|
||
}
|
||
|
||
/* Return the GDB type object for the "standard" data type of data in
|
||
pseudo register REGNUM. */
|
||
|
||
static struct type *
|
||
sparc64_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
|
||
{
|
||
regnum -= gdbarch_num_regs (gdbarch);
|
||
|
||
if (regnum == SPARC64_CWP_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_int64;
|
||
if (regnum == SPARC64_PSTATE_REGNUM)
|
||
return sparc64_pstate_type (gdbarch);
|
||
if (regnum == SPARC64_ASI_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_int64;
|
||
if (regnum == SPARC64_CCR_REGNUM)
|
||
return sparc64_ccr_type (gdbarch);
|
||
if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D62_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_double;
|
||
if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q60_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_long_double;
|
||
|
||
internal_error (__FILE__, __LINE__,
|
||
_("sparc64_pseudo_register_type: bad register number %d"),
|
||
regnum);
|
||
}
|
||
|
||
/* Return the GDB type object for the "standard" data type of data in
|
||
register REGNUM. */
|
||
|
||
static struct type *
|
||
sparc64_register_type (struct gdbarch *gdbarch, int regnum)
|
||
{
|
||
if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
|
||
return tdesc_register_type (gdbarch, regnum);
|
||
|
||
/* Raw registers. */
|
||
if (regnum == SPARC_SP_REGNUM || regnum == SPARC_FP_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_data_ptr;
|
||
if (regnum >= SPARC_G0_REGNUM && regnum <= SPARC_I7_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_int64;
|
||
if (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F31_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_float;
|
||
if (regnum >= SPARC64_F32_REGNUM && regnum <= SPARC64_F62_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_double;
|
||
if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_func_ptr;
|
||
/* This raw register contains the contents of %cwp, %pstate, %asi
|
||
and %ccr as laid out in a %tstate register. */
|
||
if (regnum == SPARC64_STATE_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_int64;
|
||
if (regnum == SPARC64_FSR_REGNUM)
|
||
return sparc64_fsr_type (gdbarch);
|
||
if (regnum == SPARC64_FPRS_REGNUM)
|
||
return sparc64_fprs_type (gdbarch);
|
||
/* "Although Y is a 64-bit register, its high-order 32 bits are
|
||
reserved and always read as 0." */
|
||
if (regnum == SPARC64_Y_REGNUM)
|
||
return builtin_type (gdbarch)->builtin_int64;
|
||
|
||
/* Pseudo registers. */
|
||
if (regnum >= gdbarch_num_regs (gdbarch))
|
||
return sparc64_pseudo_register_type (gdbarch, regnum);
|
||
|
||
internal_error (__FILE__, __LINE__, _("invalid regnum"));
|
||
}
|
||
|
||
static enum register_status
|
||
sparc64_pseudo_register_read (struct gdbarch *gdbarch,
|
||
readable_regcache *regcache,
|
||
int regnum, gdb_byte *buf)
|
||
{
|
||
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
||
enum register_status status;
|
||
|
||
regnum -= gdbarch_num_regs (gdbarch);
|
||
|
||
if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
|
||
{
|
||
regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
|
||
status = regcache->raw_read (regnum, buf);
|
||
if (status == REG_VALID)
|
||
status = regcache->raw_read (regnum + 1, buf + 4);
|
||
return status;
|
||
}
|
||
else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
|
||
{
|
||
regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
|
||
return regcache->raw_read (regnum, buf);
|
||
}
|
||
else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
|
||
{
|
||
regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
|
||
|
||
status = regcache->raw_read (regnum, buf);
|
||
if (status == REG_VALID)
|
||
status = regcache->raw_read (regnum + 1, buf + 4);
|
||
if (status == REG_VALID)
|
||
status = regcache->raw_read (regnum + 2, buf + 8);
|
||
if (status == REG_VALID)
|
||
status = regcache->raw_read (regnum + 3, buf + 12);
|
||
|
||
return status;
|
||
}
|
||
else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
|
||
{
|
||
regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
|
||
|
||
status = regcache->raw_read (regnum, buf);
|
||
if (status == REG_VALID)
|
||
status = regcache->raw_read (regnum + 1, buf + 8);
|
||
|
||
return status;
|
||
}
|
||
else if (regnum == SPARC64_CWP_REGNUM
|
||
|| regnum == SPARC64_PSTATE_REGNUM
|
||
|| regnum == SPARC64_ASI_REGNUM
|
||
|| regnum == SPARC64_CCR_REGNUM)
|
||
{
|
||
ULONGEST state;
|
||
|
||
status = regcache->raw_read (SPARC64_STATE_REGNUM, &state);
|
||
if (status != REG_VALID)
|
||
return status;
|
||
|
||
switch (regnum)
|
||
{
|
||
case SPARC64_CWP_REGNUM:
|
||
state = (state >> 0) & ((1 << 5) - 1);
|
||
break;
|
||
case SPARC64_PSTATE_REGNUM:
|
||
state = (state >> 8) & ((1 << 12) - 1);
|
||
break;
|
||
case SPARC64_ASI_REGNUM:
|
||
state = (state >> 24) & ((1 << 8) - 1);
|
||
break;
|
||
case SPARC64_CCR_REGNUM:
|
||
state = (state >> 32) & ((1 << 8) - 1);
|
||
break;
|
||
}
|
||
store_unsigned_integer (buf, 8, byte_order, state);
|
||
}
|
||
|
||
return REG_VALID;
|
||
}
|
||
|
||
static void
|
||
sparc64_pseudo_register_write (struct gdbarch *gdbarch,
|
||
struct regcache *regcache,
|
||
int regnum, const gdb_byte *buf)
|
||
{
|
||
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
||
|
||
regnum -= gdbarch_num_regs (gdbarch);
|
||
|
||
if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D30_REGNUM)
|
||
{
|
||
regnum = SPARC_F0_REGNUM + 2 * (regnum - SPARC64_D0_REGNUM);
|
||
regcache_raw_write (regcache, regnum, buf);
|
||
regcache_raw_write (regcache, regnum + 1, buf + 4);
|
||
}
|
||
else if (regnum >= SPARC64_D32_REGNUM && regnum <= SPARC64_D62_REGNUM)
|
||
{
|
||
regnum = SPARC64_F32_REGNUM + (regnum - SPARC64_D32_REGNUM);
|
||
regcache_raw_write (regcache, regnum, buf);
|
||
}
|
||
else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q28_REGNUM)
|
||
{
|
||
regnum = SPARC_F0_REGNUM + 4 * (regnum - SPARC64_Q0_REGNUM);
|
||
regcache_raw_write (regcache, regnum, buf);
|
||
regcache_raw_write (regcache, regnum + 1, buf + 4);
|
||
regcache_raw_write (regcache, regnum + 2, buf + 8);
|
||
regcache_raw_write (regcache, regnum + 3, buf + 12);
|
||
}
|
||
else if (regnum >= SPARC64_Q32_REGNUM && regnum <= SPARC64_Q60_REGNUM)
|
||
{
|
||
regnum = SPARC64_F32_REGNUM + 2 * (regnum - SPARC64_Q32_REGNUM);
|
||
regcache_raw_write (regcache, regnum, buf);
|
||
regcache_raw_write (regcache, regnum + 1, buf + 8);
|
||
}
|
||
else if (regnum == SPARC64_CWP_REGNUM
|
||
|| regnum == SPARC64_PSTATE_REGNUM
|
||
|| regnum == SPARC64_ASI_REGNUM
|
||
|| regnum == SPARC64_CCR_REGNUM)
|
||
{
|
||
ULONGEST state, bits;
|
||
|
||
regcache_raw_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
|
||
bits = extract_unsigned_integer (buf, 8, byte_order);
|
||
switch (regnum)
|
||
{
|
||
case SPARC64_CWP_REGNUM:
|
||
state |= ((bits & ((1 << 5) - 1)) << 0);
|
||
break;
|
||
case SPARC64_PSTATE_REGNUM:
|
||
state |= ((bits & ((1 << 12) - 1)) << 8);
|
||
break;
|
||
case SPARC64_ASI_REGNUM:
|
||
state |= ((bits & ((1 << 8) - 1)) << 24);
|
||
break;
|
||
case SPARC64_CCR_REGNUM:
|
||
state |= ((bits & ((1 << 8) - 1)) << 32);
|
||
break;
|
||
}
|
||
regcache_raw_write_unsigned (regcache, SPARC64_STATE_REGNUM, state);
|
||
}
|
||
}
|
||
|
||
|
||
/* Return PC of first real instruction of the function starting at
|
||
START_PC. */
|
||
|
||
static CORE_ADDR
|
||
sparc64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
|
||
{
|
||
struct symtab_and_line sal;
|
||
CORE_ADDR func_start, func_end;
|
||
struct sparc_frame_cache cache;
|
||
|
||
/* This is the preferred method, find the end of the prologue by
|
||
using the debugging information. */
|
||
if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
|
||
{
|
||
sal = find_pc_line (func_start, 0);
|
||
|
||
if (sal.end < func_end
|
||
&& start_pc <= sal.end)
|
||
return sal.end;
|
||
}
|
||
|
||
return sparc_analyze_prologue (gdbarch, start_pc, 0xffffffffffffffffULL,
|
||
&cache);
|
||
}
|
||
|
||
/* Normal frames. */
|
||
|
||
static struct sparc_frame_cache *
|
||
sparc64_frame_cache (struct frame_info *this_frame, void **this_cache)
|
||
{
|
||
return sparc_frame_cache (this_frame, this_cache);
|
||
}
|
||
|
||
static void
|
||
sparc64_frame_this_id (struct frame_info *this_frame, void **this_cache,
|
||
struct frame_id *this_id)
|
||
{
|
||
struct sparc_frame_cache *cache =
|
||
sparc64_frame_cache (this_frame, this_cache);
|
||
|
||
/* This marks the outermost frame. */
|
||
if (cache->base == 0)
|
||
return;
|
||
|
||
(*this_id) = frame_id_build (cache->base, cache->pc);
|
||
}
|
||
|
||
static struct value *
|
||
sparc64_frame_prev_register (struct frame_info *this_frame, void **this_cache,
|
||
int regnum)
|
||
{
|
||
struct gdbarch *gdbarch = get_frame_arch (this_frame);
|
||
struct sparc_frame_cache *cache =
|
||
sparc64_frame_cache (this_frame, this_cache);
|
||
|
||
if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM)
|
||
{
|
||
CORE_ADDR pc = (regnum == SPARC64_NPC_REGNUM) ? 4 : 0;
|
||
|
||
regnum =
|
||
(cache->copied_regs_mask & 0x80) ? SPARC_I7_REGNUM : SPARC_O7_REGNUM;
|
||
pc += get_frame_register_unsigned (this_frame, regnum) + 8;
|
||
return frame_unwind_got_constant (this_frame, regnum, pc);
|
||
}
|
||
|
||
/* Handle StackGhost. */
|
||
{
|
||
ULONGEST wcookie = sparc_fetch_wcookie (gdbarch);
|
||
|
||
if (wcookie != 0 && !cache->frameless_p && regnum == SPARC_I7_REGNUM)
|
||
{
|
||
CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
|
||
ULONGEST i7;
|
||
|
||
/* Read the value in from memory. */
|
||
i7 = get_frame_memory_unsigned (this_frame, addr, 8);
|
||
return frame_unwind_got_constant (this_frame, regnum, i7 ^ wcookie);
|
||
}
|
||
}
|
||
|
||
/* The previous frame's `local' and `in' registers may have been saved
|
||
in the register save area. */
|
||
if (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM
|
||
&& (cache->saved_regs_mask & (1 << (regnum - SPARC_L0_REGNUM))))
|
||
{
|
||
CORE_ADDR addr = cache->base + (regnum - SPARC_L0_REGNUM) * 8;
|
||
|
||
return frame_unwind_got_memory (this_frame, regnum, addr);
|
||
}
|
||
|
||
/* The previous frame's `out' registers may be accessible as the current
|
||
frame's `in' registers. */
|
||
if (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM
|
||
&& (cache->copied_regs_mask & (1 << (regnum - SPARC_O0_REGNUM))))
|
||
regnum += (SPARC_I0_REGNUM - SPARC_O0_REGNUM);
|
||
|
||
return frame_unwind_got_register (this_frame, regnum, regnum);
|
||
}
|
||
|
||
static const struct frame_unwind sparc64_frame_unwind =
|
||
{
|
||
NORMAL_FRAME,
|
||
default_frame_unwind_stop_reason,
|
||
sparc64_frame_this_id,
|
||
sparc64_frame_prev_register,
|
||
NULL,
|
||
default_frame_sniffer
|
||
};
|
||
|
||
|
||
static CORE_ADDR
|
||
sparc64_frame_base_address (struct frame_info *this_frame, void **this_cache)
|
||
{
|
||
struct sparc_frame_cache *cache =
|
||
sparc64_frame_cache (this_frame, this_cache);
|
||
|
||
return cache->base;
|
||
}
|
||
|
||
static const struct frame_base sparc64_frame_base =
|
||
{
|
||
&sparc64_frame_unwind,
|
||
sparc64_frame_base_address,
|
||
sparc64_frame_base_address,
|
||
sparc64_frame_base_address
|
||
};
|
||
|
||
/* Check whether TYPE must be 16-byte aligned. */
|
||
|
||
static int
|
||
sparc64_16_byte_align_p (struct type *type)
|
||
{
|
||
if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
|
||
{
|
||
struct type *t = check_typedef (TYPE_TARGET_TYPE (type));
|
||
|
||
if (sparc64_floating_p (t))
|
||
return 1;
|
||
}
|
||
if (sparc64_floating_p (type) && TYPE_LENGTH (type) == 16)
|
||
return 1;
|
||
|
||
if (sparc64_structure_or_union_p (type))
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < TYPE_NFIELDS (type); i++)
|
||
{
|
||
struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
|
||
|
||
if (sparc64_16_byte_align_p (subtype))
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Store floating fields of element ELEMENT of an "parameter array"
|
||
that has type TYPE and is stored at BITPOS in VALBUF in the
|
||
apropriate registers of REGCACHE. This function can be called
|
||
recursively and therefore handles floating types in addition to
|
||
structures. */
|
||
|
||
static void
|
||
sparc64_store_floating_fields (struct regcache *regcache, struct type *type,
|
||
const gdb_byte *valbuf, int element, int bitpos)
|
||
{
|
||
struct gdbarch *gdbarch = regcache->arch ();
|
||
int len = TYPE_LENGTH (type);
|
||
|
||
gdb_assert (element < 16);
|
||
|
||
if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
|
||
{
|
||
gdb_byte buf[8];
|
||
int regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
|
||
|
||
valbuf += bitpos / 8;
|
||
if (len < 8)
|
||
{
|
||
memset (buf, 0, 8 - len);
|
||
memcpy (buf + 8 - len, valbuf, len);
|
||
valbuf = buf;
|
||
len = 8;
|
||
}
|
||
for (int n = 0; n < (len + 3) / 4; n++)
|
||
regcache_cooked_write (regcache, regnum + n, valbuf + n * 4);
|
||
}
|
||
else if (sparc64_floating_p (type)
|
||
|| (sparc64_complex_floating_p (type) && len <= 16))
|
||
{
|
||
int regnum;
|
||
|
||
if (len == 16)
|
||
{
|
||
gdb_assert (bitpos == 0);
|
||
gdb_assert ((element % 2) == 0);
|
||
|
||
regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM + element / 2;
|
||
regcache_cooked_write (regcache, regnum, valbuf);
|
||
}
|
||
else if (len == 8)
|
||
{
|
||
gdb_assert (bitpos == 0 || bitpos == 64);
|
||
|
||
regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
|
||
+ element + bitpos / 64;
|
||
regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8));
|
||
}
|
||
else
|
||
{
|
||
gdb_assert (len == 4);
|
||
gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 128);
|
||
|
||
regnum = SPARC_F0_REGNUM + element * 2 + bitpos / 32;
|
||
regcache_cooked_write (regcache, regnum, valbuf + (bitpos / 8));
|
||
}
|
||
}
|
||
else if (sparc64_structure_or_union_p (type))
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < TYPE_NFIELDS (type); i++)
|
||
{
|
||
struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
|
||
int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
|
||
|
||
sparc64_store_floating_fields (regcache, subtype, valbuf,
|
||
element, subpos);
|
||
}
|
||
|
||
/* GCC has an interesting bug. If TYPE is a structure that has
|
||
a single `float' member, GCC doesn't treat it as a structure
|
||
at all, but rather as an ordinary `float' argument. This
|
||
argument will be stored in %f1, as required by the psABI.
|
||
However, as a member of a structure the psABI requires it to
|
||
be stored in %f0. This bug is present in GCC 3.3.2, but
|
||
probably in older releases to. To appease GCC, if a
|
||
structure has only a single `float' member, we store its
|
||
value in %f1 too (we already have stored in %f0). */
|
||
if (TYPE_NFIELDS (type) == 1)
|
||
{
|
||
struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, 0));
|
||
|
||
if (sparc64_floating_p (subtype) && TYPE_LENGTH (subtype) == 4)
|
||
regcache_cooked_write (regcache, SPARC_F1_REGNUM, valbuf);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Fetch floating fields from a variable of type TYPE from the
|
||
appropriate registers for BITPOS in REGCACHE and store it at BITPOS
|
||
in VALBUF. This function can be called recursively and therefore
|
||
handles floating types in addition to structures. */
|
||
|
||
static void
|
||
sparc64_extract_floating_fields (struct regcache *regcache, struct type *type,
|
||
gdb_byte *valbuf, int bitpos)
|
||
{
|
||
struct gdbarch *gdbarch = regcache->arch ();
|
||
|
||
if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
|
||
{
|
||
int len = TYPE_LENGTH (type);
|
||
int regnum = SPARC_F0_REGNUM + bitpos / 32;
|
||
|
||
valbuf += bitpos / 8;
|
||
if (len < 4)
|
||
{
|
||
gdb_byte buf[4];
|
||
regcache_cooked_read (regcache, regnum, buf);
|
||
memcpy (valbuf, buf + 4 - len, len);
|
||
}
|
||
else
|
||
for (int i = 0; i < (len + 3) / 4; i++)
|
||
regcache_cooked_read (regcache, regnum + i, valbuf + i * 4);
|
||
}
|
||
else if (sparc64_floating_p (type))
|
||
{
|
||
int len = TYPE_LENGTH (type);
|
||
int regnum;
|
||
|
||
if (len == 16)
|
||
{
|
||
gdb_assert (bitpos == 0 || bitpos == 128);
|
||
|
||
regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
|
||
+ bitpos / 128;
|
||
regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
|
||
}
|
||
else if (len == 8)
|
||
{
|
||
gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256);
|
||
|
||
regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + bitpos / 64;
|
||
regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
|
||
}
|
||
else
|
||
{
|
||
gdb_assert (len == 4);
|
||
gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 256);
|
||
|
||
regnum = SPARC_F0_REGNUM + bitpos / 32;
|
||
regcache_cooked_read (regcache, regnum, valbuf + (bitpos / 8));
|
||
}
|
||
}
|
||
else if (sparc64_structure_or_union_p (type))
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < TYPE_NFIELDS (type); i++)
|
||
{
|
||
struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));
|
||
int subpos = bitpos + TYPE_FIELD_BITPOS (type, i);
|
||
|
||
sparc64_extract_floating_fields (regcache, subtype, valbuf, subpos);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Store the NARGS arguments ARGS and STRUCT_ADDR (if STRUCT_RETURN is
|
||
non-zero) in REGCACHE and on the stack (starting from address SP). */
|
||
|
||
static CORE_ADDR
|
||
sparc64_store_arguments (struct regcache *regcache, int nargs,
|
||
struct value **args, CORE_ADDR sp,
|
||
int struct_return, CORE_ADDR struct_addr)
|
||
{
|
||
struct gdbarch *gdbarch = regcache->arch ();
|
||
/* Number of extended words in the "parameter array". */
|
||
int num_elements = 0;
|
||
int element = 0;
|
||
int i;
|
||
|
||
/* Take BIAS into account. */
|
||
sp += BIAS;
|
||
|
||
/* First we calculate the number of extended words in the "parameter
|
||
array". While doing so we also convert some of the arguments. */
|
||
|
||
if (struct_return)
|
||
num_elements++;
|
||
|
||
for (i = 0; i < nargs; i++)
|
||
{
|
||
struct type *type = value_type (args[i]);
|
||
int len = TYPE_LENGTH (type);
|
||
|
||
if (sparc64_structure_or_union_p (type)
|
||
|| (sparc64_complex_floating_p (type) && len == 32))
|
||
{
|
||
/* Structure or Union arguments. */
|
||
if (len <= 16)
|
||
{
|
||
if (num_elements % 2 && sparc64_16_byte_align_p (type))
|
||
num_elements++;
|
||
num_elements += ((len + 7) / 8);
|
||
}
|
||
else
|
||
{
|
||
/* The psABI says that "Structures or unions larger than
|
||
sixteen bytes are copied by the caller and passed
|
||
indirectly; the caller will pass the address of a
|
||
correctly aligned structure value. This sixty-four
|
||
bit address will occupy one word in the parameter
|
||
array, and may be promoted to an %o register like any
|
||
other pointer value." Allocate memory for these
|
||
values on the stack. */
|
||
sp -= len;
|
||
|
||
/* Use 16-byte alignment for these values. That's
|
||
always correct, and wasting a few bytes shouldn't be
|
||
a problem. */
|
||
sp &= ~0xf;
|
||
|
||
write_memory (sp, value_contents (args[i]), len);
|
||
args[i] = value_from_pointer (lookup_pointer_type (type), sp);
|
||
num_elements++;
|
||
}
|
||
}
|
||
else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
|
||
{
|
||
/* Floating arguments. */
|
||
if (len == 16)
|
||
{
|
||
/* The psABI says that "Each quad-precision parameter
|
||
value will be assigned to two extended words in the
|
||
parameter array. */
|
||
num_elements += 2;
|
||
|
||
/* The psABI says that "Long doubles must be
|
||
quad-aligned, and thus a hole might be introduced
|
||
into the parameter array to force alignment." Skip
|
||
an element if necessary. */
|
||
if ((num_elements % 2) && sparc64_16_byte_align_p (type))
|
||
num_elements++;
|
||
}
|
||
else
|
||
num_elements++;
|
||
}
|
||
else
|
||
{
|
||
/* Integral and pointer arguments. */
|
||
gdb_assert (sparc64_integral_or_pointer_p (type));
|
||
|
||
/* The psABI says that "Each argument value of integral type
|
||
smaller than an extended word will be widened by the
|
||
caller to an extended word according to the signed-ness
|
||
of the argument type." */
|
||
if (len < 8)
|
||
args[i] = value_cast (builtin_type (gdbarch)->builtin_int64,
|
||
args[i]);
|
||
num_elements++;
|
||
}
|
||
}
|
||
|
||
/* Allocate the "parameter array". */
|
||
sp -= num_elements * 8;
|
||
|
||
/* The psABI says that "Every stack frame must be 16-byte aligned." */
|
||
sp &= ~0xf;
|
||
|
||
/* Now we store the arguments in to the "paramater array". Some
|
||
Integer or Pointer arguments and Structure or Union arguments
|
||
will be passed in %o registers. Some Floating arguments and
|
||
floating members of structures are passed in floating-point
|
||
registers. However, for functions with variable arguments,
|
||
floating arguments are stored in an %0 register, and for
|
||
functions without a prototype floating arguments are stored in
|
||
both a floating-point and an %o registers, or a floating-point
|
||
register and memory. To simplify the logic here we always pass
|
||
arguments in memory, an %o register, and a floating-point
|
||
register if appropriate. This should be no problem since the
|
||
contents of any unused memory or registers in the "parameter
|
||
array" are undefined. */
|
||
|
||
if (struct_return)
|
||
{
|
||
regcache_cooked_write_unsigned (regcache, SPARC_O0_REGNUM, struct_addr);
|
||
element++;
|
||
}
|
||
|
||
for (i = 0; i < nargs; i++)
|
||
{
|
||
const gdb_byte *valbuf = value_contents (args[i]);
|
||
struct type *type = value_type (args[i]);
|
||
int len = TYPE_LENGTH (type);
|
||
int regnum = -1;
|
||
gdb_byte buf[16];
|
||
|
||
if (sparc64_structure_or_union_p (type)
|
||
|| (sparc64_complex_floating_p (type) && len == 32))
|
||
{
|
||
/* Structure, Union or long double Complex arguments. */
|
||
gdb_assert (len <= 16);
|
||
memset (buf, 0, sizeof (buf));
|
||
memcpy (buf, valbuf, len);
|
||
valbuf = buf;
|
||
|
||
if (element % 2 && sparc64_16_byte_align_p (type))
|
||
element++;
|
||
|
||
if (element < 6)
|
||
{
|
||
regnum = SPARC_O0_REGNUM + element;
|
||
if (len > 8 && element < 5)
|
||
regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
|
||
}
|
||
|
||
if (element < 16)
|
||
sparc64_store_floating_fields (regcache, type, valbuf, element, 0);
|
||
}
|
||
else if (sparc64_complex_floating_p (type))
|
||
{
|
||
/* Float Complex or double Complex arguments. */
|
||
if (element < 16)
|
||
{
|
||
regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM + element;
|
||
|
||
if (len == 16)
|
||
{
|
||
if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D30_REGNUM)
|
||
regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
|
||
if (regnum < gdbarch_num_regs (gdbarch) + SPARC64_D10_REGNUM)
|
||
regcache_cooked_write (regcache,
|
||
SPARC_O0_REGNUM + element + 1,
|
||
valbuf + 8);
|
||
}
|
||
}
|
||
}
|
||
else if (sparc64_floating_p (type))
|
||
{
|
||
/* Floating arguments. */
|
||
if (len == 16)
|
||
{
|
||
if (element % 2)
|
||
element++;
|
||
if (element < 16)
|
||
regnum = gdbarch_num_regs (gdbarch) + SPARC64_Q0_REGNUM
|
||
+ element / 2;
|
||
}
|
||
else if (len == 8)
|
||
{
|
||
if (element < 16)
|
||
regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
|
||
+ element;
|
||
}
|
||
else if (len == 4)
|
||
{
|
||
/* The psABI says "Each single-precision parameter value
|
||
will be assigned to one extended word in the
|
||
parameter array, and right-justified within that
|
||
word; the left half (even float register) is
|
||
undefined." Even though the psABI says that "the
|
||
left half is undefined", set it to zero here. */
|
||
memset (buf, 0, 4);
|
||
memcpy (buf + 4, valbuf, 4);
|
||
valbuf = buf;
|
||
len = 8;
|
||
if (element < 16)
|
||
regnum = gdbarch_num_regs (gdbarch) + SPARC64_D0_REGNUM
|
||
+ element;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* Integral and pointer arguments. */
|
||
gdb_assert (len == 8);
|
||
if (element < 6)
|
||
regnum = SPARC_O0_REGNUM + element;
|
||
}
|
||
|
||
if (regnum != -1)
|
||
{
|
||
regcache_cooked_write (regcache, regnum, valbuf);
|
||
|
||
/* If we're storing the value in a floating-point register,
|
||
also store it in the corresponding %0 register(s). */
|
||
if (regnum >= gdbarch_num_regs (gdbarch))
|
||
{
|
||
regnum -= gdbarch_num_regs (gdbarch);
|
||
|
||
if (regnum >= SPARC64_D0_REGNUM && regnum <= SPARC64_D10_REGNUM)
|
||
{
|
||
gdb_assert (element < 6);
|
||
regnum = SPARC_O0_REGNUM + element;
|
||
regcache_cooked_write (regcache, regnum, valbuf);
|
||
}
|
||
else if (regnum >= SPARC64_Q0_REGNUM && regnum <= SPARC64_Q8_REGNUM)
|
||
{
|
||
gdb_assert (element < 5);
|
||
regnum = SPARC_O0_REGNUM + element;
|
||
regcache_cooked_write (regcache, regnum, valbuf);
|
||
regcache_cooked_write (regcache, regnum + 1, valbuf + 8);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Always store the argument in memory. */
|
||
write_memory (sp + element * 8, valbuf, len);
|
||
element += ((len + 7) / 8);
|
||
}
|
||
|
||
gdb_assert (element == num_elements);
|
||
|
||
/* Take BIAS into account. */
|
||
sp -= BIAS;
|
||
return sp;
|
||
}
|
||
|
||
static CORE_ADDR
|
||
sparc64_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
|
||
{
|
||
/* The ABI requires 16-byte alignment. */
|
||
return address & ~0xf;
|
||
}
|
||
|
||
static CORE_ADDR
|
||
sparc64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||
struct regcache *regcache, CORE_ADDR bp_addr,
|
||
int nargs, struct value **args, CORE_ADDR sp,
|
||
int struct_return, CORE_ADDR struct_addr)
|
||
{
|
||
/* Set return address. */
|
||
regcache_cooked_write_unsigned (regcache, SPARC_O7_REGNUM, bp_addr - 8);
|
||
|
||
/* Set up function arguments. */
|
||
sp = sparc64_store_arguments (regcache, nargs, args, sp,
|
||
struct_return, struct_addr);
|
||
|
||
/* Allocate the register save area. */
|
||
sp -= 16 * 8;
|
||
|
||
/* Stack should be 16-byte aligned at this point. */
|
||
gdb_assert ((sp + BIAS) % 16 == 0);
|
||
|
||
/* Finally, update the stack pointer. */
|
||
regcache_cooked_write_unsigned (regcache, SPARC_SP_REGNUM, sp);
|
||
|
||
return sp + BIAS;
|
||
}
|
||
|
||
|
||
/* Extract from an array REGBUF containing the (raw) register state, a
|
||
function return value of TYPE, and copy that into VALBUF. */
|
||
|
||
static void
|
||
sparc64_extract_return_value (struct type *type, struct regcache *regcache,
|
||
gdb_byte *valbuf)
|
||
{
|
||
int len = TYPE_LENGTH (type);
|
||
gdb_byte buf[32];
|
||
int i;
|
||
|
||
if (sparc64_structure_or_union_p (type))
|
||
{
|
||
/* Structure or Union return values. */
|
||
gdb_assert (len <= 32);
|
||
|
||
for (i = 0; i < ((len + 7) / 8); i++)
|
||
regcache_cooked_read (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
|
||
if (TYPE_CODE (type) != TYPE_CODE_UNION)
|
||
sparc64_extract_floating_fields (regcache, type, buf, 0);
|
||
memcpy (valbuf, buf, len);
|
||
}
|
||
else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
|
||
{
|
||
/* Floating return values. */
|
||
for (i = 0; i < len / 4; i++)
|
||
regcache_cooked_read (regcache, SPARC_F0_REGNUM + i, buf + i * 4);
|
||
memcpy (valbuf, buf, len);
|
||
}
|
||
else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
|
||
{
|
||
/* Small arrays are returned the same way as small structures. */
|
||
gdb_assert (len <= 32);
|
||
|
||
for (i = 0; i < ((len + 7) / 8); i++)
|
||
regcache_cooked_read (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
|
||
memcpy (valbuf, buf, len);
|
||
}
|
||
else
|
||
{
|
||
/* Integral and pointer return values. */
|
||
gdb_assert (sparc64_integral_or_pointer_p (type));
|
||
|
||
/* Just stripping off any unused bytes should preserve the
|
||
signed-ness just fine. */
|
||
regcache_cooked_read (regcache, SPARC_O0_REGNUM, buf);
|
||
memcpy (valbuf, buf + 8 - len, len);
|
||
}
|
||
}
|
||
|
||
/* Write into the appropriate registers a function return value stored
|
||
in VALBUF of type TYPE. */
|
||
|
||
static void
|
||
sparc64_store_return_value (struct type *type, struct regcache *regcache,
|
||
const gdb_byte *valbuf)
|
||
{
|
||
int len = TYPE_LENGTH (type);
|
||
gdb_byte buf[16];
|
||
int i;
|
||
|
||
if (sparc64_structure_or_union_p (type))
|
||
{
|
||
/* Structure or Union return values. */
|
||
gdb_assert (len <= 32);
|
||
|
||
/* Simplify matters by storing the complete value (including
|
||
floating members) into %o0 and %o1. Floating members are
|
||
also store in the appropriate floating-point registers. */
|
||
memset (buf, 0, sizeof (buf));
|
||
memcpy (buf, valbuf, len);
|
||
for (i = 0; i < ((len + 7) / 8); i++)
|
||
regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
|
||
if (TYPE_CODE (type) != TYPE_CODE_UNION)
|
||
sparc64_store_floating_fields (regcache, type, buf, 0, 0);
|
||
}
|
||
else if (sparc64_floating_p (type) || sparc64_complex_floating_p (type))
|
||
{
|
||
/* Floating return values. */
|
||
memcpy (buf, valbuf, len);
|
||
for (i = 0; i < len / 4; i++)
|
||
regcache_cooked_write (regcache, SPARC_F0_REGNUM + i, buf + i * 4);
|
||
}
|
||
else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
|
||
{
|
||
/* Small arrays are returned the same way as small structures. */
|
||
gdb_assert (len <= 32);
|
||
|
||
memset (buf, 0, sizeof (buf));
|
||
memcpy (buf, valbuf, len);
|
||
for (i = 0; i < ((len + 7) / 8); i++)
|
||
regcache_cooked_write (regcache, SPARC_O0_REGNUM + i, buf + i * 8);
|
||
}
|
||
else
|
||
{
|
||
/* Integral and pointer return values. */
|
||
gdb_assert (sparc64_integral_or_pointer_p (type));
|
||
|
||
/* ??? Do we need to do any sign-extension here? */
|
||
memset (buf, 0, 8);
|
||
memcpy (buf + 8 - len, valbuf, len);
|
||
regcache_cooked_write (regcache, SPARC_O0_REGNUM, buf);
|
||
}
|
||
}
|
||
|
||
static enum return_value_convention
|
||
sparc64_return_value (struct gdbarch *gdbarch, struct value *function,
|
||
struct type *type, struct regcache *regcache,
|
||
gdb_byte *readbuf, const gdb_byte *writebuf)
|
||
{
|
||
if (TYPE_LENGTH (type) > 32)
|
||
return RETURN_VALUE_STRUCT_CONVENTION;
|
||
|
||
if (readbuf)
|
||
sparc64_extract_return_value (type, regcache, readbuf);
|
||
if (writebuf)
|
||
sparc64_store_return_value (type, regcache, writebuf);
|
||
|
||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||
}
|
||
|
||
|
||
static void
|
||
sparc64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
|
||
struct dwarf2_frame_state_reg *reg,
|
||
struct frame_info *this_frame)
|
||
{
|
||
switch (regnum)
|
||
{
|
||
case SPARC_G0_REGNUM:
|
||
/* Since %g0 is always zero, there is no point in saving it, and
|
||
people will be inclined omit it from the CFI. Make sure we
|
||
don't warn about that. */
|
||
reg->how = DWARF2_FRAME_REG_SAME_VALUE;
|
||
break;
|
||
case SPARC_SP_REGNUM:
|
||
reg->how = DWARF2_FRAME_REG_CFA;
|
||
break;
|
||
case SPARC64_PC_REGNUM:
|
||
reg->how = DWARF2_FRAME_REG_RA_OFFSET;
|
||
reg->loc.offset = 8;
|
||
break;
|
||
case SPARC64_NPC_REGNUM:
|
||
reg->how = DWARF2_FRAME_REG_RA_OFFSET;
|
||
reg->loc.offset = 12;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* sparc64_addr_bits_remove - remove useless address bits */
|
||
|
||
static CORE_ADDR
|
||
sparc64_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
|
||
{
|
||
return adi_normalize_address (addr);
|
||
}
|
||
|
||
void
|
||
sparc64_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
|
||
{
|
||
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
||
|
||
tdep->pc_regnum = SPARC64_PC_REGNUM;
|
||
tdep->npc_regnum = SPARC64_NPC_REGNUM;
|
||
tdep->fpu_register_names = sparc64_fpu_register_names;
|
||
tdep->fpu_registers_num = ARRAY_SIZE (sparc64_fpu_register_names);
|
||
tdep->cp0_register_names = sparc64_cp0_register_names;
|
||
tdep->cp0_registers_num = ARRAY_SIZE (sparc64_cp0_register_names);
|
||
|
||
/* This is what all the fuss is about. */
|
||
set_gdbarch_long_bit (gdbarch, 64);
|
||
set_gdbarch_long_long_bit (gdbarch, 64);
|
||
set_gdbarch_ptr_bit (gdbarch, 64);
|
||
|
||
set_gdbarch_wchar_bit (gdbarch, 16);
|
||
set_gdbarch_wchar_signed (gdbarch, 0);
|
||
|
||
set_gdbarch_num_regs (gdbarch, SPARC64_NUM_REGS);
|
||
set_gdbarch_register_name (gdbarch, sparc64_register_name);
|
||
set_gdbarch_register_type (gdbarch, sparc64_register_type);
|
||
set_gdbarch_num_pseudo_regs (gdbarch, SPARC64_NUM_PSEUDO_REGS);
|
||
set_tdesc_pseudo_register_name (gdbarch, sparc64_pseudo_register_name);
|
||
set_tdesc_pseudo_register_type (gdbarch, sparc64_pseudo_register_type);
|
||
set_gdbarch_pseudo_register_read (gdbarch, sparc64_pseudo_register_read);
|
||
set_gdbarch_pseudo_register_write (gdbarch, sparc64_pseudo_register_write);
|
||
|
||
/* Register numbers of various important registers. */
|
||
set_gdbarch_pc_regnum (gdbarch, SPARC64_PC_REGNUM); /* %pc */
|
||
|
||
/* Call dummy code. */
|
||
set_gdbarch_frame_align (gdbarch, sparc64_frame_align);
|
||
set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
|
||
set_gdbarch_push_dummy_code (gdbarch, NULL);
|
||
set_gdbarch_push_dummy_call (gdbarch, sparc64_push_dummy_call);
|
||
|
||
set_gdbarch_return_value (gdbarch, sparc64_return_value);
|
||
set_gdbarch_stabs_argument_has_addr
|
||
(gdbarch, default_stabs_argument_has_addr);
|
||
|
||
set_gdbarch_skip_prologue (gdbarch, sparc64_skip_prologue);
|
||
set_gdbarch_stack_frame_destroyed_p (gdbarch, sparc_stack_frame_destroyed_p);
|
||
|
||
/* Hook in the DWARF CFI frame unwinder. */
|
||
dwarf2_frame_set_init_reg (gdbarch, sparc64_dwarf2_frame_init_reg);
|
||
/* FIXME: kettenis/20050423: Don't enable the unwinder until the
|
||
StackGhost issues have been resolved. */
|
||
|
||
frame_unwind_append_unwinder (gdbarch, &sparc64_frame_unwind);
|
||
frame_base_set_default (gdbarch, &sparc64_frame_base);
|
||
|
||
set_gdbarch_addr_bits_remove (gdbarch, sparc64_addr_bits_remove);
|
||
}
|
||
|
||
|
||
/* Helper functions for dealing with register sets. */
|
||
|
||
#define TSTATE_CWP 0x000000000000001fULL
|
||
#define TSTATE_ICC 0x0000000f00000000ULL
|
||
#define TSTATE_XCC 0x000000f000000000ULL
|
||
|
||
#define PSR_S 0x00000080
|
||
#ifndef PSR_ICC
|
||
#define PSR_ICC 0x00f00000
|
||
#endif
|
||
#define PSR_VERS 0x0f000000
|
||
#ifndef PSR_IMPL
|
||
#define PSR_IMPL 0xf0000000
|
||
#endif
|
||
#define PSR_V8PLUS 0xff000000
|
||
#define PSR_XCC 0x000f0000
|
||
|
||
void
|
||
sparc64_supply_gregset (const struct sparc_gregmap *gregmap,
|
||
struct regcache *regcache,
|
||
int regnum, const void *gregs)
|
||
{
|
||
struct gdbarch *gdbarch = regcache->arch ();
|
||
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
||
int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
|
||
const gdb_byte *regs = (const gdb_byte *) gregs;
|
||
gdb_byte zero[8] = { 0 };
|
||
int i;
|
||
|
||
if (sparc32)
|
||
{
|
||
if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
|
||
{
|
||
int offset = gregmap->r_tstate_offset;
|
||
ULONGEST tstate, psr;
|
||
gdb_byte buf[4];
|
||
|
||
tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
|
||
psr = ((tstate & TSTATE_CWP) | PSR_S | ((tstate & TSTATE_ICC) >> 12)
|
||
| ((tstate & TSTATE_XCC) >> 20) | PSR_V8PLUS);
|
||
store_unsigned_integer (buf, 4, byte_order, psr);
|
||
regcache_raw_supply (regcache, SPARC32_PSR_REGNUM, buf);
|
||
}
|
||
|
||
if (regnum == SPARC32_PC_REGNUM || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC32_PC_REGNUM,
|
||
regs + gregmap->r_pc_offset + 4);
|
||
|
||
if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC32_NPC_REGNUM,
|
||
regs + gregmap->r_npc_offset + 4);
|
||
|
||
if (regnum == SPARC32_Y_REGNUM || regnum == -1)
|
||
{
|
||
int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
|
||
regcache_raw_supply (regcache, SPARC32_Y_REGNUM, regs + offset);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC64_STATE_REGNUM,
|
||
regs + gregmap->r_tstate_offset);
|
||
|
||
if (regnum == SPARC64_PC_REGNUM || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC64_PC_REGNUM,
|
||
regs + gregmap->r_pc_offset);
|
||
|
||
if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC64_NPC_REGNUM,
|
||
regs + gregmap->r_npc_offset);
|
||
|
||
if (regnum == SPARC64_Y_REGNUM || regnum == -1)
|
||
{
|
||
gdb_byte buf[8];
|
||
|
||
memset (buf, 0, 8);
|
||
memcpy (buf + 8 - gregmap->r_y_size,
|
||
regs + gregmap->r_y_offset, gregmap->r_y_size);
|
||
regcache_raw_supply (regcache, SPARC64_Y_REGNUM, buf);
|
||
}
|
||
|
||
if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
|
||
&& gregmap->r_fprs_offset != -1)
|
||
regcache_raw_supply (regcache, SPARC64_FPRS_REGNUM,
|
||
regs + gregmap->r_fprs_offset);
|
||
}
|
||
|
||
if (regnum == SPARC_G0_REGNUM || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC_G0_REGNUM, &zero);
|
||
|
||
if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
|
||
{
|
||
int offset = gregmap->r_g1_offset;
|
||
|
||
if (sparc32)
|
||
offset += 4;
|
||
|
||
for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
|
||
{
|
||
if (regnum == i || regnum == -1)
|
||
regcache_raw_supply (regcache, i, regs + offset);
|
||
offset += 8;
|
||
}
|
||
}
|
||
|
||
if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
|
||
{
|
||
/* Not all of the register set variants include Locals and
|
||
Inputs. For those that don't, we read them off the stack. */
|
||
if (gregmap->r_l0_offset == -1)
|
||
{
|
||
ULONGEST sp;
|
||
|
||
regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, &sp);
|
||
sparc_supply_rwindow (regcache, sp, regnum);
|
||
}
|
||
else
|
||
{
|
||
int offset = gregmap->r_l0_offset;
|
||
|
||
if (sparc32)
|
||
offset += 4;
|
||
|
||
for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
|
||
{
|
||
if (regnum == i || regnum == -1)
|
||
regcache_raw_supply (regcache, i, regs + offset);
|
||
offset += 8;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void
|
||
sparc64_collect_gregset (const struct sparc_gregmap *gregmap,
|
||
const struct regcache *regcache,
|
||
int regnum, void *gregs)
|
||
{
|
||
struct gdbarch *gdbarch = regcache->arch ();
|
||
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
||
int sparc32 = (gdbarch_ptr_bit (gdbarch) == 32);
|
||
gdb_byte *regs = (gdb_byte *) gregs;
|
||
int i;
|
||
|
||
if (sparc32)
|
||
{
|
||
if (regnum == SPARC32_PSR_REGNUM || regnum == -1)
|
||
{
|
||
int offset = gregmap->r_tstate_offset;
|
||
ULONGEST tstate, psr;
|
||
gdb_byte buf[8];
|
||
|
||
tstate = extract_unsigned_integer (regs + offset, 8, byte_order);
|
||
regcache_raw_collect (regcache, SPARC32_PSR_REGNUM, buf);
|
||
psr = extract_unsigned_integer (buf, 4, byte_order);
|
||
tstate |= (psr & PSR_ICC) << 12;
|
||
if ((psr & (PSR_VERS | PSR_IMPL)) == PSR_V8PLUS)
|
||
tstate |= (psr & PSR_XCC) << 20;
|
||
store_unsigned_integer (buf, 8, byte_order, tstate);
|
||
memcpy (regs + offset, buf, 8);
|
||
}
|
||
|
||
if (regnum == SPARC32_PC_REGNUM || regnum == -1)
|
||
regcache_raw_collect (regcache, SPARC32_PC_REGNUM,
|
||
regs + gregmap->r_pc_offset + 4);
|
||
|
||
if (regnum == SPARC32_NPC_REGNUM || regnum == -1)
|
||
regcache_raw_collect (regcache, SPARC32_NPC_REGNUM,
|
||
regs + gregmap->r_npc_offset + 4);
|
||
|
||
if (regnum == SPARC32_Y_REGNUM || regnum == -1)
|
||
{
|
||
int offset = gregmap->r_y_offset + 8 - gregmap->r_y_size;
|
||
regcache_raw_collect (regcache, SPARC32_Y_REGNUM, regs + offset);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (regnum == SPARC64_STATE_REGNUM || regnum == -1)
|
||
regcache_raw_collect (regcache, SPARC64_STATE_REGNUM,
|
||
regs + gregmap->r_tstate_offset);
|
||
|
||
if (regnum == SPARC64_PC_REGNUM || regnum == -1)
|
||
regcache_raw_collect (regcache, SPARC64_PC_REGNUM,
|
||
regs + gregmap->r_pc_offset);
|
||
|
||
if (regnum == SPARC64_NPC_REGNUM || regnum == -1)
|
||
regcache_raw_collect (regcache, SPARC64_NPC_REGNUM,
|
||
regs + gregmap->r_npc_offset);
|
||
|
||
if (regnum == SPARC64_Y_REGNUM || regnum == -1)
|
||
{
|
||
gdb_byte buf[8];
|
||
|
||
regcache_raw_collect (regcache, SPARC64_Y_REGNUM, buf);
|
||
memcpy (regs + gregmap->r_y_offset,
|
||
buf + 8 - gregmap->r_y_size, gregmap->r_y_size);
|
||
}
|
||
|
||
if ((regnum == SPARC64_FPRS_REGNUM || regnum == -1)
|
||
&& gregmap->r_fprs_offset != -1)
|
||
regcache_raw_collect (regcache, SPARC64_FPRS_REGNUM,
|
||
regs + gregmap->r_fprs_offset);
|
||
|
||
}
|
||
|
||
if ((regnum >= SPARC_G1_REGNUM && regnum <= SPARC_O7_REGNUM) || regnum == -1)
|
||
{
|
||
int offset = gregmap->r_g1_offset;
|
||
|
||
if (sparc32)
|
||
offset += 4;
|
||
|
||
/* %g0 is always zero. */
|
||
for (i = SPARC_G1_REGNUM; i <= SPARC_O7_REGNUM; i++)
|
||
{
|
||
if (regnum == i || regnum == -1)
|
||
regcache_raw_collect (regcache, i, regs + offset);
|
||
offset += 8;
|
||
}
|
||
}
|
||
|
||
if ((regnum >= SPARC_L0_REGNUM && regnum <= SPARC_I7_REGNUM) || regnum == -1)
|
||
{
|
||
/* Not all of the register set variants include Locals and
|
||
Inputs. For those that don't, we read them off the stack. */
|
||
if (gregmap->r_l0_offset != -1)
|
||
{
|
||
int offset = gregmap->r_l0_offset;
|
||
|
||
if (sparc32)
|
||
offset += 4;
|
||
|
||
for (i = SPARC_L0_REGNUM; i <= SPARC_I7_REGNUM; i++)
|
||
{
|
||
if (regnum == i || regnum == -1)
|
||
regcache_raw_collect (regcache, i, regs + offset);
|
||
offset += 8;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void
|
||
sparc64_supply_fpregset (const struct sparc_fpregmap *fpregmap,
|
||
struct regcache *regcache,
|
||
int regnum, const void *fpregs)
|
||
{
|
||
int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
|
||
const gdb_byte *regs = (const gdb_byte *) fpregs;
|
||
int i;
|
||
|
||
for (i = 0; i < 32; i++)
|
||
{
|
||
if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC_F0_REGNUM + i,
|
||
regs + fpregmap->r_f0_offset + (i * 4));
|
||
}
|
||
|
||
if (sparc32)
|
||
{
|
||
if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC32_FSR_REGNUM,
|
||
regs + fpregmap->r_fsr_offset);
|
||
}
|
||
else
|
||
{
|
||
for (i = 0; i < 16; i++)
|
||
{
|
||
if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC64_F32_REGNUM + i,
|
||
(regs + fpregmap->r_f0_offset
|
||
+ (32 * 4) + (i * 8)));
|
||
}
|
||
|
||
if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
|
||
regcache_raw_supply (regcache, SPARC64_FSR_REGNUM,
|
||
regs + fpregmap->r_fsr_offset);
|
||
}
|
||
}
|
||
|
||
void
|
||
sparc64_collect_fpregset (const struct sparc_fpregmap *fpregmap,
|
||
const struct regcache *regcache,
|
||
int regnum, void *fpregs)
|
||
{
|
||
int sparc32 = (gdbarch_ptr_bit (regcache->arch ()) == 32);
|
||
gdb_byte *regs = (gdb_byte *) fpregs;
|
||
int i;
|
||
|
||
for (i = 0; i < 32; i++)
|
||
{
|
||
if (regnum == (SPARC_F0_REGNUM + i) || regnum == -1)
|
||
regcache_raw_collect (regcache, SPARC_F0_REGNUM + i,
|
||
regs + fpregmap->r_f0_offset + (i * 4));
|
||
}
|
||
|
||
if (sparc32)
|
||
{
|
||
if (regnum == SPARC32_FSR_REGNUM || regnum == -1)
|
||
regcache_raw_collect (regcache, SPARC32_FSR_REGNUM,
|
||
regs + fpregmap->r_fsr_offset);
|
||
}
|
||
else
|
||
{
|
||
for (i = 0; i < 16; i++)
|
||
{
|
||
if (regnum == (SPARC64_F32_REGNUM + i) || regnum == -1)
|
||
regcache_raw_collect (regcache, SPARC64_F32_REGNUM + i,
|
||
(regs + fpregmap->r_f0_offset
|
||
+ (32 * 4) + (i * 8)));
|
||
}
|
||
|
||
if (regnum == SPARC64_FSR_REGNUM || regnum == -1)
|
||
regcache_raw_collect (regcache, SPARC64_FSR_REGNUM,
|
||
regs + fpregmap->r_fsr_offset);
|
||
}
|
||
}
|
||
|
||
const struct sparc_fpregmap sparc64_bsd_fpregmap =
|
||
{
|
||
0 * 8, /* %f0 */
|
||
32 * 8, /* %fsr */
|
||
};
|