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