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