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