gdb/target-delegates.c

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