gdb/target-delegates.c

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