gdb/target-delegates.c

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