mirror of
https://github.com/bminor/binutils-gdb.git
synced 2025-12-25 08:47:28 +00: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.
2165 lines
60 KiB
C
2165 lines
60 KiB
C
/* Native debugging support for Intel x86 running DJGPP.
|
|
Copyright (C) 1997-2018 Free Software Foundation, Inc.
|
|
Written by Robert Hoehne.
|
|
|
|
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/>. */
|
|
|
|
/* To whomever it may concern, here's a general description of how
|
|
debugging in DJGPP works, and the special quirks GDB does to
|
|
support that.
|
|
|
|
When the DJGPP port of GDB is debugging a DJGPP program natively,
|
|
there aren't 2 separate processes, the debuggee and GDB itself, as
|
|
on other systems. (This is DOS, where there can only be one active
|
|
process at any given time, remember?) Instead, GDB and the
|
|
debuggee live in the same process. So when GDB calls
|
|
go32_create_inferior below, and that function calls edi_init from
|
|
the DJGPP debug support library libdbg.a, we load the debuggee's
|
|
executable file into GDB's address space, set it up for execution
|
|
as the stub loader (a short real-mode program prepended to each
|
|
DJGPP executable) normally would, and do a lot of preparations for
|
|
swapping between GDB's and debuggee's internal state, primarily wrt
|
|
the exception handlers. This swapping happens every time we resume
|
|
the debuggee or switch back to GDB's code, and it includes:
|
|
|
|
. swapping all the segment registers
|
|
. swapping the PSP (the Program Segment Prefix)
|
|
. swapping the signal handlers
|
|
. swapping the exception handlers
|
|
. swapping the FPU status
|
|
. swapping the 3 standard file handles (more about this below)
|
|
|
|
Then running the debuggee simply means longjmp into it where its PC
|
|
is and let it run until it stops for some reason. When it stops,
|
|
GDB catches the exception that stopped it and longjmp's back into
|
|
its own code. All the possible exit points of the debuggee are
|
|
watched; for example, the normal exit point is recognized because a
|
|
DOS program issues a special system call to exit. If one of those
|
|
exit points is hit, we mourn the inferior and clean up after it.
|
|
Cleaning up is very important, even if the process exits normally,
|
|
because otherwise we might leave behind traces of previous
|
|
execution, and in several cases GDB itself might be left hosed,
|
|
because all the exception handlers were not restored.
|
|
|
|
Swapping of the standard handles (in redir_to_child and
|
|
redir_to_debugger) is needed because, since both GDB and the
|
|
debuggee live in the same process, as far as the OS is concerned,
|
|
the share the same file table. This means that the standard
|
|
handles 0, 1, and 2 point to the same file table entries, and thus
|
|
are connected to the same devices. Therefore, if the debugger
|
|
redirects its standard output, the standard output of the debuggee
|
|
is also automagically redirected to the same file/device!
|
|
Similarly, if the debuggee redirects its stdout to a file, you
|
|
won't be able to see debugger's output (it will go to the same file
|
|
where the debuggee has its output); and if the debuggee closes its
|
|
standard input, you will lose the ability to talk to debugger!
|
|
|
|
For this reason, every time the debuggee is about to be resumed, we
|
|
call redir_to_child, which redirects the standard handles to where
|
|
the debuggee expects them to be. When the debuggee stops and GDB
|
|
regains control, we call redir_to_debugger, which redirects those 3
|
|
handles back to where GDB expects.
|
|
|
|
Note that only the first 3 handles are swapped, so if the debuggee
|
|
redirects or closes any other handles, GDB will not notice. In
|
|
particular, the exit code of a DJGPP program forcibly closes all
|
|
file handles beyond the first 3 ones, so when the debuggee exits,
|
|
GDB currently loses its stdaux and stdprn streams. Fortunately,
|
|
GDB does not use those as of this writing, and will never need
|
|
to. */
|
|
|
|
#include "defs.h"
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include "x86-nat.h"
|
|
#include "inferior.h"
|
|
#include "infrun.h"
|
|
#include "gdbthread.h"
|
|
#include "gdb_wait.h"
|
|
#include "gdbcore.h"
|
|
#include "command.h"
|
|
#include "gdbcmd.h"
|
|
#include "floatformat.h"
|
|
#include "buildsym.h"
|
|
#include "i387-tdep.h"
|
|
#include "i386-tdep.h"
|
|
#include "nat/x86-cpuid.h"
|
|
#include "value.h"
|
|
#include "regcache.h"
|
|
#include "top.h"
|
|
#include "cli/cli-utils.h"
|
|
#include "inf-child.h"
|
|
|
|
#include <ctype.h>
|
|
#include <unistd.h>
|
|
#include <sys/utsname.h>
|
|
#include <io.h>
|
|
#include <dos.h>
|
|
#include <dpmi.h>
|
|
#include <go32.h>
|
|
#include <sys/farptr.h>
|
|
#include <debug/v2load.h>
|
|
#include <debug/dbgcom.h>
|
|
#if __DJGPP_MINOR__ > 2
|
|
#include <debug/redir.h>
|
|
#endif
|
|
|
|
#include <langinfo.h>
|
|
|
|
#if __DJGPP_MINOR__ < 3
|
|
/* This code will be provided from DJGPP 2.03 on. Until then I code it
|
|
here. */
|
|
typedef struct
|
|
{
|
|
unsigned short sig0;
|
|
unsigned short sig1;
|
|
unsigned short sig2;
|
|
unsigned short sig3;
|
|
unsigned short exponent:15;
|
|
unsigned short sign:1;
|
|
}
|
|
NPXREG;
|
|
|
|
typedef struct
|
|
{
|
|
unsigned int control;
|
|
unsigned int status;
|
|
unsigned int tag;
|
|
unsigned int eip;
|
|
unsigned int cs;
|
|
unsigned int dataptr;
|
|
unsigned int datasel;
|
|
NPXREG reg[8];
|
|
}
|
|
NPX;
|
|
|
|
static NPX npx;
|
|
|
|
static void save_npx (void); /* Save the FPU of the debugged program. */
|
|
static void load_npx (void); /* Restore the FPU of the debugged program. */
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* Store the contents of the NPX in the global variable `npx'. */
|
|
/* *INDENT-OFF* */
|
|
|
|
static void
|
|
save_npx (void)
|
|
{
|
|
asm ("inb $0xa0, %%al \n\
|
|
testb $0x20, %%al \n\
|
|
jz 1f \n\
|
|
xorb %%al, %%al \n\
|
|
outb %%al, $0xf0 \n\
|
|
movb $0x20, %%al \n\
|
|
outb %%al, $0xa0 \n\
|
|
outb %%al, $0x20 \n\
|
|
1: \n\
|
|
fnsave %0 \n\
|
|
fwait "
|
|
: "=m" (npx)
|
|
: /* No input */
|
|
: "%eax");
|
|
}
|
|
|
|
/* *INDENT-ON* */
|
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* Reload the contents of the NPX from the global variable `npx'. */
|
|
|
|
static void
|
|
load_npx (void)
|
|
{
|
|
asm ("frstor %0":"=m" (npx));
|
|
}
|
|
/* ------------------------------------------------------------------------- */
|
|
/* Stubs for the missing redirection functions. */
|
|
typedef struct {
|
|
char *command;
|
|
int redirected;
|
|
} cmdline_t;
|
|
|
|
void
|
|
redir_cmdline_delete (cmdline_t *ptr)
|
|
{
|
|
ptr->redirected = 0;
|
|
}
|
|
|
|
int
|
|
redir_cmdline_parse (const char *args, cmdline_t *ptr)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
int
|
|
redir_to_child (cmdline_t *ptr)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
redir_to_debugger (cmdline_t *ptr)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
redir_debug_init (cmdline_t *ptr)
|
|
{
|
|
return 0;
|
|
}
|
|
#endif /* __DJGPP_MINOR < 3 */
|
|
|
|
typedef enum { wp_insert, wp_remove, wp_count } wp_op;
|
|
|
|
/* This holds the current reference counts for each debug register. */
|
|
static int dr_ref_count[4];
|
|
|
|
#define SOME_PID 42
|
|
|
|
static int prog_has_started = 0;
|
|
|
|
#define r_ofs(x) (offsetof(TSS,x))
|
|
|
|
static struct
|
|
{
|
|
size_t tss_ofs;
|
|
size_t size;
|
|
}
|
|
regno_mapping[] =
|
|
{
|
|
{r_ofs (tss_eax), 4}, /* normal registers, from a_tss */
|
|
{r_ofs (tss_ecx), 4},
|
|
{r_ofs (tss_edx), 4},
|
|
{r_ofs (tss_ebx), 4},
|
|
{r_ofs (tss_esp), 4},
|
|
{r_ofs (tss_ebp), 4},
|
|
{r_ofs (tss_esi), 4},
|
|
{r_ofs (tss_edi), 4},
|
|
{r_ofs (tss_eip), 4},
|
|
{r_ofs (tss_eflags), 4},
|
|
{r_ofs (tss_cs), 2},
|
|
{r_ofs (tss_ss), 2},
|
|
{r_ofs (tss_ds), 2},
|
|
{r_ofs (tss_es), 2},
|
|
{r_ofs (tss_fs), 2},
|
|
{r_ofs (tss_gs), 2},
|
|
{0, 10}, /* 8 FP registers, from npx.reg[] */
|
|
{1, 10},
|
|
{2, 10},
|
|
{3, 10},
|
|
{4, 10},
|
|
{5, 10},
|
|
{6, 10},
|
|
{7, 10},
|
|
/* The order of the next 7 registers must be consistent
|
|
with their numbering in config/i386/tm-i386.h, which see. */
|
|
{0, 2}, /* control word, from npx */
|
|
{4, 2}, /* status word, from npx */
|
|
{8, 2}, /* tag word, from npx */
|
|
{16, 2}, /* last FP exception CS from npx */
|
|
{12, 4}, /* last FP exception EIP from npx */
|
|
{24, 2}, /* last FP exception operand selector from npx */
|
|
{20, 4}, /* last FP exception operand offset from npx */
|
|
{18, 2} /* last FP opcode from npx */
|
|
};
|
|
|
|
static struct
|
|
{
|
|
int go32_sig;
|
|
enum gdb_signal gdb_sig;
|
|
}
|
|
sig_map[] =
|
|
{
|
|
{0, GDB_SIGNAL_FPE},
|
|
{1, GDB_SIGNAL_TRAP},
|
|
/* Exception 2 is triggered by the NMI. DJGPP handles it as SIGILL,
|
|
but I think SIGBUS is better, since the NMI is usually activated
|
|
as a result of a memory parity check failure. */
|
|
{2, GDB_SIGNAL_BUS},
|
|
{3, GDB_SIGNAL_TRAP},
|
|
{4, GDB_SIGNAL_FPE},
|
|
{5, GDB_SIGNAL_SEGV},
|
|
{6, GDB_SIGNAL_ILL},
|
|
{7, GDB_SIGNAL_EMT}, /* no-coprocessor exception */
|
|
{8, GDB_SIGNAL_SEGV},
|
|
{9, GDB_SIGNAL_SEGV},
|
|
{10, GDB_SIGNAL_BUS},
|
|
{11, GDB_SIGNAL_SEGV},
|
|
{12, GDB_SIGNAL_SEGV},
|
|
{13, GDB_SIGNAL_SEGV},
|
|
{14, GDB_SIGNAL_SEGV},
|
|
{16, GDB_SIGNAL_FPE},
|
|
{17, GDB_SIGNAL_BUS},
|
|
{31, GDB_SIGNAL_ILL},
|
|
{0x1b, GDB_SIGNAL_INT},
|
|
{0x75, GDB_SIGNAL_FPE},
|
|
{0x78, GDB_SIGNAL_ALRM},
|
|
{0x79, GDB_SIGNAL_INT},
|
|
{0x7a, GDB_SIGNAL_QUIT},
|
|
{-1, GDB_SIGNAL_LAST}
|
|
};
|
|
|
|
static struct {
|
|
enum gdb_signal gdb_sig;
|
|
int djgpp_excepno;
|
|
} excepn_map[] = {
|
|
{GDB_SIGNAL_0, -1},
|
|
{GDB_SIGNAL_ILL, 6}, /* Invalid Opcode */
|
|
{GDB_SIGNAL_EMT, 7}, /* triggers SIGNOFP */
|
|
{GDB_SIGNAL_SEGV, 13}, /* GPF */
|
|
{GDB_SIGNAL_BUS, 17}, /* Alignment Check */
|
|
/* The rest are fake exceptions, see dpmiexcp.c in djlsr*.zip for
|
|
details. */
|
|
{GDB_SIGNAL_TERM, 0x1b}, /* triggers Ctrl-Break type of SIGINT */
|
|
{GDB_SIGNAL_FPE, 0x75},
|
|
{GDB_SIGNAL_INT, 0x79},
|
|
{GDB_SIGNAL_QUIT, 0x7a},
|
|
{GDB_SIGNAL_ALRM, 0x78}, /* triggers SIGTIMR */
|
|
{GDB_SIGNAL_PROF, 0x78},
|
|
{GDB_SIGNAL_LAST, -1}
|
|
};
|
|
|
|
/* The go32 target. */
|
|
|
|
struct go32_nat_target final : public x86_nat_target<inf_child_target>
|
|
{
|
|
void attach (const char *, int) override;
|
|
|
|
void resume (ptid_t, int, enum gdb_signal) override;
|
|
|
|
ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
|
|
|
|
void fetch_registers (struct regcache *, int) override;
|
|
void store_registers (struct regcache *, int) override;
|
|
|
|
enum target_xfer_status xfer_partial (enum target_object object,
|
|
const char *annex,
|
|
gdb_byte *readbuf,
|
|
const gdb_byte *writebuf,
|
|
ULONGEST offset, ULONGEST len,
|
|
ULONGEST *xfered_len) override;
|
|
|
|
void files_info () override;
|
|
|
|
void terminal_init () override;
|
|
|
|
void terminal_inferior () override;
|
|
|
|
void terminal_ours_for_output () override;
|
|
|
|
void terminal_ours () override;
|
|
|
|
void terminal_info (const char *, int) override;
|
|
|
|
void pass_ctrlc () override;
|
|
|
|
void kill () override;
|
|
|
|
void create_inferior (const char *, const std::string &,
|
|
char **, int) override;
|
|
|
|
void mourn_inferior () override;
|
|
|
|
int thread_alive (ptid_t ptid) override;
|
|
|
|
const char *pid_to_str (ptid_t) override;
|
|
};
|
|
|
|
static go32_nat_target the_go32_nat_target;
|
|
|
|
void
|
|
go32_nat_target::attach (const char *args, int from_tty)
|
|
{
|
|
error (_("\
|
|
You cannot attach to a running program on this platform.\n\
|
|
Use the `run' command to run DJGPP programs."));
|
|
}
|
|
|
|
static int resume_is_step;
|
|
static int resume_signal = -1;
|
|
|
|
void
|
|
go32_nat_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal)
|
|
{
|
|
int i;
|
|
|
|
resume_is_step = step;
|
|
|
|
if (siggnal != GDB_SIGNAL_0 && siggnal != GDB_SIGNAL_TRAP)
|
|
{
|
|
for (i = 0, resume_signal = -1;
|
|
excepn_map[i].gdb_sig != GDB_SIGNAL_LAST; i++)
|
|
if (excepn_map[i].gdb_sig == siggnal)
|
|
{
|
|
resume_signal = excepn_map[i].djgpp_excepno;
|
|
break;
|
|
}
|
|
if (resume_signal == -1)
|
|
printf_unfiltered ("Cannot deliver signal %s on this platform.\n",
|
|
gdb_signal_to_name (siggnal));
|
|
}
|
|
}
|
|
|
|
static char child_cwd[FILENAME_MAX];
|
|
|
|
ptid_t
|
|
go32_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,
|
|
int options)
|
|
{
|
|
int i;
|
|
unsigned char saved_opcode;
|
|
unsigned long INT3_addr = 0;
|
|
int stepping_over_INT = 0;
|
|
|
|
a_tss.tss_eflags &= 0xfeff; /* Reset the single-step flag (TF). */
|
|
if (resume_is_step)
|
|
{
|
|
/* If the next instruction is INT xx or INTO, we need to handle
|
|
them specially. Intel manuals say that these instructions
|
|
reset the single-step flag (a.k.a. TF). However, it seems
|
|
that, at least in the DPMI environment, and at least when
|
|
stepping over the DPMI interrupt 31h, the problem is having
|
|
TF set at all when INT 31h is executed: the debuggee either
|
|
crashes (and takes the system with it) or is killed by a
|
|
SIGTRAP.
|
|
|
|
So we need to emulate single-step mode: we put an INT3 opcode
|
|
right after the INT xx instruction, let the debuggee run
|
|
until it hits INT3 and stops, then restore the original
|
|
instruction which we overwrote with the INT3 opcode, and back
|
|
up the debuggee's EIP to that instruction. */
|
|
read_child (a_tss.tss_eip, &saved_opcode, 1);
|
|
if (saved_opcode == 0xCD || saved_opcode == 0xCE)
|
|
{
|
|
unsigned char INT3_opcode = 0xCC;
|
|
|
|
INT3_addr
|
|
= saved_opcode == 0xCD ? a_tss.tss_eip + 2 : a_tss.tss_eip + 1;
|
|
stepping_over_INT = 1;
|
|
read_child (INT3_addr, &saved_opcode, 1);
|
|
write_child (INT3_addr, &INT3_opcode, 1);
|
|
}
|
|
else
|
|
a_tss.tss_eflags |= 0x0100; /* normal instruction: set TF */
|
|
}
|
|
|
|
/* The special value FFFFh in tss_trap indicates to run_child that
|
|
tss_irqn holds a signal to be delivered to the debuggee. */
|
|
if (resume_signal <= -1)
|
|
{
|
|
a_tss.tss_trap = 0;
|
|
a_tss.tss_irqn = 0xff;
|
|
}
|
|
else
|
|
{
|
|
a_tss.tss_trap = 0xffff; /* run_child looks for this. */
|
|
a_tss.tss_irqn = resume_signal;
|
|
}
|
|
|
|
/* The child might change working directory behind our back. The
|
|
GDB users won't like the side effects of that when they work with
|
|
relative file names, and GDB might be confused by its current
|
|
directory not being in sync with the truth. So we always make a
|
|
point of changing back to where GDB thinks is its cwd, when we
|
|
return control to the debugger, but restore child's cwd before we
|
|
run it. */
|
|
/* Initialize child_cwd, before the first call to run_child and not
|
|
in the initialization, so the child get also the changed directory
|
|
set with the gdb-command "cd ..." */
|
|
if (!*child_cwd)
|
|
/* Initialize child's cwd with the current one. */
|
|
getcwd (child_cwd, sizeof (child_cwd));
|
|
|
|
chdir (child_cwd);
|
|
|
|
#if __DJGPP_MINOR__ < 3
|
|
load_npx ();
|
|
#endif
|
|
run_child ();
|
|
#if __DJGPP_MINOR__ < 3
|
|
save_npx ();
|
|
#endif
|
|
|
|
/* Did we step over an INT xx instruction? */
|
|
if (stepping_over_INT && a_tss.tss_eip == INT3_addr + 1)
|
|
{
|
|
/* Restore the original opcode. */
|
|
a_tss.tss_eip--; /* EIP points *after* the INT3 instruction. */
|
|
write_child (a_tss.tss_eip, &saved_opcode, 1);
|
|
/* Simulate a TRAP exception. */
|
|
a_tss.tss_irqn = 1;
|
|
a_tss.tss_eflags |= 0x0100;
|
|
}
|
|
|
|
getcwd (child_cwd, sizeof (child_cwd)); /* in case it has changed */
|
|
chdir (current_directory);
|
|
|
|
if (a_tss.tss_irqn == 0x21)
|
|
{
|
|
status->kind = TARGET_WAITKIND_EXITED;
|
|
status->value.integer = a_tss.tss_eax & 0xff;
|
|
}
|
|
else
|
|
{
|
|
status->value.sig = GDB_SIGNAL_UNKNOWN;
|
|
status->kind = TARGET_WAITKIND_STOPPED;
|
|
for (i = 0; sig_map[i].go32_sig != -1; i++)
|
|
{
|
|
if (a_tss.tss_irqn == sig_map[i].go32_sig)
|
|
{
|
|
#if __DJGPP_MINOR__ < 3
|
|
if ((status->value.sig = sig_map[i].gdb_sig) !=
|
|
GDB_SIGNAL_TRAP)
|
|
status->kind = TARGET_WAITKIND_SIGNALLED;
|
|
#else
|
|
status->value.sig = sig_map[i].gdb_sig;
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return pid_to_ptid (SOME_PID);
|
|
}
|
|
|
|
static void
|
|
fetch_register (struct regcache *regcache, int regno)
|
|
{
|
|
struct gdbarch *gdbarch = regcache->arch ();
|
|
if (regno < gdbarch_fp0_regnum (gdbarch))
|
|
regcache_raw_supply (regcache, regno,
|
|
(char *) &a_tss + regno_mapping[regno].tss_ofs);
|
|
else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch,
|
|
regno))
|
|
i387_supply_fsave (regcache, regno, &npx);
|
|
else
|
|
internal_error (__FILE__, __LINE__,
|
|
_("Invalid register no. %d in fetch_register."), regno);
|
|
}
|
|
|
|
void
|
|
go32_nat_target::fetch_registers (struct regcache *regcache, int regno)
|
|
{
|
|
if (regno >= 0)
|
|
fetch_register (regcache, regno);
|
|
else
|
|
{
|
|
for (regno = 0;
|
|
regno < gdbarch_fp0_regnum (regcache->arch ());
|
|
regno++)
|
|
fetch_register (regcache, regno);
|
|
i387_supply_fsave (regcache, -1, &npx);
|
|
}
|
|
}
|
|
|
|
static void
|
|
store_register (const struct regcache *regcache, int regno)
|
|
{
|
|
struct gdbarch *gdbarch = regcache->arch ();
|
|
if (regno < gdbarch_fp0_regnum (gdbarch))
|
|
regcache_raw_collect (regcache, regno,
|
|
(char *) &a_tss + regno_mapping[regno].tss_ofs);
|
|
else if (i386_fp_regnum_p (gdbarch, regno) || i386_fpc_regnum_p (gdbarch,
|
|
regno))
|
|
i387_collect_fsave (regcache, regno, &npx);
|
|
else
|
|
internal_error (__FILE__, __LINE__,
|
|
_("Invalid register no. %d in store_register."), regno);
|
|
}
|
|
|
|
void
|
|
go32_nat_target::store_registers (struct regcache *regcache, int regno)
|
|
{
|
|
unsigned r;
|
|
|
|
if (regno >= 0)
|
|
store_register (regcache, regno);
|
|
else
|
|
{
|
|
for (r = 0; r < gdbarch_fp0_regnum (regcache->arch ()); r++)
|
|
store_register (regcache, r);
|
|
i387_collect_fsave (regcache, -1, &npx);
|
|
}
|
|
}
|
|
|
|
/* Const-correct version of DJGPP's write_child, which unfortunately
|
|
takes a non-const buffer pointer. */
|
|
|
|
static int
|
|
my_write_child (unsigned child_addr, const void *buf, unsigned len)
|
|
{
|
|
static void *buffer = NULL;
|
|
static unsigned buffer_len = 0;
|
|
int res;
|
|
|
|
if (buffer_len < len)
|
|
{
|
|
buffer = xrealloc (buffer, len);
|
|
buffer_len = len;
|
|
}
|
|
|
|
memcpy (buffer, buf, len);
|
|
res = write_child (child_addr, buffer, len);
|
|
return res;
|
|
}
|
|
|
|
/* Helper for go32_xfer_partial that handles memory transfers.
|
|
Arguments are like target_xfer_partial. */
|
|
|
|
static enum target_xfer_status
|
|
go32_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
|
|
ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
|
|
{
|
|
int res;
|
|
|
|
if (writebuf != NULL)
|
|
res = my_write_child (memaddr, writebuf, len);
|
|
else
|
|
res = read_child (memaddr, readbuf, len);
|
|
|
|
/* read_child and write_child return zero on success, non-zero on
|
|
failure. */
|
|
if (res != 0)
|
|
return TARGET_XFER_E_IO;
|
|
|
|
*xfered_len = len;
|
|
return TARGET_XFER_OK;
|
|
}
|
|
|
|
/* Target to_xfer_partial implementation. */
|
|
|
|
enum target_xfer_status
|
|
go32_nat_target::xfer_partial (enum target_object object,
|
|
const char *annex, gdb_byte *readbuf,
|
|
const gdb_byte *writebuf, ULONGEST offset,
|
|
ULONGEST len,
|
|
ULONGEST *xfered_len)
|
|
{
|
|
switch (object)
|
|
{
|
|
case TARGET_OBJECT_MEMORY:
|
|
return go32_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
|
|
|
|
default:
|
|
return this->beneath->xfer_partial (object, annex,
|
|
readbuf, writebuf, offset, len,
|
|
xfered_len);
|
|
}
|
|
}
|
|
|
|
static cmdline_t child_cmd; /* Parsed child's command line kept here. */
|
|
|
|
void
|
|
go32_nat_target::files_info ()
|
|
{
|
|
printf_unfiltered ("You are running a DJGPP V2 program.\n");
|
|
}
|
|
|
|
void
|
|
go32_nat_target::kill_inferior ()
|
|
{
|
|
mourn_inferior ();
|
|
}
|
|
|
|
void
|
|
go32_nat_target::create_inferior (const char *exec_file,
|
|
const std::string &allargs,
|
|
char **env, int from_tty)
|
|
{
|
|
extern char **environ;
|
|
jmp_buf start_state;
|
|
char *cmdline;
|
|
char **env_save = environ;
|
|
size_t cmdlen;
|
|
struct inferior *inf;
|
|
int result;
|
|
const char *args = allargs.c_str ();
|
|
|
|
/* If no exec file handed to us, get it from the exec-file command -- with
|
|
a good, common error message if none is specified. */
|
|
if (exec_file == 0)
|
|
exec_file = get_exec_file (1);
|
|
|
|
resume_signal = -1;
|
|
resume_is_step = 0;
|
|
|
|
/* Initialize child's cwd as empty to be initialized when starting
|
|
the child. */
|
|
*child_cwd = 0;
|
|
|
|
/* Init command line storage. */
|
|
if (redir_debug_init (&child_cmd) == -1)
|
|
internal_error (__FILE__, __LINE__,
|
|
_("Cannot allocate redirection storage: "
|
|
"not enough memory.\n"));
|
|
|
|
/* Parse the command line and create redirections. */
|
|
if (strpbrk (args, "<>"))
|
|
{
|
|
if (redir_cmdline_parse (args, &child_cmd) == 0)
|
|
args = child_cmd.command;
|
|
else
|
|
error (_("Syntax error in command line."));
|
|
}
|
|
else
|
|
child_cmd.command = xstrdup (args);
|
|
|
|
cmdlen = strlen (args);
|
|
/* v2loadimage passes command lines via DOS memory, so it cannot
|
|
possibly handle commands longer than 1MB. */
|
|
if (cmdlen > 1024*1024)
|
|
error (_("Command line too long."));
|
|
|
|
cmdline = (char *) xmalloc (cmdlen + 4);
|
|
strcpy (cmdline + 1, args);
|
|
/* If the command-line length fits into DOS 126-char limits, use the
|
|
DOS command tail format; otherwise, tell v2loadimage to pass it
|
|
through a buffer in conventional memory. */
|
|
if (cmdlen < 127)
|
|
{
|
|
cmdline[0] = strlen (args);
|
|
cmdline[cmdlen + 1] = 13;
|
|
}
|
|
else
|
|
cmdline[0] = 0xff; /* Signal v2loadimage it's a long command. */
|
|
|
|
environ = env;
|
|
|
|
result = v2loadimage (exec_file, cmdline, start_state);
|
|
|
|
environ = env_save;
|
|
xfree (cmdline);
|
|
|
|
if (result != 0)
|
|
error (_("Load failed for image %s"), exec_file);
|
|
|
|
edi_init (start_state);
|
|
#if __DJGPP_MINOR__ < 3
|
|
save_npx ();
|
|
#endif
|
|
|
|
inferior_ptid = pid_to_ptid (SOME_PID);
|
|
inf = current_inferior ();
|
|
inferior_appeared (inf, SOME_PID);
|
|
|
|
if (!target_is_pushed (this))
|
|
push_target (this);
|
|
|
|
add_thread_silent (inferior_ptid);
|
|
|
|
clear_proceed_status (0);
|
|
insert_breakpoints ();
|
|
prog_has_started = 1;
|
|
}
|
|
|
|
void
|
|
go32_nat_target::mourn_inferior ()
|
|
{
|
|
ptid_t ptid;
|
|
|
|
redir_cmdline_delete (&child_cmd);
|
|
resume_signal = -1;
|
|
resume_is_step = 0;
|
|
|
|
cleanup_client ();
|
|
|
|
/* We need to make sure all the breakpoint enable bits in the DR7
|
|
register are reset when the inferior exits. Otherwise, if they
|
|
rerun the inferior, the uncleared bits may cause random SIGTRAPs,
|
|
failure to set more watchpoints, and other calamities. It would
|
|
be nice if GDB itself would take care to remove all breakpoints
|
|
at all times, but it doesn't, probably under an assumption that
|
|
the OS cleans up when the debuggee exits. */
|
|
x86_cleanup_dregs ();
|
|
|
|
ptid = inferior_ptid;
|
|
inferior_ptid = null_ptid;
|
|
delete_thread_silent (ptid);
|
|
prog_has_started = 0;
|
|
|
|
generic_mourn_inferior ();
|
|
maybe_unpush_target ();
|
|
}
|
|
|
|
/* Hardware watchpoint support. */
|
|
|
|
#define D_REGS edi.dr
|
|
#define CONTROL D_REGS[7]
|
|
#define STATUS D_REGS[6]
|
|
|
|
/* Pass the address ADDR to the inferior in the I'th debug register.
|
|
Here we just store the address in D_REGS, the watchpoint will be
|
|
actually set up when go32_wait runs the debuggee. */
|
|
static void
|
|
go32_set_dr (int i, CORE_ADDR addr)
|
|
{
|
|
if (i < 0 || i > 3)
|
|
internal_error (__FILE__, __LINE__,
|
|
_("Invalid register %d in go32_set_dr.\n"), i);
|
|
D_REGS[i] = addr;
|
|
}
|
|
|
|
/* Pass the value VAL to the inferior in the DR7 debug control
|
|
register. Here we just store the address in D_REGS, the watchpoint
|
|
will be actually set up when go32_wait runs the debuggee. */
|
|
static void
|
|
go32_set_dr7 (unsigned long val)
|
|
{
|
|
CONTROL = val;
|
|
}
|
|
|
|
/* Get the value of the DR6 debug status register from the inferior.
|
|
Here we just return the value stored in D_REGS, as we've got it
|
|
from the last go32_wait call. */
|
|
static unsigned long
|
|
go32_get_dr6 (void)
|
|
{
|
|
return STATUS;
|
|
}
|
|
|
|
/* Get the value of the DR7 debug status register from the inferior.
|
|
Here we just return the value stored in D_REGS, as we've got it
|
|
from the last go32_wait call. */
|
|
|
|
static unsigned long
|
|
go32_get_dr7 (void)
|
|
{
|
|
return CONTROL;
|
|
}
|
|
|
|
/* Get the value of the DR debug register I from the inferior. Here
|
|
we just return the value stored in D_REGS, as we've got it from the
|
|
last go32_wait call. */
|
|
|
|
static CORE_ADDR
|
|
go32_get_dr (int i)
|
|
{
|
|
if (i < 0 || i > 3)
|
|
internal_error (__FILE__, __LINE__,
|
|
_("Invalid register %d in go32_get_dr.\n"), i);
|
|
return D_REGS[i];
|
|
}
|
|
|
|
/* Put the device open on handle FD into either raw or cooked
|
|
mode, return 1 if it was in raw mode, zero otherwise. */
|
|
|
|
static int
|
|
device_mode (int fd, int raw_p)
|
|
{
|
|
int oldmode, newmode;
|
|
__dpmi_regs regs;
|
|
|
|
regs.x.ax = 0x4400;
|
|
regs.x.bx = fd;
|
|
__dpmi_int (0x21, ®s);
|
|
if (regs.x.flags & 1)
|
|
return -1;
|
|
newmode = oldmode = regs.x.dx;
|
|
|
|
if (raw_p)
|
|
newmode |= 0x20;
|
|
else
|
|
newmode &= ~0x20;
|
|
|
|
if (oldmode & 0x80) /* Only for character dev. */
|
|
{
|
|
regs.x.ax = 0x4401;
|
|
regs.x.bx = fd;
|
|
regs.x.dx = newmode & 0xff; /* Force upper byte zero, else it fails. */
|
|
__dpmi_int (0x21, ®s);
|
|
if (regs.x.flags & 1)
|
|
return -1;
|
|
}
|
|
return (oldmode & 0x20) == 0x20;
|
|
}
|
|
|
|
|
|
static int inf_mode_valid = 0;
|
|
static int inf_terminal_mode;
|
|
|
|
/* This semaphore is needed because, amazingly enough, GDB calls
|
|
target.to_terminal_ours more than once after the inferior stops.
|
|
But we need the information from the first call only, since the
|
|
second call will always see GDB's own cooked terminal. */
|
|
static int terminal_is_ours = 1;
|
|
|
|
void
|
|
go32_nat_target::terminal_init ()
|
|
{
|
|
inf_mode_valid = 0; /* Reinitialize, in case they are restarting child. */
|
|
terminal_is_ours = 1;
|
|
}
|
|
|
|
void
|
|
go32_nat_target::terminal_info (const char *args, int from_tty)
|
|
{
|
|
printf_unfiltered ("Inferior's terminal is in %s mode.\n",
|
|
!inf_mode_valid
|
|
? "default" : inf_terminal_mode ? "raw" : "cooked");
|
|
|
|
#if __DJGPP_MINOR__ > 2
|
|
if (child_cmd.redirection)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < DBG_HANDLES; i++)
|
|
{
|
|
if (child_cmd.redirection[i]->file_name)
|
|
printf_unfiltered ("\tFile handle %d is redirected to `%s'.\n",
|
|
i, child_cmd.redirection[i]->file_name);
|
|
else if (_get_dev_info (child_cmd.redirection[i]->inf_handle) == -1)
|
|
printf_unfiltered
|
|
("\tFile handle %d appears to be closed by inferior.\n", i);
|
|
/* Mask off the raw/cooked bit when comparing device info words. */
|
|
else if ((_get_dev_info (child_cmd.redirection[i]->inf_handle) & 0xdf)
|
|
!= (_get_dev_info (i) & 0xdf))
|
|
printf_unfiltered
|
|
("\tFile handle %d appears to be redirected by inferior.\n", i);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void
|
|
go32_nat_target::terminal_inferior ()
|
|
{
|
|
/* Redirect standard handles as child wants them. */
|
|
errno = 0;
|
|
if (redir_to_child (&child_cmd) == -1)
|
|
{
|
|
redir_to_debugger (&child_cmd);
|
|
error (_("Cannot redirect standard handles for program: %s."),
|
|
safe_strerror (errno));
|
|
}
|
|
/* Set the console device of the inferior to whatever mode
|
|
(raw or cooked) we found it last time. */
|
|
if (terminal_is_ours)
|
|
{
|
|
if (inf_mode_valid)
|
|
device_mode (0, inf_terminal_mode);
|
|
terminal_is_ours = 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
go32_nat_target::terminal_ours ()
|
|
{
|
|
/* Switch to cooked mode on the gdb terminal and save the inferior
|
|
terminal mode to be restored when it is resumed. */
|
|
if (!terminal_is_ours)
|
|
{
|
|
inf_terminal_mode = device_mode (0, 0);
|
|
if (inf_terminal_mode != -1)
|
|
inf_mode_valid = 1;
|
|
else
|
|
/* If device_mode returned -1, we don't know what happens with
|
|
handle 0 anymore, so make the info invalid. */
|
|
inf_mode_valid = 0;
|
|
terminal_is_ours = 1;
|
|
|
|
/* Restore debugger's standard handles. */
|
|
errno = 0;
|
|
if (redir_to_debugger (&child_cmd) == -1)
|
|
{
|
|
redir_to_child (&child_cmd);
|
|
error (_("Cannot redirect standard handles for debugger: %s."),
|
|
safe_strerror (errno));
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
go32_nat_target::pass_ctrlc ()
|
|
{
|
|
}
|
|
|
|
int
|
|
go32_nat_target::thread_alive (ptid_t ptid)
|
|
{
|
|
return !ptid_equal (ptid, null_ptid);
|
|
}
|
|
|
|
const char *
|
|
go32_nat_target::pid_to_str (ptid_t ptid)
|
|
{
|
|
return normal_pid_to_str (ptid);
|
|
}
|
|
|
|
/* Return the current DOS codepage number. */
|
|
static int
|
|
dos_codepage (void)
|
|
{
|
|
__dpmi_regs regs;
|
|
|
|
regs.x.ax = 0x6601;
|
|
__dpmi_int (0x21, ®s);
|
|
if (!(regs.x.flags & 1))
|
|
return regs.x.bx & 0xffff;
|
|
else
|
|
return 437; /* default */
|
|
}
|
|
|
|
/* Limited emulation of `nl_langinfo', for charset.c. */
|
|
char *
|
|
nl_langinfo (nl_item item)
|
|
{
|
|
char *retval;
|
|
|
|
switch (item)
|
|
{
|
|
case CODESET:
|
|
{
|
|
/* 8 is enough for SHORT_MAX + "CP" + null. */
|
|
char buf[8];
|
|
int blen = sizeof (buf);
|
|
int needed = snprintf (buf, blen, "CP%d", dos_codepage ());
|
|
|
|
if (needed > blen) /* Should never happen. */
|
|
buf[0] = 0;
|
|
retval = xstrdup (buf);
|
|
}
|
|
break;
|
|
default:
|
|
retval = xstrdup ("");
|
|
break;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
unsigned short windows_major, windows_minor;
|
|
|
|
/* Compute the version Windows reports via Int 2Fh/AX=1600h. */
|
|
static void
|
|
go32_get_windows_version(void)
|
|
{
|
|
__dpmi_regs r;
|
|
|
|
r.x.ax = 0x1600;
|
|
__dpmi_int(0x2f, &r);
|
|
if (r.h.al > 2 && r.h.al != 0x80 && r.h.al != 0xff
|
|
&& (r.h.al > 3 || r.h.ah > 0))
|
|
{
|
|
windows_major = r.h.al;
|
|
windows_minor = r.h.ah;
|
|
}
|
|
else
|
|
windows_major = 0xff; /* meaning no Windows */
|
|
}
|
|
|
|
/* A subroutine of go32_sysinfo to display memory info. */
|
|
static void
|
|
print_mem (unsigned long datum, const char *header, int in_pages_p)
|
|
{
|
|
if (datum != 0xffffffffUL)
|
|
{
|
|
if (in_pages_p)
|
|
datum <<= 12;
|
|
puts_filtered (header);
|
|
if (datum > 1024)
|
|
{
|
|
printf_filtered ("%lu KB", datum >> 10);
|
|
if (datum > 1024 * 1024)
|
|
printf_filtered (" (%lu MB)", datum >> 20);
|
|
}
|
|
else
|
|
printf_filtered ("%lu Bytes", datum);
|
|
puts_filtered ("\n");
|
|
}
|
|
}
|
|
|
|
/* Display assorted information about the underlying OS. */
|
|
static void
|
|
go32_sysinfo (const char *arg, int from_tty)
|
|
{
|
|
static const char test_pattern[] =
|
|
"deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
|
|
"deadbeafdeadbeafdeadbeafdeadbeafdeadbeaf"
|
|
"deadbeafdeadbeafdeadbeafdeadbeafdeadbeafdeadbeaf";
|
|
struct utsname u;
|
|
char cpuid_vendor[13];
|
|
unsigned cpuid_max = 0, cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
|
|
unsigned true_dos_version = _get_dos_version (1);
|
|
unsigned advertized_dos_version = ((unsigned int)_osmajor << 8) | _osminor;
|
|
int dpmi_flags;
|
|
char dpmi_vendor_info[129];
|
|
int dpmi_vendor_available;
|
|
__dpmi_version_ret dpmi_version_data;
|
|
long eflags;
|
|
__dpmi_free_mem_info mem_info;
|
|
__dpmi_regs regs;
|
|
|
|
cpuid_vendor[0] = '\0';
|
|
if (uname (&u))
|
|
strcpy (u.machine, "Unknown x86");
|
|
else if (u.machine[0] == 'i' && u.machine[1] > 4)
|
|
{
|
|
/* CPUID with EAX = 0 returns the Vendor ID. */
|
|
#if 0
|
|
/* Ideally we would use x86_cpuid(), but it needs someone to run
|
|
native tests first to make sure things actually work. They should.
|
|
http://sourceware.org/ml/gdb-patches/2013-05/msg00164.html */
|
|
unsigned int eax, ebx, ecx, edx;
|
|
|
|
if (x86_cpuid (0, &eax, &ebx, &ecx, &edx))
|
|
{
|
|
cpuid_max = eax;
|
|
memcpy (&vendor[0], &ebx, 4);
|
|
memcpy (&vendor[4], &ecx, 4);
|
|
memcpy (&vendor[8], &edx, 4);
|
|
cpuid_vendor[12] = '\0';
|
|
}
|
|
#else
|
|
__asm__ __volatile__ ("xorl %%ebx, %%ebx;"
|
|
"xorl %%ecx, %%ecx;"
|
|
"xorl %%edx, %%edx;"
|
|
"movl $0, %%eax;"
|
|
"cpuid;"
|
|
"movl %%ebx, %0;"
|
|
"movl %%edx, %1;"
|
|
"movl %%ecx, %2;"
|
|
"movl %%eax, %3;"
|
|
: "=m" (cpuid_vendor[0]),
|
|
"=m" (cpuid_vendor[4]),
|
|
"=m" (cpuid_vendor[8]),
|
|
"=m" (cpuid_max)
|
|
:
|
|
: "%eax", "%ebx", "%ecx", "%edx");
|
|
cpuid_vendor[12] = '\0';
|
|
#endif
|
|
}
|
|
|
|
printf_filtered ("CPU Type.......................%s", u.machine);
|
|
if (cpuid_vendor[0])
|
|
printf_filtered (" (%s)", cpuid_vendor);
|
|
puts_filtered ("\n");
|
|
|
|
/* CPUID with EAX = 1 returns processor signature and features. */
|
|
if (cpuid_max >= 1)
|
|
{
|
|
static const char *brand_name[] = {
|
|
"",
|
|
" Celeron",
|
|
" III",
|
|
" III Xeon",
|
|
"", "", "", "",
|
|
" 4"
|
|
};
|
|
char cpu_string[80];
|
|
char cpu_brand[20];
|
|
unsigned brand_idx;
|
|
int intel_p = strcmp (cpuid_vendor, "GenuineIntel") == 0;
|
|
int amd_p = strcmp (cpuid_vendor, "AuthenticAMD") == 0;
|
|
unsigned cpu_family, cpu_model;
|
|
|
|
#if 0
|
|
/* See comment above about cpuid usage. */
|
|
x86_cpuid (1, &cpuid_eax, &cpuid_ebx, NULL, &cpuid_edx);
|
|
#else
|
|
__asm__ __volatile__ ("movl $1, %%eax;"
|
|
"cpuid;"
|
|
: "=a" (cpuid_eax),
|
|
"=b" (cpuid_ebx),
|
|
"=d" (cpuid_edx)
|
|
:
|
|
: "%ecx");
|
|
#endif
|
|
brand_idx = cpuid_ebx & 0xff;
|
|
cpu_family = (cpuid_eax >> 8) & 0xf;
|
|
cpu_model = (cpuid_eax >> 4) & 0xf;
|
|
cpu_brand[0] = '\0';
|
|
if (intel_p)
|
|
{
|
|
if (brand_idx > 0
|
|
&& brand_idx < sizeof(brand_name)/sizeof(brand_name[0])
|
|
&& *brand_name[brand_idx])
|
|
strcpy (cpu_brand, brand_name[brand_idx]);
|
|
else if (cpu_family == 5)
|
|
{
|
|
if (((cpuid_eax >> 12) & 3) == 0 && cpu_model == 4)
|
|
strcpy (cpu_brand, " MMX");
|
|
else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 1)
|
|
strcpy (cpu_brand, " OverDrive");
|
|
else if (cpu_model > 1 && ((cpuid_eax >> 12) & 3) == 2)
|
|
strcpy (cpu_brand, " Dual");
|
|
}
|
|
else if (cpu_family == 6 && cpu_model < 8)
|
|
{
|
|
switch (cpu_model)
|
|
{
|
|
case 1:
|
|
strcpy (cpu_brand, " Pro");
|
|
break;
|
|
case 3:
|
|
strcpy (cpu_brand, " II");
|
|
break;
|
|
case 5:
|
|
strcpy (cpu_brand, " II Xeon");
|
|
break;
|
|
case 6:
|
|
strcpy (cpu_brand, " Celeron");
|
|
break;
|
|
case 7:
|
|
strcpy (cpu_brand, " III");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (amd_p)
|
|
{
|
|
switch (cpu_family)
|
|
{
|
|
case 4:
|
|
strcpy (cpu_brand, "486/5x86");
|
|
break;
|
|
case 5:
|
|
switch (cpu_model)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
strcpy (cpu_brand, "-K5");
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
strcpy (cpu_brand, "-K6");
|
|
break;
|
|
case 8:
|
|
strcpy (cpu_brand, "-K6-2");
|
|
break;
|
|
case 9:
|
|
strcpy (cpu_brand, "-K6-III");
|
|
break;
|
|
}
|
|
break;
|
|
case 6:
|
|
switch (cpu_model)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 4:
|
|
strcpy (cpu_brand, " Athlon");
|
|
break;
|
|
case 3:
|
|
strcpy (cpu_brand, " Duron");
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
xsnprintf (cpu_string, sizeof (cpu_string), "%s%s Model %d Stepping %d",
|
|
intel_p ? "Pentium" : (amd_p ? "AMD" : "ix86"),
|
|
cpu_brand, cpu_model, cpuid_eax & 0xf);
|
|
printfi_filtered (31, "%s\n", cpu_string);
|
|
if (((cpuid_edx & (6 | (0x0d << 23))) != 0)
|
|
|| ((cpuid_edx & 1) == 0)
|
|
|| (amd_p && (cpuid_edx & (3 << 30)) != 0))
|
|
{
|
|
puts_filtered ("CPU Features...................");
|
|
/* We only list features which might be useful in the DPMI
|
|
environment. */
|
|
if ((cpuid_edx & 1) == 0)
|
|
puts_filtered ("No FPU "); /* It's unusual to not have an FPU. */
|
|
if ((cpuid_edx & (1 << 1)) != 0)
|
|
puts_filtered ("VME ");
|
|
if ((cpuid_edx & (1 << 2)) != 0)
|
|
puts_filtered ("DE ");
|
|
if ((cpuid_edx & (1 << 4)) != 0)
|
|
puts_filtered ("TSC ");
|
|
if ((cpuid_edx & (1 << 23)) != 0)
|
|
puts_filtered ("MMX ");
|
|
if ((cpuid_edx & (1 << 25)) != 0)
|
|
puts_filtered ("SSE ");
|
|
if ((cpuid_edx & (1 << 26)) != 0)
|
|
puts_filtered ("SSE2 ");
|
|
if (amd_p)
|
|
{
|
|
if ((cpuid_edx & (1 << 31)) != 0)
|
|
puts_filtered ("3DNow! ");
|
|
if ((cpuid_edx & (1 << 30)) != 0)
|
|
puts_filtered ("3DNow!Ext");
|
|
}
|
|
puts_filtered ("\n");
|
|
}
|
|
}
|
|
puts_filtered ("\n");
|
|
printf_filtered ("DOS Version....................%s %s.%s",
|
|
_os_flavor, u.release, u.version);
|
|
if (true_dos_version != advertized_dos_version)
|
|
printf_filtered (" (disguised as v%d.%d)", _osmajor, _osminor);
|
|
puts_filtered ("\n");
|
|
if (!windows_major)
|
|
go32_get_windows_version ();
|
|
if (windows_major != 0xff)
|
|
{
|
|
const char *windows_flavor;
|
|
|
|
printf_filtered ("Windows Version................%d.%02d (Windows ",
|
|
windows_major, windows_minor);
|
|
switch (windows_major)
|
|
{
|
|
case 3:
|
|
windows_flavor = "3.X";
|
|
break;
|
|
case 4:
|
|
switch (windows_minor)
|
|
{
|
|
case 0:
|
|
windows_flavor = "95, 95A, or 95B";
|
|
break;
|
|
case 3:
|
|
windows_flavor = "95B OSR2.1 or 95C OSR2.5";
|
|
break;
|
|
case 10:
|
|
windows_flavor = "98 or 98 SE";
|
|
break;
|
|
case 90:
|
|
windows_flavor = "ME";
|
|
break;
|
|
default:
|
|
windows_flavor = "9X";
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
windows_flavor = "??";
|
|
break;
|
|
}
|
|
printf_filtered ("%s)\n", windows_flavor);
|
|
}
|
|
else if (true_dos_version == 0x532 && advertized_dos_version == 0x500)
|
|
printf_filtered ("Windows Version................"
|
|
"Windows NT family (W2K/XP/W2K3/Vista/W2K8)\n");
|
|
puts_filtered ("\n");
|
|
/* On some versions of Windows, __dpmi_get_capabilities returns
|
|
zero, but the buffer is not filled with info, so we fill the
|
|
buffer with a known pattern and test for it afterwards. */
|
|
memcpy (dpmi_vendor_info, test_pattern, sizeof(dpmi_vendor_info));
|
|
dpmi_vendor_available =
|
|
__dpmi_get_capabilities (&dpmi_flags, dpmi_vendor_info);
|
|
if (dpmi_vendor_available == 0
|
|
&& memcmp (dpmi_vendor_info, test_pattern,
|
|
sizeof(dpmi_vendor_info)) != 0)
|
|
{
|
|
/* The DPMI spec says the vendor string should be ASCIIZ, but
|
|
I don't trust the vendors to follow that... */
|
|
if (!memchr (&dpmi_vendor_info[2], 0, 126))
|
|
dpmi_vendor_info[128] = '\0';
|
|
printf_filtered ("DPMI Host......................"
|
|
"%s v%d.%d (capabilities: %#x)\n",
|
|
&dpmi_vendor_info[2],
|
|
(unsigned)dpmi_vendor_info[0],
|
|
(unsigned)dpmi_vendor_info[1],
|
|
((unsigned)dpmi_flags & 0x7f));
|
|
}
|
|
else
|
|
printf_filtered ("DPMI Host......................(Info not available)\n");
|
|
__dpmi_get_version (&dpmi_version_data);
|
|
printf_filtered ("DPMI Version...................%d.%02d\n",
|
|
dpmi_version_data.major, dpmi_version_data.minor);
|
|
printf_filtered ("DPMI Info......................"
|
|
"%s-bit DPMI, with%s Virtual Memory support\n",
|
|
(dpmi_version_data.flags & 1) ? "32" : "16",
|
|
(dpmi_version_data.flags & 4) ? "" : "out");
|
|
printfi_filtered (31, "Interrupts reflected to %s mode\n",
|
|
(dpmi_version_data.flags & 2) ? "V86" : "Real");
|
|
printfi_filtered (31, "Processor type: i%d86\n",
|
|
dpmi_version_data.cpu);
|
|
printfi_filtered (31, "PIC base interrupt: Master: %#x Slave: %#x\n",
|
|
dpmi_version_data.master_pic, dpmi_version_data.slave_pic);
|
|
|
|
/* a_tss is only initialized when the debuggee is first run. */
|
|
if (prog_has_started)
|
|
{
|
|
__asm__ __volatile__ ("pushfl ; popl %0" : "=g" (eflags));
|
|
printf_filtered ("Protection....................."
|
|
"Ring %d (in %s), with%s I/O protection\n",
|
|
a_tss.tss_cs & 3, (a_tss.tss_cs & 4) ? "LDT" : "GDT",
|
|
(a_tss.tss_cs & 3) > ((eflags >> 12) & 3) ? "" : "out");
|
|
}
|
|
puts_filtered ("\n");
|
|
__dpmi_get_free_memory_information (&mem_info);
|
|
print_mem (mem_info.total_number_of_physical_pages,
|
|
"DPMI Total Physical Memory.....", 1);
|
|
print_mem (mem_info.total_number_of_free_pages,
|
|
"DPMI Free Physical Memory......", 1);
|
|
print_mem (mem_info.size_of_paging_file_partition_in_pages,
|
|
"DPMI Swap Space................", 1);
|
|
print_mem (mem_info.linear_address_space_size_in_pages,
|
|
"DPMI Total Linear Address Size.", 1);
|
|
print_mem (mem_info.free_linear_address_space_in_pages,
|
|
"DPMI Free Linear Address Size..", 1);
|
|
print_mem (mem_info.largest_available_free_block_in_bytes,
|
|
"DPMI Largest Free Memory Block.", 0);
|
|
|
|
regs.h.ah = 0x48;
|
|
regs.x.bx = 0xffff;
|
|
__dpmi_int (0x21, ®s);
|
|
print_mem (regs.x.bx << 4, "Free DOS Memory................", 0);
|
|
regs.x.ax = 0x5800;
|
|
__dpmi_int (0x21, ®s);
|
|
if ((regs.x.flags & 1) == 0)
|
|
{
|
|
static const char *dos_hilo[] = {
|
|
"Low", "", "", "", "High", "", "", "", "High, then Low"
|
|
};
|
|
static const char *dos_fit[] = {
|
|
"First", "Best", "Last"
|
|
};
|
|
int hilo_idx = (regs.x.ax >> 4) & 0x0f;
|
|
int fit_idx = regs.x.ax & 0x0f;
|
|
|
|
if (hilo_idx > 8)
|
|
hilo_idx = 0;
|
|
if (fit_idx > 2)
|
|
fit_idx = 0;
|
|
printf_filtered ("DOS Memory Allocation..........%s memory, %s fit\n",
|
|
dos_hilo[hilo_idx], dos_fit[fit_idx]);
|
|
regs.x.ax = 0x5802;
|
|
__dpmi_int (0x21, ®s);
|
|
if ((regs.x.flags & 1) != 0)
|
|
regs.h.al = 0;
|
|
printfi_filtered (31, "UMBs %sin DOS memory chain\n",
|
|
regs.h.al == 0 ? "not " : "");
|
|
}
|
|
}
|
|
|
|
struct seg_descr {
|
|
unsigned short limit0;
|
|
unsigned short base0;
|
|
unsigned char base1;
|
|
unsigned stype:5;
|
|
unsigned dpl:2;
|
|
unsigned present:1;
|
|
unsigned limit1:4;
|
|
unsigned available:1;
|
|
unsigned dummy:1;
|
|
unsigned bit32:1;
|
|
unsigned page_granular:1;
|
|
unsigned char base2;
|
|
} __attribute__ ((packed));
|
|
|
|
struct gate_descr {
|
|
unsigned short offset0;
|
|
unsigned short selector;
|
|
unsigned param_count:5;
|
|
unsigned dummy:3;
|
|
unsigned stype:5;
|
|
unsigned dpl:2;
|
|
unsigned present:1;
|
|
unsigned short offset1;
|
|
} __attribute__ ((packed));
|
|
|
|
/* Read LEN bytes starting at logical address ADDR, and put the result
|
|
into DEST. Return 1 if success, zero if not. */
|
|
static int
|
|
read_memory_region (unsigned long addr, void *dest, size_t len)
|
|
{
|
|
unsigned long dos_ds_limit = __dpmi_get_segment_limit (_dos_ds);
|
|
int retval = 1;
|
|
|
|
/* For the low memory, we can simply use _dos_ds. */
|
|
if (addr <= dos_ds_limit - len)
|
|
dosmemget (addr, len, dest);
|
|
else
|
|
{
|
|
/* For memory above 1MB we need to set up a special segment to
|
|
be able to access that memory. */
|
|
int sel = __dpmi_allocate_ldt_descriptors (1);
|
|
|
|
if (sel <= 0)
|
|
retval = 0;
|
|
else
|
|
{
|
|
int access_rights = __dpmi_get_descriptor_access_rights (sel);
|
|
size_t segment_limit = len - 1;
|
|
|
|
/* Make sure the crucial bits in the descriptor access
|
|
rights are set correctly. Some DPMI providers might barf
|
|
if we set the segment limit to something that is not an
|
|
integral multiple of 4KB pages if the granularity bit is
|
|
not set to byte-granular, even though the DPMI spec says
|
|
it's the host's responsibility to set that bit correctly. */
|
|
if (len > 1024 * 1024)
|
|
{
|
|
access_rights |= 0x8000;
|
|
/* Page-granular segments should have the low 12 bits of
|
|
the limit set. */
|
|
segment_limit |= 0xfff;
|
|
}
|
|
else
|
|
access_rights &= ~0x8000;
|
|
|
|
if (__dpmi_set_segment_base_address (sel, addr) != -1
|
|
&& __dpmi_set_descriptor_access_rights (sel, access_rights) != -1
|
|
&& __dpmi_set_segment_limit (sel, segment_limit) != -1
|
|
/* W2K silently fails to set the segment limit, leaving
|
|
it at zero; this test avoids the resulting crash. */
|
|
&& __dpmi_get_segment_limit (sel) >= segment_limit)
|
|
movedata (sel, 0, _my_ds (), (unsigned)dest, len);
|
|
else
|
|
retval = 0;
|
|
|
|
__dpmi_free_ldt_descriptor (sel);
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
/* Get a segment descriptor stored at index IDX in the descriptor
|
|
table whose base address is TABLE_BASE. Return the descriptor
|
|
type, or -1 if failure. */
|
|
static int
|
|
get_descriptor (unsigned long table_base, int idx, void *descr)
|
|
{
|
|
unsigned long addr = table_base + idx * 8; /* 8 bytes per entry */
|
|
|
|
if (read_memory_region (addr, descr, 8))
|
|
return (int)((struct seg_descr *)descr)->stype;
|
|
return -1;
|
|
}
|
|
|
|
struct dtr_reg {
|
|
unsigned short limit __attribute__((packed));
|
|
unsigned long base __attribute__((packed));
|
|
};
|
|
|
|
/* Display a segment descriptor stored at index IDX in a descriptor
|
|
table whose type is TYPE and whose base address is BASE_ADDR. If
|
|
FORCE is non-zero, display even invalid descriptors. */
|
|
static void
|
|
display_descriptor (unsigned type, unsigned long base_addr, int idx, int force)
|
|
{
|
|
struct seg_descr descr;
|
|
struct gate_descr gate;
|
|
|
|
/* Get the descriptor from the table. */
|
|
if (idx == 0 && type == 0)
|
|
puts_filtered ("0x000: null descriptor\n");
|
|
else if (get_descriptor (base_addr, idx, &descr) != -1)
|
|
{
|
|
/* For each type of descriptor table, this has a bit set if the
|
|
corresponding type of selectors is valid in that table. */
|
|
static unsigned allowed_descriptors[] = {
|
|
0xffffdafeL, /* GDT */
|
|
0x0000c0e0L, /* IDT */
|
|
0xffffdafaL /* LDT */
|
|
};
|
|
|
|
/* If the program hasn't started yet, assume the debuggee will
|
|
have the same CPL as the debugger. */
|
|
int cpl = prog_has_started ? (a_tss.tss_cs & 3) : _my_cs () & 3;
|
|
unsigned long limit = (descr.limit1 << 16) | descr.limit0;
|
|
|
|
if (descr.present
|
|
&& (allowed_descriptors[type] & (1 << descr.stype)) != 0)
|
|
{
|
|
printf_filtered ("0x%03x: ",
|
|
type == 1
|
|
? idx : (idx * 8) | (type ? (cpl | 4) : 0));
|
|
if (descr.page_granular)
|
|
limit = (limit << 12) | 0xfff; /* big segment: low 12 bit set */
|
|
if (descr.stype == 1 || descr.stype == 2 || descr.stype == 3
|
|
|| descr.stype == 9 || descr.stype == 11
|
|
|| (descr.stype >= 16 && descr.stype < 32))
|
|
printf_filtered ("base=0x%02x%02x%04x limit=0x%08lx",
|
|
descr.base2, descr.base1, descr.base0, limit);
|
|
|
|
switch (descr.stype)
|
|
{
|
|
case 1:
|
|
case 3:
|
|
printf_filtered (" 16-bit TSS (task %sactive)",
|
|
descr.stype == 3 ? "" : "in");
|
|
break;
|
|
case 2:
|
|
puts_filtered (" LDT");
|
|
break;
|
|
case 4:
|
|
memcpy (&gate, &descr, sizeof gate);
|
|
printf_filtered ("selector=0x%04x offs=0x%04x%04x",
|
|
gate.selector, gate.offset1, gate.offset0);
|
|
printf_filtered (" 16-bit Call Gate (params=%d)",
|
|
gate.param_count);
|
|
break;
|
|
case 5:
|
|
printf_filtered ("TSS selector=0x%04x", descr.base0);
|
|
printfi_filtered (16, "Task Gate");
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
memcpy (&gate, &descr, sizeof gate);
|
|
printf_filtered ("selector=0x%04x offs=0x%04x%04x",
|
|
gate.selector, gate.offset1, gate.offset0);
|
|
printf_filtered (" 16-bit %s Gate",
|
|
descr.stype == 6 ? "Interrupt" : "Trap");
|
|
break;
|
|
case 9:
|
|
case 11:
|
|
printf_filtered (" 32-bit TSS (task %sactive)",
|
|
descr.stype == 3 ? "" : "in");
|
|
break;
|
|
case 12:
|
|
memcpy (&gate, &descr, sizeof gate);
|
|
printf_filtered ("selector=0x%04x offs=0x%04x%04x",
|
|
gate.selector, gate.offset1, gate.offset0);
|
|
printf_filtered (" 32-bit Call Gate (params=%d)",
|
|
gate.param_count);
|
|
break;
|
|
case 14:
|
|
case 15:
|
|
memcpy (&gate, &descr, sizeof gate);
|
|
printf_filtered ("selector=0x%04x offs=0x%04x%04x",
|
|
gate.selector, gate.offset1, gate.offset0);
|
|
printf_filtered (" 32-bit %s Gate",
|
|
descr.stype == 14 ? "Interrupt" : "Trap");
|
|
break;
|
|
case 16: /* data segments */
|
|
case 17:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 21:
|
|
case 22:
|
|
case 23:
|
|
printf_filtered (" %s-bit Data (%s Exp-%s%s)",
|
|
descr.bit32 ? "32" : "16",
|
|
descr.stype & 2
|
|
? "Read/Write," : "Read-Only, ",
|
|
descr.stype & 4 ? "down" : "up",
|
|
descr.stype & 1 ? "" : ", N.Acc");
|
|
break;
|
|
case 24: /* code segments */
|
|
case 25:
|
|
case 26:
|
|
case 27:
|
|
case 28:
|
|
case 29:
|
|
case 30:
|
|
case 31:
|
|
printf_filtered (" %s-bit Code (%s, %sConf%s)",
|
|
descr.bit32 ? "32" : "16",
|
|
descr.stype & 2 ? "Exec/Read" : "Exec-Only",
|
|
descr.stype & 4 ? "" : "N.",
|
|
descr.stype & 1 ? "" : ", N.Acc");
|
|
break;
|
|
default:
|
|
printf_filtered ("Unknown type 0x%02x", descr.stype);
|
|
break;
|
|
}
|
|
puts_filtered ("\n");
|
|
}
|
|
else if (force)
|
|
{
|
|
printf_filtered ("0x%03x: ",
|
|
type == 1
|
|
? idx : (idx * 8) | (type ? (cpl | 4) : 0));
|
|
if (!descr.present)
|
|
puts_filtered ("Segment not present\n");
|
|
else
|
|
printf_filtered ("Segment type 0x%02x is invalid in this table\n",
|
|
descr.stype);
|
|
}
|
|
}
|
|
else if (force)
|
|
printf_filtered ("0x%03x: Cannot read this descriptor\n", idx);
|
|
}
|
|
|
|
static void
|
|
go32_sldt (const char *arg, int from_tty)
|
|
{
|
|
struct dtr_reg gdtr;
|
|
unsigned short ldtr = 0;
|
|
int ldt_idx;
|
|
struct seg_descr ldt_descr;
|
|
long ldt_entry = -1L;
|
|
int cpl = (prog_has_started ? a_tss.tss_cs : _my_cs ()) & 3;
|
|
|
|
if (arg && *arg)
|
|
{
|
|
arg = skip_spaces (arg);
|
|
|
|
if (*arg)
|
|
{
|
|
ldt_entry = parse_and_eval_long (arg);
|
|
if (ldt_entry < 0
|
|
|| (ldt_entry & 4) == 0
|
|
|| (ldt_entry & 3) != (cpl & 3))
|
|
error (_("Invalid LDT entry 0x%03lx."), (unsigned long)ldt_entry);
|
|
}
|
|
}
|
|
|
|
__asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
|
|
__asm__ __volatile__ ("sldt %0" : "=m" (ldtr) : /* no inputs */ );
|
|
ldt_idx = ldtr / 8;
|
|
if (ldt_idx == 0)
|
|
puts_filtered ("There is no LDT.\n");
|
|
/* LDT's entry in the GDT must have the type LDT, which is 2. */
|
|
else if (get_descriptor (gdtr.base, ldt_idx, &ldt_descr) != 2)
|
|
printf_filtered ("LDT is present (at %#x), but unreadable by GDB.\n",
|
|
ldt_descr.base0
|
|
| (ldt_descr.base1 << 16)
|
|
| (ldt_descr.base2 << 24));
|
|
else
|
|
{
|
|
unsigned base =
|
|
ldt_descr.base0
|
|
| (ldt_descr.base1 << 16)
|
|
| (ldt_descr.base2 << 24);
|
|
unsigned limit = ldt_descr.limit0 | (ldt_descr.limit1 << 16);
|
|
int max_entry;
|
|
|
|
if (ldt_descr.page_granular)
|
|
/* Page-granular segments must have the low 12 bits of their
|
|
limit set. */
|
|
limit = (limit << 12) | 0xfff;
|
|
/* LDT cannot have more than 8K 8-byte entries, i.e. more than
|
|
64KB. */
|
|
if (limit > 0xffff)
|
|
limit = 0xffff;
|
|
|
|
max_entry = (limit + 1) / 8;
|
|
|
|
if (ldt_entry >= 0)
|
|
{
|
|
if (ldt_entry > limit)
|
|
error (_("Invalid LDT entry %#lx: outside valid limits [0..%#x]"),
|
|
(unsigned long)ldt_entry, limit);
|
|
|
|
display_descriptor (ldt_descr.stype, base, ldt_entry / 8, 1);
|
|
}
|
|
else
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < max_entry; i++)
|
|
display_descriptor (ldt_descr.stype, base, i, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
go32_sgdt (const char *arg, int from_tty)
|
|
{
|
|
struct dtr_reg gdtr;
|
|
long gdt_entry = -1L;
|
|
int max_entry;
|
|
|
|
if (arg && *arg)
|
|
{
|
|
arg = skip_spaces (arg);
|
|
|
|
if (*arg)
|
|
{
|
|
gdt_entry = parse_and_eval_long (arg);
|
|
if (gdt_entry < 0 || (gdt_entry & 7) != 0)
|
|
error (_("Invalid GDT entry 0x%03lx: "
|
|
"not an integral multiple of 8."),
|
|
(unsigned long)gdt_entry);
|
|
}
|
|
}
|
|
|
|
__asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
|
|
max_entry = (gdtr.limit + 1) / 8;
|
|
|
|
if (gdt_entry >= 0)
|
|
{
|
|
if (gdt_entry > gdtr.limit)
|
|
error (_("Invalid GDT entry %#lx: outside valid limits [0..%#x]"),
|
|
(unsigned long)gdt_entry, gdtr.limit);
|
|
|
|
display_descriptor (0, gdtr.base, gdt_entry / 8, 1);
|
|
}
|
|
else
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < max_entry; i++)
|
|
display_descriptor (0, gdtr.base, i, 0);
|
|
}
|
|
}
|
|
|
|
static void
|
|
go32_sidt (const char *arg, int from_tty)
|
|
{
|
|
struct dtr_reg idtr;
|
|
long idt_entry = -1L;
|
|
int max_entry;
|
|
|
|
if (arg && *arg)
|
|
{
|
|
arg = skip_spaces (arg);
|
|
|
|
if (*arg)
|
|
{
|
|
idt_entry = parse_and_eval_long (arg);
|
|
if (idt_entry < 0)
|
|
error (_("Invalid (negative) IDT entry %ld."), idt_entry);
|
|
}
|
|
}
|
|
|
|
__asm__ __volatile__ ("sidt %0" : "=m" (idtr) : /* no inputs */ );
|
|
max_entry = (idtr.limit + 1) / 8;
|
|
if (max_entry > 0x100) /* No more than 256 entries. */
|
|
max_entry = 0x100;
|
|
|
|
if (idt_entry >= 0)
|
|
{
|
|
if (idt_entry > idtr.limit)
|
|
error (_("Invalid IDT entry %#lx: outside valid limits [0..%#x]"),
|
|
(unsigned long)idt_entry, idtr.limit);
|
|
|
|
display_descriptor (1, idtr.base, idt_entry, 1);
|
|
}
|
|
else
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < max_entry; i++)
|
|
display_descriptor (1, idtr.base, i, 0);
|
|
}
|
|
}
|
|
|
|
/* Cached linear address of the base of the page directory. For
|
|
now, available only under CWSDPMI. Code based on ideas and
|
|
suggestions from Charles Sandmann <sandmann@clio.rice.edu>. */
|
|
static unsigned long pdbr;
|
|
|
|
static unsigned long
|
|
get_cr3 (void)
|
|
{
|
|
unsigned offset;
|
|
unsigned taskreg;
|
|
unsigned long taskbase, cr3;
|
|
struct dtr_reg gdtr;
|
|
|
|
if (pdbr > 0 && pdbr <= 0xfffff)
|
|
return pdbr;
|
|
|
|
/* Get the linear address of GDT and the Task Register. */
|
|
__asm__ __volatile__ ("sgdt %0" : "=m" (gdtr) : /* no inputs */ );
|
|
__asm__ __volatile__ ("str %0" : "=m" (taskreg) : /* no inputs */ );
|
|
|
|
/* Task Register is a segment selector for the TSS of the current
|
|
task. Therefore, it can be used as an index into the GDT to get
|
|
at the segment descriptor for the TSS. To get the index, reset
|
|
the low 3 bits of the selector (which give the CPL). Add 2 to the
|
|
offset to point to the 3 low bytes of the base address. */
|
|
offset = gdtr.base + (taskreg & 0xfff8) + 2;
|
|
|
|
|
|
/* CWSDPMI's task base is always under the 1MB mark. */
|
|
if (offset > 0xfffff)
|
|
return 0;
|
|
|
|
_farsetsel (_dos_ds);
|
|
taskbase = _farnspeekl (offset) & 0xffffffU;
|
|
taskbase += _farnspeekl (offset + 2) & 0xff000000U;
|
|
if (taskbase > 0xfffff)
|
|
return 0;
|
|
|
|
/* CR3 (a.k.a. PDBR, the Page Directory Base Register) is stored at
|
|
offset 1Ch in the TSS. */
|
|
cr3 = _farnspeekl (taskbase + 0x1c) & ~0xfff;
|
|
if (cr3 > 0xfffff)
|
|
{
|
|
#if 0 /* Not fullly supported yet. */
|
|
/* The Page Directory is in UMBs. In that case, CWSDPMI puts
|
|
the first Page Table right below the Page Directory. Thus,
|
|
the first Page Table's entry for its own address and the Page
|
|
Directory entry for that Page Table will hold the same
|
|
physical address. The loop below searches the entire UMB
|
|
range of addresses for such an occurence. */
|
|
unsigned long addr, pte_idx;
|
|
|
|
for (addr = 0xb0000, pte_idx = 0xb0;
|
|
pte_idx < 0xff;
|
|
addr += 0x1000, pte_idx++)
|
|
{
|
|
if (((_farnspeekl (addr + 4 * pte_idx) & 0xfffff027) ==
|
|
(_farnspeekl (addr + 0x1000) & 0xfffff027))
|
|
&& ((_farnspeekl (addr + 4 * pte_idx + 4) & 0xfffff000) == cr3))
|
|
{
|
|
cr3 = addr + 0x1000;
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (cr3 > 0xfffff)
|
|
cr3 = 0;
|
|
}
|
|
|
|
return cr3;
|
|
}
|
|
|
|
/* Return the N'th Page Directory entry. */
|
|
static unsigned long
|
|
get_pde (int n)
|
|
{
|
|
unsigned long pde = 0;
|
|
|
|
if (pdbr && n >= 0 && n < 1024)
|
|
{
|
|
pde = _farpeekl (_dos_ds, pdbr + 4*n);
|
|
}
|
|
return pde;
|
|
}
|
|
|
|
/* Return the N'th entry of the Page Table whose Page Directory entry
|
|
is PDE. */
|
|
static unsigned long
|
|
get_pte (unsigned long pde, int n)
|
|
{
|
|
unsigned long pte = 0;
|
|
|
|
/* pde & 0x80 tests the 4MB page bit. We don't support 4MB
|
|
page tables, for now. */
|
|
if ((pde & 1) && !(pde & 0x80) && n >= 0 && n < 1024)
|
|
{
|
|
pde &= ~0xfff; /* Clear non-address bits. */
|
|
pte = _farpeekl (_dos_ds, pde + 4*n);
|
|
}
|
|
return pte;
|
|
}
|
|
|
|
/* Display a Page Directory or Page Table entry. IS_DIR, if non-zero,
|
|
says this is a Page Directory entry. If FORCE is non-zero, display
|
|
the entry even if its Present flag is off. OFF is the offset of the
|
|
address from the page's base address. */
|
|
static void
|
|
display_ptable_entry (unsigned long entry, int is_dir, int force, unsigned off)
|
|
{
|
|
if ((entry & 1) != 0)
|
|
{
|
|
printf_filtered ("Base=0x%05lx000", entry >> 12);
|
|
if ((entry & 0x100) && !is_dir)
|
|
puts_filtered (" Global");
|
|
if ((entry & 0x40) && !is_dir)
|
|
puts_filtered (" Dirty");
|
|
printf_filtered (" %sAcc.", (entry & 0x20) ? "" : "Not-");
|
|
printf_filtered (" %sCached", (entry & 0x10) ? "" : "Not-");
|
|
printf_filtered (" Write-%s", (entry & 8) ? "Thru" : "Back");
|
|
printf_filtered (" %s", (entry & 4) ? "Usr" : "Sup");
|
|
printf_filtered (" Read-%s", (entry & 2) ? "Write" : "Only");
|
|
if (off)
|
|
printf_filtered (" +0x%x", off);
|
|
puts_filtered ("\n");
|
|
}
|
|
else if (force)
|
|
printf_filtered ("Page%s not present or not supported; value=0x%lx.\n",
|
|
is_dir ? " Table" : "", entry >> 1);
|
|
}
|
|
|
|
static void
|
|
go32_pde (const char *arg, int from_tty)
|
|
{
|
|
long pde_idx = -1, i;
|
|
|
|
if (arg && *arg)
|
|
{
|
|
arg = skip_spaces (arg);
|
|
|
|
if (*arg)
|
|
{
|
|
pde_idx = parse_and_eval_long (arg);
|
|
if (pde_idx < 0 || pde_idx >= 1024)
|
|
error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
|
|
}
|
|
}
|
|
|
|
pdbr = get_cr3 ();
|
|
if (!pdbr)
|
|
puts_filtered ("Access to Page Directories is "
|
|
"not supported on this system.\n");
|
|
else if (pde_idx >= 0)
|
|
display_ptable_entry (get_pde (pde_idx), 1, 1, 0);
|
|
else
|
|
for (i = 0; i < 1024; i++)
|
|
display_ptable_entry (get_pde (i), 1, 0, 0);
|
|
}
|
|
|
|
/* A helper function to display entries in a Page Table pointed to by
|
|
the N'th entry in the Page Directory. If FORCE is non-zero, say
|
|
something even if the Page Table is not accessible. */
|
|
static void
|
|
display_page_table (long n, int force)
|
|
{
|
|
unsigned long pde = get_pde (n);
|
|
|
|
if ((pde & 1) != 0)
|
|
{
|
|
int i;
|
|
|
|
printf_filtered ("Page Table pointed to by "
|
|
"Page Directory entry 0x%lx:\n", n);
|
|
for (i = 0; i < 1024; i++)
|
|
display_ptable_entry (get_pte (pde, i), 0, 0, 0);
|
|
puts_filtered ("\n");
|
|
}
|
|
else if (force)
|
|
printf_filtered ("Page Table not present; value=0x%lx.\n", pde >> 1);
|
|
}
|
|
|
|
static void
|
|
go32_pte (const char *arg, int from_tty)
|
|
{
|
|
long pde_idx = -1L, i;
|
|
|
|
if (arg && *arg)
|
|
{
|
|
arg = skip_spaces (arg);
|
|
|
|
if (*arg)
|
|
{
|
|
pde_idx = parse_and_eval_long (arg);
|
|
if (pde_idx < 0 || pde_idx >= 1024)
|
|
error (_("Entry %ld is outside valid limits [0..1023]."), pde_idx);
|
|
}
|
|
}
|
|
|
|
pdbr = get_cr3 ();
|
|
if (!pdbr)
|
|
puts_filtered ("Access to Page Tables is not supported on this system.\n");
|
|
else if (pde_idx >= 0)
|
|
display_page_table (pde_idx, 1);
|
|
else
|
|
for (i = 0; i < 1024; i++)
|
|
display_page_table (i, 0);
|
|
}
|
|
|
|
static void
|
|
go32_pte_for_address (const char *arg, int from_tty)
|
|
{
|
|
CORE_ADDR addr = 0, i;
|
|
|
|
if (arg && *arg)
|
|
{
|
|
arg = skip_spaces (arg);
|
|
|
|
if (*arg)
|
|
addr = parse_and_eval_address (arg);
|
|
}
|
|
if (!addr)
|
|
error_no_arg (_("linear address"));
|
|
|
|
pdbr = get_cr3 ();
|
|
if (!pdbr)
|
|
puts_filtered ("Access to Page Tables is not supported on this system.\n");
|
|
else
|
|
{
|
|
int pde_idx = (addr >> 22) & 0x3ff;
|
|
int pte_idx = (addr >> 12) & 0x3ff;
|
|
unsigned offs = addr & 0xfff;
|
|
|
|
printf_filtered ("Page Table entry for address %s:\n",
|
|
hex_string(addr));
|
|
display_ptable_entry (get_pte (get_pde (pde_idx), pte_idx), 0, 1, offs);
|
|
}
|
|
}
|
|
|
|
static struct cmd_list_element *info_dos_cmdlist = NULL;
|
|
|
|
static void
|
|
go32_info_dos_command (const char *args, int from_tty)
|
|
{
|
|
help_list (info_dos_cmdlist, "info dos ", class_info, gdb_stdout);
|
|
}
|
|
|
|
void
|
|
_initialize_go32_nat (void)
|
|
{
|
|
x86_dr_low.set_control = go32_set_dr7;
|
|
x86_dr_low.set_addr = go32_set_dr;
|
|
x86_dr_low.get_status = go32_get_dr6;
|
|
x86_dr_low.get_control = go32_get_dr7;
|
|
x86_dr_low.get_addr = go32_get_dr;
|
|
x86_set_debug_register_length (4);
|
|
|
|
add_target (&the_go32_nat_target);
|
|
|
|
/* Initialize child's cwd as empty to be initialized when starting
|
|
the child. */
|
|
*child_cwd = 0;
|
|
|
|
/* Initialize child's command line storage. */
|
|
if (redir_debug_init (&child_cmd) == -1)
|
|
internal_error (__FILE__, __LINE__,
|
|
_("Cannot allocate redirection storage: "
|
|
"not enough memory.\n"));
|
|
|
|
/* We are always processing GCC-compiled programs. */
|
|
processing_gcc_compilation = 2;
|
|
|
|
add_prefix_cmd ("dos", class_info, go32_info_dos_command, _("\
|
|
Print information specific to DJGPP (aka MS-DOS) debugging."),
|
|
&info_dos_cmdlist, "info dos ", 0, &infolist);
|
|
|
|
add_cmd ("sysinfo", class_info, go32_sysinfo, _("\
|
|
Display information about the target system, including CPU, OS, DPMI, etc."),
|
|
&info_dos_cmdlist);
|
|
add_cmd ("ldt", class_info, go32_sldt, _("\
|
|
Display entries in the LDT (Local Descriptor Table).\n\
|
|
Entry number (an expression) as an argument means display only that entry."),
|
|
&info_dos_cmdlist);
|
|
add_cmd ("gdt", class_info, go32_sgdt, _("\
|
|
Display entries in the GDT (Global Descriptor Table).\n\
|
|
Entry number (an expression) as an argument means display only that entry."),
|
|
&info_dos_cmdlist);
|
|
add_cmd ("idt", class_info, go32_sidt, _("\
|
|
Display entries in the IDT (Interrupt Descriptor Table).\n\
|
|
Entry number (an expression) as an argument means display only that entry."),
|
|
&info_dos_cmdlist);
|
|
add_cmd ("pde", class_info, go32_pde, _("\
|
|
Display entries in the Page Directory.\n\
|
|
Entry number (an expression) as an argument means display only that entry."),
|
|
&info_dos_cmdlist);
|
|
add_cmd ("pte", class_info, go32_pte, _("\
|
|
Display entries in Page Tables.\n\
|
|
Entry number (an expression) as an argument means display only entries\n\
|
|
from the Page Table pointed to by the specified Page Directory entry."),
|
|
&info_dos_cmdlist);
|
|
add_cmd ("address-pte", class_info, go32_pte_for_address, _("\
|
|
Display a Page Table entry for a linear address.\n\
|
|
The address argument must be a linear address, after adding to\n\
|
|
it the base address of the appropriate segment.\n\
|
|
The base address of variables and functions in the debuggee's data\n\
|
|
or code segment is stored in the variable __djgpp_base_address,\n\
|
|
so use `__djgpp_base_address + (char *)&var' as the argument.\n\
|
|
For other segments, look up their base address in the output of\n\
|
|
the `info dos ldt' command."),
|
|
&info_dos_cmdlist);
|
|
}
|
|
|
|
pid_t
|
|
tcgetpgrp (int fd)
|
|
{
|
|
if (isatty (fd))
|
|
return SOME_PID;
|
|
errno = ENOTTY;
|
|
return -1;
|
|
}
|
|
|
|
int
|
|
tcsetpgrp (int fd, pid_t pgid)
|
|
{
|
|
if (isatty (fd) && pgid == SOME_PID)
|
|
return 0;
|
|
errno = pgid == SOME_PID ? ENOTTY : ENOSYS;
|
|
return -1;
|
|
}
|