gdb/target-delegates.c

   1 /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
   2 /* vi:set ro: */
   3
   4 /* Boilerplate target methods for GDB
   5
   6    Copyright (C) 2013-2023 Free Software Foundation, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* To regenerate this file, run:
  24    ./make-target-delegates.py
  25 */
  26
  27 struct dummy_target : public target_ops
  28 {
  29   const target_info &info () const override;
  30
  31   strata stratum () const override;
  32
  33   void post_attach (int arg0) override;
  34   void detach (inferior *arg0, int arg1) override;
  35   void disconnect (const char *arg0, int arg1) override;
  36   void resume (ptid_t arg0, int arg1, enum gdb_signal arg2) override;
  37   void commit_resumed () override;
  38   ptid_t wait (ptid_t arg0, struct target_waitstatus *arg1, target_wait_flags arg2) override;
  39   void fetch_registers (struct regcache *arg0, int arg1) override;
  40   void store_registers (struct regcache *arg0, int arg1) override;
  41   void prepare_to_store (struct regcache *arg0) override;
  42   void files_info () override;
  43   int insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
  44   int remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2) override;
  45   bool stopped_by_sw_breakpoint () override;
  46   bool supports_stopped_by_sw_breakpoint () override;
  47   bool stopped_by_hw_breakpoint () override;
  48   bool supports_stopped_by_hw_breakpoint () override;
  49   int can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2) override;
  50   int ranged_break_num_registers () override;
  51   int insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
  52   int remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
  53   int remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
  54   int insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
  55   int insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
  56   int remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
  57   bool stopped_by_watchpoint () override;
  58   bool have_steppable_watchpoint () override;
  59   bool stopped_data_address (CORE_ADDR *arg0) override;
  60   bool watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2) override;
  61   int region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1) override;
  62   bool can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3) override;
  63   int masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1) override;
  64   int can_do_single_step () override;
  65   bool supports_terminal_ours () override;
  66   void terminal_init () override;
  67   void terminal_inferior () override;
  68   void terminal_save_inferior () override;
  69   void terminal_ours_for_output () override;
  70   void terminal_ours () override;
  71   void terminal_info (const char *arg0, int arg1) override;
  72   void kill () override;
  73   void load (const char *arg0, int arg1) override;
  74   int insert_fork_catchpoint (int arg0) override;
  75   int remove_fork_catchpoint (int arg0) override;
  76   int insert_vfork_catchpoint (int arg0) override;
  77   int remove_vfork_catchpoint (int arg0) override;
  78   void follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4) override;
  79   int insert_exec_catchpoint (int arg0) override;
  80   int remove_exec_catchpoint (int arg0) override;
  81   void follow_exec (inferior *arg0, ptid_t arg1, const char *arg2) override;
  82   int set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3) override;
  83   void mourn_inferior () override;
  84   void pass_signals (gdb::array_view<const unsigned char> arg0) override;
  85   void program_signals (gdb::array_view<const unsigned char> arg0) override;
  86   bool thread_alive (ptid_t arg0) override;
  87   void update_thread_list () override;
  88   std::string pid_to_str (ptid_t arg0) override;
  89   const char *extra_thread_info (thread_info *arg0) override;
  90   const char *thread_name (thread_info *arg0) override;
  91   thread_info *thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2) override;
  92   gdb::array_view<const_gdb_byte> thread_info_to_thread_handle (struct thread_info *arg0) override;
  93   void stop (ptid_t arg0) override;
  94   void interrupt () override;
  95   void pass_ctrlc () override;
  96   void rcmd (const char *arg0, struct ui_file *arg1) override;
  97   const char *pid_to_exec_file (int arg0) override;
  98   void log_command (const char *arg0) override;
  99   const std::vector<target_section> *get_section_table () override;
 100   thread_control_capabilities get_thread_control_capabilities () override;
 101   bool attach_no_wait () override;
 102   bool can_async_p () override;
 103   bool is_async_p () override;
 104   void async (bool arg0) override;
 105   int async_wait_fd () override;
 106   bool has_pending_events () override;
 107   void thread_events (int arg0) override;
 108   bool supports_non_stop () override;
 109   bool always_non_stop_p () override;
 110   int find_memory_regions (find_memory_region_ftype arg0, void *arg1) override;
 111   gdb::unique_xmalloc_ptr<char> make_corefile_notes (bfd *arg0, int *arg1) override;
 112   gdb_byte *get_bookmark (const char *arg0, int arg1) override;
 113   void goto_bookmark (const gdb_byte *arg0, int arg1) override;
 114   CORE_ADDR get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2) override;
 115   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;
 116   ULONGEST get_memory_xfer_limit () override;
 117   std::vector<mem_region> memory_map () override;
 118   void flash_erase (ULONGEST arg0, LONGEST arg1) override;
 119   void flash_done () override;
 120   const struct target_desc *read_description () override;
 121   ptid_t get_ada_task_ptid (long arg0, ULONGEST arg1) override;
 122   int auxv_parse (const gdb_byte **arg0, const gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3) override;
 123   int search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4) override;
 124   bool can_execute_reverse () override;
 125   enum exec_direction_kind execution_direction () override;
 126   bool supports_multi_process () override;
 127   bool supports_enable_disable_tracepoint () override;
 128   bool supports_disable_randomization () override;
 129   bool supports_string_tracing () override;
 130   bool supports_evaluation_of_breakpoint_conditions () override;
 131   bool supports_dumpcore () override;
 132   void dumpcore (const char *arg0) override;
 133   bool can_run_breakpoint_commands () override;
 134   struct gdbarch *thread_architecture (ptid_t arg0) override;
 135   struct address_space *thread_address_space (ptid_t arg0) override;
 136   bool filesystem_is_local () override;
 137   void trace_init () override;
 138   void download_tracepoint (struct bp_location *arg0) override;
 139   bool can_download_tracepoint () override;
 140   void download_trace_state_variable (const trace_state_variable &arg0) override;
 141   void enable_tracepoint (struct bp_location *arg0) override;
 142   void disable_tracepoint (struct bp_location *arg0) override;
 143   void trace_set_readonly_regions () override;
 144   void trace_start () override;
 145   int get_trace_status (struct trace_status *arg0) override;
 146   void get_tracepoint_status (tracepoint *arg0, struct uploaded_tp *arg1) override;
 147   void trace_stop () override;
 148   int trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4) override;
 149   bool get_trace_state_variable_value (int arg0, LONGEST *arg1) override;
 150   int save_trace_data (const char *arg0) override;
 151   int upload_tracepoints (struct uploaded_tp **arg0) override;
 152   int upload_trace_state_variables (struct uploaded_tsv **arg0) override;
 153   LONGEST get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2) override;
 154   int get_min_fast_tracepoint_insn_len () override;
 155   void set_disconnected_tracing (int arg0) override;
 156   void set_circular_trace_buffer (int arg0) override;
 157   void set_trace_buffer_size (LONGEST arg0) override;
 158   bool set_trace_notes (const char *arg0, const char *arg1, const char *arg2) override;
 159   int core_of_thread (ptid_t arg0) override;
 160   int verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2) override;
 161   bool get_tib_address (ptid_t arg0, CORE_ADDR *arg1) override;
 162   void set_permissions () override;
 163   bool static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1) override;
 164   std::vector<static_tracepoint_marker> static_tracepoint_markers_by_strid (const char *arg0) override;
 165   traceframe_info_up traceframe_info () override;
 166   bool use_agent (bool arg0) override;
 167   bool can_use_agent () override;
 168   struct btrace_target_info *enable_btrace (thread_info *arg0, const struct btrace_config *arg1) override;
 169   void disable_btrace (struct btrace_target_info *arg0) override;
 170   void teardown_btrace (struct btrace_target_info *arg0) override;
 171   enum btrace_error read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2) override;
 172   const struct btrace_config *btrace_conf (const struct btrace_target_info *arg0) override;
 173   enum record_method record_method (ptid_t arg0) override;
 174   void stop_recording () override;
 175   void info_record () override;
 176   void save_record (const char *arg0) override;
 177   bool supports_delete_record () override;
 178   void delete_record () override;
 179   bool record_is_replaying (ptid_t arg0) override;
 180   bool record_will_replay (ptid_t arg0, int arg1) override;
 181   void record_stop_replaying () override;
 182   void goto_record_begin () override;
 183   void goto_record_end () override;
 184   void goto_record (ULONGEST arg0) override;
 185   void insn_history (int arg0, gdb_disassembly_flags arg1) override;
 186   void insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2) override;
 187   void insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2) override;
 188   void call_history (int arg0, record_print_flags arg1) override;
 189   void call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2) override;
 190   void call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2) override;
 191   bool augmented_libraries_svr4_read () override;
 192   const struct frame_unwind *get_unwinder () override;
 193   const struct frame_unwind *get_tailcall_unwinder () override;
 194   void prepare_to_generate_core () override;
 195   void done_generating_core () override;
 196   bool supports_memory_tagging () override;
 197   bool fetch_memtags (CORE_ADDR arg0, size_t arg1, gdb::byte_vector &arg2, int arg3) override;
 198   bool store_memtags (CORE_ADDR arg0, size_t arg1, const gdb::byte_vector &arg2, int arg3) override;
 199   x86_xsave_layout fetch_x86_xsave_layout () override;
 200 };
 201
 202 struct debug_target : public target_ops
 203 {
 204   const target_info &info () const override;
 205
 206   strata stratum () const override;
 207
 208   void post_attach (int arg0) override;
 209   void detach (inferior *arg0, int arg1) override;
 210   void disconnect (const char *arg0, int arg1) override;
 211   void resume (ptid_t arg0, int arg1, enum gdb_signal arg2) override;
 212   void commit_resumed () override;
 213   ptid_t wait (ptid_t arg0, struct target_waitstatus *arg1, target_wait_flags arg2) override;
 214   void fetch_registers (struct regcache *arg0, int arg1) override;
 215   void store_registers (struct regcache *arg0, int arg1) override;
 216   void prepare_to_store (struct regcache *arg0) override;
 217   void files_info () override;
 218   int insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
 219   int remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2) override;
 220   bool stopped_by_sw_breakpoint () override;
 221   bool supports_stopped_by_sw_breakpoint () override;
 222   bool stopped_by_hw_breakpoint () override;
 223   bool supports_stopped_by_hw_breakpoint () override;
 224   int can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2) override;
 225   int ranged_break_num_registers () override;
 226   int insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
 227   int remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
 228   int remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
 229   int insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
 230   int insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
 231   int remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
 232   bool stopped_by_watchpoint () override;
 233   bool have_steppable_watchpoint () override;
 234   bool stopped_data_address (CORE_ADDR *arg0) override;
 235   bool watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2) override;
 236   int region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1) override;
 237   bool can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3) override;
 238   int masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1) override;
 239   int can_do_single_step () override;
 240   bool supports_terminal_ours () override;
 241   void terminal_init () override;
 242   void terminal_inferior () override;
 243   void terminal_save_inferior () override;
 244   void terminal_ours_for_output () override;
 245   void terminal_ours () override;
 246   void terminal_info (const char *arg0, int arg1) override;
 247   void kill () override;
 248   void load (const char *arg0, int arg1) override;
 249   int insert_fork_catchpoint (int arg0) override;
 250   int remove_fork_catchpoint (int arg0) override;
 251   int insert_vfork_catchpoint (int arg0) override;
 252   int remove_vfork_catchpoint (int arg0) override;
 253   void follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4) override;
 254   int insert_exec_catchpoint (int arg0) override;
 255   int remove_exec_catchpoint (int arg0) override;
 256   void follow_exec (inferior *arg0, ptid_t arg1, const char *arg2) override;
 257   int set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3) override;
 258   void mourn_inferior () override;
 259   void pass_signals (gdb::array_view<const unsigned char> arg0) override;
 260   void program_signals (gdb::array_view<const unsigned char> arg0) override;
 261   bool thread_alive (ptid_t arg0) override;
 262   void update_thread_list () override;
 263   std::string pid_to_str (ptid_t arg0) override;
 264   const char *extra_thread_info (thread_info *arg0) override;
 265   const char *thread_name (thread_info *arg0) override;
 266   thread_info *thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2) override;
 267   gdb::array_view<const_gdb_byte> thread_info_to_thread_handle (struct thread_info *arg0) override;
 268   void stop (ptid_t arg0) override;
 269   void interrupt () override;
 270   void pass_ctrlc () override;
 271   void rcmd (const char *arg0, struct ui_file *arg1) override;
 272   const char *pid_to_exec_file (int arg0) override;
 273   void log_command (const char *arg0) override;
 274   const std::vector<target_section> *get_section_table () override;
 275   thread_control_capabilities get_thread_control_capabilities () override;
 276   bool attach_no_wait () override;
 277   bool can_async_p () override;
 278   bool is_async_p () override;
 279   void async (bool arg0) override;
 280   int async_wait_fd () override;
 281   bool has_pending_events () override;
 282   void thread_events (int arg0) override;
 283   bool supports_non_stop () override;
 284   bool always_non_stop_p () override;
 285   int find_memory_regions (find_memory_region_ftype arg0, void *arg1) override;
 286   gdb::unique_xmalloc_ptr<char> make_corefile_notes (bfd *arg0, int *arg1) override;
 287   gdb_byte *get_bookmark (const char *arg0, int arg1) override;
 288   void goto_bookmark (const gdb_byte *arg0, int arg1) override;
 289   CORE_ADDR get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2) override;
 290   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;
 291   ULONGEST get_memory_xfer_limit () override;
 292   std::vector<mem_region> memory_map () override;
 293   void flash_erase (ULONGEST arg0, LONGEST arg1) override;
 294   void flash_done () override;
 295   const struct target_desc *read_description () override;
 296   ptid_t get_ada_task_ptid (long arg0, ULONGEST arg1) override;
 297   int auxv_parse (const gdb_byte **arg0, const gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3) override;
 298   int search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4) override;
 299   bool can_execute_reverse () override;
 300   enum exec_direction_kind execution_direction () override;
 301   bool supports_multi_process () override;
 302   bool supports_enable_disable_tracepoint () override;
 303   bool supports_disable_randomization () override;
 304   bool supports_string_tracing () override;
 305   bool supports_evaluation_of_breakpoint_conditions () override;
 306   bool supports_dumpcore () override;
 307   void dumpcore (const char *arg0) override;
 308   bool can_run_breakpoint_commands () override;
 309   struct gdbarch *thread_architecture (ptid_t arg0) override;
 310   struct address_space *thread_address_space (ptid_t arg0) override;
 311   bool filesystem_is_local () override;
 312   void trace_init () override;
 313   void download_tracepoint (struct bp_location *arg0) override;
 314   bool can_download_tracepoint () override;
 315   void download_trace_state_variable (const trace_state_variable &arg0) override;
 316   void enable_tracepoint (struct bp_location *arg0) override;
 317   void disable_tracepoint (struct bp_location *arg0) override;
 318   void trace_set_readonly_regions () override;
 319   void trace_start () override;
 320   int get_trace_status (struct trace_status *arg0) override;
 321   void get_tracepoint_status (tracepoint *arg0, struct uploaded_tp *arg1) override;
 322   void trace_stop () override;
 323   int trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4) override;
 324   bool get_trace_state_variable_value (int arg0, LONGEST *arg1) override;
 325   int save_trace_data (const char *arg0) override;
 326   int upload_tracepoints (struct uploaded_tp **arg0) override;
 327   int upload_trace_state_variables (struct uploaded_tsv **arg0) override;
 328   LONGEST get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2) override;
 329   int get_min_fast_tracepoint_insn_len () override;
 330   void set_disconnected_tracing (int arg0) override;
 331   void set_circular_trace_buffer (int arg0) override;
 332   void set_trace_buffer_size (LONGEST arg0) override;
 333   bool set_trace_notes (const char *arg0, const char *arg1, const char *arg2) override;
 334   int core_of_thread (ptid_t arg0) override;
 335   int verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2) override;
 336   bool get_tib_address (ptid_t arg0, CORE_ADDR *arg1) override;
 337   void set_permissions () override;
 338   bool static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1) override;
 339   std::vector<static_tracepoint_marker> static_tracepoint_markers_by_strid (const char *arg0) override;
 340   traceframe_info_up traceframe_info () override;
 341   bool use_agent (bool arg0) override;
 342   bool can_use_agent () override;
 343   struct btrace_target_info *enable_btrace (thread_info *arg0, const struct btrace_config *arg1) override;
 344   void disable_btrace (struct btrace_target_info *arg0) override;
 345   void teardown_btrace (struct btrace_target_info *arg0) override;
 346   enum btrace_error read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2) override;
 347   const struct btrace_config *btrace_conf (const struct btrace_target_info *arg0) override;
 348   enum record_method record_method (ptid_t arg0) override;
 349   void stop_recording () override;
 350   void info_record () override;
 351   void save_record (const char *arg0) override;
 352   bool supports_delete_record () override;
 353   void delete_record () override;
 354   bool record_is_replaying (ptid_t arg0) override;
 355   bool record_will_replay (ptid_t arg0, int arg1) override;
 356   void record_stop_replaying () override;
 357   void goto_record_begin () override;
 358   void goto_record_end () override;
 359   void goto_record (ULONGEST arg0) override;
 360   void insn_history (int arg0, gdb_disassembly_flags arg1) override;
 361   void insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2) override;
 362   void insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2) override;
 363   void call_history (int arg0, record_print_flags arg1) override;
 364   void call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2) override;
 365   void call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2) override;
 366   bool augmented_libraries_svr4_read () override;
 367   const struct frame_unwind *get_unwinder () override;
 368   const struct frame_unwind *get_tailcall_unwinder () override;
 369   void prepare_to_generate_core () override;
 370   void done_generating_core () override;
 371   bool supports_memory_tagging () override;
 372   bool fetch_memtags (CORE_ADDR arg0, size_t arg1, gdb::byte_vector &arg2, int arg3) override;
 373   bool store_memtags (CORE_ADDR arg0, size_t arg1, const gdb::byte_vector &arg2, int arg3) override;
 374   x86_xsave_layout fetch_x86_xsave_layout () override;
 375 };
 376
 377 void
 378 target_ops::post_attach (int arg0)
 379 {
 380   this->beneath ()->post_attach (arg0);
 381 }
 382
 383 void
 384 dummy_target::post_attach (int arg0)
 385 {
 386 }
 387
 388 void
 389 debug_target::post_attach (int arg0)
 390 {
 391   gdb_printf (gdb_stdlog, "-> %s->post_attach (...)\n", this->beneath ()->shortname ());
 392   this->beneath ()->post_attach (arg0);
 393   gdb_printf (gdb_stdlog, "<- %s->post_attach (", this->beneath ()->shortname ());
 394   target_debug_print_int (arg0);
 395   gdb_puts (")\n", gdb_stdlog);
 396 }
 397
 398 void
 399 target_ops::detach (inferior *arg0, int arg1)
 400 {
 401   this->beneath ()->detach (arg0, arg1);
 402 }
 403
 404 void
 405 dummy_target::detach (inferior *arg0, int arg1)
 406 {
 407 }
 408
 409 void
 410 debug_target::detach (inferior *arg0, int arg1)
 411 {
 412   gdb_printf (gdb_stdlog, "-> %s->detach (...)\n", this->beneath ()->shortname ());
 413   this->beneath ()->detach (arg0, arg1);
 414   gdb_printf (gdb_stdlog, "<- %s->detach (", this->beneath ()->shortname ());
 415   target_debug_print_inferior_p (arg0);
 416   gdb_puts (", ", gdb_stdlog);
 417   target_debug_print_int (arg1);
 418   gdb_puts (")\n", gdb_stdlog);
 419 }
 420
 421 void
 422 target_ops::disconnect (const char *arg0, int arg1)
 423 {
 424   this->beneath ()->disconnect (arg0, arg1);
 425 }
 426
 427 void
 428 dummy_target::disconnect (const char *arg0, int arg1)
 429 {
 430   tcomplain ();
 431 }
 432
 433 void
 434 debug_target::disconnect (const char *arg0, int arg1)
 435 {
 436   gdb_printf (gdb_stdlog, "-> %s->disconnect (...)\n", this->beneath ()->shortname ());
 437   this->beneath ()->disconnect (arg0, arg1);
 438   gdb_printf (gdb_stdlog, "<- %s->disconnect (", this->beneath ()->shortname ());
 439   target_debug_print_const_char_p (arg0);
 440   gdb_puts (", ", gdb_stdlog);
 441   target_debug_print_int (arg1);
 442   gdb_puts (")\n", gdb_stdlog);
 443 }
 444
 445 void
 446 target_ops::resume (ptid_t arg0, int arg1, enum gdb_signal arg2)
 447 {
 448   this->beneath ()->resume (arg0, arg1, arg2);
 449 }
 450
 451 void
 452 dummy_target::resume (ptid_t arg0, int arg1, enum gdb_signal arg2)
 453 {
 454   noprocess ();
 455 }
 456
 457 void
 458 debug_target::resume (ptid_t arg0, int arg1, enum gdb_signal arg2)
 459 {
 460   gdb_printf (gdb_stdlog, "-> %s->resume (...)\n", this->beneath ()->shortname ());
 461   this->beneath ()->resume (arg0, arg1, arg2);
 462   gdb_printf (gdb_stdlog, "<- %s->resume (", this->beneath ()->shortname ());
 463   target_debug_print_ptid_t (arg0);
 464   gdb_puts (", ", gdb_stdlog);
 465   target_debug_print_step (arg1);
 466   gdb_puts (", ", gdb_stdlog);
 467   target_debug_print_gdb_signal (arg2);
 468   gdb_puts (")\n", gdb_stdlog);
 469 }
 470
 471 void
 472 target_ops::commit_resumed ()
 473 {
 474   this->beneath ()->commit_resumed ();
 475 }
 476
 477 void
 478 dummy_target::commit_resumed ()
 479 {
 480 }
 481
 482 void
 483 debug_target::commit_resumed ()
 484 {
 485   gdb_printf (gdb_stdlog, "-> %s->commit_resumed (...)\n", this->beneath ()->shortname ());
 486   this->beneath ()->commit_resumed ();
 487   gdb_printf (gdb_stdlog, "<- %s->commit_resumed (", this->beneath ()->shortname ());
 488   gdb_puts (")\n", gdb_stdlog);
 489 }
 490
 491 ptid_t
 492 target_ops::wait (ptid_t arg0, struct target_waitstatus *arg1, target_wait_flags arg2)
 493 {
 494   return this->beneath ()->wait (arg0, arg1, arg2);
 495 }
 496
 497 ptid_t
 498 dummy_target::wait (ptid_t arg0, struct target_waitstatus *arg1, target_wait_flags arg2)
 499 {
 500   return default_target_wait (this, arg0, arg1, arg2);
 501 }
 502
 503 ptid_t
 504 debug_target::wait (ptid_t arg0, struct target_waitstatus *arg1, target_wait_flags arg2)
 505 {
 506   gdb_printf (gdb_stdlog, "-> %s->wait (...)\n", this->beneath ()->shortname ());
 507   ptid_t result
 508     = this->beneath ()->wait (arg0, arg1, arg2);
 509   gdb_printf (gdb_stdlog, "<- %s->wait (", this->beneath ()->shortname ());
 510   target_debug_print_ptid_t (arg0);
 511   gdb_puts (", ", gdb_stdlog);
 512   target_debug_print_target_waitstatus_p (arg1);
 513   gdb_puts (", ", gdb_stdlog);
 514   target_debug_print_target_wait_flags (arg2);
 515   gdb_puts (") = ", gdb_stdlog);
 516   target_debug_print_ptid_t (result);
 517   gdb_puts ("\n", gdb_stdlog);
 518   return result;
 519 }
 520
 521 void
 522 target_ops::fetch_registers (struct regcache *arg0, int arg1)
 523 {
 524   this->beneath ()->fetch_registers (arg0, arg1);
 525 }
 526
 527 void
 528 dummy_target::fetch_registers (struct regcache *arg0, int arg1)
 529 {
 530 }
 531
 532 void
 533 debug_target::fetch_registers (struct regcache *arg0, int arg1)
 534 {
 535   gdb_printf (gdb_stdlog, "-> %s->fetch_registers (...)\n", this->beneath ()->shortname ());
 536   this->beneath ()->fetch_registers (arg0, arg1);
 537   gdb_printf (gdb_stdlog, "<- %s->fetch_registers (", this->beneath ()->shortname ());
 538   target_debug_print_regcache_p (arg0);
 539   gdb_puts (", ", gdb_stdlog);
 540   target_debug_print_int (arg1);
 541   gdb_puts (")\n", gdb_stdlog);
 542 }
 543
 544 void
 545 target_ops::store_registers (struct regcache *arg0, int arg1)
 546 {
 547   this->beneath ()->store_registers (arg0, arg1);
 548 }
 549
 550 void
 551 dummy_target::store_registers (struct regcache *arg0, int arg1)
 552 {
 553   noprocess ();
 554 }
 555
 556 void
 557 debug_target::store_registers (struct regcache *arg0, int arg1)
 558 {
 559   gdb_printf (gdb_stdlog, "-> %s->store_registers (...)\n", this->beneath ()->shortname ());
 560   this->beneath ()->store_registers (arg0, arg1);
 561   gdb_printf (gdb_stdlog, "<- %s->store_registers (", this->beneath ()->shortname ());
 562   target_debug_print_regcache_p (arg0);
 563   gdb_puts (", ", gdb_stdlog);
 564   target_debug_print_int (arg1);
 565   gdb_puts (")\n", gdb_stdlog);
 566 }
 567
 568 void
 569 target_ops::prepare_to_store (struct regcache *arg0)
 570 {
 571   this->beneath ()->prepare_to_store (arg0);
 572 }
 573
 574 void
 575 dummy_target::prepare_to_store (struct regcache *arg0)
 576 {
 577   noprocess ();
 578 }
 579
 580 void
 581 debug_target::prepare_to_store (struct regcache *arg0)
 582 {
 583   gdb_printf (gdb_stdlog, "-> %s->prepare_to_store (...)\n", this->beneath ()->shortname ());
 584   this->beneath ()->prepare_to_store (arg0);
 585   gdb_printf (gdb_stdlog, "<- %s->prepare_to_store (", this->beneath ()->shortname ());
 586   target_debug_print_regcache_p (arg0);
 587   gdb_puts (")\n", gdb_stdlog);
 588 }
 589
 590 void
 591 target_ops::files_info ()
 592 {
 593   this->beneath ()->files_info ();
 594 }
 595
 596 void
 597 dummy_target::files_info ()
 598 {
 599 }
 600
 601 void
 602 debug_target::files_info ()
 603 {
 604   gdb_printf (gdb_stdlog, "-> %s->files_info (...)\n", this->beneath ()->shortname ());
 605   this->beneath ()->files_info ();
 606   gdb_printf (gdb_stdlog, "<- %s->files_info (", this->beneath ()->shortname ());
 607   gdb_puts (")\n", gdb_stdlog);
 608 }
 609
 610 int
 611 target_ops::insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
 612 {
 613   return this->beneath ()->insert_breakpoint (arg0, arg1);
 614 }
 615
 616 int
 617 dummy_target::insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
 618 {
 619   noprocess ();
 620 }
 621
 622 int
 623 debug_target::insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
 624 {
 625   gdb_printf (gdb_stdlog, "-> %s->insert_breakpoint (...)\n", this->beneath ()->shortname ());
 626   int result
 627     = this->beneath ()->insert_breakpoint (arg0, arg1);
 628   gdb_printf (gdb_stdlog, "<- %s->insert_breakpoint (", this->beneath ()->shortname ());
 629   target_debug_print_gdbarch_p (arg0);
 630   gdb_puts (", ", gdb_stdlog);
 631   target_debug_print_bp_target_info_p (arg1);
 632   gdb_puts (") = ", gdb_stdlog);
 633   target_debug_print_int (result);
 634   gdb_puts ("\n", gdb_stdlog);
 635   return result;
 636 }
 637
 638 int
 639 target_ops::remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2)
 640 {
 641   return this->beneath ()->remove_breakpoint (arg0, arg1, arg2);
 642 }
 643
 644 int
 645 dummy_target::remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2)
 646 {
 647   noprocess ();
 648 }
 649
 650 int
 651 debug_target::remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2)
 652 {
 653   gdb_printf (gdb_stdlog, "-> %s->remove_breakpoint (...)\n", this->beneath ()->shortname ());
 654   int result
 655     = this->beneath ()->remove_breakpoint (arg0, arg1, arg2);
 656   gdb_printf (gdb_stdlog, "<- %s->remove_breakpoint (", this->beneath ()->shortname ());
 657   target_debug_print_gdbarch_p (arg0);
 658   gdb_puts (", ", gdb_stdlog);
 659   target_debug_print_bp_target_info_p (arg1);
 660   gdb_puts (", ", gdb_stdlog);
 661   target_debug_print_remove_bp_reason (arg2);
 662   gdb_puts (") = ", gdb_stdlog);
 663   target_debug_print_int (result);
 664   gdb_puts ("\n", gdb_stdlog);
 665   return result;
 666 }
 667
 668 bool
 669 target_ops::stopped_by_sw_breakpoint ()
 670 {
 671   return this->beneath ()->stopped_by_sw_breakpoint ();
 672 }
 673
 674 bool
 675 dummy_target::stopped_by_sw_breakpoint ()
 676 {
 677   return false;
 678 }
 679
 680 bool
 681 debug_target::stopped_by_sw_breakpoint ()
 682 {
 683   gdb_printf (gdb_stdlog, "-> %s->stopped_by_sw_breakpoint (...)\n", this->beneath ()->shortname ());
 684   bool result
 685     = this->beneath ()->stopped_by_sw_breakpoint ();
 686   gdb_printf (gdb_stdlog, "<- %s->stopped_by_sw_breakpoint (", this->beneath ()->shortname ());
 687   gdb_puts (") = ", gdb_stdlog);
 688   target_debug_print_bool (result);
 689   gdb_puts ("\n", gdb_stdlog);
 690   return result;
 691 }
 692
 693 bool
 694 target_ops::supports_stopped_by_sw_breakpoint ()
 695 {
 696   return this->beneath ()->supports_stopped_by_sw_breakpoint ();
 697 }
 698
 699 bool
 700 dummy_target::supports_stopped_by_sw_breakpoint ()
 701 {
 702   return false;
 703 }
 704
 705 bool
 706 debug_target::supports_stopped_by_sw_breakpoint ()
 707 {
 708   gdb_printf (gdb_stdlog, "-> %s->supports_stopped_by_sw_breakpoint (...)\n", this->beneath ()->shortname ());
 709   bool result
 710     = this->beneath ()->supports_stopped_by_sw_breakpoint ();
 711   gdb_printf (gdb_stdlog, "<- %s->supports_stopped_by_sw_breakpoint (", this->beneath ()->shortname ());
 712   gdb_puts (") = ", gdb_stdlog);
 713   target_debug_print_bool (result);
 714   gdb_puts ("\n", gdb_stdlog);
 715   return result;
 716 }
 717
 718 bool
 719 target_ops::stopped_by_hw_breakpoint ()
 720 {
 721   return this->beneath ()->stopped_by_hw_breakpoint ();
 722 }
 723
 724 bool
 725 dummy_target::stopped_by_hw_breakpoint ()
 726 {
 727   return false;
 728 }
 729
 730 bool
 731 debug_target::stopped_by_hw_breakpoint ()
 732 {
 733   gdb_printf (gdb_stdlog, "-> %s->stopped_by_hw_breakpoint (...)\n", this->beneath ()->shortname ());
 734   bool result
 735     = this->beneath ()->stopped_by_hw_breakpoint ();
 736   gdb_printf (gdb_stdlog, "<- %s->stopped_by_hw_breakpoint (", this->beneath ()->shortname ());
 737   gdb_puts (") = ", gdb_stdlog);
 738   target_debug_print_bool (result);
 739   gdb_puts ("\n", gdb_stdlog);
 740   return result;
 741 }
 742
 743 bool
 744 target_ops::supports_stopped_by_hw_breakpoint ()
 745 {
 746   return this->beneath ()->supports_stopped_by_hw_breakpoint ();
 747 }
 748
 749 bool
 750 dummy_target::supports_stopped_by_hw_breakpoint ()
 751 {
 752   return false;
 753 }
 754
 755 bool
 756 debug_target::supports_stopped_by_hw_breakpoint ()
 757 {
 758   gdb_printf (gdb_stdlog, "-> %s->supports_stopped_by_hw_breakpoint (...)\n", this->beneath ()->shortname ());
 759   bool result
 760     = this->beneath ()->supports_stopped_by_hw_breakpoint ();
 761   gdb_printf (gdb_stdlog, "<- %s->supports_stopped_by_hw_breakpoint (", this->beneath ()->shortname ());
 762   gdb_puts (") = ", gdb_stdlog);
 763   target_debug_print_bool (result);
 764   gdb_puts ("\n", gdb_stdlog);
 765   return result;
 766 }
 767
 768 int
 769 target_ops::can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2)
 770 {
 771   return this->beneath ()->can_use_hw_breakpoint (arg0, arg1, arg2);
 772 }
 773
 774 int
 775 dummy_target::can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2)
 776 {
 777   return 0;
 778 }
 779
 780 int
 781 debug_target::can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2)
 782 {
 783   gdb_printf (gdb_stdlog, "-> %s->can_use_hw_breakpoint (...)\n", this->beneath ()->shortname ());
 784   int result
 785     = this->beneath ()->can_use_hw_breakpoint (arg0, arg1, arg2);
 786   gdb_printf (gdb_stdlog, "<- %s->can_use_hw_breakpoint (", this->beneath ()->shortname ());
 787   target_debug_print_bptype (arg0);
 788   gdb_puts (", ", gdb_stdlog);
 789   target_debug_print_int (arg1);
 790   gdb_puts (", ", gdb_stdlog);
 791   target_debug_print_int (arg2);
 792   gdb_puts (") = ", gdb_stdlog);
 793   target_debug_print_int (result);
 794   gdb_puts ("\n", gdb_stdlog);
 795   return result;
 796 }
 797
 798 int
 799 target_ops::ranged_break_num_registers ()
 800 {
 801   return this->beneath ()->ranged_break_num_registers ();
 802 }
 803
 804 int
 805 dummy_target::ranged_break_num_registers ()
 806 {
 807   return -1;
 808 }
 809
 810 int
 811 debug_target::ranged_break_num_registers ()
 812 {
 813   gdb_printf (gdb_stdlog, "-> %s->ranged_break_num_registers (...)\n", this->beneath ()->shortname ());
 814   int result
 815     = this->beneath ()->ranged_break_num_registers ();
 816   gdb_printf (gdb_stdlog, "<- %s->ranged_break_num_registers (", this->beneath ()->shortname ());
 817   gdb_puts (") = ", gdb_stdlog);
 818   target_debug_print_int (result);
 819   gdb_puts ("\n", gdb_stdlog);
 820   return result;
 821 }
 822
 823 int
 824 target_ops::insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
 825 {
 826   return this->beneath ()->insert_hw_breakpoint (arg0, arg1);
 827 }
 828
 829 int
 830 dummy_target::insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
 831 {
 832   return -1;
 833 }
 834
 835 int
 836 debug_target::insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
 837 {
 838   gdb_printf (gdb_stdlog, "-> %s->insert_hw_breakpoint (...)\n", this->beneath ()->shortname ());
 839   int result
 840     = this->beneath ()->insert_hw_breakpoint (arg0, arg1);
 841   gdb_printf (gdb_stdlog, "<- %s->insert_hw_breakpoint (", this->beneath ()->shortname ());
 842   target_debug_print_gdbarch_p (arg0);
 843   gdb_puts (", ", gdb_stdlog);
 844   target_debug_print_bp_target_info_p (arg1);
 845   gdb_puts (") = ", gdb_stdlog);
 846   target_debug_print_int (result);
 847   gdb_puts ("\n", gdb_stdlog);
 848   return result;
 849 }
 850
 851 int
 852 target_ops::remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
 853 {
 854   return this->beneath ()->remove_hw_breakpoint (arg0, arg1);
 855 }
 856
 857 int
 858 dummy_target::remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
 859 {
 860   return -1;
 861 }
 862
 863 int
 864 debug_target::remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1)
 865 {
 866   gdb_printf (gdb_stdlog, "-> %s->remove_hw_breakpoint (...)\n", this->beneath ()->shortname ());
 867   int result
 868     = this->beneath ()->remove_hw_breakpoint (arg0, arg1);
 869   gdb_printf (gdb_stdlog, "<- %s->remove_hw_breakpoint (", this->beneath ()->shortname ());
 870   target_debug_print_gdbarch_p (arg0);
 871   gdb_puts (", ", gdb_stdlog);
 872   target_debug_print_bp_target_info_p (arg1);
 873   gdb_puts (") = ", gdb_stdlog);
 874   target_debug_print_int (result);
 875   gdb_puts ("\n", gdb_stdlog);
 876   return result;
 877 }
 878
 879 int
 880 target_ops::remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
 881 {
 882   return this->beneath ()->remove_watchpoint (arg0, arg1, arg2, arg3);
 883 }
 884
 885 int
 886 dummy_target::remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
 887 {
 888   return -1;
 889 }
 890
 891 int
 892 debug_target::remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
 893 {
 894   gdb_printf (gdb_stdlog, "-> %s->remove_watchpoint (...)\n", this->beneath ()->shortname ());
 895   int result
 896     = this->beneath ()->remove_watchpoint (arg0, arg1, arg2, arg3);
 897   gdb_printf (gdb_stdlog, "<- %s->remove_watchpoint (", this->beneath ()->shortname ());
 898   target_debug_print_CORE_ADDR (arg0);
 899   gdb_puts (", ", gdb_stdlog);
 900   target_debug_print_int (arg1);
 901   gdb_puts (", ", gdb_stdlog);
 902   target_debug_print_target_hw_bp_type (arg2);
 903   gdb_puts (", ", gdb_stdlog);
 904   target_debug_print_expression_p (arg3);
 905   gdb_puts (") = ", gdb_stdlog);
 906   target_debug_print_int (result);
 907   gdb_puts ("\n", gdb_stdlog);
 908   return result;
 909 }
 910
 911 int
 912 target_ops::insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
 913 {
 914   return this->beneath ()->insert_watchpoint (arg0, arg1, arg2, arg3);
 915 }
 916
 917 int
 918 dummy_target::insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
 919 {
 920   return -1;
 921 }
 922
 923 int
 924 debug_target::insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3)
 925 {
 926   gdb_printf (gdb_stdlog, "-> %s->insert_watchpoint (...)\n", this->beneath ()->shortname ());
 927   int result
 928     = this->beneath ()->insert_watchpoint (arg0, arg1, arg2, arg3);
 929   gdb_printf (gdb_stdlog, "<- %s->insert_watchpoint (", this->beneath ()->shortname ());
 930   target_debug_print_CORE_ADDR (arg0);
 931   gdb_puts (", ", gdb_stdlog);
 932   target_debug_print_int (arg1);
 933   gdb_puts (", ", gdb_stdlog);
 934   target_debug_print_target_hw_bp_type (arg2);
 935   gdb_puts (", ", gdb_stdlog);
 936   target_debug_print_expression_p (arg3);
 937   gdb_puts (") = ", gdb_stdlog);
 938   target_debug_print_int (result);
 939   gdb_puts ("\n", gdb_stdlog);
 940   return result;
 941 }
 942
 943 int
 944 target_ops::insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
 945 {
 946   return this->beneath ()->insert_mask_watchpoint (arg0, arg1, arg2);
 947 }
 948
 949 int
 950 dummy_target::insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
 951 {
 952   return 1;
 953 }
 954
 955 int
 956 debug_target::insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
 957 {
 958   gdb_printf (gdb_stdlog, "-> %s->insert_mask_watchpoint (...)\n", this->beneath ()->shortname ());
 959   int result
 960     = this->beneath ()->insert_mask_watchpoint (arg0, arg1, arg2);
 961   gdb_printf (gdb_stdlog, "<- %s->insert_mask_watchpoint (", this->beneath ()->shortname ());
 962   target_debug_print_CORE_ADDR (arg0);
 963   gdb_puts (", ", gdb_stdlog);
 964   target_debug_print_CORE_ADDR (arg1);
 965   gdb_puts (", ", gdb_stdlog);
 966   target_debug_print_target_hw_bp_type (arg2);
 967   gdb_puts (") = ", gdb_stdlog);
 968   target_debug_print_int (result);
 969   gdb_puts ("\n", gdb_stdlog);
 970   return result;
 971 }
 972
 973 int
 974 target_ops::remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
 975 {
 976   return this->beneath ()->remove_mask_watchpoint (arg0, arg1, arg2);
 977 }
 978
 979 int
 980 dummy_target::remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
 981 {
 982   return 1;
 983 }
 984
 985 int
 986 debug_target::remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2)
 987 {
 988   gdb_printf (gdb_stdlog, "-> %s->remove_mask_watchpoint (...)\n", this->beneath ()->shortname ());
 989   int result
 990     = this->beneath ()->remove_mask_watchpoint (arg0, arg1, arg2);
 991   gdb_printf (gdb_stdlog, "<- %s->remove_mask_watchpoint (", this->beneath ()->shortname ());
 992   target_debug_print_CORE_ADDR (arg0);
 993   gdb_puts (", ", gdb_stdlog);
 994   target_debug_print_CORE_ADDR (arg1);
 995   gdb_puts (", ", gdb_stdlog);
 996   target_debug_print_target_hw_bp_type (arg2);
 997   gdb_puts (") = ", gdb_stdlog);
 998   target_debug_print_int (result);
 999   gdb_puts ("\n", gdb_stdlog);
1000   return result;
1001 }
1002
1003 bool
1004 target_ops::stopped_by_watchpoint ()
1005 {
1006   return this->beneath ()->stopped_by_watchpoint ();
1007 }
1008
1009 bool
1010 dummy_target::stopped_by_watchpoint ()
1011 {
1012   return false;
1013 }
1014
1015 bool
1016 debug_target::stopped_by_watchpoint ()
1017 {
1018   gdb_printf (gdb_stdlog, "-> %s->stopped_by_watchpoint (...)\n", this->beneath ()->shortname ());
1019   bool result
1020     = this->beneath ()->stopped_by_watchpoint ();
1021   gdb_printf (gdb_stdlog, "<- %s->stopped_by_watchpoint (", this->beneath ()->shortname ());
1022   gdb_puts (") = ", gdb_stdlog);
1023   target_debug_print_bool (result);
1024   gdb_puts ("\n", gdb_stdlog);
1025   return result;
1026 }
1027
1028 bool
1029 target_ops::have_steppable_watchpoint ()
1030 {
1031   return this->beneath ()->have_steppable_watchpoint ();
1032 }
1033
1034 bool
1035 dummy_target::have_steppable_watchpoint ()
1036 {
1037   return false;
1038 }
1039
1040 bool
1041 debug_target::have_steppable_watchpoint ()
1042 {
1043   gdb_printf (gdb_stdlog, "-> %s->have_steppable_watchpoint (...)\n", this->beneath ()->shortname ());
1044   bool result
1045     = this->beneath ()->have_steppable_watchpoint ();
1046   gdb_printf (gdb_stdlog, "<- %s->have_steppable_watchpoint (", this->beneath ()->shortname ());
1047   gdb_puts (") = ", gdb_stdlog);
1048   target_debug_print_bool (result);
1049   gdb_puts ("\n", gdb_stdlog);
1050   return result;
1051 }
1052
1053 bool
1054 target_ops::stopped_data_address (CORE_ADDR *arg0)
1055 {
1056   return this->beneath ()->stopped_data_address (arg0);
1057 }
1058
1059 bool
1060 dummy_target::stopped_data_address (CORE_ADDR *arg0)
1061 {
1062   return false;
1063 }
1064
1065 bool
1066 debug_target::stopped_data_address (CORE_ADDR *arg0)
1067 {
1068   gdb_printf (gdb_stdlog, "-> %s->stopped_data_address (...)\n", this->beneath ()->shortname ());
1069   bool result
1070     = this->beneath ()->stopped_data_address (arg0);
1071   gdb_printf (gdb_stdlog, "<- %s->stopped_data_address (", this->beneath ()->shortname ());
1072   target_debug_print_CORE_ADDR_p (arg0);
1073   gdb_puts (") = ", gdb_stdlog);
1074   target_debug_print_bool (result);
1075   gdb_puts ("\n", gdb_stdlog);
1076   return result;
1077 }
1078
1079 bool
1080 target_ops::watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2)
1081 {
1082   return this->beneath ()->watchpoint_addr_within_range (arg0, arg1, arg2);
1083 }
1084
1085 bool
1086 dummy_target::watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2)
1087 {
1088   return default_watchpoint_addr_within_range (this, arg0, arg1, arg2);
1089 }
1090
1091 bool
1092 debug_target::watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2)
1093 {
1094   gdb_printf (gdb_stdlog, "-> %s->watchpoint_addr_within_range (...)\n", this->beneath ()->shortname ());
1095   bool result
1096     = this->beneath ()->watchpoint_addr_within_range (arg0, arg1, arg2);
1097   gdb_printf (gdb_stdlog, "<- %s->watchpoint_addr_within_range (", this->beneath ()->shortname ());
1098   target_debug_print_CORE_ADDR (arg0);
1099   gdb_puts (", ", gdb_stdlog);
1100   target_debug_print_CORE_ADDR (arg1);
1101   gdb_puts (", ", gdb_stdlog);
1102   target_debug_print_int (arg2);
1103   gdb_puts (") = ", gdb_stdlog);
1104   target_debug_print_bool (result);
1105   gdb_puts ("\n", gdb_stdlog);
1106   return result;
1107 }
1108
1109 int
1110 target_ops::region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1)
1111 {
1112   return this->beneath ()->region_ok_for_hw_watchpoint (arg0, arg1);
1113 }
1114
1115 int
1116 dummy_target::region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1)
1117 {
1118   return default_region_ok_for_hw_watchpoint (this, arg0, arg1);
1119 }
1120
1121 int
1122 debug_target::region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1)
1123 {
1124   gdb_printf (gdb_stdlog, "-> %s->region_ok_for_hw_watchpoint (...)\n", this->beneath ()->shortname ());
1125   int result
1126     = this->beneath ()->region_ok_for_hw_watchpoint (arg0, arg1);
1127   gdb_printf (gdb_stdlog, "<- %s->region_ok_for_hw_watchpoint (", this->beneath ()->shortname ());
1128   target_debug_print_CORE_ADDR (arg0);
1129   gdb_puts (", ", gdb_stdlog);
1130   target_debug_print_int (arg1);
1131   gdb_puts (") = ", gdb_stdlog);
1132   target_debug_print_int (result);
1133   gdb_puts ("\n", gdb_stdlog);
1134   return result;
1135 }
1136
1137 bool
1138 target_ops::can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3)
1139 {
1140   return this->beneath ()->can_accel_watchpoint_condition (arg0, arg1, arg2, arg3);
1141 }
1142
1143 bool
1144 dummy_target::can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3)
1145 {
1146   return false;
1147 }
1148
1149 bool
1150 debug_target::can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3)
1151 {
1152   gdb_printf (gdb_stdlog, "-> %s->can_accel_watchpoint_condition (...)\n", this->beneath ()->shortname ());
1153   bool result
1154     = this->beneath ()->can_accel_watchpoint_condition (arg0, arg1, arg2, arg3);
1155   gdb_printf (gdb_stdlog, "<- %s->can_accel_watchpoint_condition (", this->beneath ()->shortname ());
1156   target_debug_print_CORE_ADDR (arg0);
1157   gdb_puts (", ", gdb_stdlog);
1158   target_debug_print_int (arg1);
1159   gdb_puts (", ", gdb_stdlog);
1160   target_debug_print_int (arg2);
1161   gdb_puts (", ", gdb_stdlog);
1162   target_debug_print_expression_p (arg3);
1163   gdb_puts (") = ", gdb_stdlog);
1164   target_debug_print_bool (result);
1165   gdb_puts ("\n", gdb_stdlog);
1166   return result;
1167 }
1168
1169 int
1170 target_ops::masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1)
1171 {
1172   return this->beneath ()->masked_watch_num_registers (arg0, arg1);
1173 }
1174
1175 int
1176 dummy_target::masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1)
1177 {
1178   return -1;
1179 }
1180
1181 int
1182 debug_target::masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1)
1183 {
1184   gdb_printf (gdb_stdlog, "-> %s->masked_watch_num_registers (...)\n", this->beneath ()->shortname ());
1185   int result
1186     = this->beneath ()->masked_watch_num_registers (arg0, arg1);
1187   gdb_printf (gdb_stdlog, "<- %s->masked_watch_num_registers (", this->beneath ()->shortname ());
1188   target_debug_print_CORE_ADDR (arg0);
1189   gdb_puts (", ", gdb_stdlog);
1190   target_debug_print_CORE_ADDR (arg1);
1191   gdb_puts (") = ", gdb_stdlog);
1192   target_debug_print_int (result);
1193   gdb_puts ("\n", gdb_stdlog);
1194   return result;
1195 }
1196
1197 int
1198 target_ops::can_do_single_step ()
1199 {
1200   return this->beneath ()->can_do_single_step ();
1201 }
1202
1203 int
1204 dummy_target::can_do_single_step ()
1205 {
1206   return -1;
1207 }
1208
1209 int
1210 debug_target::can_do_single_step ()
1211 {
1212   gdb_printf (gdb_stdlog, "-> %s->can_do_single_step (...)\n", this->beneath ()->shortname ());
1213   int result
1214     = this->beneath ()->can_do_single_step ();
1215   gdb_printf (gdb_stdlog, "<- %s->can_do_single_step (", this->beneath ()->shortname ());
1216   gdb_puts (") = ", gdb_stdlog);
1217   target_debug_print_int (result);
1218   gdb_puts ("\n", gdb_stdlog);
1219   return result;
1220 }
1221
1222 bool
1223 target_ops::supports_terminal_ours ()
1224 {
1225   return this->beneath ()->supports_terminal_ours ();
1226 }
1227
1228 bool
1229 dummy_target::supports_terminal_ours ()
1230 {
1231   return false;
1232 }
1233
1234 bool
1235 debug_target::supports_terminal_ours ()
1236 {
1237   gdb_printf (gdb_stdlog, "-> %s->supports_terminal_ours (...)\n", this->beneath ()->shortname ());
1238   bool result
1239     = this->beneath ()->supports_terminal_ours ();
1240   gdb_printf (gdb_stdlog, "<- %s->supports_terminal_ours (", this->beneath ()->shortname ());
1241   gdb_puts (") = ", gdb_stdlog);
1242   target_debug_print_bool (result);
1243   gdb_puts ("\n", gdb_stdlog);
1244   return result;
1245 }
1246
1247 void
1248 target_ops::terminal_init ()
1249 {
1250   this->beneath ()->terminal_init ();
1251 }
1252
1253 void
1254 dummy_target::terminal_init ()
1255 {
1256 }
1257
1258 void
1259 debug_target::terminal_init ()
1260 {
1261   gdb_printf (gdb_stdlog, "-> %s->terminal_init (...)\n", this->beneath ()->shortname ());
1262   this->beneath ()->terminal_init ();
1263   gdb_printf (gdb_stdlog, "<- %s->terminal_init (", this->beneath ()->shortname ());
1264   gdb_puts (")\n", gdb_stdlog);
1265 }
1266
1267 void
1268 target_ops::terminal_inferior ()
1269 {
1270   this->beneath ()->terminal_inferior ();
1271 }
1272
1273 void
1274 dummy_target::terminal_inferior ()
1275 {
1276 }
1277
1278 void
1279 debug_target::terminal_inferior ()
1280 {
1281   gdb_printf (gdb_stdlog, "-> %s->terminal_inferior (...)\n", this->beneath ()->shortname ());
1282   this->beneath ()->terminal_inferior ();
1283   gdb_printf (gdb_stdlog, "<- %s->terminal_inferior (", this->beneath ()->shortname ());
1284   gdb_puts (")\n", gdb_stdlog);
1285 }
1286
1287 void
1288 target_ops::terminal_save_inferior ()
1289 {
1290   this->beneath ()->terminal_save_inferior ();
1291 }
1292
1293 void
1294 dummy_target::terminal_save_inferior ()
1295 {
1296 }
1297
1298 void
1299 debug_target::terminal_save_inferior ()
1300 {
1301   gdb_printf (gdb_stdlog, "-> %s->terminal_save_inferior (...)\n", this->beneath ()->shortname ());
1302   this->beneath ()->terminal_save_inferior ();
1303   gdb_printf (gdb_stdlog, "<- %s->terminal_save_inferior (", this->beneath ()->shortname ());
1304   gdb_puts (")\n", gdb_stdlog);
1305 }
1306
1307 void
1308 target_ops::terminal_ours_for_output ()
1309 {
1310   this->beneath ()->terminal_ours_for_output ();
1311 }
1312
1313 void
1314 dummy_target::terminal_ours_for_output ()
1315 {
1316 }
1317
1318 void
1319 debug_target::terminal_ours_for_output ()
1320 {
1321   gdb_printf (gdb_stdlog, "-> %s->terminal_ours_for_output (...)\n", this->beneath ()->shortname ());
1322   this->beneath ()->terminal_ours_for_output ();
1323   gdb_printf (gdb_stdlog, "<- %s->terminal_ours_for_output (", this->beneath ()->shortname ());
1324   gdb_puts (")\n", gdb_stdlog);
1325 }
1326
1327 void
1328 target_ops::terminal_ours ()
1329 {
1330   this->beneath ()->terminal_ours ();
1331 }
1332
1333 void
1334 dummy_target::terminal_ours ()
1335 {
1336 }
1337
1338 void
1339 debug_target::terminal_ours ()
1340 {
1341   gdb_printf (gdb_stdlog, "-> %s->terminal_ours (...)\n", this->beneath ()->shortname ());
1342   this->beneath ()->terminal_ours ();
1343   gdb_printf (gdb_stdlog, "<- %s->terminal_ours (", this->beneath ()->shortname ());
1344   gdb_puts (")\n", gdb_stdlog);
1345 }
1346
1347 void
1348 target_ops::terminal_info (const char *arg0, int arg1)
1349 {
1350   this->beneath ()->terminal_info (arg0, arg1);
1351 }
1352
1353 void
1354 dummy_target::terminal_info (const char *arg0, int arg1)
1355 {
1356   default_terminal_info (this, arg0, arg1);
1357 }
1358
1359 void
1360 debug_target::terminal_info (const char *arg0, int arg1)
1361 {
1362   gdb_printf (gdb_stdlog, "-> %s->terminal_info (...)\n", this->beneath ()->shortname ());
1363   this->beneath ()->terminal_info (arg0, arg1);
1364   gdb_printf (gdb_stdlog, "<- %s->terminal_info (", this->beneath ()->shortname ());
1365   target_debug_print_const_char_p (arg0);
1366   gdb_puts (", ", gdb_stdlog);
1367   target_debug_print_int (arg1);
1368   gdb_puts (")\n", gdb_stdlog);
1369 }
1370
1371 void
1372 target_ops::kill ()
1373 {
1374   this->beneath ()->kill ();
1375 }
1376
1377 void
1378 dummy_target::kill ()
1379 {
1380   noprocess ();
1381 }
1382
1383 void
1384 debug_target::kill ()
1385 {
1386   gdb_printf (gdb_stdlog, "-> %s->kill (...)\n", this->beneath ()->shortname ());
1387   this->beneath ()->kill ();
1388   gdb_printf (gdb_stdlog, "<- %s->kill (", this->beneath ()->shortname ());
1389   gdb_puts (")\n", gdb_stdlog);
1390 }
1391
1392 void
1393 target_ops::load (const char *arg0, int arg1)
1394 {
1395   this->beneath ()->load (arg0, arg1);
1396 }
1397
1398 void
1399 dummy_target::load (const char *arg0, int arg1)
1400 {
1401   tcomplain ();
1402 }
1403
1404 void
1405 debug_target::load (const char *arg0, int arg1)
1406 {
1407   gdb_printf (gdb_stdlog, "-> %s->load (...)\n", this->beneath ()->shortname ());
1408   this->beneath ()->load (arg0, arg1);
1409   gdb_printf (gdb_stdlog, "<- %s->load (", this->beneath ()->shortname ());
1410   target_debug_print_const_char_p (arg0);
1411   gdb_puts (", ", gdb_stdlog);
1412   target_debug_print_int (arg1);
1413   gdb_puts (")\n", gdb_stdlog);
1414 }
1415
1416 int
1417 target_ops::insert_fork_catchpoint (int arg0)
1418 {
1419   return this->beneath ()->insert_fork_catchpoint (arg0);
1420 }
1421
1422 int
1423 dummy_target::insert_fork_catchpoint (int arg0)
1424 {
1425   return 1;
1426 }
1427
1428 int
1429 debug_target::insert_fork_catchpoint (int arg0)
1430 {
1431   gdb_printf (gdb_stdlog, "-> %s->insert_fork_catchpoint (...)\n", this->beneath ()->shortname ());
1432   int result
1433     = this->beneath ()->insert_fork_catchpoint (arg0);
1434   gdb_printf (gdb_stdlog, "<- %s->insert_fork_catchpoint (", this->beneath ()->shortname ());
1435   target_debug_print_int (arg0);
1436   gdb_puts (") = ", gdb_stdlog);
1437   target_debug_print_int (result);
1438   gdb_puts ("\n", gdb_stdlog);
1439   return result;
1440 }
1441
1442 int
1443 target_ops::remove_fork_catchpoint (int arg0)
1444 {
1445   return this->beneath ()->remove_fork_catchpoint (arg0);
1446 }
1447
1448 int
1449 dummy_target::remove_fork_catchpoint (int arg0)
1450 {
1451   return 1;
1452 }
1453
1454 int
1455 debug_target::remove_fork_catchpoint (int arg0)
1456 {
1457   gdb_printf (gdb_stdlog, "-> %s->remove_fork_catchpoint (...)\n", this->beneath ()->shortname ());
1458   int result
1459     = this->beneath ()->remove_fork_catchpoint (arg0);
1460   gdb_printf (gdb_stdlog, "<- %s->remove_fork_catchpoint (", this->beneath ()->shortname ());
1461   target_debug_print_int (arg0);
1462   gdb_puts (") = ", gdb_stdlog);
1463   target_debug_print_int (result);
1464   gdb_puts ("\n", gdb_stdlog);
1465   return result;
1466 }
1467
1468 int
1469 target_ops::insert_vfork_catchpoint (int arg0)
1470 {
1471   return this->beneath ()->insert_vfork_catchpoint (arg0);
1472 }
1473
1474 int
1475 dummy_target::insert_vfork_catchpoint (int arg0)
1476 {
1477   return 1;
1478 }
1479
1480 int
1481 debug_target::insert_vfork_catchpoint (int arg0)
1482 {
1483   gdb_printf (gdb_stdlog, "-> %s->insert_vfork_catchpoint (...)\n", this->beneath ()->shortname ());
1484   int result
1485     = this->beneath ()->insert_vfork_catchpoint (arg0);
1486   gdb_printf (gdb_stdlog, "<- %s->insert_vfork_catchpoint (", this->beneath ()->shortname ());
1487   target_debug_print_int (arg0);
1488   gdb_puts (") = ", gdb_stdlog);
1489   target_debug_print_int (result);
1490   gdb_puts ("\n", gdb_stdlog);
1491   return result;
1492 }
1493
1494 int
1495 target_ops::remove_vfork_catchpoint (int arg0)
1496 {
1497   return this->beneath ()->remove_vfork_catchpoint (arg0);
1498 }
1499
1500 int
1501 dummy_target::remove_vfork_catchpoint (int arg0)
1502 {
1503   return 1;
1504 }
1505
1506 int
1507 debug_target::remove_vfork_catchpoint (int arg0)
1508 {
1509   gdb_printf (gdb_stdlog, "-> %s->remove_vfork_catchpoint (...)\n", this->beneath ()->shortname ());
1510   int result
1511     = this->beneath ()->remove_vfork_catchpoint (arg0);
1512   gdb_printf (gdb_stdlog, "<- %s->remove_vfork_catchpoint (", this->beneath ()->shortname ());
1513   target_debug_print_int (arg0);
1514   gdb_puts (") = ", gdb_stdlog);
1515   target_debug_print_int (result);
1516   gdb_puts ("\n", gdb_stdlog);
1517   return result;
1518 }
1519
1520 void
1521 target_ops::follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4)
1522 {
1523   this->beneath ()->follow_fork (arg0, arg1, arg2, arg3, arg4);
1524 }
1525
1526 void
1527 dummy_target::follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4)
1528 {
1529   default_follow_fork (this, arg0, arg1, arg2, arg3, arg4);
1530 }
1531
1532 void
1533 debug_target::follow_fork (inferior *arg0, ptid_t arg1, target_waitkind arg2, bool arg3, bool arg4)
1534 {
1535   gdb_printf (gdb_stdlog, "-> %s->follow_fork (...)\n", this->beneath ()->shortname ());
1536   this->beneath ()->follow_fork (arg0, arg1, arg2, arg3, arg4);
1537   gdb_printf (gdb_stdlog, "<- %s->follow_fork (", this->beneath ()->shortname ());
1538   target_debug_print_inferior_p (arg0);
1539   gdb_puts (", ", gdb_stdlog);
1540   target_debug_print_ptid_t (arg1);
1541   gdb_puts (", ", gdb_stdlog);
1542   target_debug_print_target_waitkind (arg2);
1543   gdb_puts (", ", gdb_stdlog);
1544   target_debug_print_bool (arg3);
1545   gdb_puts (", ", gdb_stdlog);
1546   target_debug_print_bool (arg4);
1547   gdb_puts (")\n", gdb_stdlog);
1548 }
1549
1550 int
1551 target_ops::insert_exec_catchpoint (int arg0)
1552 {
1553   return this->beneath ()->insert_exec_catchpoint (arg0);
1554 }
1555
1556 int
1557 dummy_target::insert_exec_catchpoint (int arg0)
1558 {
1559   return 1;
1560 }
1561
1562 int
1563 debug_target::insert_exec_catchpoint (int arg0)
1564 {
1565   gdb_printf (gdb_stdlog, "-> %s->insert_exec_catchpoint (...)\n", this->beneath ()->shortname ());
1566   int result
1567     = this->beneath ()->insert_exec_catchpoint (arg0);
1568   gdb_printf (gdb_stdlog, "<- %s->insert_exec_catchpoint (", this->beneath ()->shortname ());
1569   target_debug_print_int (arg0);
1570   gdb_puts (") = ", gdb_stdlog);
1571   target_debug_print_int (result);
1572   gdb_puts ("\n", gdb_stdlog);
1573   return result;
1574 }
1575
1576 int
1577 target_ops::remove_exec_catchpoint (int arg0)
1578 {
1579   return this->beneath ()->remove_exec_catchpoint (arg0);
1580 }
1581
1582 int
1583 dummy_target::remove_exec_catchpoint (int arg0)
1584 {
1585   return 1;
1586 }
1587
1588 int
1589 debug_target::remove_exec_catchpoint (int arg0)
1590 {
1591   gdb_printf (gdb_stdlog, "-> %s->remove_exec_catchpoint (...)\n", this->beneath ()->shortname ());
1592   int result
1593     = this->beneath ()->remove_exec_catchpoint (arg0);
1594   gdb_printf (gdb_stdlog, "<- %s->remove_exec_catchpoint (", this->beneath ()->shortname ());
1595   target_debug_print_int (arg0);
1596   gdb_puts (") = ", gdb_stdlog);
1597   target_debug_print_int (result);
1598   gdb_puts ("\n", gdb_stdlog);
1599   return result;
1600 }
1601
1602 void
1603 target_ops::follow_exec (inferior *arg0, ptid_t arg1, const char *arg2)
1604 {
1605   this->beneath ()->follow_exec (arg0, arg1, arg2);
1606 }
1607
1608 void
1609 dummy_target::follow_exec (inferior *arg0, ptid_t arg1, const char *arg2)
1610 {
1611 }
1612
1613 void
1614 debug_target::follow_exec (inferior *arg0, ptid_t arg1, const char *arg2)
1615 {
1616   gdb_printf (gdb_stdlog, "-> %s->follow_exec (...)\n", this->beneath ()->shortname ());
1617   this->beneath ()->follow_exec (arg0, arg1, arg2);
1618   gdb_printf (gdb_stdlog, "<- %s->follow_exec (", this->beneath ()->shortname ());
1619   target_debug_print_inferior_p (arg0);
1620   gdb_puts (", ", gdb_stdlog);
1621   target_debug_print_ptid_t (arg1);
1622   gdb_puts (", ", gdb_stdlog);
1623   target_debug_print_const_char_p (arg2);
1624   gdb_puts (")\n", gdb_stdlog);
1625 }
1626
1627 int
1628 target_ops::set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3)
1629 {
1630   return this->beneath ()->set_syscall_catchpoint (arg0, arg1, arg2, arg3);
1631 }
1632
1633 int
1634 dummy_target::set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3)
1635 {
1636   return 1;
1637 }
1638
1639 int
1640 debug_target::set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3)
1641 {
1642   gdb_printf (gdb_stdlog, "-> %s->set_syscall_catchpoint (...)\n", this->beneath ()->shortname ());
1643   int result
1644     = this->beneath ()->set_syscall_catchpoint (arg0, arg1, arg2, arg3);
1645   gdb_printf (gdb_stdlog, "<- %s->set_syscall_catchpoint (", this->beneath ()->shortname ());
1646   target_debug_print_int (arg0);
1647   gdb_puts (", ", gdb_stdlog);
1648   target_debug_print_bool (arg1);
1649   gdb_puts (", ", gdb_stdlog);
1650   target_debug_print_int (arg2);
1651   gdb_puts (", ", gdb_stdlog);
1652   target_debug_print_gdb_array_view_const_int (arg3);
1653   gdb_puts (") = ", gdb_stdlog);
1654   target_debug_print_int (result);
1655   gdb_puts ("\n", gdb_stdlog);
1656   return result;
1657 }
1658
1659 void
1660 target_ops::mourn_inferior ()
1661 {
1662   this->beneath ()->mourn_inferior ();
1663 }
1664
1665 void
1666 dummy_target::mourn_inferior ()
1667 {
1668   default_mourn_inferior (this);
1669 }
1670
1671 void
1672 debug_target::mourn_inferior ()
1673 {
1674   gdb_printf (gdb_stdlog, "-> %s->mourn_inferior (...)\n", this->beneath ()->shortname ());
1675   this->beneath ()->mourn_inferior ();
1676   gdb_printf (gdb_stdlog, "<- %s->mourn_inferior (", this->beneath ()->shortname ());
1677   gdb_puts (")\n", gdb_stdlog);
1678 }
1679
1680 void
1681 target_ops::pass_signals (gdb::array_view<const unsigned char> arg0)
1682 {
1683   this->beneath ()->pass_signals (arg0);
1684 }
1685
1686 void
1687 dummy_target::pass_signals (gdb::array_view<const unsigned char> arg0)
1688 {
1689 }
1690
1691 void
1692 debug_target::pass_signals (gdb::array_view<const unsigned char> arg0)
1693 {
1694   gdb_printf (gdb_stdlog, "-> %s->pass_signals (...)\n", this->beneath ()->shortname ());
1695   this->beneath ()->pass_signals (arg0);
1696   gdb_printf (gdb_stdlog, "<- %s->pass_signals (", this->beneath ()->shortname ());
1697   target_debug_print_signals (arg0);
1698   gdb_puts (")\n", gdb_stdlog);
1699 }
1700
1701 void
1702 target_ops::program_signals (gdb::array_view<const unsigned char> arg0)
1703 {
1704   this->beneath ()->program_signals (arg0);
1705 }
1706
1707 void
1708 dummy_target::program_signals (gdb::array_view<const unsigned char> arg0)
1709 {
1710 }
1711
1712 void
1713 debug_target::program_signals (gdb::array_view<const unsigned char> arg0)
1714 {
1715   gdb_printf (gdb_stdlog, "-> %s->program_signals (...)\n", this->beneath ()->shortname ());
1716   this->beneath ()->program_signals (arg0);
1717   gdb_printf (gdb_stdlog, "<- %s->program_signals (", this->beneath ()->shortname ());
1718   target_debug_print_signals (arg0);
1719   gdb_puts (")\n", gdb_stdlog);
1720 }
1721
1722 bool
1723 target_ops::thread_alive (ptid_t arg0)
1724 {
1725   return this->beneath ()->thread_alive (arg0);
1726 }
1727
1728 bool
1729 dummy_target::thread_alive (ptid_t arg0)
1730 {
1731   return false;
1732 }
1733
1734 bool
1735 debug_target::thread_alive (ptid_t arg0)
1736 {
1737   gdb_printf (gdb_stdlog, "-> %s->thread_alive (...)\n", this->beneath ()->shortname ());
1738   bool result
1739     = this->beneath ()->thread_alive (arg0);
1740   gdb_printf (gdb_stdlog, "<- %s->thread_alive (", this->beneath ()->shortname ());
1741   target_debug_print_ptid_t (arg0);
1742   gdb_puts (") = ", gdb_stdlog);
1743   target_debug_print_bool (result);
1744   gdb_puts ("\n", gdb_stdlog);
1745   return result;
1746 }
1747
1748 void
1749 target_ops::update_thread_list ()
1750 {
1751   this->beneath ()->update_thread_list ();
1752 }
1753
1754 void
1755 dummy_target::update_thread_list ()
1756 {
1757 }
1758
1759 void
1760 debug_target::update_thread_list ()
1761 {
1762   gdb_printf (gdb_stdlog, "-> %s->update_thread_list (...)\n", this->beneath ()->shortname ());
1763   this->beneath ()->update_thread_list ();
1764   gdb_printf (gdb_stdlog, "<- %s->update_thread_list (", this->beneath ()->shortname ());
1765   gdb_puts (")\n", gdb_stdlog);
1766 }
1767
1768 std::string
1769 target_ops::pid_to_str (ptid_t arg0)
1770 {
1771   return this->beneath ()->pid_to_str (arg0);
1772 }
1773
1774 std::string
1775 dummy_target::pid_to_str (ptid_t arg0)
1776 {
1777   return default_pid_to_str (this, arg0);
1778 }
1779
1780 std::string
1781 debug_target::pid_to_str (ptid_t arg0)
1782 {
1783   gdb_printf (gdb_stdlog, "-> %s->pid_to_str (...)\n", this->beneath ()->shortname ());
1784   std::string result
1785     = this->beneath ()->pid_to_str (arg0);
1786   gdb_printf (gdb_stdlog, "<- %s->pid_to_str (", this->beneath ()->shortname ());
1787   target_debug_print_ptid_t (arg0);
1788   gdb_puts (") = ", gdb_stdlog);
1789   target_debug_print_std_string (result);
1790   gdb_puts ("\n", gdb_stdlog);
1791   return result;
1792 }
1793
1794 const char *
1795 target_ops::extra_thread_info (thread_info *arg0)
1796 {
1797   return this->beneath ()->extra_thread_info (arg0);
1798 }
1799
1800 const char *
1801 dummy_target::extra_thread_info (thread_info *arg0)
1802 {
1803   return NULL;
1804 }
1805
1806 const char *
1807 debug_target::extra_thread_info (thread_info *arg0)
1808 {
1809   gdb_printf (gdb_stdlog, "-> %s->extra_thread_info (...)\n", this->beneath ()->shortname ());
1810   const char * result
1811     = this->beneath ()->extra_thread_info (arg0);
1812   gdb_printf (gdb_stdlog, "<- %s->extra_thread_info (", this->beneath ()->shortname ());
1813   target_debug_print_thread_info_p (arg0);
1814   gdb_puts (") = ", gdb_stdlog);
1815   target_debug_print_const_char_p (result);
1816   gdb_puts ("\n", gdb_stdlog);
1817   return result;
1818 }
1819
1820 const char *
1821 target_ops::thread_name (thread_info *arg0)
1822 {
1823   return this->beneath ()->thread_name (arg0);
1824 }
1825
1826 const char *
1827 dummy_target::thread_name (thread_info *arg0)
1828 {
1829   return NULL;
1830 }
1831
1832 const char *
1833 debug_target::thread_name (thread_info *arg0)
1834 {
1835   gdb_printf (gdb_stdlog, "-> %s->thread_name (...)\n", this->beneath ()->shortname ());
1836   const char * result
1837     = this->beneath ()->thread_name (arg0);
1838   gdb_printf (gdb_stdlog, "<- %s->thread_name (", this->beneath ()->shortname ());
1839   target_debug_print_thread_info_p (arg0);
1840   gdb_puts (") = ", gdb_stdlog);
1841   target_debug_print_const_char_p (result);
1842   gdb_puts ("\n", gdb_stdlog);
1843   return result;
1844 }
1845
1846 thread_info *
1847 target_ops::thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2)
1848 {
1849   return this->beneath ()->thread_handle_to_thread_info (arg0, arg1, arg2);
1850 }
1851
1852 thread_info *
1853 dummy_target::thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2)
1854 {
1855   return NULL;
1856 }
1857
1858 thread_info *
1859 debug_target::thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2)
1860 {
1861   gdb_printf (gdb_stdlog, "-> %s->thread_handle_to_thread_info (...)\n", this->beneath ()->shortname ());
1862   thread_info * result
1863     = this->beneath ()->thread_handle_to_thread_info (arg0, arg1, arg2);
1864   gdb_printf (gdb_stdlog, "<- %s->thread_handle_to_thread_info (", this->beneath ()->shortname ());
1865   target_debug_print_const_gdb_byte_p (arg0);
1866   gdb_puts (", ", gdb_stdlog);
1867   target_debug_print_int (arg1);
1868   gdb_puts (", ", gdb_stdlog);
1869   target_debug_print_inferior_p (arg2);
1870   gdb_puts (") = ", gdb_stdlog);
1871   target_debug_print_thread_info_p (result);
1872   gdb_puts ("\n", gdb_stdlog);
1873   return result;
1874 }
1875
1876 gdb::array_view<const_gdb_byte>
1877 target_ops::thread_info_to_thread_handle (struct thread_info *arg0)
1878 {
1879   return this->beneath ()->thread_info_to_thread_handle (arg0);
1880 }
1881
1882 gdb::array_view<const_gdb_byte>
1883 dummy_target::thread_info_to_thread_handle (struct thread_info *arg0)
1884 {
1885   return gdb::array_view<const gdb_byte> ();
1886 }
1887
1888 gdb::array_view<const_gdb_byte>
1889 debug_target::thread_info_to_thread_handle (struct thread_info *arg0)
1890 {
1891   gdb_printf (gdb_stdlog, "-> %s->thread_info_to_thread_handle (...)\n", this->beneath ()->shortname ());
1892   gdb::array_view<const_gdb_byte> result
1893     = this->beneath ()->thread_info_to_thread_handle (arg0);
1894   gdb_printf (gdb_stdlog, "<- %s->thread_info_to_thread_handle (", this->beneath ()->shortname ());
1895   target_debug_print_thread_info_p (arg0);
1896   gdb_puts (") = ", gdb_stdlog);
1897   target_debug_print_gdb_array_view_const_gdb_byte (result);
1898   gdb_puts ("\n", gdb_stdlog);
1899   return result;
1900 }
1901
1902 void
1903 target_ops::stop (ptid_t arg0)
1904 {
1905   this->beneath ()->stop (arg0);
1906 }
1907
1908 void
1909 dummy_target::stop (ptid_t arg0)
1910 {
1911 }
1912
1913 void
1914 debug_target::stop (ptid_t arg0)
1915 {
1916   gdb_printf (gdb_stdlog, "-> %s->stop (...)\n", this->beneath ()->shortname ());
1917   this->beneath ()->stop (arg0);
1918   gdb_printf (gdb_stdlog, "<- %s->stop (", this->beneath ()->shortname ());
1919   target_debug_print_ptid_t (arg0);
1920   gdb_puts (")\n", gdb_stdlog);
1921 }
1922
1923 void
1924 target_ops::interrupt ()
1925 {
1926   this->beneath ()->interrupt ();
1927 }
1928
1929 void
1930 dummy_target::interrupt ()
1931 {
1932 }
1933
1934 void
1935 debug_target::interrupt ()
1936 {
1937   gdb_printf (gdb_stdlog, "-> %s->interrupt (...)\n", this->beneath ()->shortname ());
1938   this->beneath ()->interrupt ();
1939   gdb_printf (gdb_stdlog, "<- %s->interrupt (", this->beneath ()->shortname ());
1940   gdb_puts (")\n", gdb_stdlog);
1941 }
1942
1943 void
1944 target_ops::pass_ctrlc ()
1945 {
1946   this->beneath ()->pass_ctrlc ();
1947 }
1948
1949 void
1950 dummy_target::pass_ctrlc ()
1951 {
1952   default_target_pass_ctrlc (this);
1953 }
1954
1955 void
1956 debug_target::pass_ctrlc ()
1957 {
1958   gdb_printf (gdb_stdlog, "-> %s->pass_ctrlc (...)\n", this->beneath ()->shortname ());
1959   this->beneath ()->pass_ctrlc ();
1960   gdb_printf (gdb_stdlog, "<- %s->pass_ctrlc (", this->beneath ()->shortname ());
1961   gdb_puts (")\n", gdb_stdlog);
1962 }
1963
1964 void
1965 target_ops::rcmd (const char *arg0, struct ui_file *arg1)
1966 {
1967   this->beneath ()->rcmd (arg0, arg1);
1968 }
1969
1970 void
1971 dummy_target::rcmd (const char *arg0, struct ui_file *arg1)
1972 {
1973   default_rcmd (this, arg0, arg1);
1974 }
1975
1976 void
1977 debug_target::rcmd (const char *arg0, struct ui_file *arg1)
1978 {
1979   gdb_printf (gdb_stdlog, "-> %s->rcmd (...)\n", this->beneath ()->shortname ());
1980   this->beneath ()->rcmd (arg0, arg1);
1981   gdb_printf (gdb_stdlog, "<- %s->rcmd (", this->beneath ()->shortname ());
1982   target_debug_print_const_char_p (arg0);
1983   gdb_puts (", ", gdb_stdlog);
1984   target_debug_print_ui_file_p (arg1);
1985   gdb_puts (")\n", gdb_stdlog);
1986 }
1987
1988 const char *
1989 target_ops::pid_to_exec_file (int arg0)
1990 {
1991   return this->beneath ()->pid_to_exec_file (arg0);
1992 }
1993
1994 const char *
1995 dummy_target::pid_to_exec_file (int arg0)
1996 {
1997   return NULL;
1998 }
1999
2000 const char *
2001 debug_target::pid_to_exec_file (int arg0)
2002 {
2003   gdb_printf (gdb_stdlog, "-> %s->pid_to_exec_file (...)\n", this->beneath ()->shortname ());
2004   const char * result
2005     = this->beneath ()->pid_to_exec_file (arg0);
2006   gdb_printf (gdb_stdlog, "<- %s->pid_to_exec_file (", this->beneath ()->shortname ());
2007   target_debug_print_int (arg0);
2008   gdb_puts (") = ", gdb_stdlog);
2009   target_debug_print_const_char_p (result);
2010   gdb_puts ("\n", gdb_stdlog);
2011   return result;
2012 }
2013
2014 void
2015 target_ops::log_command (const char *arg0)
2016 {
2017   this->beneath ()->log_command (arg0);
2018 }
2019
2020 void
2021 dummy_target::log_command (const char *arg0)
2022 {
2023 }
2024
2025 void
2026 debug_target::log_command (const char *arg0)
2027 {
2028   gdb_printf (gdb_stdlog, "-> %s->log_command (...)\n", this->beneath ()->shortname ());
2029   this->beneath ()->log_command (arg0);
2030   gdb_printf (gdb_stdlog, "<- %s->log_command (", this->beneath ()->shortname ());
2031   target_debug_print_const_char_p (arg0);
2032   gdb_puts (")\n", gdb_stdlog);
2033 }
2034
2035 const std::vector<target_section> *
2036 target_ops::get_section_table ()
2037 {
2038   return this->beneath ()->get_section_table ();
2039 }
2040
2041 const std::vector<target_section> *
2042 dummy_target::get_section_table ()
2043 {
2044   return default_get_section_table ();
2045 }
2046
2047 const std::vector<target_section> *
2048 debug_target::get_section_table ()
2049 {
2050   gdb_printf (gdb_stdlog, "-> %s->get_section_table (...)\n", this->beneath ()->shortname ());
2051   const std::vector<target_section> * result
2052     = this->beneath ()->get_section_table ();
2053   gdb_printf (gdb_stdlog, "<- %s->get_section_table (", this->beneath ()->shortname ());
2054   gdb_puts (") = ", gdb_stdlog);
2055   target_debug_print_const_std_vector_target_section_p (result);
2056   gdb_puts ("\n", gdb_stdlog);
2057   return result;
2058 }
2059
2060 thread_control_capabilities
2061 target_ops::get_thread_control_capabilities ()
2062 {
2063   return this->beneath ()->get_thread_control_capabilities ();
2064 }
2065
2066 thread_control_capabilities
2067 dummy_target::get_thread_control_capabilities ()
2068 {
2069   return tc_none;
2070 }
2071
2072 thread_control_capabilities
2073 debug_target::get_thread_control_capabilities ()
2074 {
2075   gdb_printf (gdb_stdlog, "-> %s->get_thread_control_capabilities (...)\n", this->beneath ()->shortname ());
2076   thread_control_capabilities result
2077     = this->beneath ()->get_thread_control_capabilities ();
2078   gdb_printf (gdb_stdlog, "<- %s->get_thread_control_capabilities (", this->beneath ()->shortname ());
2079   gdb_puts (") = ", gdb_stdlog);
2080   target_debug_print_thread_control_capabilities (result);
2081   gdb_puts ("\n", gdb_stdlog);
2082   return result;
2083 }
2084
2085 bool
2086 target_ops::attach_no_wait ()
2087 {
2088   return this->beneath ()->attach_no_wait ();
2089 }
2090
2091 bool
2092 dummy_target::attach_no_wait ()
2093 {
2094   return 0;
2095 }
2096
2097 bool
2098 debug_target::attach_no_wait ()
2099 {
2100   gdb_printf (gdb_stdlog, "-> %s->attach_no_wait (...)\n", this->beneath ()->shortname ());
2101   bool result
2102     = this->beneath ()->attach_no_wait ();
2103   gdb_printf (gdb_stdlog, "<- %s->attach_no_wait (", this->beneath ()->shortname ());
2104   gdb_puts (") = ", gdb_stdlog);
2105   target_debug_print_bool (result);
2106   gdb_puts ("\n", gdb_stdlog);
2107   return result;
2108 }
2109
2110 bool
2111 target_ops::can_async_p ()
2112 {
2113   return this->beneath ()->can_async_p ();
2114 }
2115
2116 bool
2117 dummy_target::can_async_p ()
2118 {
2119   return false;
2120 }
2121
2122 bool
2123 debug_target::can_async_p ()
2124 {
2125   gdb_printf (gdb_stdlog, "-> %s->can_async_p (...)\n", this->beneath ()->shortname ());
2126   bool result
2127     = this->beneath ()->can_async_p ();
2128   gdb_printf (gdb_stdlog, "<- %s->can_async_p (", this->beneath ()->shortname ());
2129   gdb_puts (") = ", gdb_stdlog);
2130   target_debug_print_bool (result);
2131   gdb_puts ("\n", gdb_stdlog);
2132   return result;
2133 }
2134
2135 bool
2136 target_ops::is_async_p ()
2137 {
2138   return this->beneath ()->is_async_p ();
2139 }
2140
2141 bool
2142 dummy_target::is_async_p ()
2143 {
2144   return false;
2145 }
2146
2147 bool
2148 debug_target::is_async_p ()
2149 {
2150   gdb_printf (gdb_stdlog, "-> %s->is_async_p (...)\n", this->beneath ()->shortname ());
2151   bool result
2152     = this->beneath ()->is_async_p ();
2153   gdb_printf (gdb_stdlog, "<- %s->is_async_p (", this->beneath ()->shortname ());
2154   gdb_puts (") = ", gdb_stdlog);
2155   target_debug_print_bool (result);
2156   gdb_puts ("\n", gdb_stdlog);
2157   return result;
2158 }
2159
2160 void
2161 target_ops::async (bool arg0)
2162 {
2163   this->beneath ()->async (arg0);
2164 }
2165
2166 void
2167 dummy_target::async (bool arg0)
2168 {
2169   tcomplain ();
2170 }
2171
2172 void
2173 debug_target::async (bool arg0)
2174 {
2175   gdb_printf (gdb_stdlog, "-> %s->async (...)\n", this->beneath ()->shortname ());
2176   this->beneath ()->async (arg0);
2177   gdb_printf (gdb_stdlog, "<- %s->async (", this->beneath ()->shortname ());
2178   target_debug_print_bool (arg0);
2179   gdb_puts (")\n", gdb_stdlog);
2180 }
2181
2182 int
2183 target_ops::async_wait_fd ()
2184 {
2185   return this->beneath ()->async_wait_fd ();
2186 }
2187
2188 int
2189 dummy_target::async_wait_fd ()
2190 {
2191   noprocess ();
2192 }
2193
2194 int
2195 debug_target::async_wait_fd ()
2196 {
2197   gdb_printf (gdb_stdlog, "-> %s->async_wait_fd (...)\n", this->beneath ()->shortname ());
2198   int result
2199     = this->beneath ()->async_wait_fd ();
2200   gdb_printf (gdb_stdlog, "<- %s->async_wait_fd (", this->beneath ()->shortname ());
2201   gdb_puts (") = ", gdb_stdlog);
2202   target_debug_print_int (result);
2203   gdb_puts ("\n", gdb_stdlog);
2204   return result;
2205 }
2206
2207 bool
2208 target_ops::has_pending_events ()
2209 {
2210   return this->beneath ()->has_pending_events ();
2211 }
2212
2213 bool
2214 dummy_target::has_pending_events ()
2215 {
2216   return false;
2217 }
2218
2219 bool
2220 debug_target::has_pending_events ()
2221 {
2222   gdb_printf (gdb_stdlog, "-> %s->has_pending_events (...)\n", this->beneath ()->shortname ());
2223   bool result
2224     = this->beneath ()->has_pending_events ();
2225   gdb_printf (gdb_stdlog, "<- %s->has_pending_events (", this->beneath ()->shortname ());
2226   gdb_puts (") = ", gdb_stdlog);
2227   target_debug_print_bool (result);
2228   gdb_puts ("\n", gdb_stdlog);
2229   return result;
2230 }
2231
2232 void
2233 target_ops::thread_events (int arg0)
2234 {
2235   this->beneath ()->thread_events (arg0);
2236 }
2237
2238 void
2239 dummy_target::thread_events (int arg0)
2240 {
2241 }
2242
2243 void
2244 debug_target::thread_events (int arg0)
2245 {
2246   gdb_printf (gdb_stdlog, "-> %s->thread_events (...)\n", this->beneath ()->shortname ());
2247   this->beneath ()->thread_events (arg0);
2248   gdb_printf (gdb_stdlog, "<- %s->thread_events (", this->beneath ()->shortname ());
2249   target_debug_print_int (arg0);
2250   gdb_puts (")\n", gdb_stdlog);
2251 }
2252
2253 bool
2254 target_ops::supports_non_stop ()
2255 {
2256   return this->beneath ()->supports_non_stop ();
2257 }
2258
2259 bool
2260 dummy_target::supports_non_stop ()
2261 {
2262   return false;
2263 }
2264
2265 bool
2266 debug_target::supports_non_stop ()
2267 {
2268   gdb_printf (gdb_stdlog, "-> %s->supports_non_stop (...)\n", this->beneath ()->shortname ());
2269   bool result
2270     = this->beneath ()->supports_non_stop ();
2271   gdb_printf (gdb_stdlog, "<- %s->supports_non_stop (", this->beneath ()->shortname ());
2272   gdb_puts (") = ", gdb_stdlog);
2273   target_debug_print_bool (result);
2274   gdb_puts ("\n", gdb_stdlog);
2275   return result;
2276 }
2277
2278 bool
2279 target_ops::always_non_stop_p ()
2280 {
2281   return this->beneath ()->always_non_stop_p ();
2282 }
2283
2284 bool
2285 dummy_target::always_non_stop_p ()
2286 {
2287   return false;
2288 }
2289
2290 bool
2291 debug_target::always_non_stop_p ()
2292 {
2293   gdb_printf (gdb_stdlog, "-> %s->always_non_stop_p (...)\n", this->beneath ()->shortname ());
2294   bool result
2295     = this->beneath ()->always_non_stop_p ();
2296   gdb_printf (gdb_stdlog, "<- %s->always_non_stop_p (", this->beneath ()->shortname ());
2297   gdb_puts (") = ", gdb_stdlog);
2298   target_debug_print_bool (result);
2299   gdb_puts ("\n", gdb_stdlog);
2300   return result;
2301 }
2302
2303 int
2304 target_ops::find_memory_regions (find_memory_region_ftype arg0, void *arg1)
2305 {
2306   return this->beneath ()->find_memory_regions (arg0, arg1);
2307 }
2308
2309 int
2310 dummy_target::find_memory_regions (find_memory_region_ftype arg0, void *arg1)
2311 {
2312   return dummy_find_memory_regions (this, arg0, arg1);
2313 }
2314
2315 int
2316 debug_target::find_memory_regions (find_memory_region_ftype arg0, void *arg1)
2317 {
2318   gdb_printf (gdb_stdlog, "-> %s->find_memory_regions (...)\n", this->beneath ()->shortname ());
2319   int result
2320     = this->beneath ()->find_memory_regions (arg0, arg1);
2321   gdb_printf (gdb_stdlog, "<- %s->find_memory_regions (", this->beneath ()->shortname ());
2322   target_debug_print_find_memory_region_ftype (arg0);
2323   gdb_puts (", ", gdb_stdlog);
2324   target_debug_print_void_p (arg1);
2325   gdb_puts (") = ", gdb_stdlog);
2326   target_debug_print_int (result);
2327   gdb_puts ("\n", gdb_stdlog);
2328   return result;
2329 }
2330
2331 gdb::unique_xmalloc_ptr<char>
2332 target_ops::make_corefile_notes (bfd *arg0, int *arg1)
2333 {
2334   return this->beneath ()->make_corefile_notes (arg0, arg1);
2335 }
2336
2337 gdb::unique_xmalloc_ptr<char>
2338 dummy_target::make_corefile_notes (bfd *arg0, int *arg1)
2339 {
2340   return dummy_make_corefile_notes (this, arg0, arg1);
2341 }
2342
2343 gdb::unique_xmalloc_ptr<char>
2344 debug_target::make_corefile_notes (bfd *arg0, int *arg1)
2345 {
2346   gdb_printf (gdb_stdlog, "-> %s->make_corefile_notes (...)\n", this->beneath ()->shortname ());
2347   gdb::unique_xmalloc_ptr<char> result
2348     = this->beneath ()->make_corefile_notes (arg0, arg1);
2349   gdb_printf (gdb_stdlog, "<- %s->make_corefile_notes (", this->beneath ()->shortname ());
2350   target_debug_print_bfd_p (arg0);
2351   gdb_puts (", ", gdb_stdlog);
2352   target_debug_print_int_p (arg1);
2353   gdb_puts (") = ", gdb_stdlog);
2354   target_debug_print_gdb_unique_xmalloc_ptr_char (result);
2355   gdb_puts ("\n", gdb_stdlog);
2356   return result;
2357 }
2358
2359 gdb_byte *
2360 target_ops::get_bookmark (const char *arg0, int arg1)
2361 {
2362   return this->beneath ()->get_bookmark (arg0, arg1);
2363 }
2364
2365 gdb_byte *
2366 dummy_target::get_bookmark (const char *arg0, int arg1)
2367 {
2368   tcomplain ();
2369 }
2370
2371 gdb_byte *
2372 debug_target::get_bookmark (const char *arg0, int arg1)
2373 {
2374   gdb_printf (gdb_stdlog, "-> %s->get_bookmark (...)\n", this->beneath ()->shortname ());
2375   gdb_byte * result
2376     = this->beneath ()->get_bookmark (arg0, arg1);
2377   gdb_printf (gdb_stdlog, "<- %s->get_bookmark (", this->beneath ()->shortname ());
2378   target_debug_print_const_char_p (arg0);
2379   gdb_puts (", ", gdb_stdlog);
2380   target_debug_print_int (arg1);
2381   gdb_puts (") = ", gdb_stdlog);
2382   target_debug_print_gdb_byte_p (result);
2383   gdb_puts ("\n", gdb_stdlog);
2384   return result;
2385 }
2386
2387 void
2388 target_ops::goto_bookmark (const gdb_byte *arg0, int arg1)
2389 {
2390   this->beneath ()->goto_bookmark (arg0, arg1);
2391 }
2392
2393 void
2394 dummy_target::goto_bookmark (const gdb_byte *arg0, int arg1)
2395 {
2396   tcomplain ();
2397 }
2398
2399 void
2400 debug_target::goto_bookmark (const gdb_byte *arg0, int arg1)
2401 {
2402   gdb_printf (gdb_stdlog, "-> %s->goto_bookmark (...)\n", this->beneath ()->shortname ());
2403   this->beneath ()->goto_bookmark (arg0, arg1);
2404   gdb_printf (gdb_stdlog, "<- %s->goto_bookmark (", this->beneath ()->shortname ());
2405   target_debug_print_const_gdb_byte_p (arg0);
2406   gdb_puts (", ", gdb_stdlog);
2407   target_debug_print_int (arg1);
2408   gdb_puts (")\n", gdb_stdlog);
2409 }
2410
2411 CORE_ADDR
2412 target_ops::get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2)
2413 {
2414   return this->beneath ()->get_thread_local_address (arg0, arg1, arg2);
2415 }
2416
2417 CORE_ADDR
2418 dummy_target::get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2)
2419 {
2420   generic_tls_error ();
2421 }
2422
2423 CORE_ADDR
2424 debug_target::get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2)
2425 {
2426   gdb_printf (gdb_stdlog, "-> %s->get_thread_local_address (...)\n", this->beneath ()->shortname ());
2427   CORE_ADDR result
2428     = this->beneath ()->get_thread_local_address (arg0, arg1, arg2);
2429   gdb_printf (gdb_stdlog, "<- %s->get_thread_local_address (", this->beneath ()->shortname ());
2430   target_debug_print_ptid_t (arg0);
2431   gdb_puts (", ", gdb_stdlog);
2432   target_debug_print_CORE_ADDR (arg1);
2433   gdb_puts (", ", gdb_stdlog);
2434   target_debug_print_CORE_ADDR (arg2);
2435   gdb_puts (") = ", gdb_stdlog);
2436   target_debug_print_CORE_ADDR (result);
2437   gdb_puts ("\n", gdb_stdlog);
2438   return result;
2439 }
2440
2441 enum target_xfer_status
2442 target_ops::xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6)
2443 {
2444   return this->beneath ()->xfer_partial (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2445 }
2446
2447 enum target_xfer_status
2448 dummy_target::xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6)
2449 {
2450   return TARGET_XFER_E_IO;
2451 }
2452
2453 enum target_xfer_status
2454 debug_target::xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6)
2455 {
2456   gdb_printf (gdb_stdlog, "-> %s->xfer_partial (...)\n", this->beneath ()->shortname ());
2457   enum target_xfer_status result
2458     = this->beneath ()->xfer_partial (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2459   gdb_printf (gdb_stdlog, "<- %s->xfer_partial (", this->beneath ()->shortname ());
2460   target_debug_print_target_object (arg0);
2461   gdb_puts (", ", gdb_stdlog);
2462   target_debug_print_const_char_p (arg1);
2463   gdb_puts (", ", gdb_stdlog);
2464   target_debug_print_gdb_byte_p (arg2);
2465   gdb_puts (", ", gdb_stdlog);
2466   target_debug_print_const_gdb_byte_p (arg3);
2467   gdb_puts (", ", gdb_stdlog);
2468   target_debug_print_ULONGEST (arg4);
2469   gdb_puts (", ", gdb_stdlog);
2470   target_debug_print_ULONGEST (arg5);
2471   gdb_puts (", ", gdb_stdlog);
2472   target_debug_print_ULONGEST_p (arg6);
2473   gdb_puts (") = ", gdb_stdlog);
2474   target_debug_print_target_xfer_status (result);
2475   gdb_puts ("\n", gdb_stdlog);
2476   return result;
2477 }
2478
2479 ULONGEST
2480 target_ops::get_memory_xfer_limit ()
2481 {
2482   return this->beneath ()->get_memory_xfer_limit ();
2483 }
2484
2485 ULONGEST
2486 dummy_target::get_memory_xfer_limit ()
2487 {
2488   return ULONGEST_MAX;
2489 }
2490
2491 ULONGEST
2492 debug_target::get_memory_xfer_limit ()
2493 {
2494   gdb_printf (gdb_stdlog, "-> %s->get_memory_xfer_limit (...)\n", this->beneath ()->shortname ());
2495   ULONGEST result
2496     = this->beneath ()->get_memory_xfer_limit ();
2497   gdb_printf (gdb_stdlog, "<- %s->get_memory_xfer_limit (", this->beneath ()->shortname ());
2498   gdb_puts (") = ", gdb_stdlog);
2499   target_debug_print_ULONGEST (result);
2500   gdb_puts ("\n", gdb_stdlog);
2501   return result;
2502 }
2503
2504 std::vector<mem_region>
2505 target_ops::memory_map ()
2506 {
2507   return this->beneath ()->memory_map ();
2508 }
2509
2510 std::vector<mem_region>
2511 dummy_target::memory_map ()
2512 {
2513   return std::vector<mem_region> ();
2514 }
2515
2516 std::vector<mem_region>
2517 debug_target::memory_map ()
2518 {
2519   gdb_printf (gdb_stdlog, "-> %s->memory_map (...)\n", this->beneath ()->shortname ());
2520   std::vector<mem_region> result
2521     = this->beneath ()->memory_map ();
2522   gdb_printf (gdb_stdlog, "<- %s->memory_map (", this->beneath ()->shortname ());
2523   gdb_puts (") = ", gdb_stdlog);
2524   target_debug_print_std_vector_mem_region (result);
2525   gdb_puts ("\n", gdb_stdlog);
2526   return result;
2527 }
2528
2529 void
2530 target_ops::flash_erase (ULONGEST arg0, LONGEST arg1)
2531 {
2532   this->beneath ()->flash_erase (arg0, arg1);
2533 }
2534
2535 void
2536 dummy_target::flash_erase (ULONGEST arg0, LONGEST arg1)
2537 {
2538   tcomplain ();
2539 }
2540
2541 void
2542 debug_target::flash_erase (ULONGEST arg0, LONGEST arg1)
2543 {
2544   gdb_printf (gdb_stdlog, "-> %s->flash_erase (...)\n", this->beneath ()->shortname ());
2545   this->beneath ()->flash_erase (arg0, arg1);
2546   gdb_printf (gdb_stdlog, "<- %s->flash_erase (", this->beneath ()->shortname ());
2547   target_debug_print_ULONGEST (arg0);
2548   gdb_puts (", ", gdb_stdlog);
2549   target_debug_print_LONGEST (arg1);
2550   gdb_puts (")\n", gdb_stdlog);
2551 }
2552
2553 void
2554 target_ops::flash_done ()
2555 {
2556   this->beneath ()->flash_done ();
2557 }
2558
2559 void
2560 dummy_target::flash_done ()
2561 {
2562   tcomplain ();
2563 }
2564
2565 void
2566 debug_target::flash_done ()
2567 {
2568   gdb_printf (gdb_stdlog, "-> %s->flash_done (...)\n", this->beneath ()->shortname ());
2569   this->beneath ()->flash_done ();
2570   gdb_printf (gdb_stdlog, "<- %s->flash_done (", this->beneath ()->shortname ());
2571   gdb_puts (")\n", gdb_stdlog);
2572 }
2573
2574 const struct target_desc *
2575 target_ops::read_description ()
2576 {
2577   return this->beneath ()->read_description ();
2578 }
2579
2580 const struct target_desc *
2581 dummy_target::read_description ()
2582 {
2583   return NULL;
2584 }
2585
2586 const struct target_desc *
2587 debug_target::read_description ()
2588 {
2589   gdb_printf (gdb_stdlog, "-> %s->read_description (...)\n", this->beneath ()->shortname ());
2590   const struct target_desc * result
2591     = this->beneath ()->read_description ();
2592   gdb_printf (gdb_stdlog, "<- %s->read_description (", this->beneath ()->shortname ());
2593   gdb_puts (") = ", gdb_stdlog);
2594   target_debug_print_const_target_desc_p (result);
2595   gdb_puts ("\n", gdb_stdlog);
2596   return result;
2597 }
2598
2599 ptid_t
2600 target_ops::get_ada_task_ptid (long arg0, ULONGEST arg1)
2601 {
2602   return this->beneath ()->get_ada_task_ptid (arg0, arg1);
2603 }
2604
2605 ptid_t
2606 dummy_target::get_ada_task_ptid (long arg0, ULONGEST arg1)
2607 {
2608   return default_get_ada_task_ptid (this, arg0, arg1);
2609 }
2610
2611 ptid_t
2612 debug_target::get_ada_task_ptid (long arg0, ULONGEST arg1)
2613 {
2614   gdb_printf (gdb_stdlog, "-> %s->get_ada_task_ptid (...)\n", this->beneath ()->shortname ());
2615   ptid_t result
2616     = this->beneath ()->get_ada_task_ptid (arg0, arg1);
2617   gdb_printf (gdb_stdlog, "<- %s->get_ada_task_ptid (", this->beneath ()->shortname ());
2618   target_debug_print_long (arg0);
2619   gdb_puts (", ", gdb_stdlog);
2620   target_debug_print_ULONGEST (arg1);
2621   gdb_puts (") = ", gdb_stdlog);
2622   target_debug_print_ptid_t (result);
2623   gdb_puts ("\n", gdb_stdlog);
2624   return result;
2625 }
2626
2627 int
2628 target_ops::auxv_parse (const gdb_byte **arg0, const gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3)
2629 {
2630   return this->beneath ()->auxv_parse (arg0, arg1, arg2, arg3);
2631 }
2632
2633 int
2634 dummy_target::auxv_parse (const gdb_byte **arg0, const gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3)
2635 {
2636   return default_auxv_parse (this, arg0, arg1, arg2, arg3);
2637 }
2638
2639 int
2640 debug_target::auxv_parse (const gdb_byte **arg0, const gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3)
2641 {
2642   gdb_printf (gdb_stdlog, "-> %s->auxv_parse (...)\n", this->beneath ()->shortname ());
2643   int result
2644     = this->beneath ()->auxv_parse (arg0, arg1, arg2, arg3);
2645   gdb_printf (gdb_stdlog, "<- %s->auxv_parse (", this->beneath ()->shortname ());
2646   target_debug_print_const_gdb_byte_pp (arg0);
2647   gdb_puts (", ", gdb_stdlog);
2648   target_debug_print_const_gdb_byte_p (arg1);
2649   gdb_puts (", ", gdb_stdlog);
2650   target_debug_print_CORE_ADDR_p (arg2);
2651   gdb_puts (", ", gdb_stdlog);
2652   target_debug_print_CORE_ADDR_p (arg3);
2653   gdb_puts (") = ", gdb_stdlog);
2654   target_debug_print_int (result);
2655   gdb_puts ("\n", gdb_stdlog);
2656   return result;
2657 }
2658
2659 int
2660 target_ops::search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4)
2661 {
2662   return this->beneath ()->search_memory (arg0, arg1, arg2, arg3, arg4);
2663 }
2664
2665 int
2666 dummy_target::search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4)
2667 {
2668   return default_search_memory (this, arg0, arg1, arg2, arg3, arg4);
2669 }
2670
2671 int
2672 debug_target::search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4)
2673 {
2674   gdb_printf (gdb_stdlog, "-> %s->search_memory (...)\n", this->beneath ()->shortname ());
2675   int result
2676     = this->beneath ()->search_memory (arg0, arg1, arg2, arg3, arg4);
2677   gdb_printf (gdb_stdlog, "<- %s->search_memory (", this->beneath ()->shortname ());
2678   target_debug_print_CORE_ADDR (arg0);
2679   gdb_puts (", ", gdb_stdlog);
2680   target_debug_print_ULONGEST (arg1);
2681   gdb_puts (", ", gdb_stdlog);
2682   target_debug_print_const_gdb_byte_p (arg2);
2683   gdb_puts (", ", gdb_stdlog);
2684   target_debug_print_ULONGEST (arg3);
2685   gdb_puts (", ", gdb_stdlog);
2686   target_debug_print_CORE_ADDR_p (arg4);
2687   gdb_puts (") = ", gdb_stdlog);
2688   target_debug_print_int (result);
2689   gdb_puts ("\n", gdb_stdlog);
2690   return result;
2691 }
2692
2693 bool
2694 target_ops::can_execute_reverse ()
2695 {
2696   return this->beneath ()->can_execute_reverse ();
2697 }
2698
2699 bool
2700 dummy_target::can_execute_reverse ()
2701 {
2702   return false;
2703 }
2704
2705 bool
2706 debug_target::can_execute_reverse ()
2707 {
2708   gdb_printf (gdb_stdlog, "-> %s->can_execute_reverse (...)\n", this->beneath ()->shortname ());
2709   bool result
2710     = this->beneath ()->can_execute_reverse ();
2711   gdb_printf (gdb_stdlog, "<- %s->can_execute_reverse (", this->beneath ()->shortname ());
2712   gdb_puts (") = ", gdb_stdlog);
2713   target_debug_print_bool (result);
2714   gdb_puts ("\n", gdb_stdlog);
2715   return result;
2716 }
2717
2718 enum exec_direction_kind
2719 target_ops::execution_direction ()
2720 {
2721   return this->beneath ()->execution_direction ();
2722 }
2723
2724 enum exec_direction_kind
2725 dummy_target::execution_direction ()
2726 {
2727   return default_execution_direction (this);
2728 }
2729
2730 enum exec_direction_kind
2731 debug_target::execution_direction ()
2732 {
2733   gdb_printf (gdb_stdlog, "-> %s->execution_direction (...)\n", this->beneath ()->shortname ());
2734   enum exec_direction_kind result
2735     = this->beneath ()->execution_direction ();
2736   gdb_printf (gdb_stdlog, "<- %s->execution_direction (", this->beneath ()->shortname ());
2737   gdb_puts (") = ", gdb_stdlog);
2738   target_debug_print_exec_direction_kind (result);
2739   gdb_puts ("\n", gdb_stdlog);
2740   return result;
2741 }
2742
2743 bool
2744 target_ops::supports_multi_process ()
2745 {
2746   return this->beneath ()->supports_multi_process ();
2747 }
2748
2749 bool
2750 dummy_target::supports_multi_process ()
2751 {
2752   return false;
2753 }
2754
2755 bool
2756 debug_target::supports_multi_process ()
2757 {
2758   gdb_printf (gdb_stdlog, "-> %s->supports_multi_process (...)\n", this->beneath ()->shortname ());
2759   bool result
2760     = this->beneath ()->supports_multi_process ();
2761   gdb_printf (gdb_stdlog, "<- %s->supports_multi_process (", this->beneath ()->shortname ());
2762   gdb_puts (") = ", gdb_stdlog);
2763   target_debug_print_bool (result);
2764   gdb_puts ("\n", gdb_stdlog);
2765   return result;
2766 }
2767
2768 bool
2769 target_ops::supports_enable_disable_tracepoint ()
2770 {
2771   return this->beneath ()->supports_enable_disable_tracepoint ();
2772 }
2773
2774 bool
2775 dummy_target::supports_enable_disable_tracepoint ()
2776 {
2777   return false;
2778 }
2779
2780 bool
2781 debug_target::supports_enable_disable_tracepoint ()
2782 {
2783   gdb_printf (gdb_stdlog, "-> %s->supports_enable_disable_tracepoint (...)\n", this->beneath ()->shortname ());
2784   bool result
2785     = this->beneath ()->supports_enable_disable_tracepoint ();
2786   gdb_printf (gdb_stdlog, "<- %s->supports_enable_disable_tracepoint (", this->beneath ()->shortname ());
2787   gdb_puts (") = ", gdb_stdlog);
2788   target_debug_print_bool (result);
2789   gdb_puts ("\n", gdb_stdlog);
2790   return result;
2791 }
2792
2793 bool
2794 target_ops::supports_disable_randomization ()
2795 {
2796   return this->beneath ()->supports_disable_randomization ();
2797 }
2798
2799 bool
2800 dummy_target::supports_disable_randomization ()
2801 {
2802   return find_default_supports_disable_randomization (this);
2803 }
2804
2805 bool
2806 debug_target::supports_disable_randomization ()
2807 {
2808   gdb_printf (gdb_stdlog, "-> %s->supports_disable_randomization (...)\n", this->beneath ()->shortname ());
2809   bool result
2810     = this->beneath ()->supports_disable_randomization ();
2811   gdb_printf (gdb_stdlog, "<- %s->supports_disable_randomization (", this->beneath ()->shortname ());
2812   gdb_puts (") = ", gdb_stdlog);
2813   target_debug_print_bool (result);
2814   gdb_puts ("\n", gdb_stdlog);
2815   return result;
2816 }
2817
2818 bool
2819 target_ops::supports_string_tracing ()
2820 {
2821   return this->beneath ()->supports_string_tracing ();
2822 }
2823
2824 bool
2825 dummy_target::supports_string_tracing ()
2826 {
2827   return false;
2828 }
2829
2830 bool
2831 debug_target::supports_string_tracing ()
2832 {
2833   gdb_printf (gdb_stdlog, "-> %s->supports_string_tracing (...)\n", this->beneath ()->shortname ());
2834   bool result
2835     = this->beneath ()->supports_string_tracing ();
2836   gdb_printf (gdb_stdlog, "<- %s->supports_string_tracing (", this->beneath ()->shortname ());
2837   gdb_puts (") = ", gdb_stdlog);
2838   target_debug_print_bool (result);
2839   gdb_puts ("\n", gdb_stdlog);
2840   return result;
2841 }
2842
2843 bool
2844 target_ops::supports_evaluation_of_breakpoint_conditions ()
2845 {
2846   return this->beneath ()->supports_evaluation_of_breakpoint_conditions ();
2847 }
2848
2849 bool
2850 dummy_target::supports_evaluation_of_breakpoint_conditions ()
2851 {
2852   return false;
2853 }
2854
2855 bool
2856 debug_target::supports_evaluation_of_breakpoint_conditions ()
2857 {
2858   gdb_printf (gdb_stdlog, "-> %s->supports_evaluation_of_breakpoint_conditions (...)\n", this->beneath ()->shortname ());
2859   bool result
2860     = this->beneath ()->supports_evaluation_of_breakpoint_conditions ();
2861   gdb_printf (gdb_stdlog, "<- %s->supports_evaluation_of_breakpoint_conditions (", this->beneath ()->shortname ());
2862   gdb_puts (") = ", gdb_stdlog);
2863   target_debug_print_bool (result);
2864   gdb_puts ("\n", gdb_stdlog);
2865   return result;
2866 }
2867
2868 bool
2869 target_ops::supports_dumpcore ()
2870 {
2871   return this->beneath ()->supports_dumpcore ();
2872 }
2873
2874 bool
2875 dummy_target::supports_dumpcore ()
2876 {
2877   return false;
2878 }
2879
2880 bool
2881 debug_target::supports_dumpcore ()
2882 {
2883   gdb_printf (gdb_stdlog, "-> %s->supports_dumpcore (...)\n", this->beneath ()->shortname ());
2884   bool result
2885     = this->beneath ()->supports_dumpcore ();
2886   gdb_printf (gdb_stdlog, "<- %s->supports_dumpcore (", this->beneath ()->shortname ());
2887   gdb_puts (") = ", gdb_stdlog);
2888   target_debug_print_bool (result);
2889   gdb_puts ("\n", gdb_stdlog);
2890   return result;
2891 }
2892
2893 void
2894 target_ops::dumpcore (const char *arg0)
2895 {
2896   this->beneath ()->dumpcore (arg0);
2897 }
2898
2899 void
2900 dummy_target::dumpcore (const char *arg0)
2901 {
2902 }
2903
2904 void
2905 debug_target::dumpcore (const char *arg0)
2906 {
2907   gdb_printf (gdb_stdlog, "-> %s->dumpcore (...)\n", this->beneath ()->shortname ());
2908   this->beneath ()->dumpcore (arg0);
2909   gdb_printf (gdb_stdlog, "<- %s->dumpcore (", this->beneath ()->shortname ());
2910   target_debug_print_const_char_p (arg0);
2911   gdb_puts (")\n", gdb_stdlog);
2912 }
2913
2914 bool
2915 target_ops::can_run_breakpoint_commands ()
2916 {
2917   return this->beneath ()->can_run_breakpoint_commands ();
2918 }
2919
2920 bool
2921 dummy_target::can_run_breakpoint_commands ()
2922 {
2923   return false;
2924 }
2925
2926 bool
2927 debug_target::can_run_breakpoint_commands ()
2928 {
2929   gdb_printf (gdb_stdlog, "-> %s->can_run_breakpoint_commands (...)\n", this->beneath ()->shortname ());
2930   bool result
2931     = this->beneath ()->can_run_breakpoint_commands ();
2932   gdb_printf (gdb_stdlog, "<- %s->can_run_breakpoint_commands (", this->beneath ()->shortname ());
2933   gdb_puts (") = ", gdb_stdlog);
2934   target_debug_print_bool (result);
2935   gdb_puts ("\n", gdb_stdlog);
2936   return result;
2937 }
2938
2939 struct gdbarch *
2940 target_ops::thread_architecture (ptid_t arg0)
2941 {
2942   return this->beneath ()->thread_architecture (arg0);
2943 }
2944
2945 struct gdbarch *
2946 dummy_target::thread_architecture (ptid_t arg0)
2947 {
2948   return NULL;
2949 }
2950
2951 struct gdbarch *
2952 debug_target::thread_architecture (ptid_t arg0)
2953 {
2954   gdb_printf (gdb_stdlog, "-> %s->thread_architecture (...)\n", this->beneath ()->shortname ());
2955   struct gdbarch * result
2956     = this->beneath ()->thread_architecture (arg0);
2957   gdb_printf (gdb_stdlog, "<- %s->thread_architecture (", this->beneath ()->shortname ());
2958   target_debug_print_ptid_t (arg0);
2959   gdb_puts (") = ", gdb_stdlog);
2960   target_debug_print_gdbarch_p (result);
2961   gdb_puts ("\n", gdb_stdlog);
2962   return result;
2963 }
2964
2965 struct address_space *
2966 target_ops::thread_address_space (ptid_t arg0)
2967 {
2968   return this->beneath ()->thread_address_space (arg0);
2969 }
2970
2971 struct address_space *
2972 dummy_target::thread_address_space (ptid_t arg0)
2973 {
2974   return NULL;
2975 }
2976
2977 struct address_space *
2978 debug_target::thread_address_space (ptid_t arg0)
2979 {
2980   gdb_printf (gdb_stdlog, "-> %s->thread_address_space (...)\n", this->beneath ()->shortname ());
2981   struct address_space * result
2982     = this->beneath ()->thread_address_space (arg0);
2983   gdb_printf (gdb_stdlog, "<- %s->thread_address_space (", this->beneath ()->shortname ());
2984   target_debug_print_ptid_t (arg0);
2985   gdb_puts (") = ", gdb_stdlog);
2986   target_debug_print_address_space_p (result);
2987   gdb_puts ("\n", gdb_stdlog);
2988   return result;
2989 }
2990
2991 bool
2992 target_ops::filesystem_is_local ()
2993 {
2994   return this->beneath ()->filesystem_is_local ();
2995 }
2996
2997 bool
2998 dummy_target::filesystem_is_local ()
2999 {
3000   return true;
3001 }
3002
3003 bool
3004 debug_target::filesystem_is_local ()
3005 {
3006   gdb_printf (gdb_stdlog, "-> %s->filesystem_is_local (...)\n", this->beneath ()->shortname ());
3007   bool result
3008     = this->beneath ()->filesystem_is_local ();
3009   gdb_printf (gdb_stdlog, "<- %s->filesystem_is_local (", this->beneath ()->shortname ());
3010   gdb_puts (") = ", gdb_stdlog);
3011   target_debug_print_bool (result);
3012   gdb_puts ("\n", gdb_stdlog);
3013   return result;
3014 }
3015
3016 void
3017 target_ops::trace_init ()
3018 {
3019   this->beneath ()->trace_init ();
3020 }
3021
3022 void
3023 dummy_target::trace_init ()
3024 {
3025   tcomplain ();
3026 }
3027
3028 void
3029 debug_target::trace_init ()
3030 {
3031   gdb_printf (gdb_stdlog, "-> %s->trace_init (...)\n", this->beneath ()->shortname ());
3032   this->beneath ()->trace_init ();
3033   gdb_printf (gdb_stdlog, "<- %s->trace_init (", this->beneath ()->shortname ());
3034   gdb_puts (")\n", gdb_stdlog);
3035 }
3036
3037 void
3038 target_ops::download_tracepoint (struct bp_location *arg0)
3039 {
3040   this->beneath ()->download_tracepoint (arg0);
3041 }
3042
3043 void
3044 dummy_target::download_tracepoint (struct bp_location *arg0)
3045 {
3046   tcomplain ();
3047 }
3048
3049 void
3050 debug_target::download_tracepoint (struct bp_location *arg0)
3051 {
3052   gdb_printf (gdb_stdlog, "-> %s->download_tracepoint (...)\n", this->beneath ()->shortname ());
3053   this->beneath ()->download_tracepoint (arg0);
3054   gdb_printf (gdb_stdlog, "<- %s->download_tracepoint (", this->beneath ()->shortname ());
3055   target_debug_print_bp_location_p (arg0);
3056   gdb_puts (")\n", gdb_stdlog);
3057 }
3058
3059 bool
3060 target_ops::can_download_tracepoint ()
3061 {
3062   return this->beneath ()->can_download_tracepoint ();
3063 }
3064
3065 bool
3066 dummy_target::can_download_tracepoint ()
3067 {
3068   return false;
3069 }
3070
3071 bool
3072 debug_target::can_download_tracepoint ()
3073 {
3074   gdb_printf (gdb_stdlog, "-> %s->can_download_tracepoint (...)\n", this->beneath ()->shortname ());
3075   bool result
3076     = this->beneath ()->can_download_tracepoint ();
3077   gdb_printf (gdb_stdlog, "<- %s->can_download_tracepoint (", this->beneath ()->shortname ());
3078   gdb_puts (") = ", gdb_stdlog);
3079   target_debug_print_bool (result);
3080   gdb_puts ("\n", gdb_stdlog);
3081   return result;
3082 }
3083
3084 void
3085 target_ops::download_trace_state_variable (const trace_state_variable &arg0)
3086 {
3087   this->beneath ()->download_trace_state_variable (arg0);
3088 }
3089
3090 void
3091 dummy_target::download_trace_state_variable (const trace_state_variable &arg0)
3092 {
3093   tcomplain ();
3094 }
3095
3096 void
3097 debug_target::download_trace_state_variable (const trace_state_variable &arg0)
3098 {
3099   gdb_printf (gdb_stdlog, "-> %s->download_trace_state_variable (...)\n", this->beneath ()->shortname ());
3100   this->beneath ()->download_trace_state_variable (arg0);
3101   gdb_printf (gdb_stdlog, "<- %s->download_trace_state_variable (", this->beneath ()->shortname ());
3102   target_debug_print_const_trace_state_variable_r (arg0);
3103   gdb_puts (")\n", gdb_stdlog);
3104 }
3105
3106 void
3107 target_ops::enable_tracepoint (struct bp_location *arg0)
3108 {
3109   this->beneath ()->enable_tracepoint (arg0);
3110 }
3111
3112 void
3113 dummy_target::enable_tracepoint (struct bp_location *arg0)
3114 {
3115   tcomplain ();
3116 }
3117
3118 void
3119 debug_target::enable_tracepoint (struct bp_location *arg0)
3120 {
3121   gdb_printf (gdb_stdlog, "-> %s->enable_tracepoint (...)\n", this->beneath ()->shortname ());
3122   this->beneath ()->enable_tracepoint (arg0);
3123   gdb_printf (gdb_stdlog, "<- %s->enable_tracepoint (", this->beneath ()->shortname ());
3124   target_debug_print_bp_location_p (arg0);
3125   gdb_puts (")\n", gdb_stdlog);
3126 }
3127
3128 void
3129 target_ops::disable_tracepoint (struct bp_location *arg0)
3130 {
3131   this->beneath ()->disable_tracepoint (arg0);
3132 }
3133
3134 void
3135 dummy_target::disable_tracepoint (struct bp_location *arg0)
3136 {
3137   tcomplain ();
3138 }
3139
3140 void
3141 debug_target::disable_tracepoint (struct bp_location *arg0)
3142 {
3143   gdb_printf (gdb_stdlog, "-> %s->disable_tracepoint (...)\n", this->beneath ()->shortname ());
3144   this->beneath ()->disable_tracepoint (arg0);
3145   gdb_printf (gdb_stdlog, "<- %s->disable_tracepoint (", this->beneath ()->shortname ());
3146   target_debug_print_bp_location_p (arg0);
3147   gdb_puts (")\n", gdb_stdlog);
3148 }
3149
3150 void
3151 target_ops::trace_set_readonly_regions ()
3152 {
3153   this->beneath ()->trace_set_readonly_regions ();
3154 }
3155
3156 void
3157 dummy_target::trace_set_readonly_regions ()
3158 {
3159   tcomplain ();
3160 }
3161
3162 void
3163 debug_target::trace_set_readonly_regions ()
3164 {
3165   gdb_printf (gdb_stdlog, "-> %s->trace_set_readonly_regions (...)\n", this->beneath ()->shortname ());
3166   this->beneath ()->trace_set_readonly_regions ();
3167   gdb_printf (gdb_stdlog, "<- %s->trace_set_readonly_regions (", this->beneath ()->shortname ());
3168   gdb_puts (")\n", gdb_stdlog);
3169 }
3170
3171 void
3172 target_ops::trace_start ()
3173 {
3174   this->beneath ()->trace_start ();
3175 }
3176
3177 void
3178 dummy_target::trace_start ()
3179 {
3180   tcomplain ();
3181 }
3182
3183 void
3184 debug_target::trace_start ()
3185 {
3186   gdb_printf (gdb_stdlog, "-> %s->trace_start (...)\n", this->beneath ()->shortname ());
3187   this->beneath ()->trace_start ();
3188   gdb_printf (gdb_stdlog, "<- %s->trace_start (", this->beneath ()->shortname ());
3189   gdb_puts (")\n", gdb_stdlog);
3190 }
3191
3192 int
3193 target_ops::get_trace_status (struct trace_status *arg0)
3194 {
3195   return this->beneath ()->get_trace_status (arg0);
3196 }
3197
3198 int
3199 dummy_target::get_trace_status (struct trace_status *arg0)
3200 {
3201   return -1;
3202 }
3203
3204 int
3205 debug_target::get_trace_status (struct trace_status *arg0)
3206 {
3207   gdb_printf (gdb_stdlog, "-> %s->get_trace_status (...)\n", this->beneath ()->shortname ());
3208   int result
3209     = this->beneath ()->get_trace_status (arg0);
3210   gdb_printf (gdb_stdlog, "<- %s->get_trace_status (", this->beneath ()->shortname ());
3211   target_debug_print_trace_status_p (arg0);
3212   gdb_puts (") = ", gdb_stdlog);
3213   target_debug_print_int (result);
3214   gdb_puts ("\n", gdb_stdlog);
3215   return result;
3216 }
3217
3218 void
3219 target_ops::get_tracepoint_status (tracepoint *arg0, struct uploaded_tp *arg1)
3220 {
3221   this->beneath ()->get_tracepoint_status (arg0, arg1);
3222 }
3223
3224 void
3225 dummy_target::get_tracepoint_status (tracepoint *arg0, struct uploaded_tp *arg1)
3226 {
3227   tcomplain ();
3228 }
3229
3230 void
3231 debug_target::get_tracepoint_status (tracepoint *arg0, struct uploaded_tp *arg1)
3232 {
3233   gdb_printf (gdb_stdlog, "-> %s->get_tracepoint_status (...)\n", this->beneath ()->shortname ());
3234   this->beneath ()->get_tracepoint_status (arg0, arg1);
3235   gdb_printf (gdb_stdlog, "<- %s->get_tracepoint_status (", this->beneath ()->shortname ());
3236   target_debug_print_tracepoint_p (arg0);
3237   gdb_puts (", ", gdb_stdlog);
3238   target_debug_print_uploaded_tp_p (arg1);
3239   gdb_puts (")\n", gdb_stdlog);
3240 }
3241
3242 void
3243 target_ops::trace_stop ()
3244 {
3245   this->beneath ()->trace_stop ();
3246 }
3247
3248 void
3249 dummy_target::trace_stop ()
3250 {
3251   tcomplain ();
3252 }
3253
3254 void
3255 debug_target::trace_stop ()
3256 {
3257   gdb_printf (gdb_stdlog, "-> %s->trace_stop (...)\n", this->beneath ()->shortname ());
3258   this->beneath ()->trace_stop ();
3259   gdb_printf (gdb_stdlog, "<- %s->trace_stop (", this->beneath ()->shortname ());
3260   gdb_puts (")\n", gdb_stdlog);
3261 }
3262
3263 int
3264 target_ops::trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4)
3265 {
3266   return this->beneath ()->trace_find (arg0, arg1, arg2, arg3, arg4);
3267 }
3268
3269 int
3270 dummy_target::trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4)
3271 {
3272   return -1;
3273 }
3274
3275 int
3276 debug_target::trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4)
3277 {
3278   gdb_printf (gdb_stdlog, "-> %s->trace_find (...)\n", this->beneath ()->shortname ());
3279   int result
3280     = this->beneath ()->trace_find (arg0, arg1, arg2, arg3, arg4);
3281   gdb_printf (gdb_stdlog, "<- %s->trace_find (", this->beneath ()->shortname ());
3282   target_debug_print_trace_find_type (arg0);
3283   gdb_puts (", ", gdb_stdlog);
3284   target_debug_print_int (arg1);
3285   gdb_puts (", ", gdb_stdlog);
3286   target_debug_print_CORE_ADDR (arg2);
3287   gdb_puts (", ", gdb_stdlog);
3288   target_debug_print_CORE_ADDR (arg3);
3289   gdb_puts (", ", gdb_stdlog);
3290   target_debug_print_int_p (arg4);
3291   gdb_puts (") = ", gdb_stdlog);
3292   target_debug_print_int (result);
3293   gdb_puts ("\n", gdb_stdlog);
3294   return result;
3295 }
3296
3297 bool
3298 target_ops::get_trace_state_variable_value (int arg0, LONGEST *arg1)
3299 {
3300   return this->beneath ()->get_trace_state_variable_value (arg0, arg1);
3301 }
3302
3303 bool
3304 dummy_target::get_trace_state_variable_value (int arg0, LONGEST *arg1)
3305 {
3306   return false;
3307 }
3308
3309 bool
3310 debug_target::get_trace_state_variable_value (int arg0, LONGEST *arg1)
3311 {
3312   gdb_printf (gdb_stdlog, "-> %s->get_trace_state_variable_value (...)\n", this->beneath ()->shortname ());
3313   bool result
3314     = this->beneath ()->get_trace_state_variable_value (arg0, arg1);
3315   gdb_printf (gdb_stdlog, "<- %s->get_trace_state_variable_value (", this->beneath ()->shortname ());
3316   target_debug_print_int (arg0);
3317   gdb_puts (", ", gdb_stdlog);
3318   target_debug_print_LONGEST_p (arg1);
3319   gdb_puts (") = ", gdb_stdlog);
3320   target_debug_print_bool (result);
3321   gdb_puts ("\n", gdb_stdlog);
3322   return result;
3323 }
3324
3325 int
3326 target_ops::save_trace_data (const char *arg0)
3327 {
3328   return this->beneath ()->save_trace_data (arg0);
3329 }
3330
3331 int
3332 dummy_target::save_trace_data (const char *arg0)
3333 {
3334   tcomplain ();
3335 }
3336
3337 int
3338 debug_target::save_trace_data (const char *arg0)
3339 {
3340   gdb_printf (gdb_stdlog, "-> %s->save_trace_data (...)\n", this->beneath ()->shortname ());
3341   int result
3342     = this->beneath ()->save_trace_data (arg0);
3343   gdb_printf (gdb_stdlog, "<- %s->save_trace_data (", this->beneath ()->shortname ());
3344   target_debug_print_const_char_p (arg0);
3345   gdb_puts (") = ", gdb_stdlog);
3346   target_debug_print_int (result);
3347   gdb_puts ("\n", gdb_stdlog);
3348   return result;
3349 }
3350
3351 int
3352 target_ops::upload_tracepoints (struct uploaded_tp **arg0)
3353 {
3354   return this->beneath ()->upload_tracepoints (arg0);
3355 }
3356
3357 int
3358 dummy_target::upload_tracepoints (struct uploaded_tp **arg0)
3359 {
3360   return 0;
3361 }
3362
3363 int
3364 debug_target::upload_tracepoints (struct uploaded_tp **arg0)
3365 {
3366   gdb_printf (gdb_stdlog, "-> %s->upload_tracepoints (...)\n", this->beneath ()->shortname ());
3367   int result
3368     = this->beneath ()->upload_tracepoints (arg0);
3369   gdb_printf (gdb_stdlog, "<- %s->upload_tracepoints (", this->beneath ()->shortname ());
3370   target_debug_print_uploaded_tp_pp (arg0);
3371   gdb_puts (") = ", gdb_stdlog);
3372   target_debug_print_int (result);
3373   gdb_puts ("\n", gdb_stdlog);
3374   return result;
3375 }
3376
3377 int
3378 target_ops::upload_trace_state_variables (struct uploaded_tsv **arg0)
3379 {
3380   return this->beneath ()->upload_trace_state_variables (arg0);
3381 }
3382
3383 int
3384 dummy_target::upload_trace_state_variables (struct uploaded_tsv **arg0)
3385 {
3386   return 0;
3387 }
3388
3389 int
3390 debug_target::upload_trace_state_variables (struct uploaded_tsv **arg0)
3391 {
3392   gdb_printf (gdb_stdlog, "-> %s->upload_trace_state_variables (...)\n", this->beneath ()->shortname ());
3393   int result
3394     = this->beneath ()->upload_trace_state_variables (arg0);
3395   gdb_printf (gdb_stdlog, "<- %s->upload_trace_state_variables (", this->beneath ()->shortname ());
3396   target_debug_print_uploaded_tsv_pp (arg0);
3397   gdb_puts (") = ", gdb_stdlog);
3398   target_debug_print_int (result);
3399   gdb_puts ("\n", gdb_stdlog);
3400   return result;
3401 }
3402
3403 LONGEST
3404 target_ops::get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2)
3405 {
3406   return this->beneath ()->get_raw_trace_data (arg0, arg1, arg2);
3407 }
3408
3409 LONGEST
3410 dummy_target::get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2)
3411 {
3412   tcomplain ();
3413 }
3414
3415 LONGEST
3416 debug_target::get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2)
3417 {
3418   gdb_printf (gdb_stdlog, "-> %s->get_raw_trace_data (...)\n", this->beneath ()->shortname ());
3419   LONGEST result
3420     = this->beneath ()->get_raw_trace_data (arg0, arg1, arg2);
3421   gdb_printf (gdb_stdlog, "<- %s->get_raw_trace_data (", this->beneath ()->shortname ());
3422   target_debug_print_gdb_byte_p (arg0);
3423   gdb_puts (", ", gdb_stdlog);
3424   target_debug_print_ULONGEST (arg1);
3425   gdb_puts (", ", gdb_stdlog);
3426   target_debug_print_LONGEST (arg2);
3427   gdb_puts (") = ", gdb_stdlog);
3428   target_debug_print_LONGEST (result);
3429   gdb_puts ("\n", gdb_stdlog);
3430   return result;
3431 }
3432
3433 int
3434 target_ops::get_min_fast_tracepoint_insn_len ()
3435 {
3436   return this->beneath ()->get_min_fast_tracepoint_insn_len ();
3437 }
3438
3439 int
3440 dummy_target::get_min_fast_tracepoint_insn_len ()
3441 {
3442   return -1;
3443 }
3444
3445 int
3446 debug_target::get_min_fast_tracepoint_insn_len ()
3447 {
3448   gdb_printf (gdb_stdlog, "-> %s->get_min_fast_tracepoint_insn_len (...)\n", this->beneath ()->shortname ());
3449   int result
3450     = this->beneath ()->get_min_fast_tracepoint_insn_len ();
3451   gdb_printf (gdb_stdlog, "<- %s->get_min_fast_tracepoint_insn_len (", this->beneath ()->shortname ());
3452   gdb_puts (") = ", gdb_stdlog);
3453   target_debug_print_int (result);
3454   gdb_puts ("\n", gdb_stdlog);
3455   return result;
3456 }
3457
3458 void
3459 target_ops::set_disconnected_tracing (int arg0)
3460 {
3461   this->beneath ()->set_disconnected_tracing (arg0);
3462 }
3463
3464 void
3465 dummy_target::set_disconnected_tracing (int arg0)
3466 {
3467 }
3468
3469 void
3470 debug_target::set_disconnected_tracing (int arg0)
3471 {
3472   gdb_printf (gdb_stdlog, "-> %s->set_disconnected_tracing (...)\n", this->beneath ()->shortname ());
3473   this->beneath ()->set_disconnected_tracing (arg0);
3474   gdb_printf (gdb_stdlog, "<- %s->set_disconnected_tracing (", this->beneath ()->shortname ());
3475   target_debug_print_int (arg0);
3476   gdb_puts (")\n", gdb_stdlog);
3477 }
3478
3479 void
3480 target_ops::set_circular_trace_buffer (int arg0)
3481 {
3482   this->beneath ()->set_circular_trace_buffer (arg0);
3483 }
3484
3485 void
3486 dummy_target::set_circular_trace_buffer (int arg0)
3487 {
3488 }
3489
3490 void
3491 debug_target::set_circular_trace_buffer (int arg0)
3492 {
3493   gdb_printf (gdb_stdlog, "-> %s->set_circular_trace_buffer (...)\n", this->beneath ()->shortname ());
3494   this->beneath ()->set_circular_trace_buffer (arg0);
3495   gdb_printf (gdb_stdlog, "<- %s->set_circular_trace_buffer (", this->beneath ()->shortname ());
3496   target_debug_print_int (arg0);
3497   gdb_puts (")\n", gdb_stdlog);
3498 }
3499
3500 void
3501 target_ops::set_trace_buffer_size (LONGEST arg0)
3502 {
3503   this->beneath ()->set_trace_buffer_size (arg0);
3504 }
3505
3506 void
3507 dummy_target::set_trace_buffer_size (LONGEST arg0)
3508 {
3509 }
3510
3511 void
3512 debug_target::set_trace_buffer_size (LONGEST arg0)
3513 {
3514   gdb_printf (gdb_stdlog, "-> %s->set_trace_buffer_size (...)\n", this->beneath ()->shortname ());
3515   this->beneath ()->set_trace_buffer_size (arg0);
3516   gdb_printf (gdb_stdlog, "<- %s->set_trace_buffer_size (", this->beneath ()->shortname ());
3517   target_debug_print_LONGEST (arg0);
3518   gdb_puts (")\n", gdb_stdlog);
3519 }
3520
3521 bool
3522 target_ops::set_trace_notes (const char *arg0, const char *arg1, const char *arg2)
3523 {
3524   return this->beneath ()->set_trace_notes (arg0, arg1, arg2);
3525 }
3526
3527 bool
3528 dummy_target::set_trace_notes (const char *arg0, const char *arg1, const char *arg2)
3529 {
3530   return false;
3531 }
3532
3533 bool
3534 debug_target::set_trace_notes (const char *arg0, const char *arg1, const char *arg2)
3535 {
3536   gdb_printf (gdb_stdlog, "-> %s->set_trace_notes (...)\n", this->beneath ()->shortname ());
3537   bool result
3538     = this->beneath ()->set_trace_notes (arg0, arg1, arg2);
3539   gdb_printf (gdb_stdlog, "<- %s->set_trace_notes (", this->beneath ()->shortname ());
3540   target_debug_print_const_char_p (arg0);
3541   gdb_puts (", ", gdb_stdlog);
3542   target_debug_print_const_char_p (arg1);
3543   gdb_puts (", ", gdb_stdlog);
3544   target_debug_print_const_char_p (arg2);
3545   gdb_puts (") = ", gdb_stdlog);
3546   target_debug_print_bool (result);
3547   gdb_puts ("\n", gdb_stdlog);
3548   return result;
3549 }
3550
3551 int
3552 target_ops::core_of_thread (ptid_t arg0)
3553 {
3554   return this->beneath ()->core_of_thread (arg0);
3555 }
3556
3557 int
3558 dummy_target::core_of_thread (ptid_t arg0)
3559 {
3560   return -1;
3561 }
3562
3563 int
3564 debug_target::core_of_thread (ptid_t arg0)
3565 {
3566   gdb_printf (gdb_stdlog, "-> %s->core_of_thread (...)\n", this->beneath ()->shortname ());
3567   int result
3568     = this->beneath ()->core_of_thread (arg0);
3569   gdb_printf (gdb_stdlog, "<- %s->core_of_thread (", this->beneath ()->shortname ());
3570   target_debug_print_ptid_t (arg0);
3571   gdb_puts (") = ", gdb_stdlog);
3572   target_debug_print_int (result);
3573   gdb_puts ("\n", gdb_stdlog);
3574   return result;
3575 }
3576
3577 int
3578 target_ops::verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2)
3579 {
3580   return this->beneath ()->verify_memory (arg0, arg1, arg2);
3581 }
3582
3583 int
3584 dummy_target::verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2)
3585 {
3586   return default_verify_memory (this, arg0, arg1, arg2);
3587 }
3588
3589 int
3590 debug_target::verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2)
3591 {
3592   gdb_printf (gdb_stdlog, "-> %s->verify_memory (...)\n", this->beneath ()->shortname ());
3593   int result
3594     = this->beneath ()->verify_memory (arg0, arg1, arg2);
3595   gdb_printf (gdb_stdlog, "<- %s->verify_memory (", this->beneath ()->shortname ());
3596   target_debug_print_const_gdb_byte_p (arg0);
3597   gdb_puts (", ", gdb_stdlog);
3598   target_debug_print_CORE_ADDR (arg1);
3599   gdb_puts (", ", gdb_stdlog);
3600   target_debug_print_ULONGEST (arg2);
3601   gdb_puts (") = ", gdb_stdlog);
3602   target_debug_print_int (result);
3603   gdb_puts ("\n", gdb_stdlog);
3604   return result;
3605 }
3606
3607 bool
3608 target_ops::get_tib_address (ptid_t arg0, CORE_ADDR *arg1)
3609 {
3610   return this->beneath ()->get_tib_address (arg0, arg1);
3611 }
3612
3613 bool
3614 dummy_target::get_tib_address (ptid_t arg0, CORE_ADDR *arg1)
3615 {
3616   tcomplain ();
3617 }
3618
3619 bool
3620 debug_target::get_tib_address (ptid_t arg0, CORE_ADDR *arg1)
3621 {
3622   gdb_printf (gdb_stdlog, "-> %s->get_tib_address (...)\n", this->beneath ()->shortname ());
3623   bool result
3624     = this->beneath ()->get_tib_address (arg0, arg1);
3625   gdb_printf (gdb_stdlog, "<- %s->get_tib_address (", this->beneath ()->shortname ());
3626   target_debug_print_ptid_t (arg0);
3627   gdb_puts (", ", gdb_stdlog);
3628   target_debug_print_CORE_ADDR_p (arg1);
3629   gdb_puts (") = ", gdb_stdlog);
3630   target_debug_print_bool (result);
3631   gdb_puts ("\n", gdb_stdlog);
3632   return result;
3633 }
3634
3635 void
3636 target_ops::set_permissions ()
3637 {
3638   this->beneath ()->set_permissions ();
3639 }
3640
3641 void
3642 dummy_target::set_permissions ()
3643 {
3644 }
3645
3646 void
3647 debug_target::set_permissions ()
3648 {
3649   gdb_printf (gdb_stdlog, "-> %s->set_permissions (...)\n", this->beneath ()->shortname ());
3650   this->beneath ()->set_permissions ();
3651   gdb_printf (gdb_stdlog, "<- %s->set_permissions (", this->beneath ()->shortname ());
3652   gdb_puts (")\n", gdb_stdlog);
3653 }
3654
3655 bool
3656 target_ops::static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1)
3657 {
3658   return this->beneath ()->static_tracepoint_marker_at (arg0, arg1);
3659 }
3660
3661 bool
3662 dummy_target::static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1)
3663 {
3664   return false;
3665 }
3666
3667 bool
3668 debug_target::static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1)
3669 {
3670   gdb_printf (gdb_stdlog, "-> %s->static_tracepoint_marker_at (...)\n", this->beneath ()->shortname ());
3671   bool result
3672     = this->beneath ()->static_tracepoint_marker_at (arg0, arg1);
3673   gdb_printf (gdb_stdlog, "<- %s->static_tracepoint_marker_at (", this->beneath ()->shortname ());
3674   target_debug_print_CORE_ADDR (arg0);
3675   gdb_puts (", ", gdb_stdlog);
3676   target_debug_print_static_tracepoint_marker_p (arg1);
3677   gdb_puts (") = ", gdb_stdlog);
3678   target_debug_print_bool (result);
3679   gdb_puts ("\n", gdb_stdlog);
3680   return result;
3681 }
3682
3683 std::vector<static_tracepoint_marker>
3684 target_ops::static_tracepoint_markers_by_strid (const char *arg0)
3685 {
3686   return this->beneath ()->static_tracepoint_markers_by_strid (arg0);
3687 }
3688
3689 std::vector<static_tracepoint_marker>
3690 dummy_target::static_tracepoint_markers_by_strid (const char *arg0)
3691 {
3692   tcomplain ();
3693 }
3694
3695 std::vector<static_tracepoint_marker>
3696 debug_target::static_tracepoint_markers_by_strid (const char *arg0)
3697 {
3698   gdb_printf (gdb_stdlog, "-> %s->static_tracepoint_markers_by_strid (...)\n", this->beneath ()->shortname ());
3699   std::vector<static_tracepoint_marker> result
3700     = this->beneath ()->static_tracepoint_markers_by_strid (arg0);
3701   gdb_printf (gdb_stdlog, "<- %s->static_tracepoint_markers_by_strid (", this->beneath ()->shortname ());
3702   target_debug_print_const_char_p (arg0);
3703   gdb_puts (") = ", gdb_stdlog);
3704   target_debug_print_std_vector_static_tracepoint_marker (result);
3705   gdb_puts ("\n", gdb_stdlog);
3706   return result;
3707 }
3708
3709 traceframe_info_up
3710 target_ops::traceframe_info ()
3711 {
3712   return this->beneath ()->traceframe_info ();
3713 }
3714
3715 traceframe_info_up
3716 dummy_target::traceframe_info ()
3717 {
3718   tcomplain ();
3719 }
3720
3721 traceframe_info_up
3722 debug_target::traceframe_info ()
3723 {
3724   gdb_printf (gdb_stdlog, "-> %s->traceframe_info (...)\n", this->beneath ()->shortname ());
3725   traceframe_info_up result
3726     = this->beneath ()->traceframe_info ();
3727   gdb_printf (gdb_stdlog, "<- %s->traceframe_info (", this->beneath ()->shortname ());
3728   gdb_puts (") = ", gdb_stdlog);
3729   target_debug_print_traceframe_info_up (result);
3730   gdb_puts ("\n", gdb_stdlog);
3731   return result;
3732 }
3733
3734 bool
3735 target_ops::use_agent (bool arg0)
3736 {
3737   return this->beneath ()->use_agent (arg0);
3738 }
3739
3740 bool
3741 dummy_target::use_agent (bool arg0)
3742 {
3743   tcomplain ();
3744 }
3745
3746 bool
3747 debug_target::use_agent (bool arg0)
3748 {
3749   gdb_printf (gdb_stdlog, "-> %s->use_agent (...)\n", this->beneath ()->shortname ());
3750   bool result
3751     = this->beneath ()->use_agent (arg0);
3752   gdb_printf (gdb_stdlog, "<- %s->use_agent (", this->beneath ()->shortname ());
3753   target_debug_print_bool (arg0);
3754   gdb_puts (") = ", gdb_stdlog);
3755   target_debug_print_bool (result);
3756   gdb_puts ("\n", gdb_stdlog);
3757   return result;
3758 }
3759
3760 bool
3761 target_ops::can_use_agent ()
3762 {
3763   return this->beneath ()->can_use_agent ();
3764 }
3765
3766 bool
3767 dummy_target::can_use_agent ()
3768 {
3769   return false;
3770 }
3771
3772 bool
3773 debug_target::can_use_agent ()
3774 {
3775   gdb_printf (gdb_stdlog, "-> %s->can_use_agent (...)\n", this->beneath ()->shortname ());
3776   bool result
3777     = this->beneath ()->can_use_agent ();
3778   gdb_printf (gdb_stdlog, "<- %s->can_use_agent (", this->beneath ()->shortname ());
3779   gdb_puts (") = ", gdb_stdlog);
3780   target_debug_print_bool (result);
3781   gdb_puts ("\n", gdb_stdlog);
3782   return result;
3783 }
3784
3785 struct btrace_target_info *
3786 target_ops::enable_btrace (thread_info *arg0, const struct btrace_config *arg1)
3787 {
3788   return this->beneath ()->enable_btrace (arg0, arg1);
3789 }
3790
3791 struct btrace_target_info *
3792 dummy_target::enable_btrace (thread_info *arg0, const struct btrace_config *arg1)
3793 {
3794   tcomplain ();
3795 }
3796
3797 struct btrace_target_info *
3798 debug_target::enable_btrace (thread_info *arg0, const struct btrace_config *arg1)
3799 {
3800   gdb_printf (gdb_stdlog, "-> %s->enable_btrace (...)\n", this->beneath ()->shortname ());
3801   struct btrace_target_info * result
3802     = this->beneath ()->enable_btrace (arg0, arg1);
3803   gdb_printf (gdb_stdlog, "<- %s->enable_btrace (", this->beneath ()->shortname ());
3804   target_debug_print_thread_info_p (arg0);
3805   gdb_puts (", ", gdb_stdlog);
3806   target_debug_print_const_btrace_config_p (arg1);
3807   gdb_puts (") = ", gdb_stdlog);
3808   target_debug_print_btrace_target_info_p (result);
3809   gdb_puts ("\n", gdb_stdlog);
3810   return result;
3811 }
3812
3813 void
3814 target_ops::disable_btrace (struct btrace_target_info *arg0)
3815 {
3816   this->beneath ()->disable_btrace (arg0);
3817 }
3818
3819 void
3820 dummy_target::disable_btrace (struct btrace_target_info *arg0)
3821 {
3822   tcomplain ();
3823 }
3824
3825 void
3826 debug_target::disable_btrace (struct btrace_target_info *arg0)
3827 {
3828   gdb_printf (gdb_stdlog, "-> %s->disable_btrace (...)\n", this->beneath ()->shortname ());
3829   this->beneath ()->disable_btrace (arg0);
3830   gdb_printf (gdb_stdlog, "<- %s->disable_btrace (", this->beneath ()->shortname ());
3831   target_debug_print_btrace_target_info_p (arg0);
3832   gdb_puts (")\n", gdb_stdlog);
3833 }
3834
3835 void
3836 target_ops::teardown_btrace (struct btrace_target_info *arg0)
3837 {
3838   this->beneath ()->teardown_btrace (arg0);
3839 }
3840
3841 void
3842 dummy_target::teardown_btrace (struct btrace_target_info *arg0)
3843 {
3844   tcomplain ();
3845 }
3846
3847 void
3848 debug_target::teardown_btrace (struct btrace_target_info *arg0)
3849 {
3850   gdb_printf (gdb_stdlog, "-> %s->teardown_btrace (...)\n", this->beneath ()->shortname ());
3851   this->beneath ()->teardown_btrace (arg0);
3852   gdb_printf (gdb_stdlog, "<- %s->teardown_btrace (", this->beneath ()->shortname ());
3853   target_debug_print_btrace_target_info_p (arg0);
3854   gdb_puts (")\n", gdb_stdlog);
3855 }
3856
3857 enum btrace_error
3858 target_ops::read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2)
3859 {
3860   return this->beneath ()->read_btrace (arg0, arg1, arg2);
3861 }
3862
3863 enum btrace_error
3864 dummy_target::read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2)
3865 {
3866   tcomplain ();
3867 }
3868
3869 enum btrace_error
3870 debug_target::read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2)
3871 {
3872   gdb_printf (gdb_stdlog, "-> %s->read_btrace (...)\n", this->beneath ()->shortname ());
3873   enum btrace_error result
3874     = this->beneath ()->read_btrace (arg0, arg1, arg2);
3875   gdb_printf (gdb_stdlog, "<- %s->read_btrace (", this->beneath ()->shortname ());
3876   target_debug_print_btrace_data_p (arg0);
3877   gdb_puts (", ", gdb_stdlog);
3878   target_debug_print_btrace_target_info_p (arg1);
3879   gdb_puts (", ", gdb_stdlog);
3880   target_debug_print_btrace_read_type (arg2);
3881   gdb_puts (") = ", gdb_stdlog);
3882   target_debug_print_btrace_error (result);
3883   gdb_puts ("\n", gdb_stdlog);
3884   return result;
3885 }
3886
3887 const struct btrace_config *
3888 target_ops::btrace_conf (const struct btrace_target_info *arg0)
3889 {
3890   return this->beneath ()->btrace_conf (arg0);
3891 }
3892
3893 const struct btrace_config *
3894 dummy_target::btrace_conf (const struct btrace_target_info *arg0)
3895 {
3896   return NULL;
3897 }
3898
3899 const struct btrace_config *
3900 debug_target::btrace_conf (const struct btrace_target_info *arg0)
3901 {
3902   gdb_printf (gdb_stdlog, "-> %s->btrace_conf (...)\n", this->beneath ()->shortname ());
3903   const struct btrace_config * result
3904     = this->beneath ()->btrace_conf (arg0);
3905   gdb_printf (gdb_stdlog, "<- %s->btrace_conf (", this->beneath ()->shortname ());
3906   target_debug_print_const_btrace_target_info_p (arg0);
3907   gdb_puts (") = ", gdb_stdlog);
3908   target_debug_print_const_btrace_config_p (result);
3909   gdb_puts ("\n", gdb_stdlog);
3910   return result;
3911 }
3912
3913 enum record_method
3914 target_ops::record_method (ptid_t arg0)
3915 {
3916   return this->beneath ()->record_method (arg0);
3917 }
3918
3919 enum record_method
3920 dummy_target::record_method (ptid_t arg0)
3921 {
3922   return RECORD_METHOD_NONE;
3923 }
3924
3925 enum record_method
3926 debug_target::record_method (ptid_t arg0)
3927 {
3928   gdb_printf (gdb_stdlog, "-> %s->record_method (...)\n", this->beneath ()->shortname ());
3929   enum record_method result
3930     = this->beneath ()->record_method (arg0);
3931   gdb_printf (gdb_stdlog, "<- %s->record_method (", this->beneath ()->shortname ());
3932   target_debug_print_ptid_t (arg0);
3933   gdb_puts (") = ", gdb_stdlog);
3934   target_debug_print_record_method (result);
3935   gdb_puts ("\n", gdb_stdlog);
3936   return result;
3937 }
3938
3939 void
3940 target_ops::stop_recording ()
3941 {
3942   this->beneath ()->stop_recording ();
3943 }
3944
3945 void
3946 dummy_target::stop_recording ()
3947 {
3948 }
3949
3950 void
3951 debug_target::stop_recording ()
3952 {
3953   gdb_printf (gdb_stdlog, "-> %s->stop_recording (...)\n", this->beneath ()->shortname ());
3954   this->beneath ()->stop_recording ();
3955   gdb_printf (gdb_stdlog, "<- %s->stop_recording (", this->beneath ()->shortname ());
3956   gdb_puts (")\n", gdb_stdlog);
3957 }
3958
3959 void
3960 target_ops::info_record ()
3961 {
3962   this->beneath ()->info_record ();
3963 }
3964
3965 void
3966 dummy_target::info_record ()
3967 {
3968 }
3969
3970 void
3971 debug_target::info_record ()
3972 {
3973   gdb_printf (gdb_stdlog, "-> %s->info_record (...)\n", this->beneath ()->shortname ());
3974   this->beneath ()->info_record ();
3975   gdb_printf (gdb_stdlog, "<- %s->info_record (", this->beneath ()->shortname ());
3976   gdb_puts (")\n", gdb_stdlog);
3977 }
3978
3979 void
3980 target_ops::save_record (const char *arg0)
3981 {
3982   this->beneath ()->save_record (arg0);
3983 }
3984
3985 void
3986 dummy_target::save_record (const char *arg0)
3987 {
3988   tcomplain ();
3989 }
3990
3991 void
3992 debug_target::save_record (const char *arg0)
3993 {
3994   gdb_printf (gdb_stdlog, "-> %s->save_record (...)\n", this->beneath ()->shortname ());
3995   this->beneath ()->save_record (arg0);
3996   gdb_printf (gdb_stdlog, "<- %s->save_record (", this->beneath ()->shortname ());
3997   target_debug_print_const_char_p (arg0);
3998   gdb_puts (")\n", gdb_stdlog);
3999 }
4000
4001 bool
4002 target_ops::supports_delete_record ()
4003 {
4004   return this->beneath ()->supports_delete_record ();
4005 }
4006
4007 bool
4008 dummy_target::supports_delete_record ()
4009 {
4010   return false;
4011 }
4012
4013 bool
4014 debug_target::supports_delete_record ()
4015 {
4016   gdb_printf (gdb_stdlog, "-> %s->supports_delete_record (...)\n", this->beneath ()->shortname ());
4017   bool result
4018     = this->beneath ()->supports_delete_record ();
4019   gdb_printf (gdb_stdlog, "<- %s->supports_delete_record (", this->beneath ()->shortname ());
4020   gdb_puts (") = ", gdb_stdlog);
4021   target_debug_print_bool (result);
4022   gdb_puts ("\n", gdb_stdlog);
4023   return result;
4024 }
4025
4026 void
4027 target_ops::delete_record ()
4028 {
4029   this->beneath ()->delete_record ();
4030 }
4031
4032 void
4033 dummy_target::delete_record ()
4034 {
4035   tcomplain ();
4036 }
4037
4038 void
4039 debug_target::delete_record ()
4040 {
4041   gdb_printf (gdb_stdlog, "-> %s->delete_record (...)\n", this->beneath ()->shortname ());
4042   this->beneath ()->delete_record ();
4043   gdb_printf (gdb_stdlog, "<- %s->delete_record (", this->beneath ()->shortname ());
4044   gdb_puts (")\n", gdb_stdlog);
4045 }
4046
4047 bool
4048 target_ops::record_is_replaying (ptid_t arg0)
4049 {
4050   return this->beneath ()->record_is_replaying (arg0);
4051 }
4052
4053 bool
4054 dummy_target::record_is_replaying (ptid_t arg0)
4055 {
4056   return false;
4057 }
4058
4059 bool
4060 debug_target::record_is_replaying (ptid_t arg0)
4061 {
4062   gdb_printf (gdb_stdlog, "-> %s->record_is_replaying (...)\n", this->beneath ()->shortname ());
4063   bool result
4064     = this->beneath ()->record_is_replaying (arg0);
4065   gdb_printf (gdb_stdlog, "<- %s->record_is_replaying (", this->beneath ()->shortname ());
4066   target_debug_print_ptid_t (arg0);
4067   gdb_puts (") = ", gdb_stdlog);
4068   target_debug_print_bool (result);
4069   gdb_puts ("\n", gdb_stdlog);
4070   return result;
4071 }
4072
4073 bool
4074 target_ops::record_will_replay (ptid_t arg0, int arg1)
4075 {
4076   return this->beneath ()->record_will_replay (arg0, arg1);
4077 }
4078
4079 bool
4080 dummy_target::record_will_replay (ptid_t arg0, int arg1)
4081 {
4082   return false;
4083 }
4084
4085 bool
4086 debug_target::record_will_replay (ptid_t arg0, int arg1)
4087 {
4088   gdb_printf (gdb_stdlog, "-> %s->record_will_replay (...)\n", this->beneath ()->shortname ());
4089   bool result
4090     = this->beneath ()->record_will_replay (arg0, arg1);
4091   gdb_printf (gdb_stdlog, "<- %s->record_will_replay (", this->beneath ()->shortname ());
4092   target_debug_print_ptid_t (arg0);
4093   gdb_puts (", ", gdb_stdlog);
4094   target_debug_print_int (arg1);
4095   gdb_puts (") = ", gdb_stdlog);
4096   target_debug_print_bool (result);
4097   gdb_puts ("\n", gdb_stdlog);
4098   return result;
4099 }
4100
4101 void
4102 target_ops::record_stop_replaying ()
4103 {
4104   this->beneath ()->record_stop_replaying ();
4105 }
4106
4107 void
4108 dummy_target::record_stop_replaying ()
4109 {
4110 }
4111
4112 void
4113 debug_target::record_stop_replaying ()
4114 {
4115   gdb_printf (gdb_stdlog, "-> %s->record_stop_replaying (...)\n", this->beneath ()->shortname ());
4116   this->beneath ()->record_stop_replaying ();
4117   gdb_printf (gdb_stdlog, "<- %s->record_stop_replaying (", this->beneath ()->shortname ());
4118   gdb_puts (")\n", gdb_stdlog);
4119 }
4120
4121 void
4122 target_ops::goto_record_begin ()
4123 {
4124   this->beneath ()->goto_record_begin ();
4125 }
4126
4127 void
4128 dummy_target::goto_record_begin ()
4129 {
4130   tcomplain ();
4131 }
4132
4133 void
4134 debug_target::goto_record_begin ()
4135 {
4136   gdb_printf (gdb_stdlog, "-> %s->goto_record_begin (...)\n", this->beneath ()->shortname ());
4137   this->beneath ()->goto_record_begin ();
4138   gdb_printf (gdb_stdlog, "<- %s->goto_record_begin (", this->beneath ()->shortname ());
4139   gdb_puts (")\n", gdb_stdlog);
4140 }
4141
4142 void
4143 target_ops::goto_record_end ()
4144 {
4145   this->beneath ()->goto_record_end ();
4146 }
4147
4148 void
4149 dummy_target::goto_record_end ()
4150 {
4151   tcomplain ();
4152 }
4153
4154 void
4155 debug_target::goto_record_end ()
4156 {
4157   gdb_printf (gdb_stdlog, "-> %s->goto_record_end (...)\n", this->beneath ()->shortname ());
4158   this->beneath ()->goto_record_end ();
4159   gdb_printf (gdb_stdlog, "<- %s->goto_record_end (", this->beneath ()->shortname ());
4160   gdb_puts (")\n", gdb_stdlog);
4161 }
4162
4163 void
4164 target_ops::goto_record (ULONGEST arg0)
4165 {
4166   this->beneath ()->goto_record (arg0);
4167 }
4168
4169 void
4170 dummy_target::goto_record (ULONGEST arg0)
4171 {
4172   tcomplain ();
4173 }
4174
4175 void
4176 debug_target::goto_record (ULONGEST arg0)
4177 {
4178   gdb_printf (gdb_stdlog, "-> %s->goto_record (...)\n", this->beneath ()->shortname ());
4179   this->beneath ()->goto_record (arg0);
4180   gdb_printf (gdb_stdlog, "<- %s->goto_record (", this->beneath ()->shortname ());
4181   target_debug_print_ULONGEST (arg0);
4182   gdb_puts (")\n", gdb_stdlog);
4183 }
4184
4185 void
4186 target_ops::insn_history (int arg0, gdb_disassembly_flags arg1)
4187 {
4188   this->beneath ()->insn_history (arg0, arg1);
4189 }
4190
4191 void
4192 dummy_target::insn_history (int arg0, gdb_disassembly_flags arg1)
4193 {
4194   tcomplain ();
4195 }
4196
4197 void
4198 debug_target::insn_history (int arg0, gdb_disassembly_flags arg1)
4199 {
4200   gdb_printf (gdb_stdlog, "-> %s->insn_history (...)\n", this->beneath ()->shortname ());
4201   this->beneath ()->insn_history (arg0, arg1);
4202   gdb_printf (gdb_stdlog, "<- %s->insn_history (", this->beneath ()->shortname ());
4203   target_debug_print_int (arg0);
4204   gdb_puts (", ", gdb_stdlog);
4205   target_debug_print_gdb_disassembly_flags (arg1);
4206   gdb_puts (")\n", gdb_stdlog);
4207 }
4208
4209 void
4210 target_ops::insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2)
4211 {
4212   this->beneath ()->insn_history_from (arg0, arg1, arg2);
4213 }
4214
4215 void
4216 dummy_target::insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2)
4217 {
4218   tcomplain ();
4219 }
4220
4221 void
4222 debug_target::insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2)
4223 {
4224   gdb_printf (gdb_stdlog, "-> %s->insn_history_from (...)\n", this->beneath ()->shortname ());
4225   this->beneath ()->insn_history_from (arg0, arg1, arg2);
4226   gdb_printf (gdb_stdlog, "<- %s->insn_history_from (", this->beneath ()->shortname ());
4227   target_debug_print_ULONGEST (arg0);
4228   gdb_puts (", ", gdb_stdlog);
4229   target_debug_print_int (arg1);
4230   gdb_puts (", ", gdb_stdlog);
4231   target_debug_print_gdb_disassembly_flags (arg2);
4232   gdb_puts (")\n", gdb_stdlog);
4233 }
4234
4235 void
4236 target_ops::insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2)
4237 {
4238   this->beneath ()->insn_history_range (arg0, arg1, arg2);
4239 }
4240
4241 void
4242 dummy_target::insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2)
4243 {
4244   tcomplain ();
4245 }
4246
4247 void
4248 debug_target::insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2)
4249 {
4250   gdb_printf (gdb_stdlog, "-> %s->insn_history_range (...)\n", this->beneath ()->shortname ());
4251   this->beneath ()->insn_history_range (arg0, arg1, arg2);
4252   gdb_printf (gdb_stdlog, "<- %s->insn_history_range (", this->beneath ()->shortname ());
4253   target_debug_print_ULONGEST (arg0);
4254   gdb_puts (", ", gdb_stdlog);
4255   target_debug_print_ULONGEST (arg1);
4256   gdb_puts (", ", gdb_stdlog);
4257   target_debug_print_gdb_disassembly_flags (arg2);
4258   gdb_puts (")\n", gdb_stdlog);
4259 }
4260
4261 void
4262 target_ops::call_history (int arg0, record_print_flags arg1)
4263 {
4264   this->beneath ()->call_history (arg0, arg1);
4265 }
4266
4267 void
4268 dummy_target::call_history (int arg0, record_print_flags arg1)
4269 {
4270   tcomplain ();
4271 }
4272
4273 void
4274 debug_target::call_history (int arg0, record_print_flags arg1)
4275 {
4276   gdb_printf (gdb_stdlog, "-> %s->call_history (...)\n", this->beneath ()->shortname ());
4277   this->beneath ()->call_history (arg0, arg1);
4278   gdb_printf (gdb_stdlog, "<- %s->call_history (", this->beneath ()->shortname ());
4279   target_debug_print_int (arg0);
4280   gdb_puts (", ", gdb_stdlog);
4281   target_debug_print_record_print_flags (arg1);
4282   gdb_puts (")\n", gdb_stdlog);
4283 }
4284
4285 void
4286 target_ops::call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2)
4287 {
4288   this->beneath ()->call_history_from (arg0, arg1, arg2);
4289 }
4290
4291 void
4292 dummy_target::call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2)
4293 {
4294   tcomplain ();
4295 }
4296
4297 void
4298 debug_target::call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2)
4299 {
4300   gdb_printf (gdb_stdlog, "-> %s->call_history_from (...)\n", this->beneath ()->shortname ());
4301   this->beneath ()->call_history_from (arg0, arg1, arg2);
4302   gdb_printf (gdb_stdlog, "<- %s->call_history_from (", this->beneath ()->shortname ());
4303   target_debug_print_ULONGEST (arg0);
4304   gdb_puts (", ", gdb_stdlog);
4305   target_debug_print_int (arg1);
4306   gdb_puts (", ", gdb_stdlog);
4307   target_debug_print_record_print_flags (arg2);
4308   gdb_puts (")\n", gdb_stdlog);
4309 }
4310
4311 void
4312 target_ops::call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2)
4313 {
4314   this->beneath ()->call_history_range (arg0, arg1, arg2);
4315 }
4316
4317 void
4318 dummy_target::call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2)
4319 {
4320   tcomplain ();
4321 }
4322
4323 void
4324 debug_target::call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2)
4325 {
4326   gdb_printf (gdb_stdlog, "-> %s->call_history_range (...)\n", this->beneath ()->shortname ());
4327   this->beneath ()->call_history_range (arg0, arg1, arg2);
4328   gdb_printf (gdb_stdlog, "<- %s->call_history_range (", this->beneath ()->shortname ());
4329   target_debug_print_ULONGEST (arg0);
4330   gdb_puts (", ", gdb_stdlog);
4331   target_debug_print_ULONGEST (arg1);
4332   gdb_puts (", ", gdb_stdlog);
4333   target_debug_print_record_print_flags (arg2);
4334   gdb_puts (")\n", gdb_stdlog);
4335 }
4336
4337 bool
4338 target_ops::augmented_libraries_svr4_read ()
4339 {
4340   return this->beneath ()->augmented_libraries_svr4_read ();
4341 }
4342
4343 bool
4344 dummy_target::augmented_libraries_svr4_read ()
4345 {
4346   return false;
4347 }
4348
4349 bool
4350 debug_target::augmented_libraries_svr4_read ()
4351 {
4352   gdb_printf (gdb_stdlog, "-> %s->augmented_libraries_svr4_read (...)\n", this->beneath ()->shortname ());
4353   bool result
4354     = this->beneath ()->augmented_libraries_svr4_read ();
4355   gdb_printf (gdb_stdlog, "<- %s->augmented_libraries_svr4_read (", this->beneath ()->shortname ());
4356   gdb_puts (") = ", gdb_stdlog);
4357   target_debug_print_bool (result);
4358   gdb_puts ("\n", gdb_stdlog);
4359   return result;
4360 }
4361
4362 const struct frame_unwind *
4363 target_ops::get_unwinder ()
4364 {
4365   return this->beneath ()->get_unwinder ();
4366 }
4367
4368 const struct frame_unwind *
4369 dummy_target::get_unwinder ()
4370 {
4371   return NULL;
4372 }
4373
4374 const struct frame_unwind *
4375 debug_target::get_unwinder ()
4376 {
4377   gdb_printf (gdb_stdlog, "-> %s->get_unwinder (...)\n", this->beneath ()->shortname ());
4378   const struct frame_unwind * result
4379     = this->beneath ()->get_unwinder ();
4380   gdb_printf (gdb_stdlog, "<- %s->get_unwinder (", this->beneath ()->shortname ());
4381   gdb_puts (") = ", gdb_stdlog);
4382   target_debug_print_const_frame_unwind_p (result);
4383   gdb_puts ("\n", gdb_stdlog);
4384   return result;
4385 }
4386
4387 const struct frame_unwind *
4388 target_ops::get_tailcall_unwinder ()
4389 {
4390   return this->beneath ()->get_tailcall_unwinder ();
4391 }
4392
4393 const struct frame_unwind *
4394 dummy_target::get_tailcall_unwinder ()
4395 {
4396   return NULL;
4397 }
4398
4399 const struct frame_unwind *
4400 debug_target::get_tailcall_unwinder ()
4401 {
4402   gdb_printf (gdb_stdlog, "-> %s->get_tailcall_unwinder (...)\n", this->beneath ()->shortname ());
4403   const struct frame_unwind * result
4404     = this->beneath ()->get_tailcall_unwinder ();
4405   gdb_printf (gdb_stdlog, "<- %s->get_tailcall_unwinder (", this->beneath ()->shortname ());
4406   gdb_puts (") = ", gdb_stdlog);
4407   target_debug_print_const_frame_unwind_p (result);
4408   gdb_puts ("\n", gdb_stdlog);
4409   return result;
4410 }
4411
4412 void
4413 target_ops::prepare_to_generate_core ()
4414 {
4415   this->beneath ()->prepare_to_generate_core ();
4416 }
4417
4418 void
4419 dummy_target::prepare_to_generate_core ()
4420 {
4421 }
4422
4423 void
4424 debug_target::prepare_to_generate_core ()
4425 {
4426   gdb_printf (gdb_stdlog, "-> %s->prepare_to_generate_core (...)\n", this->beneath ()->shortname ());
4427   this->beneath ()->prepare_to_generate_core ();
4428   gdb_printf (gdb_stdlog, "<- %s->prepare_to_generate_core (", this->beneath ()->shortname ());
4429   gdb_puts (")\n", gdb_stdlog);
4430 }
4431
4432 void
4433 target_ops::done_generating_core ()
4434 {
4435   this->beneath ()->done_generating_core ();
4436 }
4437
4438 void
4439 dummy_target::done_generating_core ()
4440 {
4441 }
4442
4443 void
4444 debug_target::done_generating_core ()
4445 {
4446   gdb_printf (gdb_stdlog, "-> %s->done_generating_core (...)\n", this->beneath ()->shortname ());
4447   this->beneath ()->done_generating_core ();
4448   gdb_printf (gdb_stdlog, "<- %s->done_generating_core (", this->beneath ()->shortname ());
4449   gdb_puts (")\n", gdb_stdlog);
4450 }
4451
4452 bool
4453 target_ops::supports_memory_tagging ()
4454 {
4455   return this->beneath ()->supports_memory_tagging ();
4456 }
4457
4458 bool
4459 dummy_target::supports_memory_tagging ()
4460 {
4461   return false;
4462 }
4463
4464 bool
4465 debug_target::supports_memory_tagging ()
4466 {
4467   gdb_printf (gdb_stdlog, "-> %s->supports_memory_tagging (...)\n", this->beneath ()->shortname ());
4468   bool result
4469     = this->beneath ()->supports_memory_tagging ();
4470   gdb_printf (gdb_stdlog, "<- %s->supports_memory_tagging (", this->beneath ()->shortname ());
4471   gdb_puts (") = ", gdb_stdlog);
4472   target_debug_print_bool (result);
4473   gdb_puts ("\n", gdb_stdlog);
4474   return result;
4475 }
4476
4477 bool
4478 target_ops::fetch_memtags (CORE_ADDR arg0, size_t arg1, gdb::byte_vector &arg2, int arg3)
4479 {
4480   return this->beneath ()->fetch_memtags (arg0, arg1, arg2, arg3);
4481 }
4482
4483 bool
4484 dummy_target::fetch_memtags (CORE_ADDR arg0, size_t arg1, gdb::byte_vector &arg2, int arg3)
4485 {
4486   tcomplain ();
4487 }
4488
4489 bool
4490 debug_target::fetch_memtags (CORE_ADDR arg0, size_t arg1, gdb::byte_vector &arg2, int arg3)
4491 {
4492   gdb_printf (gdb_stdlog, "-> %s->fetch_memtags (...)\n", this->beneath ()->shortname ());
4493   bool result
4494     = this->beneath ()->fetch_memtags (arg0, arg1, arg2, arg3);
4495   gdb_printf (gdb_stdlog, "<- %s->fetch_memtags (", this->beneath ()->shortname ());
4496   target_debug_print_CORE_ADDR (arg0);
4497   gdb_puts (", ", gdb_stdlog);
4498   target_debug_print_size_t (arg1);
4499   gdb_puts (", ", gdb_stdlog);
4500   target_debug_print_gdb_byte_vector_r (arg2);
4501   gdb_puts (", ", gdb_stdlog);
4502   target_debug_print_int (arg3);
4503   gdb_puts (") = ", gdb_stdlog);
4504   target_debug_print_bool (result);
4505   gdb_puts ("\n", gdb_stdlog);
4506   return result;
4507 }
4508
4509 bool
4510 target_ops::store_memtags (CORE_ADDR arg0, size_t arg1, const gdb::byte_vector &arg2, int arg3)
4511 {
4512   return this->beneath ()->store_memtags (arg0, arg1, arg2, arg3);
4513 }
4514
4515 bool
4516 dummy_target::store_memtags (CORE_ADDR arg0, size_t arg1, const gdb::byte_vector &arg2, int arg3)
4517 {
4518   tcomplain ();
4519 }
4520
4521 bool
4522 debug_target::store_memtags (CORE_ADDR arg0, size_t arg1, const gdb::byte_vector &arg2, int arg3)
4523 {
4524   gdb_printf (gdb_stdlog, "-> %s->store_memtags (...)\n", this->beneath ()->shortname ());
4525   bool result
4526     = this->beneath ()->store_memtags (arg0, arg1, arg2, arg3);
4527   gdb_printf (gdb_stdlog, "<- %s->store_memtags (", this->beneath ()->shortname ());
4528   target_debug_print_CORE_ADDR (arg0);
4529   gdb_puts (", ", gdb_stdlog);
4530   target_debug_print_size_t (arg1);
4531   gdb_puts (", ", gdb_stdlog);
4532   target_debug_print_const_gdb_byte_vector_r (arg2);
4533   gdb_puts (", ", gdb_stdlog);
4534   target_debug_print_int (arg3);
4535   gdb_puts (") = ", gdb_stdlog);
4536   target_debug_print_bool (result);
4537   gdb_puts ("\n", gdb_stdlog);
4538   return result;
4539 }
4540
4541 x86_xsave_layout
4542 target_ops::fetch_x86_xsave_layout ()
4543 {
4544   return this->beneath ()->fetch_x86_xsave_layout ();
4545 }
4546
4547 x86_xsave_layout
4548 dummy_target::fetch_x86_xsave_layout ()
4549 {
4550   return x86_xsave_layout ();
4551 }
4552
4553 x86_xsave_layout
4554 debug_target::fetch_x86_xsave_layout ()
4555 {
4556   gdb_printf (gdb_stdlog, "-> %s->fetch_x86_xsave_layout (...)\n", this->beneath ()->shortname ());
4557   x86_xsave_layout result
4558     = this->beneath ()->fetch_x86_xsave_layout ();
4559   gdb_printf (gdb_stdlog, "<- %s->fetch_x86_xsave_layout (", this->beneath ()->shortname ());
4560   gdb_puts (") = ", gdb_stdlog);
4561   target_debug_print_x86_xsave_layout (result);
4562   gdb_puts ("\n", gdb_stdlog);
4563   return result;
4564 }