MatCat.OpenSource/8sa1-binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
f6ac5f3d63
8sa1-binutils-gdb/gdb/target-delegates.c
Pedro Alves f6ac5f3d63 Convert struct target_ops to C++ 
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.
2018-05-03 00:48:36 +01:00

4346 lines
127 KiB
C
Raw Blame History

/* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
/* vi:set ro: */
/* To regenerate this file, run:*/
/* make-target-delegates target.h > target-delegates.c */
struct dummy_target : public target_ops
{
dummy_target ();
const char *shortname () override;
const char *longname () override;
const char *doc () override;
void post_attach (int arg0) override;
void detach (inferior *arg0, int arg1) override;
void disconnect (const char *arg0, int arg1) override;
void resume (ptid_t arg0, int arg1, enum gdb_signal arg2) override;
void commit_resume () override;
ptid_t wait (ptid_t arg0, struct target_waitstatus *arg1, int arg2) override;
void fetch_registers (struct regcache *arg0, int arg1) override;
void store_registers (struct regcache *arg0, int arg1) override;
void prepare_to_store (struct regcache *arg0) override;
void files_info () override;
int insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
int remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2) override;
int stopped_by_sw_breakpoint () override;
int supports_stopped_by_sw_breakpoint () override;
int stopped_by_hw_breakpoint () override;
int supports_stopped_by_hw_breakpoint () override;
int can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2) override;
int ranged_break_num_registers () override;
int insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
int remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
int remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
int insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
int insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
int remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
int stopped_by_watchpoint () override;
int have_steppable_watchpoint () override;
bool have_continuable_watchpoint () override;
int stopped_data_address (CORE_ADDR *arg0) override;
int watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2) override;
int region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1) override;
int can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3) override;
int masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1) override;
int can_do_single_step () override;
bool supports_terminal_ours () override;
void terminal_init () override;
void terminal_inferior () override;
void terminal_save_inferior () override;
void terminal_ours_for_output () override;
void terminal_ours () override;
void terminal_info (const char *arg0, int arg1) override;
void kill () override;
void load (const char *arg0, int arg1) override;
void post_startup_inferior (ptid_t arg0) override;
int insert_fork_catchpoint (int arg0) override;
int remove_fork_catchpoint (int arg0) override;
int insert_vfork_catchpoint (int arg0) override;
int remove_vfork_catchpoint (int arg0) override;
int follow_fork (int arg0, int arg1) override;
int insert_exec_catchpoint (int arg0) override;
int remove_exec_catchpoint (int arg0) override;
void follow_exec (struct inferior *arg0, char *arg1) override;
int set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3) override;
void mourn_inferior () override;
void pass_signals (int arg0, unsigned char * arg1) override;
void program_signals (int arg0, unsigned char * arg1) override;
int thread_alive (ptid_t arg0) override;
void update_thread_list () override;
const char *pid_to_str (ptid_t arg0) override;
const char *extra_thread_info (thread_info *arg0) override;
const char *thread_name (thread_info *arg0) override;
thread_info *thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2) override;
void stop (ptid_t arg0) override;
void interrupt () override;
void pass_ctrlc () override;
void rcmd (const char *arg0, struct ui_file *arg1) override;
char *pid_to_exec_file (int arg0) override;
void log_command (const char *arg0) override;
struct target_section_table *get_section_table () override;
thread_control_capabilities get_thread_control_capabilities () override;
bool attach_no_wait () override;
int can_async_p () override;
int is_async_p () override;
void async (int arg0) override;
void thread_events (int arg0) override;
int supports_non_stop () override;
int always_non_stop_p () override;
int find_memory_regions (find_memory_region_ftype arg0, void *arg1) override;
char *make_corefile_notes (bfd *arg0, int *arg1) override;
gdb_byte *get_bookmark (const char *arg0, int arg1) override;
void goto_bookmark (const gdb_byte *arg0, int arg1) override;
CORE_ADDR get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2) override;
enum target_xfer_status xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6) override;
ULONGEST get_memory_xfer_limit () override;
std::vector<mem_region> memory_map () override;
void flash_erase (ULONGEST arg0, LONGEST arg1) override;
void flash_done () override;
const struct target_desc *read_description () override;
ptid_t get_ada_task_ptid (long arg0, long arg1) override;
int auxv_parse (gdb_byte **arg0, gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3) override;
int search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4) override;
int can_execute_reverse () override;
enum exec_direction_kind execution_direction () override;
int supports_multi_process () override;
int supports_enable_disable_tracepoint () override;
int supports_disable_randomization () override;
int supports_string_tracing () override;
int supports_evaluation_of_breakpoint_conditions () override;
int can_run_breakpoint_commands () override;
struct gdbarch *thread_architecture (ptid_t arg0) override;
struct address_space *thread_address_space (ptid_t arg0) override;
int filesystem_is_local () override;
void trace_init () override;
void download_tracepoint (struct bp_location *arg0) override;
int can_download_tracepoint () override;
void download_trace_state_variable (const trace_state_variable &arg0) override;
void enable_tracepoint (struct bp_location *arg0) override;
void disable_tracepoint (struct bp_location *arg0) override;
void trace_set_readonly_regions () override;
void trace_start () override;
int get_trace_status (struct trace_status *arg0) override;
void get_tracepoint_status (struct breakpoint *arg0, struct uploaded_tp *arg1) override;
void trace_stop () override;
int trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4) override;
int get_trace_state_variable_value (int arg0, LONGEST *arg1) override;
int save_trace_data (const char *arg0) override;
int upload_tracepoints (struct uploaded_tp **arg0) override;
int upload_trace_state_variables (struct uploaded_tsv **arg0) override;
LONGEST get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2) override;
int get_min_fast_tracepoint_insn_len () override;
void set_disconnected_tracing (int arg0) override;
void set_circular_trace_buffer (int arg0) override;
void set_trace_buffer_size (LONGEST arg0) override;
int set_trace_notes (const char *arg0, const char *arg1, const char *arg2) override;
int core_of_thread (ptid_t arg0) override;
int verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2) override;
int get_tib_address (ptid_t arg0, CORE_ADDR *arg1) override;
void set_permissions () override;
bool static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1) override;
std::vector<static_tracepoint_marker> static_tracepoint_markers_by_strid (const char *arg0) override;
traceframe_info_up traceframe_info () override;
int use_agent (int arg0) override;
int can_use_agent () override;
struct btrace_target_info *enable_btrace (ptid_t arg0, const struct btrace_config *arg1) override;
void disable_btrace (struct btrace_target_info *arg0) override;
void teardown_btrace (struct btrace_target_info *arg0) override;
enum btrace_error read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2) override;
const struct btrace_config *btrace_conf (const struct btrace_target_info *arg0) override;
enum record_method record_method (ptid_t arg0) override;
void stop_recording () override;
void info_record () override;
void save_record (const char *arg0) override;
bool supports_delete_record () override;
void delete_record () override;
int record_is_replaying (ptid_t arg0) override;
int record_will_replay (ptid_t arg0, int arg1) override;
void record_stop_replaying () override;
void goto_record_begin () override;
void goto_record_end () override;
void goto_record (ULONGEST arg0) override;
void insn_history (int arg0, gdb_disassembly_flags arg1) override;
void insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2) override;
void insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2) override;
void call_history (int arg0, record_print_flags arg1) override;
void call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2) override;
void call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2) override;
int augmented_libraries_svr4_read () override;
const struct frame_unwind *get_unwinder () override;
const struct frame_unwind *get_tailcall_unwinder () override;
void prepare_to_generate_core () override;
void done_generating_core () override;
};
struct debug_target : public target_ops
{
debug_target ();
const char *shortname () override;
const char *longname () override;
const char *doc () override;
void post_attach (int arg0) override;
void detach (inferior *arg0, int arg1) override;
void disconnect (const char *arg0, int arg1) override;
void resume (ptid_t arg0, int arg1, enum gdb_signal arg2) override;
void commit_resume () override;
ptid_t wait (ptid_t arg0, struct target_waitstatus *arg1, int arg2) override;
void fetch_registers (struct regcache *arg0, int arg1) override;
void store_registers (struct regcache *arg0, int arg1) override;
void prepare_to_store (struct regcache *arg0) override;
void files_info () override;
int insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
int remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2) override;
int stopped_by_sw_breakpoint () override;
int supports_stopped_by_sw_breakpoint () override;
int stopped_by_hw_breakpoint () override;
int supports_stopped_by_hw_breakpoint () override;
int can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2) override;
int ranged_break_num_registers () override;
int insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
int remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
int remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
int insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
int insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
int remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
int stopped_by_watchpoint () override;
int have_steppable_watchpoint () override;
bool have_continuable_watchpoint () override;
int stopped_data_address (CORE_ADDR *arg0) override;
int watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2) override;
int region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1) override;
int can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3) override;
int masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1) override;
int can_do_single_step () override;
bool supports_terminal_ours () override;
void terminal_init () override;
void terminal_inferior () override;
void terminal_save_inferior () override;
void terminal_ours_for_output () override;
void terminal_ours () override;
void terminal_info (const char *arg0, int arg1) override;
void kill () override;
void load (const char *arg0, int arg1) override;
void post_startup_inferior (ptid_t arg0) override;
int insert_fork_catchpoint (int arg0) override;
int remove_fork_catchpoint (int arg0) override;
int insert_vfork_catchpoint (int arg0) override;
int remove_vfork_catchpoint (int arg0) override;
int follow_fork (int arg0, int arg1) override;
int insert_exec_catchpoint (int arg0) override;
int remove_exec_catchpoint (int arg0) override;
void follow_exec (struct inferior *arg0, char *arg1) override;
int set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3) override;
void mourn_inferior () override;
void pass_signals (int arg0, unsigned char * arg1) override;
void program_signals (int arg0, unsigned char * arg1) override;
int thread_alive (ptid_t arg0) override;
void update_thread_list () override;
const char *pid_to_str (ptid_t arg0) override;
const char *extra_thread_info (thread_info *arg0) override;
const char *thread_name (thread_info *arg0) override;
thread_info *thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2) override;
void stop (ptid_t arg0) override;
void interrupt () override;
void pass_ctrlc () override;
void rcmd (const char *arg0, struct ui_file *arg1) override;
char *pid_to_exec_file (int arg0) override;
void log_command (const char *arg0) override;
struct target_section_table *get_section_table () override;
thread_control_capabilities get_thread_control_capabilities () override;
bool attach_no_wait () override;
int can_async_p () override;
int is_async_p () override;
void async (int arg0) override;
void thread_events (int arg0) override;
int supports_non_stop () override;
int always_non_stop_p () override;
int find_memory_regions (find_memory_region_ftype arg0, void *arg1) override;
char *make_corefile_notes (bfd *arg0, int *arg1) override;
gdb_byte *get_bookmark (const char *arg0, int arg1) override;
void goto_bookmark (const gdb_byte *arg0, int arg1) override;
CORE_ADDR get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2) override;
enum target_xfer_status xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6) override;
ULONGEST get_memory_xfer_limit () override;
std::vector<mem_region> memory_map () override;
void flash_erase (ULONGEST arg0, LONGEST arg1) override;
void flash_done () override;
const struct target_desc *read_description () override;
ptid_t get_ada_task_ptid (long arg0, long arg1) override;
int auxv_parse (gdb_byte **arg0, gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3) override;
int search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4) override;
int can_execute_reverse () override;
enum exec_direction_kind execution_direction () override;
int supports_multi_process () override;
int supports_enable_disable_tracepoint () override;
int supports_disable_randomization () override;
int supports_string_tracing () override;
int supports_evaluation_of_breakpoint_conditions () override;
int can_run_breakpoint_commands () override;
struct gdbarch *thread_architecture (ptid_t arg0) override;
struct address_space *thread_address_space (ptid_t arg0) override;
int filesystem_is_local () override;
void trace_init () override;
void download_tracepoint (struct bp_location *arg0) override;
int can_download_tracepoint () override;
void download_trace_state_variable (const trace_state_variable &arg0) override;
void enable_tracepoint (struct bp_location *arg0) override;
void disable_tracepoint (struct bp_location *arg0) override;
void trace_set_readonly_regions () override;
void trace_start () override;
int get_trace_status (struct trace_status *arg0) override;
void get_tracepoint_status (struct breakpoint *arg0, struct uploaded_tp *arg1) override;
void trace_stop () override;
int trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4) override;
int get_trace_state_variable_value (int arg0, LONGEST *arg1) override;
int save_trace_data (const char *arg0) override;
int upload_tracepoints (struct uploaded_tp **arg0) override;
int upload_trace_state_variables (struct uploaded_tsv **arg0) override;
LONGEST get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2) override;
int get_min_fast_tracepoint_insn_len () override;
void set_disconnected_tracing (int arg0) override;
void set_circular_trace_buffer (int arg0) override;
void set_trace_buffer_size (LONGEST arg0) override;
int set_trace_notes (const char *arg0, const char *arg1, const char *arg2) override;
int core_of_thread (ptid_t arg0) override;
int verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2) override;
int get_tib_address (ptid_t arg0, CORE_ADDR *arg1) override;
void set_permissions () override;
bool static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1) override;
std::vector<static_tracepoint_marker> static_tracepoint_markers_by_strid (const char *arg0) override;
traceframe_info_up traceframe_info () override;
int use_agent (int arg0) override;
int can_use_agent () override;
struct btrace_target_info *enable_btrace (ptid_t arg0, const struct btrace_config *arg1) override;
void disable_btrace (struct btrace_target_info *arg0) override;
void teardown_btrace (struct btrace_target_info *arg0) override;
enum btrace_error read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2) override;
const struct btrace_config *btrace_conf (const struct btrace_target_info *arg0) override;
enum record_method record_method (ptid_t arg0) override;
void stop_recording () override;
void info_record () override;
void save_record (const char *arg0) override;
bool supports_delete_record () override;
void delete_record () override;
int record_is_replaying (ptid_t arg0) override;
int record_will_replay (ptid_t arg0, int arg1) override;
void record_stop_replaying () override;
void goto_record_begin () override;
void goto_record_end () override;
void goto_record (ULONGEST arg0) override;
void insn_history (int arg0, gdb_disassembly_flags arg1) override;
void insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2) override;
void insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2) override;
void call_history (int arg0, record_print_flags arg1) override;
void call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2) override;
void call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2) override;
int augmented_libraries_svr4_read () override;
const struct frame_unwind *get_unwinder () override;
const struct frame_unwind *get_tailcall_unwinder () override;
void prepare_to_generate_core () override;
void done_generating_core () override;
};
void
target_ops::post_attach (int arg0)
{
this->beneath->post_attach (arg0);
}
void
dummy_target::post_attach (int arg0)
{
}
void
debug_target::post_attach (int arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->post_attach (...)\n", this->beneath->shortname ());
this->beneath->post_attach (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->post_attach (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::detach (inferior *arg0, int arg1)
{
this->beneath->detach (arg0, arg1);
}
void
dummy_target::detach (inferior *arg0, int arg1)
{
}
void
debug_target::detach (inferior *arg0, int arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->detach (...)\n", this->beneath->shortname ());
this->beneath->detach (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->detach (", this->beneath->shortname ());
target_debug_print_inferior_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::disconnect (const char *arg0, int arg1)
{
this->beneath->disconnect (arg0, arg1);
}
void
dummy_target::disconnect (const char *arg0, int arg1)
{
tcomplain ();
}
void
debug_target::disconnect (const char *arg0, int arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->disconnect (...)\n", this->beneath->shortname ());
this->beneath->disconnect (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->disconnect (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::resume (ptid_t arg0, int arg1, enum gdb_signal arg2)
{
this->beneath->resume (arg0, arg1, arg2);
}
void
dummy_target::resume (ptid_t arg0, int arg1, enum gdb_signal arg2)
{
noprocess ();
}
void
debug_target::resume (ptid_t arg0, int arg1, enum gdb_signal arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->resume (...)\n", this->beneath->shortname ());
this->beneath->resume (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->resume (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_step (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_gdb_signal (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::commit_resume ()
{
this->beneath->commit_resume ();
}
void
dummy_target::commit_resume ()
{
}
void
debug_target::commit_resume ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->commit_resume (...)\n", this->beneath->shortname ());
this->beneath->commit_resume ();
fprintf_unfiltered (gdb_stdlog, "<- %s->commit_resume (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
ptid_t
target_ops::wait (ptid_t arg0, struct target_waitstatus *arg1, int arg2)
{
return this->beneath->wait (arg0, arg1, arg2);
}
ptid_t
dummy_target::wait (ptid_t arg0, struct target_waitstatus *arg1, int arg2)
{
return default_target_wait (this, arg0, arg1, arg2);
}
ptid_t
debug_target::wait (ptid_t arg0, struct target_waitstatus *arg1, int arg2)
{
ptid_t result;
fprintf_unfiltered (gdb_stdlog, "-> %s->wait (...)\n", this->beneath->shortname ());
result = this->beneath->wait (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->wait (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_target_waitstatus_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_options (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_ptid_t (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::fetch_registers (struct regcache *arg0, int arg1)
{
this->beneath->fetch_registers (arg0, arg1);
}
void
dummy_target::fetch_registers (struct regcache *arg0, int arg1)
{
}
void
debug_target::fetch_registers (struct regcache *arg0, int arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->fetch_registers (...)\n", this->beneath->shortname ());
this->beneath->fetch_registers (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->fetch_registers (", this->beneath->shortname ());
target_debug_print_struct_regcache_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::store_registers (struct regcache *arg0, int arg1)
{
this->beneath->store_registers (arg0, arg1);
}
void
dummy_target::store_registers (struct regcache *arg0, int arg1)
{
noprocess ();
}
void
debug_target::store_registers (struct regcache *arg0, int arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->store_registers (...)\n", this->beneath->shortname ());
this->beneath->store_registers (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->store_registers (", this->beneath->shortname ());
target_debug_print_struct_regcache_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::prepare_to_store (struct regcache *arg0)
{
this->beneath->prepare_to_store (arg0);
}
void
dummy_target::prepare_to_store (struct regcache *arg0)
{
noprocess ();
}
void
debug_target::prepare_to_store (struct regcache *arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->prepare_to_store (...)\n", this->beneath->shortname ());
this->beneath->prepare_to_store (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->prepare_to_store (", this->beneath->shortname ());
target_debug_print_struct_regcache_p (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::files_info ()
{
this->beneath->files_info ();
}
void
dummy_target::files_info ()
{
}
void
debug_target::files_info ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->files_info (...)\n", this->beneath->shortname ());
this->beneath->files_info ();
fprintf_unfiltered (gdb_stdlog, "<- %s->files_info (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
{
return this->beneath->insert_breakpoint (arg0, arg1);
}
int
dummy_target::insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
{
noprocess ();
}
int
debug_target::insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->insert_breakpoint (...)\n", this->beneath->shortname ());
result = this->beneath->insert_breakpoint (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_breakpoint (", this->beneath->shortname ());
target_debug_print_struct_gdbarch_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_bp_target_info_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2)
{
return this->beneath->remove_breakpoint (arg0, arg1, arg2);
}
int
dummy_target::remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2)
{
noprocess ();
}
int
debug_target::remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->remove_breakpoint (...)\n", this->beneath->shortname ());
result = this->beneath->remove_breakpoint (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_breakpoint (", this->beneath->shortname ());
target_debug_print_struct_gdbarch_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_bp_target_info_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_remove_bp_reason (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::stopped_by_sw_breakpoint ()
{
return this->beneath->stopped_by_sw_breakpoint ();
}
int
dummy_target::stopped_by_sw_breakpoint ()
{
return 0;
}
int
debug_target::stopped_by_sw_breakpoint ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->stopped_by_sw_breakpoint (...)\n", this->beneath->shortname ());
result = this->beneath->stopped_by_sw_breakpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->stopped_by_sw_breakpoint (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::supports_stopped_by_sw_breakpoint ()
{
return this->beneath->supports_stopped_by_sw_breakpoint ();
}
int
dummy_target::supports_stopped_by_sw_breakpoint ()
{
return 0;
}
int
debug_target::supports_stopped_by_sw_breakpoint ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_stopped_by_sw_breakpoint (...)\n", this->beneath->shortname ());
result = this->beneath->supports_stopped_by_sw_breakpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_stopped_by_sw_breakpoint (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::stopped_by_hw_breakpoint ()
{
return this->beneath->stopped_by_hw_breakpoint ();
}
int
dummy_target::stopped_by_hw_breakpoint ()
{
return 0;
}
int
debug_target::stopped_by_hw_breakpoint ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->stopped_by_hw_breakpoint (...)\n", this->beneath->shortname ());
result = this->beneath->stopped_by_hw_breakpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->stopped_by_hw_breakpoint (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::supports_stopped_by_hw_breakpoint ()
{
return this->beneath->supports_stopped_by_hw_breakpoint ();
}
int
dummy_target::supports_stopped_by_hw_breakpoint ()
{
return 0;
}
int
debug_target::supports_stopped_by_hw_breakpoint ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_stopped_by_hw_breakpoint (...)\n", this->beneath->shortname ());
result = this->beneath->supports_stopped_by_hw_breakpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_stopped_by_hw_breakpoint (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2)
{
return this->beneath->can_use_hw_breakpoint (arg0, arg1, arg2);
}
int
dummy_target::can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2)
{
return 0;
}
int
debug_target::can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->can_use_hw_breakpoint (...)\n", this->beneath->shortname ());
result = this->beneath->can_use_hw_breakpoint (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->can_use_hw_breakpoint (", this->beneath->shortname ());
target_debug_print_enum_bptype (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::ranged_break_num_registers ()
{
return this->beneath->ranged_break_num_registers ();
}
int
dummy_target::ranged_break_num_registers ()
{
return -1;
}
int
debug_target::ranged_break_num_registers ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->ranged_break_num_registers (...)\n", this->beneath->shortname ());
result = this->beneath->ranged_break_num_registers ();
fprintf_unfiltered (gdb_stdlog, "<- %s->ranged_break_num_registers (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
{
return this->beneath->insert_hw_breakpoint (arg0, arg1);
}
int
dummy_target::insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
{
return -1;
}
int
debug_target::insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->insert_hw_breakpoint (...)\n", this->beneath->shortname ());
result = this->beneath->insert_hw_breakpoint (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_hw_breakpoint (", this->beneath->shortname ());
target_debug_print_struct_gdbarch_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_bp_target_info_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
{
return this->beneath->remove_hw_breakpoint (arg0, arg1);
}
int
dummy_target::remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
{
return -1;
}
int
debug_target::remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->remove_hw_breakpoint (...)\n", this->beneath->shortname ());
result = this->beneath->remove_hw_breakpoint (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_hw_breakpoint (", this->beneath->shortname ());
target_debug_print_struct_gdbarch_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_bp_target_info_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
{
return this->beneath->remove_watchpoint (arg0, arg1, arg2, arg3);
}
int
dummy_target::remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
{
return -1;
}
int
debug_target::remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->remove_watchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->remove_watchpoint (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_watchpoint (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_expression_p (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
{
return this->beneath->insert_watchpoint (arg0, arg1, arg2, arg3);
}
int
dummy_target::insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
{
return -1;
}
int
debug_target::insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->insert_watchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->insert_watchpoint (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_watchpoint (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_expression_p (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
{
return this->beneath->insert_mask_watchpoint (arg0, arg1, arg2);
}
int
dummy_target::insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
{
return 1;
}
int
debug_target::insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->insert_mask_watchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->insert_mask_watchpoint (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_mask_watchpoint (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
{
return this->beneath->remove_mask_watchpoint (arg0, arg1, arg2);
}
int
dummy_target::remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
{
return 1;
}
int
debug_target::remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->remove_mask_watchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->remove_mask_watchpoint (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_mask_watchpoint (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_target_hw_bp_type (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::stopped_by_watchpoint ()
{
return this->beneath->stopped_by_watchpoint ();
}
int
dummy_target::stopped_by_watchpoint ()
{
return 0;
}
int
debug_target::stopped_by_watchpoint ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->stopped_by_watchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->stopped_by_watchpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->stopped_by_watchpoint (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::have_steppable_watchpoint ()
{
return this->beneath->have_steppable_watchpoint ();
}
int
dummy_target::have_steppable_watchpoint ()
{
return 0;
}
int
debug_target::have_steppable_watchpoint ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->have_steppable_watchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->have_steppable_watchpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->have_steppable_watchpoint (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
bool
target_ops::have_continuable_watchpoint ()
{
return this->beneath->have_continuable_watchpoint ();
}
bool
dummy_target::have_continuable_watchpoint ()
{
return 0;
}
bool
debug_target::have_continuable_watchpoint ()
{
bool result;
fprintf_unfiltered (gdb_stdlog, "-> %s->have_continuable_watchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->have_continuable_watchpoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->have_continuable_watchpoint (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_bool (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::stopped_data_address (CORE_ADDR *arg0)
{
return this->beneath->stopped_data_address (arg0);
}
int
dummy_target::stopped_data_address (CORE_ADDR *arg0)
{
return 0;
}
int
debug_target::stopped_data_address (CORE_ADDR *arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->stopped_data_address (...)\n", this->beneath->shortname ());
result = this->beneath->stopped_data_address (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->stopped_data_address (", this->beneath->shortname ());
target_debug_print_CORE_ADDR_p (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2)
{
return this->beneath->watchpoint_addr_within_range (arg0, arg1, arg2);
}
int
dummy_target::watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2)
{
return default_watchpoint_addr_within_range (this, arg0, arg1, arg2);
}
int
debug_target::watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->watchpoint_addr_within_range (...)\n", this->beneath->shortname ());
result = this->beneath->watchpoint_addr_within_range (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->watchpoint_addr_within_range (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1)
{
return this->beneath->region_ok_for_hw_watchpoint (arg0, arg1);
}
int
dummy_target::region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1)
{
return default_region_ok_for_hw_watchpoint (this, arg0, arg1);
}
int
debug_target::region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->region_ok_for_hw_watchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->region_ok_for_hw_watchpoint (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->region_ok_for_hw_watchpoint (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3)
{
return this->beneath->can_accel_watchpoint_condition (arg0, arg1, arg2, arg3);
}
int
dummy_target::can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3)
{
return 0;
}
int
debug_target::can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->can_accel_watchpoint_condition (...)\n", this->beneath->shortname ());
result = this->beneath->can_accel_watchpoint_condition (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->can_accel_watchpoint_condition (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_expression_p (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1)
{
return this->beneath->masked_watch_num_registers (arg0, arg1);
}
int
dummy_target::masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1)
{
return -1;
}
int
debug_target::masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->masked_watch_num_registers (...)\n", this->beneath->shortname ());
result = this->beneath->masked_watch_num_registers (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->masked_watch_num_registers (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::can_do_single_step ()
{
return this->beneath->can_do_single_step ();
}
int
dummy_target::can_do_single_step ()
{
return -1;
}
int
debug_target::can_do_single_step ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->can_do_single_step (...)\n", this->beneath->shortname ());
result = this->beneath->can_do_single_step ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_do_single_step (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
bool
target_ops::supports_terminal_ours ()
{
return this->beneath->supports_terminal_ours ();
}
bool
dummy_target::supports_terminal_ours ()
{
return 0;
}
bool
debug_target::supports_terminal_ours ()
{
bool result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_terminal_ours (...)\n", this->beneath->shortname ());
result = this->beneath->supports_terminal_ours ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_terminal_ours (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_bool (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::terminal_init ()
{
this->beneath->terminal_init ();
}
void
dummy_target::terminal_init ()
{
}
void
debug_target::terminal_init ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_init (...)\n", this->beneath->shortname ());
this->beneath->terminal_init ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_init (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::terminal_inferior ()
{
this->beneath->terminal_inferior ();
}
void
dummy_target::terminal_inferior ()
{
}
void
debug_target::terminal_inferior ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_inferior (...)\n", this->beneath->shortname ());
this->beneath->terminal_inferior ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_inferior (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::terminal_save_inferior ()
{
this->beneath->terminal_save_inferior ();
}
void
dummy_target::terminal_save_inferior ()
{
}
void
debug_target::terminal_save_inferior ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_save_inferior (...)\n", this->beneath->shortname ());
this->beneath->terminal_save_inferior ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_save_inferior (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::terminal_ours_for_output ()
{
this->beneath->terminal_ours_for_output ();
}
void
dummy_target::terminal_ours_for_output ()
{
}
void
debug_target::terminal_ours_for_output ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_ours_for_output (...)\n", this->beneath->shortname ());
this->beneath->terminal_ours_for_output ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_ours_for_output (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::terminal_ours ()
{
this->beneath->terminal_ours ();
}
void
dummy_target::terminal_ours ()
{
}
void
debug_target::terminal_ours ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_ours (...)\n", this->beneath->shortname ());
this->beneath->terminal_ours ();
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_ours (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::terminal_info (const char *arg0, int arg1)
{
this->beneath->terminal_info (arg0, arg1);
}
void
dummy_target::terminal_info (const char *arg0, int arg1)
{
default_terminal_info (this, arg0, arg1);
}
void
debug_target::terminal_info (const char *arg0, int arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->terminal_info (...)\n", this->beneath->shortname ());
this->beneath->terminal_info (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->terminal_info (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::kill ()
{
this->beneath->kill ();
}
void
dummy_target::kill ()
{
noprocess ();
}
void
debug_target::kill ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->kill (...)\n", this->beneath->shortname ());
this->beneath->kill ();
fprintf_unfiltered (gdb_stdlog, "<- %s->kill (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::load (const char *arg0, int arg1)
{
this->beneath->load (arg0, arg1);
}
void
dummy_target::load (const char *arg0, int arg1)
{
tcomplain ();
}
void
debug_target::load (const char *arg0, int arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->load (...)\n", this->beneath->shortname ());
this->beneath->load (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->load (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::post_startup_inferior (ptid_t arg0)
{
this->beneath->post_startup_inferior (arg0);
}
void
dummy_target::post_startup_inferior (ptid_t arg0)
{
}
void
debug_target::post_startup_inferior (ptid_t arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->post_startup_inferior (...)\n", this->beneath->shortname ());
this->beneath->post_startup_inferior (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->post_startup_inferior (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::insert_fork_catchpoint (int arg0)
{
return this->beneath->insert_fork_catchpoint (arg0);
}
int
dummy_target::insert_fork_catchpoint (int arg0)
{
return 1;
}
int
debug_target::insert_fork_catchpoint (int arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->insert_fork_catchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->insert_fork_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_fork_catchpoint (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::remove_fork_catchpoint (int arg0)
{
return this->beneath->remove_fork_catchpoint (arg0);
}
int
dummy_target::remove_fork_catchpoint (int arg0)
{
return 1;
}
int
debug_target::remove_fork_catchpoint (int arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->remove_fork_catchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->remove_fork_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_fork_catchpoint (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::insert_vfork_catchpoint (int arg0)
{
return this->beneath->insert_vfork_catchpoint (arg0);
}
int
dummy_target::insert_vfork_catchpoint (int arg0)
{
return 1;
}
int
debug_target::insert_vfork_catchpoint (int arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->insert_vfork_catchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->insert_vfork_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_vfork_catchpoint (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::remove_vfork_catchpoint (int arg0)
{
return this->beneath->remove_vfork_catchpoint (arg0);
}
int
dummy_target::remove_vfork_catchpoint (int arg0)
{
return 1;
}
int
debug_target::remove_vfork_catchpoint (int arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->remove_vfork_catchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->remove_vfork_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_vfork_catchpoint (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::follow_fork (int arg0, int arg1)
{
return this->beneath->follow_fork (arg0, arg1);
}
int
dummy_target::follow_fork (int arg0, int arg1)
{
return default_follow_fork (this, arg0, arg1);
}
int
debug_target::follow_fork (int arg0, int arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->follow_fork (...)\n", this->beneath->shortname ());
result = this->beneath->follow_fork (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->follow_fork (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::insert_exec_catchpoint (int arg0)
{
return this->beneath->insert_exec_catchpoint (arg0);
}
int
dummy_target::insert_exec_catchpoint (int arg0)
{
return 1;
}
int
debug_target::insert_exec_catchpoint (int arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->insert_exec_catchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->insert_exec_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->insert_exec_catchpoint (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::remove_exec_catchpoint (int arg0)
{
return this->beneath->remove_exec_catchpoint (arg0);
}
int
dummy_target::remove_exec_catchpoint (int arg0)
{
return 1;
}
int
debug_target::remove_exec_catchpoint (int arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->remove_exec_catchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->remove_exec_catchpoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->remove_exec_catchpoint (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::follow_exec (struct inferior *arg0, char *arg1)
{
this->beneath->follow_exec (arg0, arg1);
}
void
dummy_target::follow_exec (struct inferior *arg0, char *arg1)
{
}
void
debug_target::follow_exec (struct inferior *arg0, char *arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->follow_exec (...)\n", this->beneath->shortname ());
this->beneath->follow_exec (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->follow_exec (", this->beneath->shortname ());
target_debug_print_struct_inferior_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_char_p (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3)
{
return this->beneath->set_syscall_catchpoint (arg0, arg1, arg2, arg3);
}
int
dummy_target::set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3)
{
return 1;
}
int
debug_target::set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->set_syscall_catchpoint (...)\n", this->beneath->shortname ());
result = this->beneath->set_syscall_catchpoint (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_syscall_catchpoint (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_bool (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_gdb_array_view_const_int (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::mourn_inferior ()
{
this->beneath->mourn_inferior ();
}
void
dummy_target::mourn_inferior ()
{
default_mourn_inferior (this);
}
void
debug_target::mourn_inferior ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->mourn_inferior (...)\n", this->beneath->shortname ());
this->beneath->mourn_inferior ();
fprintf_unfiltered (gdb_stdlog, "<- %s->mourn_inferior (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::pass_signals (int arg0, unsigned char * arg1)
{
this->beneath->pass_signals (arg0, arg1);
}
void
dummy_target::pass_signals (int arg0, unsigned char * arg1)
{
}
void
debug_target::pass_signals (int arg0, unsigned char * arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->pass_signals (...)\n", this->beneath->shortname ());
this->beneath->pass_signals (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->pass_signals (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_signals (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::program_signals (int arg0, unsigned char * arg1)
{
this->beneath->program_signals (arg0, arg1);
}
void
dummy_target::program_signals (int arg0, unsigned char * arg1)
{
}
void
debug_target::program_signals (int arg0, unsigned char * arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->program_signals (...)\n", this->beneath->shortname ());
this->beneath->program_signals (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->program_signals (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_signals (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::thread_alive (ptid_t arg0)
{
return this->beneath->thread_alive (arg0);
}
int
dummy_target::thread_alive (ptid_t arg0)
{
return 0;
}
int
debug_target::thread_alive (ptid_t arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->thread_alive (...)\n", this->beneath->shortname ());
result = this->beneath->thread_alive (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_alive (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::update_thread_list ()
{
this->beneath->update_thread_list ();
}
void
dummy_target::update_thread_list ()
{
}
void
debug_target::update_thread_list ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->update_thread_list (...)\n", this->beneath->shortname ());
this->beneath->update_thread_list ();
fprintf_unfiltered (gdb_stdlog, "<- %s->update_thread_list (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
const char *
target_ops::pid_to_str (ptid_t arg0)
{
return this->beneath->pid_to_str (arg0);
}
const char *
dummy_target::pid_to_str (ptid_t arg0)
{
return default_pid_to_str (this, arg0);
}
const char *
debug_target::pid_to_str (ptid_t arg0)
{
const char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->pid_to_str (...)\n", this->beneath->shortname ());
result = this->beneath->pid_to_str (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->pid_to_str (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_const_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
const char *
target_ops::extra_thread_info (thread_info *arg0)
{
return this->beneath->extra_thread_info (arg0);
}
const char *
dummy_target::extra_thread_info (thread_info *arg0)
{
return NULL;
}
const char *
debug_target::extra_thread_info (thread_info *arg0)
{
const char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->extra_thread_info (...)\n", this->beneath->shortname ());
result = this->beneath->extra_thread_info (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->extra_thread_info (", this->beneath->shortname ());
target_debug_print_thread_info_p (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_const_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
const char *
target_ops::thread_name (thread_info *arg0)
{
return this->beneath->thread_name (arg0);
}
const char *
dummy_target::thread_name (thread_info *arg0)
{
return NULL;
}
const char *
debug_target::thread_name (thread_info *arg0)
{
const char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->thread_name (...)\n", this->beneath->shortname ());
result = this->beneath->thread_name (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_name (", this->beneath->shortname ());
target_debug_print_thread_info_p (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_const_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
thread_info *
target_ops::thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2)
{
return this->beneath->thread_handle_to_thread_info (arg0, arg1, arg2);
}
thread_info *
dummy_target::thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2)
{
return NULL;
}
thread_info *
debug_target::thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2)
{
thread_info * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->thread_handle_to_thread_info (...)\n", this->beneath->shortname ());
result = this->beneath->thread_handle_to_thread_info (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_handle_to_thread_info (", this->beneath->shortname ());
target_debug_print_const_gdb_byte_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_inferior_p (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_thread_info_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::stop (ptid_t arg0)
{
this->beneath->stop (arg0);
}
void
dummy_target::stop (ptid_t arg0)
{
}
void
debug_target::stop (ptid_t arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->stop (...)\n", this->beneath->shortname ());
this->beneath->stop (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->stop (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::interrupt ()
{
this->beneath->interrupt ();
}
void
dummy_target::interrupt ()
{
}
void
debug_target::interrupt ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->interrupt (...)\n", this->beneath->shortname ());
this->beneath->interrupt ();
fprintf_unfiltered (gdb_stdlog, "<- %s->interrupt (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::pass_ctrlc ()
{
this->beneath->pass_ctrlc ();
}
void
dummy_target::pass_ctrlc ()
{
default_target_pass_ctrlc (this);
}
void
debug_target::pass_ctrlc ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->pass_ctrlc (...)\n", this->beneath->shortname ());
this->beneath->pass_ctrlc ();
fprintf_unfiltered (gdb_stdlog, "<- %s->pass_ctrlc (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::rcmd (const char *arg0, struct ui_file *arg1)
{
this->beneath->rcmd (arg0, arg1);
}
void
dummy_target::rcmd (const char *arg0, struct ui_file *arg1)
{
default_rcmd (this, arg0, arg1);
}
void
debug_target::rcmd (const char *arg0, struct ui_file *arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->rcmd (...)\n", this->beneath->shortname ());
this->beneath->rcmd (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->rcmd (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_ui_file_p (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
char *
target_ops::pid_to_exec_file (int arg0)
{
return this->beneath->pid_to_exec_file (arg0);
}
char *
dummy_target::pid_to_exec_file (int arg0)
{
return NULL;
}
char *
debug_target::pid_to_exec_file (int arg0)
{
char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->pid_to_exec_file (...)\n", this->beneath->shortname ());
result = this->beneath->pid_to_exec_file (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->pid_to_exec_file (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::log_command (const char *arg0)
{
this->beneath->log_command (arg0);
}
void
dummy_target::log_command (const char *arg0)
{
}
void
debug_target::log_command (const char *arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->log_command (...)\n", this->beneath->shortname ());
this->beneath->log_command (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->log_command (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
struct target_section_table *
target_ops::get_section_table ()
{
return this->beneath->get_section_table ();
}
struct target_section_table *
dummy_target::get_section_table ()
{
return NULL;
}
struct target_section_table *
debug_target::get_section_table ()
{
struct target_section_table * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_section_table (...)\n", this->beneath->shortname ());
result = this->beneath->get_section_table ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_section_table (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_struct_target_section_table_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
thread_control_capabilities
target_ops::get_thread_control_capabilities ()
{
return this->beneath->get_thread_control_capabilities ();
}
thread_control_capabilities
dummy_target::get_thread_control_capabilities ()
{
return tc_none;
}
thread_control_capabilities
debug_target::get_thread_control_capabilities ()
{
thread_control_capabilities result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_thread_control_capabilities (...)\n", this->beneath->shortname ());
result = this->beneath->get_thread_control_capabilities ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_thread_control_capabilities (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_thread_control_capabilities (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
bool
target_ops::attach_no_wait ()
{
return this->beneath->attach_no_wait ();
}
bool
dummy_target::attach_no_wait ()
{
return 0;
}
bool
debug_target::attach_no_wait ()
{
bool result;
fprintf_unfiltered (gdb_stdlog, "-> %s->attach_no_wait (...)\n", this->beneath->shortname ());
result = this->beneath->attach_no_wait ();
fprintf_unfiltered (gdb_stdlog, "<- %s->attach_no_wait (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_bool (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::can_async_p ()
{
return this->beneath->can_async_p ();
}
int
dummy_target::can_async_p ()
{
return 0;
}
int
debug_target::can_async_p ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->can_async_p (...)\n", this->beneath->shortname ());
result = this->beneath->can_async_p ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_async_p (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::is_async_p ()
{
return this->beneath->is_async_p ();
}
int
dummy_target::is_async_p ()
{
return 0;
}
int
debug_target::is_async_p ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->is_async_p (...)\n", this->beneath->shortname ());
result = this->beneath->is_async_p ();
fprintf_unfiltered (gdb_stdlog, "<- %s->is_async_p (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::async (int arg0)
{
this->beneath->async (arg0);
}
void
dummy_target::async (int arg0)
{
tcomplain ();
}
void
debug_target::async (int arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->async (...)\n", this->beneath->shortname ());
this->beneath->async (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->async (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::thread_events (int arg0)
{
this->beneath->thread_events (arg0);
}
void
dummy_target::thread_events (int arg0)
{
}
void
debug_target::thread_events (int arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->thread_events (...)\n", this->beneath->shortname ());
this->beneath->thread_events (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_events (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::supports_non_stop ()
{
return this->beneath->supports_non_stop ();
}
int
dummy_target::supports_non_stop ()
{
return 0;
}
int
debug_target::supports_non_stop ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_non_stop (...)\n", this->beneath->shortname ());
result = this->beneath->supports_non_stop ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_non_stop (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::always_non_stop_p ()
{
return this->beneath->always_non_stop_p ();
}
int
dummy_target::always_non_stop_p ()
{
return 0;
}
int
debug_target::always_non_stop_p ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->always_non_stop_p (...)\n", this->beneath->shortname ());
result = this->beneath->always_non_stop_p ();
fprintf_unfiltered (gdb_stdlog, "<- %s->always_non_stop_p (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::find_memory_regions (find_memory_region_ftype arg0, void *arg1)
{
return this->beneath->find_memory_regions (arg0, arg1);
}
int
dummy_target::find_memory_regions (find_memory_region_ftype arg0, void *arg1)
{
return dummy_find_memory_regions (this, arg0, arg1);
}
int
debug_target::find_memory_regions (find_memory_region_ftype arg0, void *arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->find_memory_regions (...)\n", this->beneath->shortname ());
result = this->beneath->find_memory_regions (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->find_memory_regions (", this->beneath->shortname ());
target_debug_print_find_memory_region_ftype (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_void_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
char *
target_ops::make_corefile_notes (bfd *arg0, int *arg1)
{
return this->beneath->make_corefile_notes (arg0, arg1);
}
char *
dummy_target::make_corefile_notes (bfd *arg0, int *arg1)
{
return dummy_make_corefile_notes (this, arg0, arg1);
}
char *
debug_target::make_corefile_notes (bfd *arg0, int *arg1)
{
char * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->make_corefile_notes (...)\n", this->beneath->shortname ());
result = this->beneath->make_corefile_notes (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->make_corefile_notes (", this->beneath->shortname ());
target_debug_print_bfd_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_char_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
gdb_byte *
target_ops::get_bookmark (const char *arg0, int arg1)
{
return this->beneath->get_bookmark (arg0, arg1);
}
gdb_byte *
dummy_target::get_bookmark (const char *arg0, int arg1)
{
tcomplain ();
}
gdb_byte *
debug_target::get_bookmark (const char *arg0, int arg1)
{
gdb_byte * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_bookmark (...)\n", this->beneath->shortname ());
result = this->beneath->get_bookmark (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_bookmark (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_gdb_byte_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::goto_bookmark (const gdb_byte *arg0, int arg1)
{
this->beneath->goto_bookmark (arg0, arg1);
}
void
dummy_target::goto_bookmark (const gdb_byte *arg0, int arg1)
{
tcomplain ();
}
void
debug_target::goto_bookmark (const gdb_byte *arg0, int arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->goto_bookmark (...)\n", this->beneath->shortname ());
this->beneath->goto_bookmark (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->goto_bookmark (", this->beneath->shortname ());
target_debug_print_const_gdb_byte_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
CORE_ADDR
target_ops::get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2)
{
return this->beneath->get_thread_local_address (arg0, arg1, arg2);
}
CORE_ADDR
dummy_target::get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2)
{
generic_tls_error ();
}
CORE_ADDR
debug_target::get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2)
{
CORE_ADDR result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_thread_local_address (...)\n", this->beneath->shortname ());
result = this->beneath->get_thread_local_address (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_thread_local_address (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_CORE_ADDR (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
enum target_xfer_status
target_ops::xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6)
{
return this->beneath->xfer_partial (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
enum target_xfer_status
dummy_target::xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6)
{
return TARGET_XFER_E_IO;
}
enum target_xfer_status
debug_target::xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6)
{
enum target_xfer_status result;
fprintf_unfiltered (gdb_stdlog, "-> %s->xfer_partial (...)\n", this->beneath->shortname ());
result = this->beneath->xfer_partial (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
fprintf_unfiltered (gdb_stdlog, "<- %s->xfer_partial (", this->beneath->shortname ());
target_debug_print_enum_target_object (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_gdb_byte_p (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_gdb_byte_p (arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg4);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg5);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST_p (arg6);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_enum_target_xfer_status (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
ULONGEST
target_ops::get_memory_xfer_limit ()
{
return this->beneath->get_memory_xfer_limit ();
}
ULONGEST
dummy_target::get_memory_xfer_limit ()
{
return ULONGEST_MAX;
}
ULONGEST
debug_target::get_memory_xfer_limit ()
{
ULONGEST result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_memory_xfer_limit (...)\n", this->beneath->shortname ());
result = this->beneath->get_memory_xfer_limit ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_memory_xfer_limit (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_ULONGEST (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
std::vector<mem_region>
target_ops::memory_map ()
{
return this->beneath->memory_map ();
}
std::vector<mem_region>
dummy_target::memory_map ()
{
return std::vector<mem_region> ();
}
std::vector<mem_region>
debug_target::memory_map ()
{
std::vector<mem_region> result;
fprintf_unfiltered (gdb_stdlog, "-> %s->memory_map (...)\n", this->beneath->shortname ());
result = this->beneath->memory_map ();
fprintf_unfiltered (gdb_stdlog, "<- %s->memory_map (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_std_vector_mem_region (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::flash_erase (ULONGEST arg0, LONGEST arg1)
{
this->beneath->flash_erase (arg0, arg1);
}
void
dummy_target::flash_erase (ULONGEST arg0, LONGEST arg1)
{
tcomplain ();
}
void
debug_target::flash_erase (ULONGEST arg0, LONGEST arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->flash_erase (...)\n", this->beneath->shortname ());
this->beneath->flash_erase (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->flash_erase (", this->beneath->shortname ());
target_debug_print_ULONGEST (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_LONGEST (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::flash_done ()
{
this->beneath->flash_done ();
}
void
dummy_target::flash_done ()
{
tcomplain ();
}
void
debug_target::flash_done ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->flash_done (...)\n", this->beneath->shortname ());
this->beneath->flash_done ();
fprintf_unfiltered (gdb_stdlog, "<- %s->flash_done (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
const struct target_desc *
target_ops::read_description ()
{
return this->beneath->read_description ();
}
const struct target_desc *
dummy_target::read_description ()
{
return NULL;
}
const struct target_desc *
debug_target::read_description ()
{
const struct target_desc * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->read_description (...)\n", this->beneath->shortname ());
result = this->beneath->read_description ();
fprintf_unfiltered (gdb_stdlog, "<- %s->read_description (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_const_struct_target_desc_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
ptid_t
target_ops::get_ada_task_ptid (long arg0, long arg1)
{
return this->beneath->get_ada_task_ptid (arg0, arg1);
}
ptid_t
dummy_target::get_ada_task_ptid (long arg0, long arg1)
{
return default_get_ada_task_ptid (this, arg0, arg1);
}
ptid_t
debug_target::get_ada_task_ptid (long arg0, long arg1)
{
ptid_t result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_ada_task_ptid (...)\n", this->beneath->shortname ());
result = this->beneath->get_ada_task_ptid (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_ada_task_ptid (", this->beneath->shortname ());
target_debug_print_long (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_long (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_ptid_t (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::auxv_parse (gdb_byte **arg0, gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3)
{
return this->beneath->auxv_parse (arg0, arg1, arg2, arg3);
}
int
dummy_target::auxv_parse (gdb_byte **arg0, gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3)
{
return default_auxv_parse (this, arg0, arg1, arg2, arg3);
}
int
debug_target::auxv_parse (gdb_byte **arg0, gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->auxv_parse (...)\n", this->beneath->shortname ());
result = this->beneath->auxv_parse (arg0, arg1, arg2, arg3);
fprintf_unfiltered (gdb_stdlog, "<- %s->auxv_parse (", this->beneath->shortname ());
target_debug_print_gdb_byte_pp (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_gdb_byte_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg3);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4)
{
return this->beneath->search_memory (arg0, arg1, arg2, arg3, arg4);
}
int
dummy_target::search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4)
{
return default_search_memory (this, arg0, arg1, arg2, arg3, arg4);
}
int
debug_target::search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->search_memory (...)\n", this->beneath->shortname ());
result = this->beneath->search_memory (arg0, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->search_memory (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_gdb_byte_p (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg4);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::can_execute_reverse ()
{
return this->beneath->can_execute_reverse ();
}
int
dummy_target::can_execute_reverse ()
{
return 0;
}
int
debug_target::can_execute_reverse ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->can_execute_reverse (...)\n", this->beneath->shortname ());
result = this->beneath->can_execute_reverse ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_execute_reverse (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
enum exec_direction_kind
target_ops::execution_direction ()
{
return this->beneath->execution_direction ();
}
enum exec_direction_kind
dummy_target::execution_direction ()
{
return default_execution_direction (this);
}
enum exec_direction_kind
debug_target::execution_direction ()
{
enum exec_direction_kind result;
fprintf_unfiltered (gdb_stdlog, "-> %s->execution_direction (...)\n", this->beneath->shortname ());
result = this->beneath->execution_direction ();
fprintf_unfiltered (gdb_stdlog, "<- %s->execution_direction (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_enum_exec_direction_kind (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::supports_multi_process ()
{
return this->beneath->supports_multi_process ();
}
int
dummy_target::supports_multi_process ()
{
return 0;
}
int
debug_target::supports_multi_process ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_multi_process (...)\n", this->beneath->shortname ());
result = this->beneath->supports_multi_process ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_multi_process (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::supports_enable_disable_tracepoint ()
{
return this->beneath->supports_enable_disable_tracepoint ();
}
int
dummy_target::supports_enable_disable_tracepoint ()
{
return 0;
}
int
debug_target::supports_enable_disable_tracepoint ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_enable_disable_tracepoint (...)\n", this->beneath->shortname ());
result = this->beneath->supports_enable_disable_tracepoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_enable_disable_tracepoint (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::supports_disable_randomization ()
{
return this->beneath->supports_disable_randomization ();
}
int
dummy_target::supports_disable_randomization ()
{
return find_default_supports_disable_randomization (this);
}
int
debug_target::supports_disable_randomization ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_disable_randomization (...)\n", this->beneath->shortname ());
result = this->beneath->supports_disable_randomization ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_disable_randomization (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::supports_string_tracing ()
{
return this->beneath->supports_string_tracing ();
}
int
dummy_target::supports_string_tracing ()
{
return 0;
}
int
debug_target::supports_string_tracing ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_string_tracing (...)\n", this->beneath->shortname ());
result = this->beneath->supports_string_tracing ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_string_tracing (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::supports_evaluation_of_breakpoint_conditions ()
{
return this->beneath->supports_evaluation_of_breakpoint_conditions ();
}
int
dummy_target::supports_evaluation_of_breakpoint_conditions ()
{
return 0;
}
int
debug_target::supports_evaluation_of_breakpoint_conditions ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_evaluation_of_breakpoint_conditions (...)\n", this->beneath->shortname ());
result = this->beneath->supports_evaluation_of_breakpoint_conditions ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_evaluation_of_breakpoint_conditions (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::can_run_breakpoint_commands ()
{
return this->beneath->can_run_breakpoint_commands ();
}
int
dummy_target::can_run_breakpoint_commands ()
{
return 0;
}
int
debug_target::can_run_breakpoint_commands ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->can_run_breakpoint_commands (...)\n", this->beneath->shortname ());
result = this->beneath->can_run_breakpoint_commands ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_run_breakpoint_commands (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
struct gdbarch *
target_ops::thread_architecture (ptid_t arg0)
{
return this->beneath->thread_architecture (arg0);
}
struct gdbarch *
dummy_target::thread_architecture (ptid_t arg0)
{
return default_thread_architecture (this, arg0);
}
struct gdbarch *
debug_target::thread_architecture (ptid_t arg0)
{
struct gdbarch * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->thread_architecture (...)\n", this->beneath->shortname ());
result = this->beneath->thread_architecture (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_architecture (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_struct_gdbarch_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
struct address_space *
target_ops::thread_address_space (ptid_t arg0)
{
return this->beneath->thread_address_space (arg0);
}
struct address_space *
dummy_target::thread_address_space (ptid_t arg0)
{
return default_thread_address_space (this, arg0);
}
struct address_space *
debug_target::thread_address_space (ptid_t arg0)
{
struct address_space * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->thread_address_space (...)\n", this->beneath->shortname ());
result = this->beneath->thread_address_space (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->thread_address_space (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_struct_address_space_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::filesystem_is_local ()
{
return this->beneath->filesystem_is_local ();
}
int
dummy_target::filesystem_is_local ()
{
return 1;
}
int
debug_target::filesystem_is_local ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->filesystem_is_local (...)\n", this->beneath->shortname ());
result = this->beneath->filesystem_is_local ();
fprintf_unfiltered (gdb_stdlog, "<- %s->filesystem_is_local (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::trace_init ()
{
this->beneath->trace_init ();
}
void
dummy_target::trace_init ()
{
tcomplain ();
}
void
debug_target::trace_init ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->trace_init (...)\n", this->beneath->shortname ());
this->beneath->trace_init ();
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_init (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::download_tracepoint (struct bp_location *arg0)
{
this->beneath->download_tracepoint (arg0);
}
void
dummy_target::download_tracepoint (struct bp_location *arg0)
{
tcomplain ();
}
void
debug_target::download_tracepoint (struct bp_location *arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->download_tracepoint (...)\n", this->beneath->shortname ());
this->beneath->download_tracepoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->download_tracepoint (", this->beneath->shortname ());
target_debug_print_struct_bp_location_p (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::can_download_tracepoint ()
{
return this->beneath->can_download_tracepoint ();
}
int
dummy_target::can_download_tracepoint ()
{
return 0;
}
int
debug_target::can_download_tracepoint ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->can_download_tracepoint (...)\n", this->beneath->shortname ());
result = this->beneath->can_download_tracepoint ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_download_tracepoint (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::download_trace_state_variable (const trace_state_variable &arg0)
{
this->beneath->download_trace_state_variable (arg0);
}
void
dummy_target::download_trace_state_variable (const trace_state_variable &arg0)
{
tcomplain ();
}
void
debug_target::download_trace_state_variable (const trace_state_variable &arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->download_trace_state_variable (...)\n", this->beneath->shortname ());
this->beneath->download_trace_state_variable (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->download_trace_state_variable (", this->beneath->shortname ());
target_debug_print_const_trace_state_variable_r (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::enable_tracepoint (struct bp_location *arg0)
{
this->beneath->enable_tracepoint (arg0);
}
void
dummy_target::enable_tracepoint (struct bp_location *arg0)
{
tcomplain ();
}
void
debug_target::enable_tracepoint (struct bp_location *arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->enable_tracepoint (...)\n", this->beneath->shortname ());
this->beneath->enable_tracepoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->enable_tracepoint (", this->beneath->shortname ());
target_debug_print_struct_bp_location_p (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::disable_tracepoint (struct bp_location *arg0)
{
this->beneath->disable_tracepoint (arg0);
}
void
dummy_target::disable_tracepoint (struct bp_location *arg0)
{
tcomplain ();
}
void
debug_target::disable_tracepoint (struct bp_location *arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->disable_tracepoint (...)\n", this->beneath->shortname ());
this->beneath->disable_tracepoint (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->disable_tracepoint (", this->beneath->shortname ());
target_debug_print_struct_bp_location_p (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::trace_set_readonly_regions ()
{
this->beneath->trace_set_readonly_regions ();
}
void
dummy_target::trace_set_readonly_regions ()
{
tcomplain ();
}
void
debug_target::trace_set_readonly_regions ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->trace_set_readonly_regions (...)\n", this->beneath->shortname ());
this->beneath->trace_set_readonly_regions ();
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_set_readonly_regions (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::trace_start ()
{
this->beneath->trace_start ();
}
void
dummy_target::trace_start ()
{
tcomplain ();
}
void
debug_target::trace_start ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->trace_start (...)\n", this->beneath->shortname ());
this->beneath->trace_start ();
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_start (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::get_trace_status (struct trace_status *arg0)
{
return this->beneath->get_trace_status (arg0);
}
int
dummy_target::get_trace_status (struct trace_status *arg0)
{
return -1;
}
int
debug_target::get_trace_status (struct trace_status *arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_trace_status (...)\n", this->beneath->shortname ());
result = this->beneath->get_trace_status (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_trace_status (", this->beneath->shortname ());
target_debug_print_struct_trace_status_p (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::get_tracepoint_status (struct breakpoint *arg0, struct uploaded_tp *arg1)
{
this->beneath->get_tracepoint_status (arg0, arg1);
}
void
dummy_target::get_tracepoint_status (struct breakpoint *arg0, struct uploaded_tp *arg1)
{
tcomplain ();
}
void
debug_target::get_tracepoint_status (struct breakpoint *arg0, struct uploaded_tp *arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->get_tracepoint_status (...)\n", this->beneath->shortname ());
this->beneath->get_tracepoint_status (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_tracepoint_status (", this->beneath->shortname ());
target_debug_print_struct_breakpoint_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_uploaded_tp_p (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::trace_stop ()
{
this->beneath->trace_stop ();
}
void
dummy_target::trace_stop ()
{
tcomplain ();
}
void
debug_target::trace_stop ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->trace_stop (...)\n", this->beneath->shortname ());
this->beneath->trace_stop ();
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_stop (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4)
{
return this->beneath->trace_find (arg0, arg1, arg2, arg3, arg4);
}
int
dummy_target::trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4)
{
return -1;
}
int
debug_target::trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->trace_find (...)\n", this->beneath->shortname ());
result = this->beneath->trace_find (arg0, arg1, arg2, arg3, arg4);
fprintf_unfiltered (gdb_stdlog, "<- %s->trace_find (", this->beneath->shortname ());
target_debug_print_enum_trace_find_type (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg2);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg3);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int_p (arg4);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::get_trace_state_variable_value (int arg0, LONGEST *arg1)
{
return this->beneath->get_trace_state_variable_value (arg0, arg1);
}
int
dummy_target::get_trace_state_variable_value (int arg0, LONGEST *arg1)
{
return 0;
}
int
debug_target::get_trace_state_variable_value (int arg0, LONGEST *arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_trace_state_variable_value (...)\n", this->beneath->shortname ());
result = this->beneath->get_trace_state_variable_value (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_trace_state_variable_value (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_LONGEST_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::save_trace_data (const char *arg0)
{
return this->beneath->save_trace_data (arg0);
}
int
dummy_target::save_trace_data (const char *arg0)
{
tcomplain ();
}
int
debug_target::save_trace_data (const char *arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->save_trace_data (...)\n", this->beneath->shortname ());
result = this->beneath->save_trace_data (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->save_trace_data (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::upload_tracepoints (struct uploaded_tp **arg0)
{
return this->beneath->upload_tracepoints (arg0);
}
int
dummy_target::upload_tracepoints (struct uploaded_tp **arg0)
{
return 0;
}
int
debug_target::upload_tracepoints (struct uploaded_tp **arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->upload_tracepoints (...)\n", this->beneath->shortname ());
result = this->beneath->upload_tracepoints (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->upload_tracepoints (", this->beneath->shortname ());
target_debug_print_struct_uploaded_tp_pp (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::upload_trace_state_variables (struct uploaded_tsv **arg0)
{
return this->beneath->upload_trace_state_variables (arg0);
}
int
dummy_target::upload_trace_state_variables (struct uploaded_tsv **arg0)
{
return 0;
}
int
debug_target::upload_trace_state_variables (struct uploaded_tsv **arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->upload_trace_state_variables (...)\n", this->beneath->shortname ());
result = this->beneath->upload_trace_state_variables (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->upload_trace_state_variables (", this->beneath->shortname ());
target_debug_print_struct_uploaded_tsv_pp (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
LONGEST
target_ops::get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2)
{
return this->beneath->get_raw_trace_data (arg0, arg1, arg2);
}
LONGEST
dummy_target::get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2)
{
tcomplain ();
}
LONGEST
debug_target::get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2)
{
LONGEST result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_raw_trace_data (...)\n", this->beneath->shortname ());
result = this->beneath->get_raw_trace_data (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_raw_trace_data (", this->beneath->shortname ());
target_debug_print_gdb_byte_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_LONGEST (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_LONGEST (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::get_min_fast_tracepoint_insn_len ()
{
return this->beneath->get_min_fast_tracepoint_insn_len ();
}
int
dummy_target::get_min_fast_tracepoint_insn_len ()
{
return -1;
}
int
debug_target::get_min_fast_tracepoint_insn_len ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_min_fast_tracepoint_insn_len (...)\n", this->beneath->shortname ());
result = this->beneath->get_min_fast_tracepoint_insn_len ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_min_fast_tracepoint_insn_len (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::set_disconnected_tracing (int arg0)
{
this->beneath->set_disconnected_tracing (arg0);
}
void
dummy_target::set_disconnected_tracing (int arg0)
{
}
void
debug_target::set_disconnected_tracing (int arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->set_disconnected_tracing (...)\n", this->beneath->shortname ());
this->beneath->set_disconnected_tracing (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_disconnected_tracing (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::set_circular_trace_buffer (int arg0)
{
this->beneath->set_circular_trace_buffer (arg0);
}
void
dummy_target::set_circular_trace_buffer (int arg0)
{
}
void
debug_target::set_circular_trace_buffer (int arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->set_circular_trace_buffer (...)\n", this->beneath->shortname ());
this->beneath->set_circular_trace_buffer (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_circular_trace_buffer (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::set_trace_buffer_size (LONGEST arg0)
{
this->beneath->set_trace_buffer_size (arg0);
}
void
dummy_target::set_trace_buffer_size (LONGEST arg0)
{
}
void
debug_target::set_trace_buffer_size (LONGEST arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->set_trace_buffer_size (...)\n", this->beneath->shortname ());
this->beneath->set_trace_buffer_size (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_trace_buffer_size (", this->beneath->shortname ());
target_debug_print_LONGEST (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::set_trace_notes (const char *arg0, const char *arg1, const char *arg2)
{
return this->beneath->set_trace_notes (arg0, arg1, arg2);
}
int
dummy_target::set_trace_notes (const char *arg0, const char *arg1, const char *arg2)
{
return 0;
}
int
debug_target::set_trace_notes (const char *arg0, const char *arg1, const char *arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->set_trace_notes (...)\n", this->beneath->shortname ());
result = this->beneath->set_trace_notes (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->set_trace_notes (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_char_p (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::core_of_thread (ptid_t arg0)
{
return this->beneath->core_of_thread (arg0);
}
int
dummy_target::core_of_thread (ptid_t arg0)
{
return -1;
}
int
debug_target::core_of_thread (ptid_t arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->core_of_thread (...)\n", this->beneath->shortname ());
result = this->beneath->core_of_thread (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->core_of_thread (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2)
{
return this->beneath->verify_memory (arg0, arg1, arg2);
}
int
dummy_target::verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2)
{
return default_verify_memory (this, arg0, arg1, arg2);
}
int
debug_target::verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->verify_memory (...)\n", this->beneath->shortname ());
result = this->beneath->verify_memory (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->verify_memory (", this->beneath->shortname ());
target_debug_print_const_gdb_byte_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::get_tib_address (ptid_t arg0, CORE_ADDR *arg1)
{
return this->beneath->get_tib_address (arg0, arg1);
}
int
dummy_target::get_tib_address (ptid_t arg0, CORE_ADDR *arg1)
{
tcomplain ();
}
int
debug_target::get_tib_address (ptid_t arg0, CORE_ADDR *arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_tib_address (...)\n", this->beneath->shortname ());
result = this->beneath->get_tib_address (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->get_tib_address (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_CORE_ADDR_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::set_permissions ()
{
this->beneath->set_permissions ();
}
void
dummy_target::set_permissions ()
{
}
void
debug_target::set_permissions ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->set_permissions (...)\n", this->beneath->shortname ());
this->beneath->set_permissions ();
fprintf_unfiltered (gdb_stdlog, "<- %s->set_permissions (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
bool
target_ops::static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1)
{
return this->beneath->static_tracepoint_marker_at (arg0, arg1);
}
bool
dummy_target::static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1)
{
return false;
}
bool
debug_target::static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1)
{
bool result;
fprintf_unfiltered (gdb_stdlog, "-> %s->static_tracepoint_marker_at (...)\n", this->beneath->shortname ());
result = this->beneath->static_tracepoint_marker_at (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->static_tracepoint_marker_at (", this->beneath->shortname ());
target_debug_print_CORE_ADDR (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_static_tracepoint_marker_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_bool (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
std::vector<static_tracepoint_marker>
target_ops::static_tracepoint_markers_by_strid (const char *arg0)
{
return this->beneath->static_tracepoint_markers_by_strid (arg0);
}
std::vector<static_tracepoint_marker>
dummy_target::static_tracepoint_markers_by_strid (const char *arg0)
{
tcomplain ();
}
std::vector<static_tracepoint_marker>
debug_target::static_tracepoint_markers_by_strid (const char *arg0)
{
std::vector<static_tracepoint_marker> result;
fprintf_unfiltered (gdb_stdlog, "-> %s->static_tracepoint_markers_by_strid (...)\n", this->beneath->shortname ());
result = this->beneath->static_tracepoint_markers_by_strid (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->static_tracepoint_markers_by_strid (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_std_vector_static_tracepoint_marker (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
traceframe_info_up
target_ops::traceframe_info ()
{
return this->beneath->traceframe_info ();
}
traceframe_info_up
dummy_target::traceframe_info ()
{
tcomplain ();
}
traceframe_info_up
debug_target::traceframe_info ()
{
traceframe_info_up result;
fprintf_unfiltered (gdb_stdlog, "-> %s->traceframe_info (...)\n", this->beneath->shortname ());
result = this->beneath->traceframe_info ();
fprintf_unfiltered (gdb_stdlog, "<- %s->traceframe_info (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_traceframe_info_up (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::use_agent (int arg0)
{
return this->beneath->use_agent (arg0);
}
int
dummy_target::use_agent (int arg0)
{
tcomplain ();
}
int
debug_target::use_agent (int arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->use_agent (...)\n", this->beneath->shortname ());
result = this->beneath->use_agent (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->use_agent (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::can_use_agent ()
{
return this->beneath->can_use_agent ();
}
int
dummy_target::can_use_agent ()
{
return 0;
}
int
debug_target::can_use_agent ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->can_use_agent (...)\n", this->beneath->shortname ());
result = this->beneath->can_use_agent ();
fprintf_unfiltered (gdb_stdlog, "<- %s->can_use_agent (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
struct btrace_target_info *
target_ops::enable_btrace (ptid_t arg0, const struct btrace_config *arg1)
{
return this->beneath->enable_btrace (arg0, arg1);
}
struct btrace_target_info *
dummy_target::enable_btrace (ptid_t arg0, const struct btrace_config *arg1)
{
tcomplain ();
}
struct btrace_target_info *
debug_target::enable_btrace (ptid_t arg0, const struct btrace_config *arg1)
{
struct btrace_target_info * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->enable_btrace (...)\n", this->beneath->shortname ());
result = this->beneath->enable_btrace (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->enable_btrace (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_const_struct_btrace_config_p (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_struct_btrace_target_info_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::disable_btrace (struct btrace_target_info *arg0)
{
this->beneath->disable_btrace (arg0);
}
void
dummy_target::disable_btrace (struct btrace_target_info *arg0)
{
tcomplain ();
}
void
debug_target::disable_btrace (struct btrace_target_info *arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->disable_btrace (...)\n", this->beneath->shortname ());
this->beneath->disable_btrace (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->disable_btrace (", this->beneath->shortname ());
target_debug_print_struct_btrace_target_info_p (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::teardown_btrace (struct btrace_target_info *arg0)
{
this->beneath->teardown_btrace (arg0);
}
void
dummy_target::teardown_btrace (struct btrace_target_info *arg0)
{
tcomplain ();
}
void
debug_target::teardown_btrace (struct btrace_target_info *arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->teardown_btrace (...)\n", this->beneath->shortname ());
this->beneath->teardown_btrace (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->teardown_btrace (", this->beneath->shortname ());
target_debug_print_struct_btrace_target_info_p (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
enum btrace_error
target_ops::read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2)
{
return this->beneath->read_btrace (arg0, arg1, arg2);
}
enum btrace_error
dummy_target::read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2)
{
tcomplain ();
}
enum btrace_error
debug_target::read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2)
{
enum btrace_error result;
fprintf_unfiltered (gdb_stdlog, "-> %s->read_btrace (...)\n", this->beneath->shortname ());
result = this->beneath->read_btrace (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->read_btrace (", this->beneath->shortname ());
target_debug_print_struct_btrace_data_p (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_struct_btrace_target_info_p (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_enum_btrace_read_type (arg2);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_enum_btrace_error (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
const struct btrace_config *
target_ops::btrace_conf (const struct btrace_target_info *arg0)
{
return this->beneath->btrace_conf (arg0);
}
const struct btrace_config *
dummy_target::btrace_conf (const struct btrace_target_info *arg0)
{
return NULL;
}
const struct btrace_config *
debug_target::btrace_conf (const struct btrace_target_info *arg0)
{
const struct btrace_config * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->btrace_conf (...)\n", this->beneath->shortname ());
result = this->beneath->btrace_conf (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->btrace_conf (", this->beneath->shortname ());
target_debug_print_const_struct_btrace_target_info_p (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_const_struct_btrace_config_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
enum record_method
target_ops::record_method (ptid_t arg0)
{
return this->beneath->record_method (arg0);
}
enum record_method
dummy_target::record_method (ptid_t arg0)
{
return RECORD_METHOD_NONE;
}
enum record_method
debug_target::record_method (ptid_t arg0)
{
enum record_method result;
fprintf_unfiltered (gdb_stdlog, "-> %s->record_method (...)\n", this->beneath->shortname ());
result = this->beneath->record_method (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->record_method (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_enum_record_method (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::stop_recording ()
{
this->beneath->stop_recording ();
}
void
dummy_target::stop_recording ()
{
}
void
debug_target::stop_recording ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->stop_recording (...)\n", this->beneath->shortname ());
this->beneath->stop_recording ();
fprintf_unfiltered (gdb_stdlog, "<- %s->stop_recording (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::info_record ()
{
this->beneath->info_record ();
}
void
dummy_target::info_record ()
{
}
void
debug_target::info_record ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->info_record (...)\n", this->beneath->shortname ());
this->beneath->info_record ();
fprintf_unfiltered (gdb_stdlog, "<- %s->info_record (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::save_record (const char *arg0)
{
this->beneath->save_record (arg0);
}
void
dummy_target::save_record (const char *arg0)
{
tcomplain ();
}
void
debug_target::save_record (const char *arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->save_record (...)\n", this->beneath->shortname ());
this->beneath->save_record (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->save_record (", this->beneath->shortname ());
target_debug_print_const_char_p (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
bool
target_ops::supports_delete_record ()
{
return this->beneath->supports_delete_record ();
}
bool
dummy_target::supports_delete_record ()
{
return false;
}
bool
debug_target::supports_delete_record ()
{
bool result;
fprintf_unfiltered (gdb_stdlog, "-> %s->supports_delete_record (...)\n", this->beneath->shortname ());
result = this->beneath->supports_delete_record ();
fprintf_unfiltered (gdb_stdlog, "<- %s->supports_delete_record (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_bool (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::delete_record ()
{
this->beneath->delete_record ();
}
void
dummy_target::delete_record ()
{
tcomplain ();
}
void
debug_target::delete_record ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->delete_record (...)\n", this->beneath->shortname ());
this->beneath->delete_record ();
fprintf_unfiltered (gdb_stdlog, "<- %s->delete_record (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::record_is_replaying (ptid_t arg0)
{
return this->beneath->record_is_replaying (arg0);
}
int
dummy_target::record_is_replaying (ptid_t arg0)
{
return 0;
}
int
debug_target::record_is_replaying (ptid_t arg0)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->record_is_replaying (...)\n", this->beneath->shortname ());
result = this->beneath->record_is_replaying (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->record_is_replaying (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
int
target_ops::record_will_replay (ptid_t arg0, int arg1)
{
return this->beneath->record_will_replay (arg0, arg1);
}
int
dummy_target::record_will_replay (ptid_t arg0, int arg1)
{
return 0;
}
int
debug_target::record_will_replay (ptid_t arg0, int arg1)
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->record_will_replay (...)\n", this->beneath->shortname ());
result = this->beneath->record_will_replay (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->record_will_replay (", this->beneath->shortname ());
target_debug_print_ptid_t (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::record_stop_replaying ()
{
this->beneath->record_stop_replaying ();
}
void
dummy_target::record_stop_replaying ()
{
}
void
debug_target::record_stop_replaying ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->record_stop_replaying (...)\n", this->beneath->shortname ());
this->beneath->record_stop_replaying ();
fprintf_unfiltered (gdb_stdlog, "<- %s->record_stop_replaying (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::goto_record_begin ()
{
this->beneath->goto_record_begin ();
}
void
dummy_target::goto_record_begin ()
{
tcomplain ();
}
void
debug_target::goto_record_begin ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->goto_record_begin (...)\n", this->beneath->shortname ());
this->beneath->goto_record_begin ();
fprintf_unfiltered (gdb_stdlog, "<- %s->goto_record_begin (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::goto_record_end ()
{
this->beneath->goto_record_end ();
}
void
dummy_target::goto_record_end ()
{
tcomplain ();
}
void
debug_target::goto_record_end ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->goto_record_end (...)\n", this->beneath->shortname ());
this->beneath->goto_record_end ();
fprintf_unfiltered (gdb_stdlog, "<- %s->goto_record_end (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::goto_record (ULONGEST arg0)
{
this->beneath->goto_record (arg0);
}
void
dummy_target::goto_record (ULONGEST arg0)
{
tcomplain ();
}
void
debug_target::goto_record (ULONGEST arg0)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->goto_record (...)\n", this->beneath->shortname ());
this->beneath->goto_record (arg0);
fprintf_unfiltered (gdb_stdlog, "<- %s->goto_record (", this->beneath->shortname ());
target_debug_print_ULONGEST (arg0);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::insn_history (int arg0, gdb_disassembly_flags arg1)
{
this->beneath->insn_history (arg0, arg1);
}
void
dummy_target::insn_history (int arg0, gdb_disassembly_flags arg1)
{
tcomplain ();
}
void
debug_target::insn_history (int arg0, gdb_disassembly_flags arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->insn_history (...)\n", this->beneath->shortname ());
this->beneath->insn_history (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->insn_history (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_gdb_disassembly_flags (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2)
{
this->beneath->insn_history_from (arg0, arg1, arg2);
}
void
dummy_target::insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2)
{
tcomplain ();
}
void
debug_target::insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->insn_history_from (...)\n", this->beneath->shortname ());
this->beneath->insn_history_from (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->insn_history_from (", this->beneath->shortname ());
target_debug_print_ULONGEST (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_gdb_disassembly_flags (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2)
{
this->beneath->insn_history_range (arg0, arg1, arg2);
}
void
dummy_target::insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2)
{
tcomplain ();
}
void
debug_target::insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->insn_history_range (...)\n", this->beneath->shortname ());
this->beneath->insn_history_range (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->insn_history_range (", this->beneath->shortname ());
target_debug_print_ULONGEST (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_gdb_disassembly_flags (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::call_history (int arg0, record_print_flags arg1)
{
this->beneath->call_history (arg0, arg1);
}
void
dummy_target::call_history (int arg0, record_print_flags arg1)
{
tcomplain ();
}
void
debug_target::call_history (int arg0, record_print_flags arg1)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->call_history (...)\n", this->beneath->shortname ());
this->beneath->call_history (arg0, arg1);
fprintf_unfiltered (gdb_stdlog, "<- %s->call_history (", this->beneath->shortname ());
target_debug_print_int (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_record_print_flags (arg1);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2)
{
this->beneath->call_history_from (arg0, arg1, arg2);
}
void
dummy_target::call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2)
{
tcomplain ();
}
void
debug_target::call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->call_history_from (...)\n", this->beneath->shortname ());
this->beneath->call_history_from (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->call_history_from (", this->beneath->shortname ());
target_debug_print_ULONGEST (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_int (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_record_print_flags (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2)
{
this->beneath->call_history_range (arg0, arg1, arg2);
}
void
dummy_target::call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2)
{
tcomplain ();
}
void
debug_target::call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2)
{
fprintf_unfiltered (gdb_stdlog, "-> %s->call_history_range (...)\n", this->beneath->shortname ());
this->beneath->call_history_range (arg0, arg1, arg2);
fprintf_unfiltered (gdb_stdlog, "<- %s->call_history_range (", this->beneath->shortname ());
target_debug_print_ULONGEST (arg0);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_ULONGEST (arg1);
fputs_unfiltered (", ", gdb_stdlog);
target_debug_print_record_print_flags (arg2);
fputs_unfiltered (")\n", gdb_stdlog);
}
int
target_ops::augmented_libraries_svr4_read ()
{
return this->beneath->augmented_libraries_svr4_read ();
}
int
dummy_target::augmented_libraries_svr4_read ()
{
return 0;
}
int
debug_target::augmented_libraries_svr4_read ()
{
int result;
fprintf_unfiltered (gdb_stdlog, "-> %s->augmented_libraries_svr4_read (...)\n", this->beneath->shortname ());
result = this->beneath->augmented_libraries_svr4_read ();
fprintf_unfiltered (gdb_stdlog, "<- %s->augmented_libraries_svr4_read (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_int (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
const struct frame_unwind *
target_ops::get_unwinder ()
{
return this->beneath->get_unwinder ();
}
const struct frame_unwind *
dummy_target::get_unwinder ()
{
return NULL;
}
const struct frame_unwind *
debug_target::get_unwinder ()
{
const struct frame_unwind * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_unwinder (...)\n", this->beneath->shortname ());
result = this->beneath->get_unwinder ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_unwinder (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_const_struct_frame_unwind_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
const struct frame_unwind *
target_ops::get_tailcall_unwinder ()
{
return this->beneath->get_tailcall_unwinder ();
}
const struct frame_unwind *
dummy_target::get_tailcall_unwinder ()
{
return NULL;
}
const struct frame_unwind *
debug_target::get_tailcall_unwinder ()
{
const struct frame_unwind * result;
fprintf_unfiltered (gdb_stdlog, "-> %s->get_tailcall_unwinder (...)\n", this->beneath->shortname ());
result = this->beneath->get_tailcall_unwinder ();
fprintf_unfiltered (gdb_stdlog, "<- %s->get_tailcall_unwinder (", this->beneath->shortname ());
fputs_unfiltered (") = ", gdb_stdlog);
target_debug_print_const_struct_frame_unwind_p (result);
fputs_unfiltered ("\n", gdb_stdlog);
return result;
}
void
target_ops::prepare_to_generate_core ()
{
this->beneath->prepare_to_generate_core ();
}
void
dummy_target::prepare_to_generate_core ()
{
}
void
debug_target::prepare_to_generate_core ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->prepare_to_generate_core (...)\n", this->beneath->shortname ());
this->beneath->prepare_to_generate_core ();
fprintf_unfiltered (gdb_stdlog, "<- %s->prepare_to_generate_core (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
void
target_ops::done_generating_core ()
{
this->beneath->done_generating_core ();
}
void
dummy_target::done_generating_core ()
{
}
void
debug_target::done_generating_core ()
{
fprintf_unfiltered (gdb_stdlog, "-> %s->done_generating_core (...)\n", this->beneath->shortname ());
this->beneath->done_generating_core ();
fprintf_unfiltered (gdb_stdlog, "<- %s->done_generating_core (", this->beneath->shortname ());
fputs_unfiltered (")\n", gdb_stdlog);
}
Reference in New Issue View Git Blame Copy Permalink