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