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