gdb/target-delegates.c

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