gdb/target-delegates.c

   1 /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
   2 /* vi:set ro: */
   3
   4 /* To regenerate this file, run:*/
   5 /*      make-target-delegates target.h > target-delegates.c */
   6
   7 struct dummy_target : public target_ops
   8 {
   9   const target_info &info () const override;
  10
  11   strata stratum () const override;
  12
  13   void post_attach (int arg0) override;
  14   void detach (inferior *arg0, int arg1) override;
  15   void disconnect (const char *arg0, int arg1) override;
  16   void resume (ptid_t arg0, int arg1, enum gdb_signal arg2) override;
  17   void commit_resumed () override;
  18   ptid_t wait (ptid_t arg0, struct target_waitstatus *arg1, target_wait_flags arg2) override;
  19   void fetch_registers (struct regcache *arg0, int arg1) override;
  20   void store_registers (struct regcache *arg0, int arg1) override;
  21   void prepare_to_store (struct regcache *arg0) override;
  22   void files_info () override;
  23   int insert_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
  24   int remove_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1, enum remove_bp_reason arg2) override;
  25   bool stopped_by_sw_breakpoint () override;
  26   bool supports_stopped_by_sw_breakpoint () override;
  27   bool stopped_by_hw_breakpoint () override;
  28   bool supports_stopped_by_hw_breakpoint () override;
  29   int can_use_hw_breakpoint (enum bptype arg0, int arg1, int arg2) override;
  30   int ranged_break_num_registers () override;
  31   int insert_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
  32   int remove_hw_breakpoint (struct gdbarch *arg0, struct bp_target_info *arg1) override;
  33   int remove_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
  34   int insert_watchpoint (CORE_ADDR arg0, int arg1, enum target_hw_bp_type arg2, struct expression *arg3) override;
  35   int insert_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
  36   int remove_mask_watchpoint (CORE_ADDR arg0, CORE_ADDR arg1, enum target_hw_bp_type arg2) override;
  37   bool stopped_by_watchpoint () override;
  38   bool have_steppable_watchpoint () override;
  39   bool stopped_data_address (CORE_ADDR *arg0) override;
  40   bool watchpoint_addr_within_range (CORE_ADDR arg0, CORE_ADDR arg1, int arg2) override;
  41   int region_ok_for_hw_watchpoint (CORE_ADDR arg0, int arg1) override;
  42   bool can_accel_watchpoint_condition (CORE_ADDR arg0, int arg1, int arg2, struct expression *arg3) override;
  43   int masked_watch_num_registers (CORE_ADDR arg0, CORE_ADDR arg1) override;
  44   int can_do_single_step () override;
  45   bool supports_terminal_ours () override;
  46   void terminal_init () override;
  47   void terminal_inferior () override;
  48   void terminal_save_inferior () override;
  49   void terminal_ours_for_output () override;
  50   void terminal_ours () override;
  51   void terminal_info (const char *arg0, int arg1) override;
  52   void kill () override;
  53   void load (const char *arg0, int arg1) override;
  54   void post_startup_inferior (ptid_t arg0) override;
  55   int insert_fork_catchpoint (int arg0) override;
  56   int remove_fork_catchpoint (int arg0) override;
  57   int insert_vfork_catchpoint (int arg0) override;
  58   int remove_vfork_catchpoint (int arg0) override;
  59   void follow_fork (bool arg0, bool arg1) override;
  60   int insert_exec_catchpoint (int arg0) override;
  61   int remove_exec_catchpoint (int arg0) override;
  62   void follow_exec (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   void follow_fork (bool arg0, bool arg1) override;
 235   int insert_exec_catchpoint (int arg0) override;
 236   int remove_exec_catchpoint (int arg0) override;
 237   void follow_exec (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 void
1522 target_ops::follow_fork (bool arg0, bool arg1)
1523 {
1524   this->beneath ()->follow_fork (arg0, arg1);
1525 }
1526
1527 void
1528 dummy_target::follow_fork (bool arg0, bool arg1)
1529 {
1530   default_follow_fork (this, arg0, arg1);
1531 }
1532
1533 void
1534 debug_target::follow_fork (bool arg0, bool arg1)
1535 {
1536   fprintf_unfiltered (gdb_stdlog, "-> %s->follow_fork (...)\n", this->beneath ()->shortname ());
1537   this->beneath ()->follow_fork (arg0, arg1);
1538   fprintf_unfiltered (gdb_stdlog, "<- %s->follow_fork (", this->beneath ()->shortname ());
1539   target_debug_print_bool (arg0);
1540   fputs_unfiltered (", ", gdb_stdlog);
1541   target_debug_print_bool (arg1);
1542   fputs_unfiltered (")\n", gdb_stdlog);
1543 }
1544
1545 int
1546 target_ops::insert_exec_catchpoint (int arg0)
1547 {
1548   return this->beneath ()->insert_exec_catchpoint (arg0);
1549 }
1550
1551 int
1552 dummy_target::insert_exec_catchpoint (int arg0)
1553 {
1554   return 1;
1555 }
1556
1557 int
1558 debug_target::insert_exec_catchpoint (int arg0)
1559 {
1560   int result;
1561   fprintf_unfiltered (gdb_stdlog, "-> %s->insert_exec_catchpoint (...)\n", this->beneath ()->shortname ());
1562   result = this->beneath ()->insert_exec_catchpoint (arg0);
1563   fprintf_unfiltered (gdb_stdlog, "<- %s->insert_exec_catchpoint (", this->beneath ()->shortname ());
1564   target_debug_print_int (arg0);
1565   fputs_unfiltered (") = ", gdb_stdlog);
1566   target_debug_print_int (result);
1567   fputs_unfiltered ("\n", gdb_stdlog);
1568   return result;
1569 }
1570
1571 int
1572 target_ops::remove_exec_catchpoint (int arg0)
1573 {
1574   return this->beneath ()->remove_exec_catchpoint (arg0);
1575 }
1576
1577 int
1578 dummy_target::remove_exec_catchpoint (int arg0)
1579 {
1580   return 1;
1581 }
1582
1583 int
1584 debug_target::remove_exec_catchpoint (int arg0)
1585 {
1586   int result;
1587   fprintf_unfiltered (gdb_stdlog, "-> %s->remove_exec_catchpoint (...)\n", this->beneath ()->shortname ());
1588   result = this->beneath ()->remove_exec_catchpoint (arg0);
1589   fprintf_unfiltered (gdb_stdlog, "<- %s->remove_exec_catchpoint (", this->beneath ()->shortname ());
1590   target_debug_print_int (arg0);
1591   fputs_unfiltered (") = ", gdb_stdlog);
1592   target_debug_print_int (result);
1593   fputs_unfiltered ("\n", gdb_stdlog);
1594   return result;
1595 }
1596
1597 void
1598 target_ops::follow_exec (struct inferior *arg0, const char *arg1)
1599 {
1600   this->beneath ()->follow_exec (arg0, arg1);
1601 }
1602
1603 void
1604 dummy_target::follow_exec (struct inferior *arg0, const char *arg1)
1605 {
1606 }
1607
1608 void
1609 debug_target::follow_exec (struct inferior *arg0, const char *arg1)
1610 {
1611   fprintf_unfiltered (gdb_stdlog, "-> %s->follow_exec (...)\n", this->beneath ()->shortname ());
1612   this->beneath ()->follow_exec (arg0, arg1);
1613   fprintf_unfiltered (gdb_stdlog, "<- %s->follow_exec (", this->beneath ()->shortname ());
1614   target_debug_print_struct_inferior_p (arg0);
1615   fputs_unfiltered (", ", gdb_stdlog);
1616   target_debug_print_const_char_p (arg1);
1617   fputs_unfiltered (")\n", gdb_stdlog);
1618 }
1619
1620 int
1621 target_ops::set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3)
1622 {
1623   return this->beneath ()->set_syscall_catchpoint (arg0, arg1, arg2, arg3);
1624 }
1625
1626 int
1627 dummy_target::set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3)
1628 {
1629   return 1;
1630 }
1631
1632 int
1633 debug_target::set_syscall_catchpoint (int arg0, bool arg1, int arg2, gdb::array_view<const int> arg3)
1634 {
1635   int result;
1636   fprintf_unfiltered (gdb_stdlog, "-> %s->set_syscall_catchpoint (...)\n", this->beneath ()->shortname ());
1637   result = this->beneath ()->set_syscall_catchpoint (arg0, arg1, arg2, arg3);
1638   fprintf_unfiltered (gdb_stdlog, "<- %s->set_syscall_catchpoint (", this->beneath ()->shortname ());
1639   target_debug_print_int (arg0);
1640   fputs_unfiltered (", ", gdb_stdlog);
1641   target_debug_print_bool (arg1);
1642   fputs_unfiltered (", ", gdb_stdlog);
1643   target_debug_print_int (arg2);
1644   fputs_unfiltered (", ", gdb_stdlog);
1645   target_debug_print_gdb_array_view_const_int (arg3);
1646   fputs_unfiltered (") = ", gdb_stdlog);
1647   target_debug_print_int (result);
1648   fputs_unfiltered ("\n", gdb_stdlog);
1649   return result;
1650 }
1651
1652 void
1653 target_ops::mourn_inferior ()
1654 {
1655   this->beneath ()->mourn_inferior ();
1656 }
1657
1658 void
1659 dummy_target::mourn_inferior ()
1660 {
1661   default_mourn_inferior (this);
1662 }
1663
1664 void
1665 debug_target::mourn_inferior ()
1666 {
1667   fprintf_unfiltered (gdb_stdlog, "-> %s->mourn_inferior (...)\n", this->beneath ()->shortname ());
1668   this->beneath ()->mourn_inferior ();
1669   fprintf_unfiltered (gdb_stdlog, "<- %s->mourn_inferior (", this->beneath ()->shortname ());
1670   fputs_unfiltered (")\n", gdb_stdlog);
1671 }
1672
1673 void
1674 target_ops::pass_signals (gdb::array_view<const unsigned char> arg0)
1675 {
1676   this->beneath ()->pass_signals (arg0);
1677 }
1678
1679 void
1680 dummy_target::pass_signals (gdb::array_view<const unsigned char> arg0)
1681 {
1682 }
1683
1684 void
1685 debug_target::pass_signals (gdb::array_view<const unsigned char> arg0)
1686 {
1687   fprintf_unfiltered (gdb_stdlog, "-> %s->pass_signals (...)\n", this->beneath ()->shortname ());
1688   this->beneath ()->pass_signals (arg0);
1689   fprintf_unfiltered (gdb_stdlog, "<- %s->pass_signals (", this->beneath ()->shortname ());
1690   target_debug_print_signals (arg0);
1691   fputs_unfiltered (")\n", gdb_stdlog);
1692 }
1693
1694 void
1695 target_ops::program_signals (gdb::array_view<const unsigned char> arg0)
1696 {
1697   this->beneath ()->program_signals (arg0);
1698 }
1699
1700 void
1701 dummy_target::program_signals (gdb::array_view<const unsigned char> arg0)
1702 {
1703 }
1704
1705 void
1706 debug_target::program_signals (gdb::array_view<const unsigned char> arg0)
1707 {
1708   fprintf_unfiltered (gdb_stdlog, "-> %s->program_signals (...)\n", this->beneath ()->shortname ());
1709   this->beneath ()->program_signals (arg0);
1710   fprintf_unfiltered (gdb_stdlog, "<- %s->program_signals (", this->beneath ()->shortname ());
1711   target_debug_print_signals (arg0);
1712   fputs_unfiltered (")\n", gdb_stdlog);
1713 }
1714
1715 bool
1716 target_ops::thread_alive (ptid_t arg0)
1717 {
1718   return this->beneath ()->thread_alive (arg0);
1719 }
1720
1721 bool
1722 dummy_target::thread_alive (ptid_t arg0)
1723 {
1724   return false;
1725 }
1726
1727 bool
1728 debug_target::thread_alive (ptid_t arg0)
1729 {
1730   bool result;
1731   fprintf_unfiltered (gdb_stdlog, "-> %s->thread_alive (...)\n", this->beneath ()->shortname ());
1732   result = this->beneath ()->thread_alive (arg0);
1733   fprintf_unfiltered (gdb_stdlog, "<- %s->thread_alive (", this->beneath ()->shortname ());
1734   target_debug_print_ptid_t (arg0);
1735   fputs_unfiltered (") = ", gdb_stdlog);
1736   target_debug_print_bool (result);
1737   fputs_unfiltered ("\n", gdb_stdlog);
1738   return result;
1739 }
1740
1741 void
1742 target_ops::update_thread_list ()
1743 {
1744   this->beneath ()->update_thread_list ();
1745 }
1746
1747 void
1748 dummy_target::update_thread_list ()
1749 {
1750 }
1751
1752 void
1753 debug_target::update_thread_list ()
1754 {
1755   fprintf_unfiltered (gdb_stdlog, "-> %s->update_thread_list (...)\n", this->beneath ()->shortname ());
1756   this->beneath ()->update_thread_list ();
1757   fprintf_unfiltered (gdb_stdlog, "<- %s->update_thread_list (", this->beneath ()->shortname ());
1758   fputs_unfiltered (")\n", gdb_stdlog);
1759 }
1760
1761 std::string
1762 target_ops::pid_to_str (ptid_t arg0)
1763 {
1764   return this->beneath ()->pid_to_str (arg0);
1765 }
1766
1767 std::string
1768 dummy_target::pid_to_str (ptid_t arg0)
1769 {
1770   return default_pid_to_str (this, arg0);
1771 }
1772
1773 std::string
1774 debug_target::pid_to_str (ptid_t arg0)
1775 {
1776   std::string result;
1777   fprintf_unfiltered (gdb_stdlog, "-> %s->pid_to_str (...)\n", this->beneath ()->shortname ());
1778   result = this->beneath ()->pid_to_str (arg0);
1779   fprintf_unfiltered (gdb_stdlog, "<- %s->pid_to_str (", this->beneath ()->shortname ());
1780   target_debug_print_ptid_t (arg0);
1781   fputs_unfiltered (") = ", gdb_stdlog);
1782   target_debug_print_std_string (result);
1783   fputs_unfiltered ("\n", gdb_stdlog);
1784   return result;
1785 }
1786
1787 const char *
1788 target_ops::extra_thread_info (thread_info *arg0)
1789 {
1790   return this->beneath ()->extra_thread_info (arg0);
1791 }
1792
1793 const char *
1794 dummy_target::extra_thread_info (thread_info *arg0)
1795 {
1796   return NULL;
1797 }
1798
1799 const char *
1800 debug_target::extra_thread_info (thread_info *arg0)
1801 {
1802   const char * result;
1803   fprintf_unfiltered (gdb_stdlog, "-> %s->extra_thread_info (...)\n", this->beneath ()->shortname ());
1804   result = this->beneath ()->extra_thread_info (arg0);
1805   fprintf_unfiltered (gdb_stdlog, "<- %s->extra_thread_info (", this->beneath ()->shortname ());
1806   target_debug_print_thread_info_p (arg0);
1807   fputs_unfiltered (") = ", gdb_stdlog);
1808   target_debug_print_const_char_p (result);
1809   fputs_unfiltered ("\n", gdb_stdlog);
1810   return result;
1811 }
1812
1813 const char *
1814 target_ops::thread_name (thread_info *arg0)
1815 {
1816   return this->beneath ()->thread_name (arg0);
1817 }
1818
1819 const char *
1820 dummy_target::thread_name (thread_info *arg0)
1821 {
1822   return NULL;
1823 }
1824
1825 const char *
1826 debug_target::thread_name (thread_info *arg0)
1827 {
1828   const char * result;
1829   fprintf_unfiltered (gdb_stdlog, "-> %s->thread_name (...)\n", this->beneath ()->shortname ());
1830   result = this->beneath ()->thread_name (arg0);
1831   fprintf_unfiltered (gdb_stdlog, "<- %s->thread_name (", this->beneath ()->shortname ());
1832   target_debug_print_thread_info_p (arg0);
1833   fputs_unfiltered (") = ", gdb_stdlog);
1834   target_debug_print_const_char_p (result);
1835   fputs_unfiltered ("\n", gdb_stdlog);
1836   return result;
1837 }
1838
1839 thread_info *
1840 target_ops::thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2)
1841 {
1842   return this->beneath ()->thread_handle_to_thread_info (arg0, arg1, arg2);
1843 }
1844
1845 thread_info *
1846 dummy_target::thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2)
1847 {
1848   return NULL;
1849 }
1850
1851 thread_info *
1852 debug_target::thread_handle_to_thread_info (const gdb_byte *arg0, int arg1, inferior *arg2)
1853 {
1854   thread_info * result;
1855   fprintf_unfiltered (gdb_stdlog, "-> %s->thread_handle_to_thread_info (...)\n", this->beneath ()->shortname ());
1856   result = this->beneath ()->thread_handle_to_thread_info (arg0, arg1, arg2);
1857   fprintf_unfiltered (gdb_stdlog, "<- %s->thread_handle_to_thread_info (", this->beneath ()->shortname ());
1858   target_debug_print_const_gdb_byte_p (arg0);
1859   fputs_unfiltered (", ", gdb_stdlog);
1860   target_debug_print_int (arg1);
1861   fputs_unfiltered (", ", gdb_stdlog);
1862   target_debug_print_inferior_p (arg2);
1863   fputs_unfiltered (") = ", gdb_stdlog);
1864   target_debug_print_thread_info_p (result);
1865   fputs_unfiltered ("\n", gdb_stdlog);
1866   return result;
1867 }
1868
1869 gdb::byte_vector
1870 target_ops::thread_info_to_thread_handle (struct thread_info *arg0)
1871 {
1872   return this->beneath ()->thread_info_to_thread_handle (arg0);
1873 }
1874
1875 gdb::byte_vector
1876 dummy_target::thread_info_to_thread_handle (struct thread_info *arg0)
1877 {
1878   return gdb::byte_vector ();
1879 }
1880
1881 gdb::byte_vector
1882 debug_target::thread_info_to_thread_handle (struct thread_info *arg0)
1883 {
1884   gdb::byte_vector result;
1885   fprintf_unfiltered (gdb_stdlog, "-> %s->thread_info_to_thread_handle (...)\n", this->beneath ()->shortname ());
1886   result = this->beneath ()->thread_info_to_thread_handle (arg0);
1887   fprintf_unfiltered (gdb_stdlog, "<- %s->thread_info_to_thread_handle (", this->beneath ()->shortname ());
1888   target_debug_print_struct_thread_info_p (arg0);
1889   fputs_unfiltered (") = ", gdb_stdlog);
1890   target_debug_print_gdb_byte_vector (result);
1891   fputs_unfiltered ("\n", gdb_stdlog);
1892   return result;
1893 }
1894
1895 void
1896 target_ops::stop (ptid_t arg0)
1897 {
1898   this->beneath ()->stop (arg0);
1899 }
1900
1901 void
1902 dummy_target::stop (ptid_t arg0)
1903 {
1904 }
1905
1906 void
1907 debug_target::stop (ptid_t arg0)
1908 {
1909   fprintf_unfiltered (gdb_stdlog, "-> %s->stop (...)\n", this->beneath ()->shortname ());
1910   this->beneath ()->stop (arg0);
1911   fprintf_unfiltered (gdb_stdlog, "<- %s->stop (", this->beneath ()->shortname ());
1912   target_debug_print_ptid_t (arg0);
1913   fputs_unfiltered (")\n", gdb_stdlog);
1914 }
1915
1916 void
1917 target_ops::interrupt ()
1918 {
1919   this->beneath ()->interrupt ();
1920 }
1921
1922 void
1923 dummy_target::interrupt ()
1924 {
1925 }
1926
1927 void
1928 debug_target::interrupt ()
1929 {
1930   fprintf_unfiltered (gdb_stdlog, "-> %s->interrupt (...)\n", this->beneath ()->shortname ());
1931   this->beneath ()->interrupt ();
1932   fprintf_unfiltered (gdb_stdlog, "<- %s->interrupt (", this->beneath ()->shortname ());
1933   fputs_unfiltered (")\n", gdb_stdlog);
1934 }
1935
1936 void
1937 target_ops::pass_ctrlc ()
1938 {
1939   this->beneath ()->pass_ctrlc ();
1940 }
1941
1942 void
1943 dummy_target::pass_ctrlc ()
1944 {
1945   default_target_pass_ctrlc (this);
1946 }
1947
1948 void
1949 debug_target::pass_ctrlc ()
1950 {
1951   fprintf_unfiltered (gdb_stdlog, "-> %s->pass_ctrlc (...)\n", this->beneath ()->shortname ());
1952   this->beneath ()->pass_ctrlc ();
1953   fprintf_unfiltered (gdb_stdlog, "<- %s->pass_ctrlc (", this->beneath ()->shortname ());
1954   fputs_unfiltered (")\n", gdb_stdlog);
1955 }
1956
1957 void
1958 target_ops::rcmd (const char *arg0, struct ui_file *arg1)
1959 {
1960   this->beneath ()->rcmd (arg0, arg1);
1961 }
1962
1963 void
1964 dummy_target::rcmd (const char *arg0, struct ui_file *arg1)
1965 {
1966   default_rcmd (this, arg0, arg1);
1967 }
1968
1969 void
1970 debug_target::rcmd (const char *arg0, struct ui_file *arg1)
1971 {
1972   fprintf_unfiltered (gdb_stdlog, "-> %s->rcmd (...)\n", this->beneath ()->shortname ());
1973   this->beneath ()->rcmd (arg0, arg1);
1974   fprintf_unfiltered (gdb_stdlog, "<- %s->rcmd (", this->beneath ()->shortname ());
1975   target_debug_print_const_char_p (arg0);
1976   fputs_unfiltered (", ", gdb_stdlog);
1977   target_debug_print_struct_ui_file_p (arg1);
1978   fputs_unfiltered (")\n", gdb_stdlog);
1979 }
1980
1981 char *
1982 target_ops::pid_to_exec_file (int arg0)
1983 {
1984   return this->beneath ()->pid_to_exec_file (arg0);
1985 }
1986
1987 char *
1988 dummy_target::pid_to_exec_file (int arg0)
1989 {
1990   return NULL;
1991 }
1992
1993 char *
1994 debug_target::pid_to_exec_file (int arg0)
1995 {
1996   char * result;
1997   fprintf_unfiltered (gdb_stdlog, "-> %s->pid_to_exec_file (...)\n", this->beneath ()->shortname ());
1998   result = this->beneath ()->pid_to_exec_file (arg0);
1999   fprintf_unfiltered (gdb_stdlog, "<- %s->pid_to_exec_file (", this->beneath ()->shortname ());
2000   target_debug_print_int (arg0);
2001   fputs_unfiltered (") = ", gdb_stdlog);
2002   target_debug_print_char_p (result);
2003   fputs_unfiltered ("\n", gdb_stdlog);
2004   return result;
2005 }
2006
2007 void
2008 target_ops::log_command (const char *arg0)
2009 {
2010   this->beneath ()->log_command (arg0);
2011 }
2012
2013 void
2014 dummy_target::log_command (const char *arg0)
2015 {
2016 }
2017
2018 void
2019 debug_target::log_command (const char *arg0)
2020 {
2021   fprintf_unfiltered (gdb_stdlog, "-> %s->log_command (...)\n", this->beneath ()->shortname ());
2022   this->beneath ()->log_command (arg0);
2023   fprintf_unfiltered (gdb_stdlog, "<- %s->log_command (", this->beneath ()->shortname ());
2024   target_debug_print_const_char_p (arg0);
2025   fputs_unfiltered (")\n", gdb_stdlog);
2026 }
2027
2028 const target_section_table *
2029 target_ops::get_section_table ()
2030 {
2031   return this->beneath ()->get_section_table ();
2032 }
2033
2034 const target_section_table *
2035 dummy_target::get_section_table ()
2036 {
2037   return default_get_section_table ();
2038 }
2039
2040 const target_section_table *
2041 debug_target::get_section_table ()
2042 {
2043   const target_section_table * result;
2044   fprintf_unfiltered (gdb_stdlog, "-> %s->get_section_table (...)\n", this->beneath ()->shortname ());
2045   result = this->beneath ()->get_section_table ();
2046   fprintf_unfiltered (gdb_stdlog, "<- %s->get_section_table (", this->beneath ()->shortname ());
2047   fputs_unfiltered (") = ", gdb_stdlog);
2048   target_debug_print_const_target_section_table_p (result);
2049   fputs_unfiltered ("\n", gdb_stdlog);
2050   return result;
2051 }
2052
2053 thread_control_capabilities
2054 target_ops::get_thread_control_capabilities ()
2055 {
2056   return this->beneath ()->get_thread_control_capabilities ();
2057 }
2058
2059 thread_control_capabilities
2060 dummy_target::get_thread_control_capabilities ()
2061 {
2062   return tc_none;
2063 }
2064
2065 thread_control_capabilities
2066 debug_target::get_thread_control_capabilities ()
2067 {
2068   thread_control_capabilities result;
2069   fprintf_unfiltered (gdb_stdlog, "-> %s->get_thread_control_capabilities (...)\n", this->beneath ()->shortname ());
2070   result = this->beneath ()->get_thread_control_capabilities ();
2071   fprintf_unfiltered (gdb_stdlog, "<- %s->get_thread_control_capabilities (", this->beneath ()->shortname ());
2072   fputs_unfiltered (") = ", gdb_stdlog);
2073   target_debug_print_thread_control_capabilities (result);
2074   fputs_unfiltered ("\n", gdb_stdlog);
2075   return result;
2076 }
2077
2078 bool
2079 target_ops::attach_no_wait ()
2080 {
2081   return this->beneath ()->attach_no_wait ();
2082 }
2083
2084 bool
2085 dummy_target::attach_no_wait ()
2086 {
2087   return 0;
2088 }
2089
2090 bool
2091 debug_target::attach_no_wait ()
2092 {
2093   bool result;
2094   fprintf_unfiltered (gdb_stdlog, "-> %s->attach_no_wait (...)\n", this->beneath ()->shortname ());
2095   result = this->beneath ()->attach_no_wait ();
2096   fprintf_unfiltered (gdb_stdlog, "<- %s->attach_no_wait (", this->beneath ()->shortname ());
2097   fputs_unfiltered (") = ", gdb_stdlog);
2098   target_debug_print_bool (result);
2099   fputs_unfiltered ("\n", gdb_stdlog);
2100   return result;
2101 }
2102
2103 bool
2104 target_ops::can_async_p ()
2105 {
2106   return this->beneath ()->can_async_p ();
2107 }
2108
2109 bool
2110 dummy_target::can_async_p ()
2111 {
2112   return false;
2113 }
2114
2115 bool
2116 debug_target::can_async_p ()
2117 {
2118   bool result;
2119   fprintf_unfiltered (gdb_stdlog, "-> %s->can_async_p (...)\n", this->beneath ()->shortname ());
2120   result = this->beneath ()->can_async_p ();
2121   fprintf_unfiltered (gdb_stdlog, "<- %s->can_async_p (", this->beneath ()->shortname ());
2122   fputs_unfiltered (") = ", gdb_stdlog);
2123   target_debug_print_bool (result);
2124   fputs_unfiltered ("\n", gdb_stdlog);
2125   return result;
2126 }
2127
2128 bool
2129 target_ops::is_async_p ()
2130 {
2131   return this->beneath ()->is_async_p ();
2132 }
2133
2134 bool
2135 dummy_target::is_async_p ()
2136 {
2137   return false;
2138 }
2139
2140 bool
2141 debug_target::is_async_p ()
2142 {
2143   bool result;
2144   fprintf_unfiltered (gdb_stdlog, "-> %s->is_async_p (...)\n", this->beneath ()->shortname ());
2145   result = this->beneath ()->is_async_p ();
2146   fprintf_unfiltered (gdb_stdlog, "<- %s->is_async_p (", this->beneath ()->shortname ());
2147   fputs_unfiltered (") = ", gdb_stdlog);
2148   target_debug_print_bool (result);
2149   fputs_unfiltered ("\n", gdb_stdlog);
2150   return result;
2151 }
2152
2153 void
2154 target_ops::async (int arg0)
2155 {
2156   this->beneath ()->async (arg0);
2157 }
2158
2159 void
2160 dummy_target::async (int arg0)
2161 {
2162   tcomplain ();
2163 }
2164
2165 void
2166 debug_target::async (int arg0)
2167 {
2168   fprintf_unfiltered (gdb_stdlog, "-> %s->async (...)\n", this->beneath ()->shortname ());
2169   this->beneath ()->async (arg0);
2170   fprintf_unfiltered (gdb_stdlog, "<- %s->async (", this->beneath ()->shortname ());
2171   target_debug_print_int (arg0);
2172   fputs_unfiltered (")\n", gdb_stdlog);
2173 }
2174
2175 int
2176 target_ops::async_wait_fd ()
2177 {
2178   return this->beneath ()->async_wait_fd ();
2179 }
2180
2181 int
2182 dummy_target::async_wait_fd ()
2183 {
2184   noprocess ();
2185 }
2186
2187 int
2188 debug_target::async_wait_fd ()
2189 {
2190   int result;
2191   fprintf_unfiltered (gdb_stdlog, "-> %s->async_wait_fd (...)\n", this->beneath ()->shortname ());
2192   result = this->beneath ()->async_wait_fd ();
2193   fprintf_unfiltered (gdb_stdlog, "<- %s->async_wait_fd (", this->beneath ()->shortname ());
2194   fputs_unfiltered (") = ", gdb_stdlog);
2195   target_debug_print_int (result);
2196   fputs_unfiltered ("\n", gdb_stdlog);
2197   return result;
2198 }
2199
2200 bool
2201 target_ops::has_pending_events ()
2202 {
2203   return this->beneath ()->has_pending_events ();
2204 }
2205
2206 bool
2207 dummy_target::has_pending_events ()
2208 {
2209   return false;
2210 }
2211
2212 bool
2213 debug_target::has_pending_events ()
2214 {
2215   bool result;
2216   fprintf_unfiltered (gdb_stdlog, "-> %s->has_pending_events (...)\n", this->beneath ()->shortname ());
2217   result = this->beneath ()->has_pending_events ();
2218   fprintf_unfiltered (gdb_stdlog, "<- %s->has_pending_events (", this->beneath ()->shortname ());
2219   fputs_unfiltered (") = ", gdb_stdlog);
2220   target_debug_print_bool (result);
2221   fputs_unfiltered ("\n", gdb_stdlog);
2222   return result;
2223 }
2224
2225 void
2226 target_ops::thread_events (int arg0)
2227 {
2228   this->beneath ()->thread_events (arg0);
2229 }
2230
2231 void
2232 dummy_target::thread_events (int arg0)
2233 {
2234 }
2235
2236 void
2237 debug_target::thread_events (int arg0)
2238 {
2239   fprintf_unfiltered (gdb_stdlog, "-> %s->thread_events (...)\n", this->beneath ()->shortname ());
2240   this->beneath ()->thread_events (arg0);
2241   fprintf_unfiltered (gdb_stdlog, "<- %s->thread_events (", this->beneath ()->shortname ());
2242   target_debug_print_int (arg0);
2243   fputs_unfiltered (")\n", gdb_stdlog);
2244 }
2245
2246 bool
2247 target_ops::supports_non_stop ()
2248 {
2249   return this->beneath ()->supports_non_stop ();
2250 }
2251
2252 bool
2253 dummy_target::supports_non_stop ()
2254 {
2255   return false;
2256 }
2257
2258 bool
2259 debug_target::supports_non_stop ()
2260 {
2261   bool result;
2262   fprintf_unfiltered (gdb_stdlog, "-> %s->supports_non_stop (...)\n", this->beneath ()->shortname ());
2263   result = this->beneath ()->supports_non_stop ();
2264   fprintf_unfiltered (gdb_stdlog, "<- %s->supports_non_stop (", this->beneath ()->shortname ());
2265   fputs_unfiltered (") = ", gdb_stdlog);
2266   target_debug_print_bool (result);
2267   fputs_unfiltered ("\n", gdb_stdlog);
2268   return result;
2269 }
2270
2271 bool
2272 target_ops::always_non_stop_p ()
2273 {
2274   return this->beneath ()->always_non_stop_p ();
2275 }
2276
2277 bool
2278 dummy_target::always_non_stop_p ()
2279 {
2280   return false;
2281 }
2282
2283 bool
2284 debug_target::always_non_stop_p ()
2285 {
2286   bool result;
2287   fprintf_unfiltered (gdb_stdlog, "-> %s->always_non_stop_p (...)\n", this->beneath ()->shortname ());
2288   result = this->beneath ()->always_non_stop_p ();
2289   fprintf_unfiltered (gdb_stdlog, "<- %s->always_non_stop_p (", this->beneath ()->shortname ());
2290   fputs_unfiltered (") = ", gdb_stdlog);
2291   target_debug_print_bool (result);
2292   fputs_unfiltered ("\n", gdb_stdlog);
2293   return result;
2294 }
2295
2296 int
2297 target_ops::find_memory_regions (find_memory_region_ftype arg0, void *arg1)
2298 {
2299   return this->beneath ()->find_memory_regions (arg0, arg1);
2300 }
2301
2302 int
2303 dummy_target::find_memory_regions (find_memory_region_ftype arg0, void *arg1)
2304 {
2305   return dummy_find_memory_regions (this, arg0, arg1);
2306 }
2307
2308 int
2309 debug_target::find_memory_regions (find_memory_region_ftype arg0, void *arg1)
2310 {
2311   int result;
2312   fprintf_unfiltered (gdb_stdlog, "-> %s->find_memory_regions (...)\n", this->beneath ()->shortname ());
2313   result = this->beneath ()->find_memory_regions (arg0, arg1);
2314   fprintf_unfiltered (gdb_stdlog, "<- %s->find_memory_regions (", this->beneath ()->shortname ());
2315   target_debug_print_find_memory_region_ftype (arg0);
2316   fputs_unfiltered (", ", gdb_stdlog);
2317   target_debug_print_void_p (arg1);
2318   fputs_unfiltered (") = ", gdb_stdlog);
2319   target_debug_print_int (result);
2320   fputs_unfiltered ("\n", gdb_stdlog);
2321   return result;
2322 }
2323
2324 gdb::unique_xmalloc_ptr<char>
2325 target_ops::make_corefile_notes (bfd *arg0, int *arg1)
2326 {
2327   return this->beneath ()->make_corefile_notes (arg0, arg1);
2328 }
2329
2330 gdb::unique_xmalloc_ptr<char>
2331 dummy_target::make_corefile_notes (bfd *arg0, int *arg1)
2332 {
2333   return dummy_make_corefile_notes (this, arg0, arg1);
2334 }
2335
2336 gdb::unique_xmalloc_ptr<char>
2337 debug_target::make_corefile_notes (bfd *arg0, int *arg1)
2338 {
2339   gdb::unique_xmalloc_ptr<char> result;
2340   fprintf_unfiltered (gdb_stdlog, "-> %s->make_corefile_notes (...)\n", this->beneath ()->shortname ());
2341   result = this->beneath ()->make_corefile_notes (arg0, arg1);
2342   fprintf_unfiltered (gdb_stdlog, "<- %s->make_corefile_notes (", this->beneath ()->shortname ());
2343   target_debug_print_bfd_p (arg0);
2344   fputs_unfiltered (", ", gdb_stdlog);
2345   target_debug_print_int_p (arg1);
2346   fputs_unfiltered (") = ", gdb_stdlog);
2347   target_debug_print_gdb_unique_xmalloc_ptr_char (result);
2348   fputs_unfiltered ("\n", gdb_stdlog);
2349   return result;
2350 }
2351
2352 gdb_byte *
2353 target_ops::get_bookmark (const char *arg0, int arg1)
2354 {
2355   return this->beneath ()->get_bookmark (arg0, arg1);
2356 }
2357
2358 gdb_byte *
2359 dummy_target::get_bookmark (const char *arg0, int arg1)
2360 {
2361   tcomplain ();
2362 }
2363
2364 gdb_byte *
2365 debug_target::get_bookmark (const char *arg0, int arg1)
2366 {
2367   gdb_byte * result;
2368   fprintf_unfiltered (gdb_stdlog, "-> %s->get_bookmark (...)\n", this->beneath ()->shortname ());
2369   result = this->beneath ()->get_bookmark (arg0, arg1);
2370   fprintf_unfiltered (gdb_stdlog, "<- %s->get_bookmark (", this->beneath ()->shortname ());
2371   target_debug_print_const_char_p (arg0);
2372   fputs_unfiltered (", ", gdb_stdlog);
2373   target_debug_print_int (arg1);
2374   fputs_unfiltered (") = ", gdb_stdlog);
2375   target_debug_print_gdb_byte_p (result);
2376   fputs_unfiltered ("\n", gdb_stdlog);
2377   return result;
2378 }
2379
2380 void
2381 target_ops::goto_bookmark (const gdb_byte *arg0, int arg1)
2382 {
2383   this->beneath ()->goto_bookmark (arg0, arg1);
2384 }
2385
2386 void
2387 dummy_target::goto_bookmark (const gdb_byte *arg0, int arg1)
2388 {
2389   tcomplain ();
2390 }
2391
2392 void
2393 debug_target::goto_bookmark (const gdb_byte *arg0, int arg1)
2394 {
2395   fprintf_unfiltered (gdb_stdlog, "-> %s->goto_bookmark (...)\n", this->beneath ()->shortname ());
2396   this->beneath ()->goto_bookmark (arg0, arg1);
2397   fprintf_unfiltered (gdb_stdlog, "<- %s->goto_bookmark (", this->beneath ()->shortname ());
2398   target_debug_print_const_gdb_byte_p (arg0);
2399   fputs_unfiltered (", ", gdb_stdlog);
2400   target_debug_print_int (arg1);
2401   fputs_unfiltered (")\n", gdb_stdlog);
2402 }
2403
2404 CORE_ADDR
2405 target_ops::get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2)
2406 {
2407   return this->beneath ()->get_thread_local_address (arg0, arg1, arg2);
2408 }
2409
2410 CORE_ADDR
2411 dummy_target::get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2)
2412 {
2413   generic_tls_error ();
2414 }
2415
2416 CORE_ADDR
2417 debug_target::get_thread_local_address (ptid_t arg0, CORE_ADDR arg1, CORE_ADDR arg2)
2418 {
2419   CORE_ADDR result;
2420   fprintf_unfiltered (gdb_stdlog, "-> %s->get_thread_local_address (...)\n", this->beneath ()->shortname ());
2421   result = this->beneath ()->get_thread_local_address (arg0, arg1, arg2);
2422   fprintf_unfiltered (gdb_stdlog, "<- %s->get_thread_local_address (", this->beneath ()->shortname ());
2423   target_debug_print_ptid_t (arg0);
2424   fputs_unfiltered (", ", gdb_stdlog);
2425   target_debug_print_CORE_ADDR (arg1);
2426   fputs_unfiltered (", ", gdb_stdlog);
2427   target_debug_print_CORE_ADDR (arg2);
2428   fputs_unfiltered (") = ", gdb_stdlog);
2429   target_debug_print_CORE_ADDR (result);
2430   fputs_unfiltered ("\n", gdb_stdlog);
2431   return result;
2432 }
2433
2434 enum target_xfer_status
2435 target_ops::xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6)
2436 {
2437   return this->beneath ()->xfer_partial (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2438 }
2439
2440 enum target_xfer_status
2441 dummy_target::xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6)
2442 {
2443   return TARGET_XFER_E_IO;
2444 }
2445
2446 enum target_xfer_status
2447 debug_target::xfer_partial (enum target_object arg0, const char *arg1, gdb_byte *arg2, const gdb_byte *arg3, ULONGEST arg4, ULONGEST arg5, ULONGEST *arg6)
2448 {
2449   enum target_xfer_status result;
2450   fprintf_unfiltered (gdb_stdlog, "-> %s->xfer_partial (...)\n", this->beneath ()->shortname ());
2451   result = this->beneath ()->xfer_partial (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
2452   fprintf_unfiltered (gdb_stdlog, "<- %s->xfer_partial (", this->beneath ()->shortname ());
2453   target_debug_print_enum_target_object (arg0);
2454   fputs_unfiltered (", ", gdb_stdlog);
2455   target_debug_print_const_char_p (arg1);
2456   fputs_unfiltered (", ", gdb_stdlog);
2457   target_debug_print_gdb_byte_p (arg2);
2458   fputs_unfiltered (", ", gdb_stdlog);
2459   target_debug_print_const_gdb_byte_p (arg3);
2460   fputs_unfiltered (", ", gdb_stdlog);
2461   target_debug_print_ULONGEST (arg4);
2462   fputs_unfiltered (", ", gdb_stdlog);
2463   target_debug_print_ULONGEST (arg5);
2464   fputs_unfiltered (", ", gdb_stdlog);
2465   target_debug_print_ULONGEST_p (arg6);
2466   fputs_unfiltered (") = ", gdb_stdlog);
2467   target_debug_print_enum_target_xfer_status (result);
2468   fputs_unfiltered ("\n", gdb_stdlog);
2469   return result;
2470 }
2471
2472 ULONGEST
2473 target_ops::get_memory_xfer_limit ()
2474 {
2475   return this->beneath ()->get_memory_xfer_limit ();
2476 }
2477
2478 ULONGEST
2479 dummy_target::get_memory_xfer_limit ()
2480 {
2481   return ULONGEST_MAX;
2482 }
2483
2484 ULONGEST
2485 debug_target::get_memory_xfer_limit ()
2486 {
2487   ULONGEST result;
2488   fprintf_unfiltered (gdb_stdlog, "-> %s->get_memory_xfer_limit (...)\n", this->beneath ()->shortname ());
2489   result = this->beneath ()->get_memory_xfer_limit ();
2490   fprintf_unfiltered (gdb_stdlog, "<- %s->get_memory_xfer_limit (", this->beneath ()->shortname ());
2491   fputs_unfiltered (") = ", gdb_stdlog);
2492   target_debug_print_ULONGEST (result);
2493   fputs_unfiltered ("\n", gdb_stdlog);
2494   return result;
2495 }
2496
2497 std::vector<mem_region>
2498 target_ops::memory_map ()
2499 {
2500   return this->beneath ()->memory_map ();
2501 }
2502
2503 std::vector<mem_region>
2504 dummy_target::memory_map ()
2505 {
2506   return std::vector<mem_region> ();
2507 }
2508
2509 std::vector<mem_region>
2510 debug_target::memory_map ()
2511 {
2512   std::vector<mem_region> result;
2513   fprintf_unfiltered (gdb_stdlog, "-> %s->memory_map (...)\n", this->beneath ()->shortname ());
2514   result = this->beneath ()->memory_map ();
2515   fprintf_unfiltered (gdb_stdlog, "<- %s->memory_map (", this->beneath ()->shortname ());
2516   fputs_unfiltered (") = ", gdb_stdlog);
2517   target_debug_print_std_vector_mem_region (result);
2518   fputs_unfiltered ("\n", gdb_stdlog);
2519   return result;
2520 }
2521
2522 void
2523 target_ops::flash_erase (ULONGEST arg0, LONGEST arg1)
2524 {
2525   this->beneath ()->flash_erase (arg0, arg1);
2526 }
2527
2528 void
2529 dummy_target::flash_erase (ULONGEST arg0, LONGEST arg1)
2530 {
2531   tcomplain ();
2532 }
2533
2534 void
2535 debug_target::flash_erase (ULONGEST arg0, LONGEST arg1)
2536 {
2537   fprintf_unfiltered (gdb_stdlog, "-> %s->flash_erase (...)\n", this->beneath ()->shortname ());
2538   this->beneath ()->flash_erase (arg0, arg1);
2539   fprintf_unfiltered (gdb_stdlog, "<- %s->flash_erase (", this->beneath ()->shortname ());
2540   target_debug_print_ULONGEST (arg0);
2541   fputs_unfiltered (", ", gdb_stdlog);
2542   target_debug_print_LONGEST (arg1);
2543   fputs_unfiltered (")\n", gdb_stdlog);
2544 }
2545
2546 void
2547 target_ops::flash_done ()
2548 {
2549   this->beneath ()->flash_done ();
2550 }
2551
2552 void
2553 dummy_target::flash_done ()
2554 {
2555   tcomplain ();
2556 }
2557
2558 void
2559 debug_target::flash_done ()
2560 {
2561   fprintf_unfiltered (gdb_stdlog, "-> %s->flash_done (...)\n", this->beneath ()->shortname ());
2562   this->beneath ()->flash_done ();
2563   fprintf_unfiltered (gdb_stdlog, "<- %s->flash_done (", this->beneath ()->shortname ());
2564   fputs_unfiltered (")\n", gdb_stdlog);
2565 }
2566
2567 const struct target_desc *
2568 target_ops::read_description ()
2569 {
2570   return this->beneath ()->read_description ();
2571 }
2572
2573 const struct target_desc *
2574 dummy_target::read_description ()
2575 {
2576   return NULL;
2577 }
2578
2579 const struct target_desc *
2580 debug_target::read_description ()
2581 {
2582   const struct target_desc * result;
2583   fprintf_unfiltered (gdb_stdlog, "-> %s->read_description (...)\n", this->beneath ()->shortname ());
2584   result = this->beneath ()->read_description ();
2585   fprintf_unfiltered (gdb_stdlog, "<- %s->read_description (", this->beneath ()->shortname ());
2586   fputs_unfiltered (") = ", gdb_stdlog);
2587   target_debug_print_const_struct_target_desc_p (result);
2588   fputs_unfiltered ("\n", gdb_stdlog);
2589   return result;
2590 }
2591
2592 ptid_t
2593 target_ops::get_ada_task_ptid (long arg0, long arg1)
2594 {
2595   return this->beneath ()->get_ada_task_ptid (arg0, arg1);
2596 }
2597
2598 ptid_t
2599 dummy_target::get_ada_task_ptid (long arg0, long arg1)
2600 {
2601   return default_get_ada_task_ptid (this, arg0, arg1);
2602 }
2603
2604 ptid_t
2605 debug_target::get_ada_task_ptid (long arg0, long arg1)
2606 {
2607   ptid_t result;
2608   fprintf_unfiltered (gdb_stdlog, "-> %s->get_ada_task_ptid (...)\n", this->beneath ()->shortname ());
2609   result = this->beneath ()->get_ada_task_ptid (arg0, arg1);
2610   fprintf_unfiltered (gdb_stdlog, "<- %s->get_ada_task_ptid (", this->beneath ()->shortname ());
2611   target_debug_print_long (arg0);
2612   fputs_unfiltered (", ", gdb_stdlog);
2613   target_debug_print_long (arg1);
2614   fputs_unfiltered (") = ", gdb_stdlog);
2615   target_debug_print_ptid_t (result);
2616   fputs_unfiltered ("\n", gdb_stdlog);
2617   return result;
2618 }
2619
2620 int
2621 target_ops::auxv_parse (gdb_byte **arg0, gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3)
2622 {
2623   return this->beneath ()->auxv_parse (arg0, arg1, arg2, arg3);
2624 }
2625
2626 int
2627 dummy_target::auxv_parse (gdb_byte **arg0, gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3)
2628 {
2629   return default_auxv_parse (this, arg0, arg1, arg2, arg3);
2630 }
2631
2632 int
2633 debug_target::auxv_parse (gdb_byte **arg0, gdb_byte *arg1, CORE_ADDR *arg2, CORE_ADDR *arg3)
2634 {
2635   int result;
2636   fprintf_unfiltered (gdb_stdlog, "-> %s->auxv_parse (...)\n", this->beneath ()->shortname ());
2637   result = this->beneath ()->auxv_parse (arg0, arg1, arg2, arg3);
2638   fprintf_unfiltered (gdb_stdlog, "<- %s->auxv_parse (", this->beneath ()->shortname ());
2639   target_debug_print_gdb_byte_pp (arg0);
2640   fputs_unfiltered (", ", gdb_stdlog);
2641   target_debug_print_gdb_byte_p (arg1);
2642   fputs_unfiltered (", ", gdb_stdlog);
2643   target_debug_print_CORE_ADDR_p (arg2);
2644   fputs_unfiltered (", ", gdb_stdlog);
2645   target_debug_print_CORE_ADDR_p (arg3);
2646   fputs_unfiltered (") = ", gdb_stdlog);
2647   target_debug_print_int (result);
2648   fputs_unfiltered ("\n", gdb_stdlog);
2649   return result;
2650 }
2651
2652 int
2653 target_ops::search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4)
2654 {
2655   return this->beneath ()->search_memory (arg0, arg1, arg2, arg3, arg4);
2656 }
2657
2658 int
2659 dummy_target::search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4)
2660 {
2661   return default_search_memory (this, arg0, arg1, arg2, arg3, arg4);
2662 }
2663
2664 int
2665 debug_target::search_memory (CORE_ADDR arg0, ULONGEST arg1, const gdb_byte *arg2, ULONGEST arg3, CORE_ADDR *arg4)
2666 {
2667   int result;
2668   fprintf_unfiltered (gdb_stdlog, "-> %s->search_memory (...)\n", this->beneath ()->shortname ());
2669   result = this->beneath ()->search_memory (arg0, arg1, arg2, arg3, arg4);
2670   fprintf_unfiltered (gdb_stdlog, "<- %s->search_memory (", this->beneath ()->shortname ());
2671   target_debug_print_CORE_ADDR (arg0);
2672   fputs_unfiltered (", ", gdb_stdlog);
2673   target_debug_print_ULONGEST (arg1);
2674   fputs_unfiltered (", ", gdb_stdlog);
2675   target_debug_print_const_gdb_byte_p (arg2);
2676   fputs_unfiltered (", ", gdb_stdlog);
2677   target_debug_print_ULONGEST (arg3);
2678   fputs_unfiltered (", ", gdb_stdlog);
2679   target_debug_print_CORE_ADDR_p (arg4);
2680   fputs_unfiltered (") = ", gdb_stdlog);
2681   target_debug_print_int (result);
2682   fputs_unfiltered ("\n", gdb_stdlog);
2683   return result;
2684 }
2685
2686 bool
2687 target_ops::can_execute_reverse ()
2688 {
2689   return this->beneath ()->can_execute_reverse ();
2690 }
2691
2692 bool
2693 dummy_target::can_execute_reverse ()
2694 {
2695   return false;
2696 }
2697
2698 bool
2699 debug_target::can_execute_reverse ()
2700 {
2701   bool result;
2702   fprintf_unfiltered (gdb_stdlog, "-> %s->can_execute_reverse (...)\n", this->beneath ()->shortname ());
2703   result = this->beneath ()->can_execute_reverse ();
2704   fprintf_unfiltered (gdb_stdlog, "<- %s->can_execute_reverse (", this->beneath ()->shortname ());
2705   fputs_unfiltered (") = ", gdb_stdlog);
2706   target_debug_print_bool (result);
2707   fputs_unfiltered ("\n", gdb_stdlog);
2708   return result;
2709 }
2710
2711 enum exec_direction_kind
2712 target_ops::execution_direction ()
2713 {
2714   return this->beneath ()->execution_direction ();
2715 }
2716
2717 enum exec_direction_kind
2718 dummy_target::execution_direction ()
2719 {
2720   return default_execution_direction (this);
2721 }
2722
2723 enum exec_direction_kind
2724 debug_target::execution_direction ()
2725 {
2726   enum exec_direction_kind result;
2727   fprintf_unfiltered (gdb_stdlog, "-> %s->execution_direction (...)\n", this->beneath ()->shortname ());
2728   result = this->beneath ()->execution_direction ();
2729   fprintf_unfiltered (gdb_stdlog, "<- %s->execution_direction (", this->beneath ()->shortname ());
2730   fputs_unfiltered (") = ", gdb_stdlog);
2731   target_debug_print_enum_exec_direction_kind (result);
2732   fputs_unfiltered ("\n", gdb_stdlog);
2733   return result;
2734 }
2735
2736 bool
2737 target_ops::supports_multi_process ()
2738 {
2739   return this->beneath ()->supports_multi_process ();
2740 }
2741
2742 bool
2743 dummy_target::supports_multi_process ()
2744 {
2745   return false;
2746 }
2747
2748 bool
2749 debug_target::supports_multi_process ()
2750 {
2751   bool result;
2752   fprintf_unfiltered (gdb_stdlog, "-> %s->supports_multi_process (...)\n", this->beneath ()->shortname ());
2753   result = this->beneath ()->supports_multi_process ();
2754   fprintf_unfiltered (gdb_stdlog, "<- %s->supports_multi_process (", this->beneath ()->shortname ());
2755   fputs_unfiltered (") = ", gdb_stdlog);
2756   target_debug_print_bool (result);
2757   fputs_unfiltered ("\n", gdb_stdlog);
2758   return result;
2759 }
2760
2761 bool
2762 target_ops::supports_enable_disable_tracepoint ()
2763 {
2764   return this->beneath ()->supports_enable_disable_tracepoint ();
2765 }
2766
2767 bool
2768 dummy_target::supports_enable_disable_tracepoint ()
2769 {
2770   return false;
2771 }
2772
2773 bool
2774 debug_target::supports_enable_disable_tracepoint ()
2775 {
2776   bool result;
2777   fprintf_unfiltered (gdb_stdlog, "-> %s->supports_enable_disable_tracepoint (...)\n", this->beneath ()->shortname ());
2778   result = this->beneath ()->supports_enable_disable_tracepoint ();
2779   fprintf_unfiltered (gdb_stdlog, "<- %s->supports_enable_disable_tracepoint (", this->beneath ()->shortname ());
2780   fputs_unfiltered (") = ", gdb_stdlog);
2781   target_debug_print_bool (result);
2782   fputs_unfiltered ("\n", gdb_stdlog);
2783   return result;
2784 }
2785
2786 bool
2787 target_ops::supports_disable_randomization ()
2788 {
2789   return this->beneath ()->supports_disable_randomization ();
2790 }
2791
2792 bool
2793 dummy_target::supports_disable_randomization ()
2794 {
2795   return find_default_supports_disable_randomization (this);
2796 }
2797
2798 bool
2799 debug_target::supports_disable_randomization ()
2800 {
2801   bool result;
2802   fprintf_unfiltered (gdb_stdlog, "-> %s->supports_disable_randomization (...)\n", this->beneath ()->shortname ());
2803   result = this->beneath ()->supports_disable_randomization ();
2804   fprintf_unfiltered (gdb_stdlog, "<- %s->supports_disable_randomization (", this->beneath ()->shortname ());
2805   fputs_unfiltered (") = ", gdb_stdlog);
2806   target_debug_print_bool (result);
2807   fputs_unfiltered ("\n", gdb_stdlog);
2808   return result;
2809 }
2810
2811 bool
2812 target_ops::supports_string_tracing ()
2813 {
2814   return this->beneath ()->supports_string_tracing ();
2815 }
2816
2817 bool
2818 dummy_target::supports_string_tracing ()
2819 {
2820   return false;
2821 }
2822
2823 bool
2824 debug_target::supports_string_tracing ()
2825 {
2826   bool result;
2827   fprintf_unfiltered (gdb_stdlog, "-> %s->supports_string_tracing (...)\n", this->beneath ()->shortname ());
2828   result = this->beneath ()->supports_string_tracing ();
2829   fprintf_unfiltered (gdb_stdlog, "<- %s->supports_string_tracing (", this->beneath ()->shortname ());
2830   fputs_unfiltered (") = ", gdb_stdlog);
2831   target_debug_print_bool (result);
2832   fputs_unfiltered ("\n", gdb_stdlog);
2833   return result;
2834 }
2835
2836 bool
2837 target_ops::supports_evaluation_of_breakpoint_conditions ()
2838 {
2839   return this->beneath ()->supports_evaluation_of_breakpoint_conditions ();
2840 }
2841
2842 bool
2843 dummy_target::supports_evaluation_of_breakpoint_conditions ()
2844 {
2845   return false;
2846 }
2847
2848 bool
2849 debug_target::supports_evaluation_of_breakpoint_conditions ()
2850 {
2851   bool result;
2852   fprintf_unfiltered (gdb_stdlog, "-> %s->supports_evaluation_of_breakpoint_conditions (...)\n", this->beneath ()->shortname ());
2853   result = this->beneath ()->supports_evaluation_of_breakpoint_conditions ();
2854   fprintf_unfiltered (gdb_stdlog, "<- %s->supports_evaluation_of_breakpoint_conditions (", this->beneath ()->shortname ());
2855   fputs_unfiltered (") = ", gdb_stdlog);
2856   target_debug_print_bool (result);
2857   fputs_unfiltered ("\n", gdb_stdlog);
2858   return result;
2859 }
2860
2861 bool
2862 target_ops::supports_dumpcore ()
2863 {
2864   return this->beneath ()->supports_dumpcore ();
2865 }
2866
2867 bool
2868 dummy_target::supports_dumpcore ()
2869 {
2870   return false;
2871 }
2872
2873 bool
2874 debug_target::supports_dumpcore ()
2875 {
2876   bool result;
2877   fprintf_unfiltered (gdb_stdlog, "-> %s->supports_dumpcore (...)\n", this->beneath ()->shortname ());
2878   result = this->beneath ()->supports_dumpcore ();
2879   fprintf_unfiltered (gdb_stdlog, "<- %s->supports_dumpcore (", this->beneath ()->shortname ());
2880   fputs_unfiltered (") = ", gdb_stdlog);
2881   target_debug_print_bool (result);
2882   fputs_unfiltered ("\n", gdb_stdlog);
2883   return result;
2884 }
2885
2886 void
2887 target_ops::dumpcore (const char *arg0)
2888 {
2889   this->beneath ()->dumpcore (arg0);
2890 }
2891
2892 void
2893 dummy_target::dumpcore (const char *arg0)
2894 {
2895 }
2896
2897 void
2898 debug_target::dumpcore (const char *arg0)
2899 {
2900   fprintf_unfiltered (gdb_stdlog, "-> %s->dumpcore (...)\n", this->beneath ()->shortname ());
2901   this->beneath ()->dumpcore (arg0);
2902   fprintf_unfiltered (gdb_stdlog, "<- %s->dumpcore (", this->beneath ()->shortname ());
2903   target_debug_print_const_char_p (arg0);
2904   fputs_unfiltered (")\n", gdb_stdlog);
2905 }
2906
2907 bool
2908 target_ops::can_run_breakpoint_commands ()
2909 {
2910   return this->beneath ()->can_run_breakpoint_commands ();
2911 }
2912
2913 bool
2914 dummy_target::can_run_breakpoint_commands ()
2915 {
2916   return false;
2917 }
2918
2919 bool
2920 debug_target::can_run_breakpoint_commands ()
2921 {
2922   bool result;
2923   fprintf_unfiltered (gdb_stdlog, "-> %s->can_run_breakpoint_commands (...)\n", this->beneath ()->shortname ());
2924   result = this->beneath ()->can_run_breakpoint_commands ();
2925   fprintf_unfiltered (gdb_stdlog, "<- %s->can_run_breakpoint_commands (", this->beneath ()->shortname ());
2926   fputs_unfiltered (") = ", gdb_stdlog);
2927   target_debug_print_bool (result);
2928   fputs_unfiltered ("\n", gdb_stdlog);
2929   return result;
2930 }
2931
2932 struct gdbarch *
2933 target_ops::thread_architecture (ptid_t arg0)
2934 {
2935   return this->beneath ()->thread_architecture (arg0);
2936 }
2937
2938 struct gdbarch *
2939 dummy_target::thread_architecture (ptid_t arg0)
2940 {
2941   return NULL;
2942 }
2943
2944 struct gdbarch *
2945 debug_target::thread_architecture (ptid_t arg0)
2946 {
2947   struct gdbarch * result;
2948   fprintf_unfiltered (gdb_stdlog, "-> %s->thread_architecture (...)\n", this->beneath ()->shortname ());
2949   result = this->beneath ()->thread_architecture (arg0);
2950   fprintf_unfiltered (gdb_stdlog, "<- %s->thread_architecture (", this->beneath ()->shortname ());
2951   target_debug_print_ptid_t (arg0);
2952   fputs_unfiltered (") = ", gdb_stdlog);
2953   target_debug_print_struct_gdbarch_p (result);
2954   fputs_unfiltered ("\n", gdb_stdlog);
2955   return result;
2956 }
2957
2958 struct address_space *
2959 target_ops::thread_address_space (ptid_t arg0)
2960 {
2961   return this->beneath ()->thread_address_space (arg0);
2962 }
2963
2964 struct address_space *
2965 dummy_target::thread_address_space (ptid_t arg0)
2966 {
2967   return NULL;
2968 }
2969
2970 struct address_space *
2971 debug_target::thread_address_space (ptid_t arg0)
2972 {
2973   struct address_space * result;
2974   fprintf_unfiltered (gdb_stdlog, "-> %s->thread_address_space (...)\n", this->beneath ()->shortname ());
2975   result = this->beneath ()->thread_address_space (arg0);
2976   fprintf_unfiltered (gdb_stdlog, "<- %s->thread_address_space (", this->beneath ()->shortname ());
2977   target_debug_print_ptid_t (arg0);
2978   fputs_unfiltered (") = ", gdb_stdlog);
2979   target_debug_print_struct_address_space_p (result);
2980   fputs_unfiltered ("\n", gdb_stdlog);
2981   return result;
2982 }
2983
2984 bool
2985 target_ops::filesystem_is_local ()
2986 {
2987   return this->beneath ()->filesystem_is_local ();
2988 }
2989
2990 bool
2991 dummy_target::filesystem_is_local ()
2992 {
2993   return true;
2994 }
2995
2996 bool
2997 debug_target::filesystem_is_local ()
2998 {
2999   bool result;
3000   fprintf_unfiltered (gdb_stdlog, "-> %s->filesystem_is_local (...)\n", this->beneath ()->shortname ());
3001   result = this->beneath ()->filesystem_is_local ();
3002   fprintf_unfiltered (gdb_stdlog, "<- %s->filesystem_is_local (", this->beneath ()->shortname ());
3003   fputs_unfiltered (") = ", gdb_stdlog);
3004   target_debug_print_bool (result);
3005   fputs_unfiltered ("\n", gdb_stdlog);
3006   return result;
3007 }
3008
3009 void
3010 target_ops::trace_init ()
3011 {
3012   this->beneath ()->trace_init ();
3013 }
3014
3015 void
3016 dummy_target::trace_init ()
3017 {
3018   tcomplain ();
3019 }
3020
3021 void
3022 debug_target::trace_init ()
3023 {
3024   fprintf_unfiltered (gdb_stdlog, "-> %s->trace_init (...)\n", this->beneath ()->shortname ());
3025   this->beneath ()->trace_init ();
3026   fprintf_unfiltered (gdb_stdlog, "<- %s->trace_init (", this->beneath ()->shortname ());
3027   fputs_unfiltered (")\n", gdb_stdlog);
3028 }
3029
3030 void
3031 target_ops::download_tracepoint (struct bp_location *arg0)
3032 {
3033   this->beneath ()->download_tracepoint (arg0);
3034 }
3035
3036 void
3037 dummy_target::download_tracepoint (struct bp_location *arg0)
3038 {
3039   tcomplain ();
3040 }
3041
3042 void
3043 debug_target::download_tracepoint (struct bp_location *arg0)
3044 {
3045   fprintf_unfiltered (gdb_stdlog, "-> %s->download_tracepoint (...)\n", this->beneath ()->shortname ());
3046   this->beneath ()->download_tracepoint (arg0);
3047   fprintf_unfiltered (gdb_stdlog, "<- %s->download_tracepoint (", this->beneath ()->shortname ());
3048   target_debug_print_struct_bp_location_p (arg0);
3049   fputs_unfiltered (")\n", gdb_stdlog);
3050 }
3051
3052 bool
3053 target_ops::can_download_tracepoint ()
3054 {
3055   return this->beneath ()->can_download_tracepoint ();
3056 }
3057
3058 bool
3059 dummy_target::can_download_tracepoint ()
3060 {
3061   return false;
3062 }
3063
3064 bool
3065 debug_target::can_download_tracepoint ()
3066 {
3067   bool result;
3068   fprintf_unfiltered (gdb_stdlog, "-> %s->can_download_tracepoint (...)\n", this->beneath ()->shortname ());
3069   result = this->beneath ()->can_download_tracepoint ();
3070   fprintf_unfiltered (gdb_stdlog, "<- %s->can_download_tracepoint (", this->beneath ()->shortname ());
3071   fputs_unfiltered (") = ", gdb_stdlog);
3072   target_debug_print_bool (result);
3073   fputs_unfiltered ("\n", gdb_stdlog);
3074   return result;
3075 }
3076
3077 void
3078 target_ops::download_trace_state_variable (const trace_state_variable &arg0)
3079 {
3080   this->beneath ()->download_trace_state_variable (arg0);
3081 }
3082
3083 void
3084 dummy_target::download_trace_state_variable (const trace_state_variable &arg0)
3085 {
3086   tcomplain ();
3087 }
3088
3089 void
3090 debug_target::download_trace_state_variable (const trace_state_variable &arg0)
3091 {
3092   fprintf_unfiltered (gdb_stdlog, "-> %s->download_trace_state_variable (...)\n", this->beneath ()->shortname ());
3093   this->beneath ()->download_trace_state_variable (arg0);
3094   fprintf_unfiltered (gdb_stdlog, "<- %s->download_trace_state_variable (", this->beneath ()->shortname ());
3095   target_debug_print_const_trace_state_variable_r (arg0);
3096   fputs_unfiltered (")\n", gdb_stdlog);
3097 }
3098
3099 void
3100 target_ops::enable_tracepoint (struct bp_location *arg0)
3101 {
3102   this->beneath ()->enable_tracepoint (arg0);
3103 }
3104
3105 void
3106 dummy_target::enable_tracepoint (struct bp_location *arg0)
3107 {
3108   tcomplain ();
3109 }
3110
3111 void
3112 debug_target::enable_tracepoint (struct bp_location *arg0)
3113 {
3114   fprintf_unfiltered (gdb_stdlog, "-> %s->enable_tracepoint (...)\n", this->beneath ()->shortname ());
3115   this->beneath ()->enable_tracepoint (arg0);
3116   fprintf_unfiltered (gdb_stdlog, "<- %s->enable_tracepoint (", this->beneath ()->shortname ());
3117   target_debug_print_struct_bp_location_p (arg0);
3118   fputs_unfiltered (")\n", gdb_stdlog);
3119 }
3120
3121 void
3122 target_ops::disable_tracepoint (struct bp_location *arg0)
3123 {
3124   this->beneath ()->disable_tracepoint (arg0);
3125 }
3126
3127 void
3128 dummy_target::disable_tracepoint (struct bp_location *arg0)
3129 {
3130   tcomplain ();
3131 }
3132
3133 void
3134 debug_target::disable_tracepoint (struct bp_location *arg0)
3135 {
3136   fprintf_unfiltered (gdb_stdlog, "-> %s->disable_tracepoint (...)\n", this->beneath ()->shortname ());
3137   this->beneath ()->disable_tracepoint (arg0);
3138   fprintf_unfiltered (gdb_stdlog, "<- %s->disable_tracepoint (", this->beneath ()->shortname ());
3139   target_debug_print_struct_bp_location_p (arg0);
3140   fputs_unfiltered (")\n", gdb_stdlog);
3141 }
3142
3143 void
3144 target_ops::trace_set_readonly_regions ()
3145 {
3146   this->beneath ()->trace_set_readonly_regions ();
3147 }
3148
3149 void
3150 dummy_target::trace_set_readonly_regions ()
3151 {
3152   tcomplain ();
3153 }
3154
3155 void
3156 debug_target::trace_set_readonly_regions ()
3157 {
3158   fprintf_unfiltered (gdb_stdlog, "-> %s->trace_set_readonly_regions (...)\n", this->beneath ()->shortname ());
3159   this->beneath ()->trace_set_readonly_regions ();
3160   fprintf_unfiltered (gdb_stdlog, "<- %s->trace_set_readonly_regions (", this->beneath ()->shortname ());
3161   fputs_unfiltered (")\n", gdb_stdlog);
3162 }
3163
3164 void
3165 target_ops::trace_start ()
3166 {
3167   this->beneath ()->trace_start ();
3168 }
3169
3170 void
3171 dummy_target::trace_start ()
3172 {
3173   tcomplain ();
3174 }
3175
3176 void
3177 debug_target::trace_start ()
3178 {
3179   fprintf_unfiltered (gdb_stdlog, "-> %s->trace_start (...)\n", this->beneath ()->shortname ());
3180   this->beneath ()->trace_start ();
3181   fprintf_unfiltered (gdb_stdlog, "<- %s->trace_start (", this->beneath ()->shortname ());
3182   fputs_unfiltered (")\n", gdb_stdlog);
3183 }
3184
3185 int
3186 target_ops::get_trace_status (struct trace_status *arg0)
3187 {
3188   return this->beneath ()->get_trace_status (arg0);
3189 }
3190
3191 int
3192 dummy_target::get_trace_status (struct trace_status *arg0)
3193 {
3194   return -1;
3195 }
3196
3197 int
3198 debug_target::get_trace_status (struct trace_status *arg0)
3199 {
3200   int result;
3201   fprintf_unfiltered (gdb_stdlog, "-> %s->get_trace_status (...)\n", this->beneath ()->shortname ());
3202   result = this->beneath ()->get_trace_status (arg0);
3203   fprintf_unfiltered (gdb_stdlog, "<- %s->get_trace_status (", this->beneath ()->shortname ());
3204   target_debug_print_struct_trace_status_p (arg0);
3205   fputs_unfiltered (") = ", gdb_stdlog);
3206   target_debug_print_int (result);
3207   fputs_unfiltered ("\n", gdb_stdlog);
3208   return result;
3209 }
3210
3211 void
3212 target_ops::get_tracepoint_status (struct breakpoint *arg0, struct uploaded_tp *arg1)
3213 {
3214   this->beneath ()->get_tracepoint_status (arg0, arg1);
3215 }
3216
3217 void
3218 dummy_target::get_tracepoint_status (struct breakpoint *arg0, struct uploaded_tp *arg1)
3219 {
3220   tcomplain ();
3221 }
3222
3223 void
3224 debug_target::get_tracepoint_status (struct breakpoint *arg0, struct uploaded_tp *arg1)
3225 {
3226   fprintf_unfiltered (gdb_stdlog, "-> %s->get_tracepoint_status (...)\n", this->beneath ()->shortname ());
3227   this->beneath ()->get_tracepoint_status (arg0, arg1);
3228   fprintf_unfiltered (gdb_stdlog, "<- %s->get_tracepoint_status (", this->beneath ()->shortname ());
3229   target_debug_print_struct_breakpoint_p (arg0);
3230   fputs_unfiltered (", ", gdb_stdlog);
3231   target_debug_print_struct_uploaded_tp_p (arg1);
3232   fputs_unfiltered (")\n", gdb_stdlog);
3233 }
3234
3235 void
3236 target_ops::trace_stop ()
3237 {
3238   this->beneath ()->trace_stop ();
3239 }
3240
3241 void
3242 dummy_target::trace_stop ()
3243 {
3244   tcomplain ();
3245 }
3246
3247 void
3248 debug_target::trace_stop ()
3249 {
3250   fprintf_unfiltered (gdb_stdlog, "-> %s->trace_stop (...)\n", this->beneath ()->shortname ());
3251   this->beneath ()->trace_stop ();
3252   fprintf_unfiltered (gdb_stdlog, "<- %s->trace_stop (", this->beneath ()->shortname ());
3253   fputs_unfiltered (")\n", gdb_stdlog);
3254 }
3255
3256 int
3257 target_ops::trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4)
3258 {
3259   return this->beneath ()->trace_find (arg0, arg1, arg2, arg3, arg4);
3260 }
3261
3262 int
3263 dummy_target::trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4)
3264 {
3265   return -1;
3266 }
3267
3268 int
3269 debug_target::trace_find (enum trace_find_type arg0, int arg1, CORE_ADDR arg2, CORE_ADDR arg3, int *arg4)
3270 {
3271   int result;
3272   fprintf_unfiltered (gdb_stdlog, "-> %s->trace_find (...)\n", this->beneath ()->shortname ());
3273   result = this->beneath ()->trace_find (arg0, arg1, arg2, arg3, arg4);
3274   fprintf_unfiltered (gdb_stdlog, "<- %s->trace_find (", this->beneath ()->shortname ());
3275   target_debug_print_enum_trace_find_type (arg0);
3276   fputs_unfiltered (", ", gdb_stdlog);
3277   target_debug_print_int (arg1);
3278   fputs_unfiltered (", ", gdb_stdlog);
3279   target_debug_print_CORE_ADDR (arg2);
3280   fputs_unfiltered (", ", gdb_stdlog);
3281   target_debug_print_CORE_ADDR (arg3);
3282   fputs_unfiltered (", ", gdb_stdlog);
3283   target_debug_print_int_p (arg4);
3284   fputs_unfiltered (") = ", gdb_stdlog);
3285   target_debug_print_int (result);
3286   fputs_unfiltered ("\n", gdb_stdlog);
3287   return result;
3288 }
3289
3290 bool
3291 target_ops::get_trace_state_variable_value (int arg0, LONGEST *arg1)
3292 {
3293   return this->beneath ()->get_trace_state_variable_value (arg0, arg1);
3294 }
3295
3296 bool
3297 dummy_target::get_trace_state_variable_value (int arg0, LONGEST *arg1)
3298 {
3299   return false;
3300 }
3301
3302 bool
3303 debug_target::get_trace_state_variable_value (int arg0, LONGEST *arg1)
3304 {
3305   bool result;
3306   fprintf_unfiltered (gdb_stdlog, "-> %s->get_trace_state_variable_value (...)\n", this->beneath ()->shortname ());
3307   result = this->beneath ()->get_trace_state_variable_value (arg0, arg1);
3308   fprintf_unfiltered (gdb_stdlog, "<- %s->get_trace_state_variable_value (", this->beneath ()->shortname ());
3309   target_debug_print_int (arg0);
3310   fputs_unfiltered (", ", gdb_stdlog);
3311   target_debug_print_LONGEST_p (arg1);
3312   fputs_unfiltered (") = ", gdb_stdlog);
3313   target_debug_print_bool (result);
3314   fputs_unfiltered ("\n", gdb_stdlog);
3315   return result;
3316 }
3317
3318 int
3319 target_ops::save_trace_data (const char *arg0)
3320 {
3321   return this->beneath ()->save_trace_data (arg0);
3322 }
3323
3324 int
3325 dummy_target::save_trace_data (const char *arg0)
3326 {
3327   tcomplain ();
3328 }
3329
3330 int
3331 debug_target::save_trace_data (const char *arg0)
3332 {
3333   int result;
3334   fprintf_unfiltered (gdb_stdlog, "-> %s->save_trace_data (...)\n", this->beneath ()->shortname ());
3335   result = this->beneath ()->save_trace_data (arg0);
3336   fprintf_unfiltered (gdb_stdlog, "<- %s->save_trace_data (", this->beneath ()->shortname ());
3337   target_debug_print_const_char_p (arg0);
3338   fputs_unfiltered (") = ", gdb_stdlog);
3339   target_debug_print_int (result);
3340   fputs_unfiltered ("\n", gdb_stdlog);
3341   return result;
3342 }
3343
3344 int
3345 target_ops::upload_tracepoints (struct uploaded_tp **arg0)
3346 {
3347   return this->beneath ()->upload_tracepoints (arg0);
3348 }
3349
3350 int
3351 dummy_target::upload_tracepoints (struct uploaded_tp **arg0)
3352 {
3353   return 0;
3354 }
3355
3356 int
3357 debug_target::upload_tracepoints (struct uploaded_tp **arg0)
3358 {
3359   int result;
3360   fprintf_unfiltered (gdb_stdlog, "-> %s->upload_tracepoints (...)\n", this->beneath ()->shortname ());
3361   result = this->beneath ()->upload_tracepoints (arg0);
3362   fprintf_unfiltered (gdb_stdlog, "<- %s->upload_tracepoints (", this->beneath ()->shortname ());
3363   target_debug_print_struct_uploaded_tp_pp (arg0);
3364   fputs_unfiltered (") = ", gdb_stdlog);
3365   target_debug_print_int (result);
3366   fputs_unfiltered ("\n", gdb_stdlog);
3367   return result;
3368 }
3369
3370 int
3371 target_ops::upload_trace_state_variables (struct uploaded_tsv **arg0)
3372 {
3373   return this->beneath ()->upload_trace_state_variables (arg0);
3374 }
3375
3376 int
3377 dummy_target::upload_trace_state_variables (struct uploaded_tsv **arg0)
3378 {
3379   return 0;
3380 }
3381
3382 int
3383 debug_target::upload_trace_state_variables (struct uploaded_tsv **arg0)
3384 {
3385   int result;
3386   fprintf_unfiltered (gdb_stdlog, "-> %s->upload_trace_state_variables (...)\n", this->beneath ()->shortname ());
3387   result = this->beneath ()->upload_trace_state_variables (arg0);
3388   fprintf_unfiltered (gdb_stdlog, "<- %s->upload_trace_state_variables (", this->beneath ()->shortname ());
3389   target_debug_print_struct_uploaded_tsv_pp (arg0);
3390   fputs_unfiltered (") = ", gdb_stdlog);
3391   target_debug_print_int (result);
3392   fputs_unfiltered ("\n", gdb_stdlog);
3393   return result;
3394 }
3395
3396 LONGEST
3397 target_ops::get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2)
3398 {
3399   return this->beneath ()->get_raw_trace_data (arg0, arg1, arg2);
3400 }
3401
3402 LONGEST
3403 dummy_target::get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2)
3404 {
3405   tcomplain ();
3406 }
3407
3408 LONGEST
3409 debug_target::get_raw_trace_data (gdb_byte *arg0, ULONGEST arg1, LONGEST arg2)
3410 {
3411   LONGEST result;
3412   fprintf_unfiltered (gdb_stdlog, "-> %s->get_raw_trace_data (...)\n", this->beneath ()->shortname ());
3413   result = this->beneath ()->get_raw_trace_data (arg0, arg1, arg2);
3414   fprintf_unfiltered (gdb_stdlog, "<- %s->get_raw_trace_data (", this->beneath ()->shortname ());
3415   target_debug_print_gdb_byte_p (arg0);
3416   fputs_unfiltered (", ", gdb_stdlog);
3417   target_debug_print_ULONGEST (arg1);
3418   fputs_unfiltered (", ", gdb_stdlog);
3419   target_debug_print_LONGEST (arg2);
3420   fputs_unfiltered (") = ", gdb_stdlog);
3421   target_debug_print_LONGEST (result);
3422   fputs_unfiltered ("\n", gdb_stdlog);
3423   return result;
3424 }
3425
3426 int
3427 target_ops::get_min_fast_tracepoint_insn_len ()
3428 {
3429   return this->beneath ()->get_min_fast_tracepoint_insn_len ();
3430 }
3431
3432 int
3433 dummy_target::get_min_fast_tracepoint_insn_len ()
3434 {
3435   return -1;
3436 }
3437
3438 int
3439 debug_target::get_min_fast_tracepoint_insn_len ()
3440 {
3441   int result;
3442   fprintf_unfiltered (gdb_stdlog, "-> %s->get_min_fast_tracepoint_insn_len (...)\n", this->beneath ()->shortname ());
3443   result = this->beneath ()->get_min_fast_tracepoint_insn_len ();
3444   fprintf_unfiltered (gdb_stdlog, "<- %s->get_min_fast_tracepoint_insn_len (", this->beneath ()->shortname ());
3445   fputs_unfiltered (") = ", gdb_stdlog);
3446   target_debug_print_int (result);
3447   fputs_unfiltered ("\n", gdb_stdlog);
3448   return result;
3449 }
3450
3451 void
3452 target_ops::set_disconnected_tracing (int arg0)
3453 {
3454   this->beneath ()->set_disconnected_tracing (arg0);
3455 }
3456
3457 void
3458 dummy_target::set_disconnected_tracing (int arg0)
3459 {
3460 }
3461
3462 void
3463 debug_target::set_disconnected_tracing (int arg0)
3464 {
3465   fprintf_unfiltered (gdb_stdlog, "-> %s->set_disconnected_tracing (...)\n", this->beneath ()->shortname ());
3466   this->beneath ()->set_disconnected_tracing (arg0);
3467   fprintf_unfiltered (gdb_stdlog, "<- %s->set_disconnected_tracing (", this->beneath ()->shortname ());
3468   target_debug_print_int (arg0);
3469   fputs_unfiltered (")\n", gdb_stdlog);
3470 }
3471
3472 void
3473 target_ops::set_circular_trace_buffer (int arg0)
3474 {
3475   this->beneath ()->set_circular_trace_buffer (arg0);
3476 }
3477
3478 void
3479 dummy_target::set_circular_trace_buffer (int arg0)
3480 {
3481 }
3482
3483 void
3484 debug_target::set_circular_trace_buffer (int arg0)
3485 {
3486   fprintf_unfiltered (gdb_stdlog, "-> %s->set_circular_trace_buffer (...)\n", this->beneath ()->shortname ());
3487   this->beneath ()->set_circular_trace_buffer (arg0);
3488   fprintf_unfiltered (gdb_stdlog, "<- %s->set_circular_trace_buffer (", this->beneath ()->shortname ());
3489   target_debug_print_int (arg0);
3490   fputs_unfiltered (")\n", gdb_stdlog);
3491 }
3492
3493 void
3494 target_ops::set_trace_buffer_size (LONGEST arg0)
3495 {
3496   this->beneath ()->set_trace_buffer_size (arg0);
3497 }
3498
3499 void
3500 dummy_target::set_trace_buffer_size (LONGEST arg0)
3501 {
3502 }
3503
3504 void
3505 debug_target::set_trace_buffer_size (LONGEST arg0)
3506 {
3507   fprintf_unfiltered (gdb_stdlog, "-> %s->set_trace_buffer_size (...)\n", this->beneath ()->shortname ());
3508   this->beneath ()->set_trace_buffer_size (arg0);
3509   fprintf_unfiltered (gdb_stdlog, "<- %s->set_trace_buffer_size (", this->beneath ()->shortname ());
3510   target_debug_print_LONGEST (arg0);
3511   fputs_unfiltered (")\n", gdb_stdlog);
3512 }
3513
3514 bool
3515 target_ops::set_trace_notes (const char *arg0, const char *arg1, const char *arg2)
3516 {
3517   return this->beneath ()->set_trace_notes (arg0, arg1, arg2);
3518 }
3519
3520 bool
3521 dummy_target::set_trace_notes (const char *arg0, const char *arg1, const char *arg2)
3522 {
3523   return false;
3524 }
3525
3526 bool
3527 debug_target::set_trace_notes (const char *arg0, const char *arg1, const char *arg2)
3528 {
3529   bool result;
3530   fprintf_unfiltered (gdb_stdlog, "-> %s->set_trace_notes (...)\n", this->beneath ()->shortname ());
3531   result = this->beneath ()->set_trace_notes (arg0, arg1, arg2);
3532   fprintf_unfiltered (gdb_stdlog, "<- %s->set_trace_notes (", this->beneath ()->shortname ());
3533   target_debug_print_const_char_p (arg0);
3534   fputs_unfiltered (", ", gdb_stdlog);
3535   target_debug_print_const_char_p (arg1);
3536   fputs_unfiltered (", ", gdb_stdlog);
3537   target_debug_print_const_char_p (arg2);
3538   fputs_unfiltered (") = ", gdb_stdlog);
3539   target_debug_print_bool (result);
3540   fputs_unfiltered ("\n", gdb_stdlog);
3541   return result;
3542 }
3543
3544 int
3545 target_ops::core_of_thread (ptid_t arg0)
3546 {
3547   return this->beneath ()->core_of_thread (arg0);
3548 }
3549
3550 int
3551 dummy_target::core_of_thread (ptid_t arg0)
3552 {
3553   return -1;
3554 }
3555
3556 int
3557 debug_target::core_of_thread (ptid_t arg0)
3558 {
3559   int result;
3560   fprintf_unfiltered (gdb_stdlog, "-> %s->core_of_thread (...)\n", this->beneath ()->shortname ());
3561   result = this->beneath ()->core_of_thread (arg0);
3562   fprintf_unfiltered (gdb_stdlog, "<- %s->core_of_thread (", this->beneath ()->shortname ());
3563   target_debug_print_ptid_t (arg0);
3564   fputs_unfiltered (") = ", gdb_stdlog);
3565   target_debug_print_int (result);
3566   fputs_unfiltered ("\n", gdb_stdlog);
3567   return result;
3568 }
3569
3570 int
3571 target_ops::verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2)
3572 {
3573   return this->beneath ()->verify_memory (arg0, arg1, arg2);
3574 }
3575
3576 int
3577 dummy_target::verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2)
3578 {
3579   return default_verify_memory (this, arg0, arg1, arg2);
3580 }
3581
3582 int
3583 debug_target::verify_memory (const gdb_byte *arg0, CORE_ADDR arg1, ULONGEST arg2)
3584 {
3585   int result;
3586   fprintf_unfiltered (gdb_stdlog, "-> %s->verify_memory (...)\n", this->beneath ()->shortname ());
3587   result = this->beneath ()->verify_memory (arg0, arg1, arg2);
3588   fprintf_unfiltered (gdb_stdlog, "<- %s->verify_memory (", this->beneath ()->shortname ());
3589   target_debug_print_const_gdb_byte_p (arg0);
3590   fputs_unfiltered (", ", gdb_stdlog);
3591   target_debug_print_CORE_ADDR (arg1);
3592   fputs_unfiltered (", ", gdb_stdlog);
3593   target_debug_print_ULONGEST (arg2);
3594   fputs_unfiltered (") = ", gdb_stdlog);
3595   target_debug_print_int (result);
3596   fputs_unfiltered ("\n", gdb_stdlog);
3597   return result;
3598 }
3599
3600 bool
3601 target_ops::get_tib_address (ptid_t arg0, CORE_ADDR *arg1)
3602 {
3603   return this->beneath ()->get_tib_address (arg0, arg1);
3604 }
3605
3606 bool
3607 dummy_target::get_tib_address (ptid_t arg0, CORE_ADDR *arg1)
3608 {
3609   tcomplain ();
3610 }
3611
3612 bool
3613 debug_target::get_tib_address (ptid_t arg0, CORE_ADDR *arg1)
3614 {
3615   bool result;
3616   fprintf_unfiltered (gdb_stdlog, "-> %s->get_tib_address (...)\n", this->beneath ()->shortname ());
3617   result = this->beneath ()->get_tib_address (arg0, arg1);
3618   fprintf_unfiltered (gdb_stdlog, "<- %s->get_tib_address (", this->beneath ()->shortname ());
3619   target_debug_print_ptid_t (arg0);
3620   fputs_unfiltered (", ", gdb_stdlog);
3621   target_debug_print_CORE_ADDR_p (arg1);
3622   fputs_unfiltered (") = ", gdb_stdlog);
3623   target_debug_print_bool (result);
3624   fputs_unfiltered ("\n", gdb_stdlog);
3625   return result;
3626 }
3627
3628 void
3629 target_ops::set_permissions ()
3630 {
3631   this->beneath ()->set_permissions ();
3632 }
3633
3634 void
3635 dummy_target::set_permissions ()
3636 {
3637 }
3638
3639 void
3640 debug_target::set_permissions ()
3641 {
3642   fprintf_unfiltered (gdb_stdlog, "-> %s->set_permissions (...)\n", this->beneath ()->shortname ());
3643   this->beneath ()->set_permissions ();
3644   fprintf_unfiltered (gdb_stdlog, "<- %s->set_permissions (", this->beneath ()->shortname ());
3645   fputs_unfiltered (")\n", gdb_stdlog);
3646 }
3647
3648 bool
3649 target_ops::static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1)
3650 {
3651   return this->beneath ()->static_tracepoint_marker_at (arg0, arg1);
3652 }
3653
3654 bool
3655 dummy_target::static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1)
3656 {
3657   return false;
3658 }
3659
3660 bool
3661 debug_target::static_tracepoint_marker_at (CORE_ADDR arg0, static_tracepoint_marker *arg1)
3662 {
3663   bool result;
3664   fprintf_unfiltered (gdb_stdlog, "-> %s->static_tracepoint_marker_at (...)\n", this->beneath ()->shortname ());
3665   result = this->beneath ()->static_tracepoint_marker_at (arg0, arg1);
3666   fprintf_unfiltered (gdb_stdlog, "<- %s->static_tracepoint_marker_at (", this->beneath ()->shortname ());
3667   target_debug_print_CORE_ADDR (arg0);
3668   fputs_unfiltered (", ", gdb_stdlog);
3669   target_debug_print_static_tracepoint_marker_p (arg1);
3670   fputs_unfiltered (") = ", gdb_stdlog);
3671   target_debug_print_bool (result);
3672   fputs_unfiltered ("\n", gdb_stdlog);
3673   return result;
3674 }
3675
3676 std::vector<static_tracepoint_marker>
3677 target_ops::static_tracepoint_markers_by_strid (const char *arg0)
3678 {
3679   return this->beneath ()->static_tracepoint_markers_by_strid (arg0);
3680 }
3681
3682 std::vector<static_tracepoint_marker>
3683 dummy_target::static_tracepoint_markers_by_strid (const char *arg0)
3684 {
3685   tcomplain ();
3686 }
3687
3688 std::vector<static_tracepoint_marker>
3689 debug_target::static_tracepoint_markers_by_strid (const char *arg0)
3690 {
3691   std::vector<static_tracepoint_marker> result;
3692   fprintf_unfiltered (gdb_stdlog, "-> %s->static_tracepoint_markers_by_strid (...)\n", this->beneath ()->shortname ());
3693   result = this->beneath ()->static_tracepoint_markers_by_strid (arg0);
3694   fprintf_unfiltered (gdb_stdlog, "<- %s->static_tracepoint_markers_by_strid (", this->beneath ()->shortname ());
3695   target_debug_print_const_char_p (arg0);
3696   fputs_unfiltered (") = ", gdb_stdlog);
3697   target_debug_print_std_vector_static_tracepoint_marker (result);
3698   fputs_unfiltered ("\n", gdb_stdlog);
3699   return result;
3700 }
3701
3702 traceframe_info_up
3703 target_ops::traceframe_info ()
3704 {
3705   return this->beneath ()->traceframe_info ();
3706 }
3707
3708 traceframe_info_up
3709 dummy_target::traceframe_info ()
3710 {
3711   tcomplain ();
3712 }
3713
3714 traceframe_info_up
3715 debug_target::traceframe_info ()
3716 {
3717   traceframe_info_up result;
3718   fprintf_unfiltered (gdb_stdlog, "-> %s->traceframe_info (...)\n", this->beneath ()->shortname ());
3719   result = this->beneath ()->traceframe_info ();
3720   fprintf_unfiltered (gdb_stdlog, "<- %s->traceframe_info (", this->beneath ()->shortname ());
3721   fputs_unfiltered (") = ", gdb_stdlog);
3722   target_debug_print_traceframe_info_up (result);
3723   fputs_unfiltered ("\n", gdb_stdlog);
3724   return result;
3725 }
3726
3727 bool
3728 target_ops::use_agent (bool arg0)
3729 {
3730   return this->beneath ()->use_agent (arg0);
3731 }
3732
3733 bool
3734 dummy_target::use_agent (bool arg0)
3735 {
3736   tcomplain ();
3737 }
3738
3739 bool
3740 debug_target::use_agent (bool arg0)
3741 {
3742   bool result;
3743   fprintf_unfiltered (gdb_stdlog, "-> %s->use_agent (...)\n", this->beneath ()->shortname ());
3744   result = this->beneath ()->use_agent (arg0);
3745   fprintf_unfiltered (gdb_stdlog, "<- %s->use_agent (", this->beneath ()->shortname ());
3746   target_debug_print_bool (arg0);
3747   fputs_unfiltered (") = ", gdb_stdlog);
3748   target_debug_print_bool (result);
3749   fputs_unfiltered ("\n", gdb_stdlog);
3750   return result;
3751 }
3752
3753 bool
3754 target_ops::can_use_agent ()
3755 {
3756   return this->beneath ()->can_use_agent ();
3757 }
3758
3759 bool
3760 dummy_target::can_use_agent ()
3761 {
3762   return false;
3763 }
3764
3765 bool
3766 debug_target::can_use_agent ()
3767 {
3768   bool result;
3769   fprintf_unfiltered (gdb_stdlog, "-> %s->can_use_agent (...)\n", this->beneath ()->shortname ());
3770   result = this->beneath ()->can_use_agent ();
3771   fprintf_unfiltered (gdb_stdlog, "<- %s->can_use_agent (", this->beneath ()->shortname ());
3772   fputs_unfiltered (") = ", gdb_stdlog);
3773   target_debug_print_bool (result);
3774   fputs_unfiltered ("\n", gdb_stdlog);
3775   return result;
3776 }
3777
3778 struct btrace_target_info *
3779 target_ops::enable_btrace (ptid_t arg0, const struct btrace_config *arg1)
3780 {
3781   return this->beneath ()->enable_btrace (arg0, arg1);
3782 }
3783
3784 struct btrace_target_info *
3785 dummy_target::enable_btrace (ptid_t arg0, const struct btrace_config *arg1)
3786 {
3787   tcomplain ();
3788 }
3789
3790 struct btrace_target_info *
3791 debug_target::enable_btrace (ptid_t arg0, const struct btrace_config *arg1)
3792 {
3793   struct btrace_target_info * result;
3794   fprintf_unfiltered (gdb_stdlog, "-> %s->enable_btrace (...)\n", this->beneath ()->shortname ());
3795   result = this->beneath ()->enable_btrace (arg0, arg1);
3796   fprintf_unfiltered (gdb_stdlog, "<- %s->enable_btrace (", this->beneath ()->shortname ());
3797   target_debug_print_ptid_t (arg0);
3798   fputs_unfiltered (", ", gdb_stdlog);
3799   target_debug_print_const_struct_btrace_config_p (arg1);
3800   fputs_unfiltered (") = ", gdb_stdlog);
3801   target_debug_print_struct_btrace_target_info_p (result);
3802   fputs_unfiltered ("\n", gdb_stdlog);
3803   return result;
3804 }
3805
3806 void
3807 target_ops::disable_btrace (struct btrace_target_info *arg0)
3808 {
3809   this->beneath ()->disable_btrace (arg0);
3810 }
3811
3812 void
3813 dummy_target::disable_btrace (struct btrace_target_info *arg0)
3814 {
3815   tcomplain ();
3816 }
3817
3818 void
3819 debug_target::disable_btrace (struct btrace_target_info *arg0)
3820 {
3821   fprintf_unfiltered (gdb_stdlog, "-> %s->disable_btrace (...)\n", this->beneath ()->shortname ());
3822   this->beneath ()->disable_btrace (arg0);
3823   fprintf_unfiltered (gdb_stdlog, "<- %s->disable_btrace (", this->beneath ()->shortname ());
3824   target_debug_print_struct_btrace_target_info_p (arg0);
3825   fputs_unfiltered (")\n", gdb_stdlog);
3826 }
3827
3828 void
3829 target_ops::teardown_btrace (struct btrace_target_info *arg0)
3830 {
3831   this->beneath ()->teardown_btrace (arg0);
3832 }
3833
3834 void
3835 dummy_target::teardown_btrace (struct btrace_target_info *arg0)
3836 {
3837   tcomplain ();
3838 }
3839
3840 void
3841 debug_target::teardown_btrace (struct btrace_target_info *arg0)
3842 {
3843   fprintf_unfiltered (gdb_stdlog, "-> %s->teardown_btrace (...)\n", this->beneath ()->shortname ());
3844   this->beneath ()->teardown_btrace (arg0);
3845   fprintf_unfiltered (gdb_stdlog, "<- %s->teardown_btrace (", this->beneath ()->shortname ());
3846   target_debug_print_struct_btrace_target_info_p (arg0);
3847   fputs_unfiltered (")\n", gdb_stdlog);
3848 }
3849
3850 enum btrace_error
3851 target_ops::read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2)
3852 {
3853   return this->beneath ()->read_btrace (arg0, arg1, arg2);
3854 }
3855
3856 enum btrace_error
3857 dummy_target::read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2)
3858 {
3859   tcomplain ();
3860 }
3861
3862 enum btrace_error
3863 debug_target::read_btrace (struct btrace_data *arg0, struct btrace_target_info *arg1, enum btrace_read_type arg2)
3864 {
3865   enum btrace_error result;
3866   fprintf_unfiltered (gdb_stdlog, "-> %s->read_btrace (...)\n", this->beneath ()->shortname ());
3867   result = this->beneath ()->read_btrace (arg0, arg1, arg2);
3868   fprintf_unfiltered (gdb_stdlog, "<- %s->read_btrace (", this->beneath ()->shortname ());
3869   target_debug_print_struct_btrace_data_p (arg0);
3870   fputs_unfiltered (", ", gdb_stdlog);
3871   target_debug_print_struct_btrace_target_info_p (arg1);
3872   fputs_unfiltered (", ", gdb_stdlog);
3873   target_debug_print_enum_btrace_read_type (arg2);
3874   fputs_unfiltered (") = ", gdb_stdlog);
3875   target_debug_print_enum_btrace_error (result);
3876   fputs_unfiltered ("\n", gdb_stdlog);
3877   return result;
3878 }
3879
3880 const struct btrace_config *
3881 target_ops::btrace_conf (const struct btrace_target_info *arg0)
3882 {
3883   return this->beneath ()->btrace_conf (arg0);
3884 }
3885
3886 const struct btrace_config *
3887 dummy_target::btrace_conf (const struct btrace_target_info *arg0)
3888 {
3889   return NULL;
3890 }
3891
3892 const struct btrace_config *
3893 debug_target::btrace_conf (const struct btrace_target_info *arg0)
3894 {
3895   const struct btrace_config * result;
3896   fprintf_unfiltered (gdb_stdlog, "-> %s->btrace_conf (...)\n", this->beneath ()->shortname ());
3897   result = this->beneath ()->btrace_conf (arg0);
3898   fprintf_unfiltered (gdb_stdlog, "<- %s->btrace_conf (", this->beneath ()->shortname ());
3899   target_debug_print_const_struct_btrace_target_info_p (arg0);
3900   fputs_unfiltered (") = ", gdb_stdlog);
3901   target_debug_print_const_struct_btrace_config_p (result);
3902   fputs_unfiltered ("\n", gdb_stdlog);
3903   return result;
3904 }
3905
3906 enum record_method
3907 target_ops::record_method (ptid_t arg0)
3908 {
3909   return this->beneath ()->record_method (arg0);
3910 }
3911
3912 enum record_method
3913 dummy_target::record_method (ptid_t arg0)
3914 {
3915   return RECORD_METHOD_NONE;
3916 }
3917
3918 enum record_method
3919 debug_target::record_method (ptid_t arg0)
3920 {
3921   enum record_method result;
3922   fprintf_unfiltered (gdb_stdlog, "-> %s->record_method (...)\n", this->beneath ()->shortname ());
3923   result = this->beneath ()->record_method (arg0);
3924   fprintf_unfiltered (gdb_stdlog, "<- %s->record_method (", this->beneath ()->shortname ());
3925   target_debug_print_ptid_t (arg0);
3926   fputs_unfiltered (") = ", gdb_stdlog);
3927   target_debug_print_enum_record_method (result);
3928   fputs_unfiltered ("\n", gdb_stdlog);
3929   return result;
3930 }
3931
3932 void
3933 target_ops::stop_recording ()
3934 {
3935   this->beneath ()->stop_recording ();
3936 }
3937
3938 void
3939 dummy_target::stop_recording ()
3940 {
3941 }
3942
3943 void
3944 debug_target::stop_recording ()
3945 {
3946   fprintf_unfiltered (gdb_stdlog, "-> %s->stop_recording (...)\n", this->beneath ()->shortname ());
3947   this->beneath ()->stop_recording ();
3948   fprintf_unfiltered (gdb_stdlog, "<- %s->stop_recording (", this->beneath ()->shortname ());
3949   fputs_unfiltered (")\n", gdb_stdlog);
3950 }
3951
3952 void
3953 target_ops::info_record ()
3954 {
3955   this->beneath ()->info_record ();
3956 }
3957
3958 void
3959 dummy_target::info_record ()
3960 {
3961 }
3962
3963 void
3964 debug_target::info_record ()
3965 {
3966   fprintf_unfiltered (gdb_stdlog, "-> %s->info_record (...)\n", this->beneath ()->shortname ());
3967   this->beneath ()->info_record ();
3968   fprintf_unfiltered (gdb_stdlog, "<- %s->info_record (", this->beneath ()->shortname ());
3969   fputs_unfiltered (")\n", gdb_stdlog);
3970 }
3971
3972 void
3973 target_ops::save_record (const char *arg0)
3974 {
3975   this->beneath ()->save_record (arg0);
3976 }
3977
3978 void
3979 dummy_target::save_record (const char *arg0)
3980 {
3981   tcomplain ();
3982 }
3983
3984 void
3985 debug_target::save_record (const char *arg0)
3986 {
3987   fprintf_unfiltered (gdb_stdlog, "-> %s->save_record (...)\n", this->beneath ()->shortname ());
3988   this->beneath ()->save_record (arg0);
3989   fprintf_unfiltered (gdb_stdlog, "<- %s->save_record (", this->beneath ()->shortname ());
3990   target_debug_print_const_char_p (arg0);
3991   fputs_unfiltered (")\n", gdb_stdlog);
3992 }
3993
3994 bool
3995 target_ops::supports_delete_record ()
3996 {
3997   return this->beneath ()->supports_delete_record ();
3998 }
3999
4000 bool
4001 dummy_target::supports_delete_record ()
4002 {
4003   return false;
4004 }
4005
4006 bool
4007 debug_target::supports_delete_record ()
4008 {
4009   bool result;
4010   fprintf_unfiltered (gdb_stdlog, "-> %s->supports_delete_record (...)\n", this->beneath ()->shortname ());
4011   result = this->beneath ()->supports_delete_record ();
4012   fprintf_unfiltered (gdb_stdlog, "<- %s->supports_delete_record (", this->beneath ()->shortname ());
4013   fputs_unfiltered (") = ", gdb_stdlog);
4014   target_debug_print_bool (result);
4015   fputs_unfiltered ("\n", gdb_stdlog);
4016   return result;
4017 }
4018
4019 void
4020 target_ops::delete_record ()
4021 {
4022   this->beneath ()->delete_record ();
4023 }
4024
4025 void
4026 dummy_target::delete_record ()
4027 {
4028   tcomplain ();
4029 }
4030
4031 void
4032 debug_target::delete_record ()
4033 {
4034   fprintf_unfiltered (gdb_stdlog, "-> %s->delete_record (...)\n", this->beneath ()->shortname ());
4035   this->beneath ()->delete_record ();
4036   fprintf_unfiltered (gdb_stdlog, "<- %s->delete_record (", this->beneath ()->shortname ());
4037   fputs_unfiltered (")\n", gdb_stdlog);
4038 }
4039
4040 bool
4041 target_ops::record_is_replaying (ptid_t arg0)
4042 {
4043   return this->beneath ()->record_is_replaying (arg0);
4044 }
4045
4046 bool
4047 dummy_target::record_is_replaying (ptid_t arg0)
4048 {
4049   return false;
4050 }
4051
4052 bool
4053 debug_target::record_is_replaying (ptid_t arg0)
4054 {
4055   bool result;
4056   fprintf_unfiltered (gdb_stdlog, "-> %s->record_is_replaying (...)\n", this->beneath ()->shortname ());
4057   result = this->beneath ()->record_is_replaying (arg0);
4058   fprintf_unfiltered (gdb_stdlog, "<- %s->record_is_replaying (", this->beneath ()->shortname ());
4059   target_debug_print_ptid_t (arg0);
4060   fputs_unfiltered (") = ", gdb_stdlog);
4061   target_debug_print_bool (result);
4062   fputs_unfiltered ("\n", gdb_stdlog);
4063   return result;
4064 }
4065
4066 bool
4067 target_ops::record_will_replay (ptid_t arg0, int arg1)
4068 {
4069   return this->beneath ()->record_will_replay (arg0, arg1);
4070 }
4071
4072 bool
4073 dummy_target::record_will_replay (ptid_t arg0, int arg1)
4074 {
4075   return false;
4076 }
4077
4078 bool
4079 debug_target::record_will_replay (ptid_t arg0, int arg1)
4080 {
4081   bool result;
4082   fprintf_unfiltered (gdb_stdlog, "-> %s->record_will_replay (...)\n", this->beneath ()->shortname ());
4083   result = this->beneath ()->record_will_replay (arg0, arg1);
4084   fprintf_unfiltered (gdb_stdlog, "<- %s->record_will_replay (", this->beneath ()->shortname ());
4085   target_debug_print_ptid_t (arg0);
4086   fputs_unfiltered (", ", gdb_stdlog);
4087   target_debug_print_int (arg1);
4088   fputs_unfiltered (") = ", gdb_stdlog);
4089   target_debug_print_bool (result);
4090   fputs_unfiltered ("\n", gdb_stdlog);
4091   return result;
4092 }
4093
4094 void
4095 target_ops::record_stop_replaying ()
4096 {
4097   this->beneath ()->record_stop_replaying ();
4098 }
4099
4100 void
4101 dummy_target::record_stop_replaying ()
4102 {
4103 }
4104
4105 void
4106 debug_target::record_stop_replaying ()
4107 {
4108   fprintf_unfiltered (gdb_stdlog, "-> %s->record_stop_replaying (...)\n", this->beneath ()->shortname ());
4109   this->beneath ()->record_stop_replaying ();
4110   fprintf_unfiltered (gdb_stdlog, "<- %s->record_stop_replaying (", this->beneath ()->shortname ());
4111   fputs_unfiltered (")\n", gdb_stdlog);
4112 }
4113
4114 void
4115 target_ops::goto_record_begin ()
4116 {
4117   this->beneath ()->goto_record_begin ();
4118 }
4119
4120 void
4121 dummy_target::goto_record_begin ()
4122 {
4123   tcomplain ();
4124 }
4125
4126 void
4127 debug_target::goto_record_begin ()
4128 {
4129   fprintf_unfiltered (gdb_stdlog, "-> %s->goto_record_begin (...)\n", this->beneath ()->shortname ());
4130   this->beneath ()->goto_record_begin ();
4131   fprintf_unfiltered (gdb_stdlog, "<- %s->goto_record_begin (", this->beneath ()->shortname ());
4132   fputs_unfiltered (")\n", gdb_stdlog);
4133 }
4134
4135 void
4136 target_ops::goto_record_end ()
4137 {
4138   this->beneath ()->goto_record_end ();
4139 }
4140
4141 void
4142 dummy_target::goto_record_end ()
4143 {
4144   tcomplain ();
4145 }
4146
4147 void
4148 debug_target::goto_record_end ()
4149 {
4150   fprintf_unfiltered (gdb_stdlog, "-> %s->goto_record_end (...)\n", this->beneath ()->shortname ());
4151   this->beneath ()->goto_record_end ();
4152   fprintf_unfiltered (gdb_stdlog, "<- %s->goto_record_end (", this->beneath ()->shortname ());
4153   fputs_unfiltered (")\n", gdb_stdlog);
4154 }
4155
4156 void
4157 target_ops::goto_record (ULONGEST arg0)
4158 {
4159   this->beneath ()->goto_record (arg0);
4160 }
4161
4162 void
4163 dummy_target::goto_record (ULONGEST arg0)
4164 {
4165   tcomplain ();
4166 }
4167
4168 void
4169 debug_target::goto_record (ULONGEST arg0)
4170 {
4171   fprintf_unfiltered (gdb_stdlog, "-> %s->goto_record (...)\n", this->beneath ()->shortname ());
4172   this->beneath ()->goto_record (arg0);
4173   fprintf_unfiltered (gdb_stdlog, "<- %s->goto_record (", this->beneath ()->shortname ());
4174   target_debug_print_ULONGEST (arg0);
4175   fputs_unfiltered (")\n", gdb_stdlog);
4176 }
4177
4178 void
4179 target_ops::insn_history (int arg0, gdb_disassembly_flags arg1)
4180 {
4181   this->beneath ()->insn_history (arg0, arg1);
4182 }
4183
4184 void
4185 dummy_target::insn_history (int arg0, gdb_disassembly_flags arg1)
4186 {
4187   tcomplain ();
4188 }
4189
4190 void
4191 debug_target::insn_history (int arg0, gdb_disassembly_flags arg1)
4192 {
4193   fprintf_unfiltered (gdb_stdlog, "-> %s->insn_history (...)\n", this->beneath ()->shortname ());
4194   this->beneath ()->insn_history (arg0, arg1);
4195   fprintf_unfiltered (gdb_stdlog, "<- %s->insn_history (", this->beneath ()->shortname ());
4196   target_debug_print_int (arg0);
4197   fputs_unfiltered (", ", gdb_stdlog);
4198   target_debug_print_gdb_disassembly_flags (arg1);
4199   fputs_unfiltered (")\n", gdb_stdlog);
4200 }
4201
4202 void
4203 target_ops::insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2)
4204 {
4205   this->beneath ()->insn_history_from (arg0, arg1, arg2);
4206 }
4207
4208 void
4209 dummy_target::insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2)
4210 {
4211   tcomplain ();
4212 }
4213
4214 void
4215 debug_target::insn_history_from (ULONGEST arg0, int arg1, gdb_disassembly_flags arg2)
4216 {
4217   fprintf_unfiltered (gdb_stdlog, "-> %s->insn_history_from (...)\n", this->beneath ()->shortname ());
4218   this->beneath ()->insn_history_from (arg0, arg1, arg2);
4219   fprintf_unfiltered (gdb_stdlog, "<- %s->insn_history_from (", this->beneath ()->shortname ());
4220   target_debug_print_ULONGEST (arg0);
4221   fputs_unfiltered (", ", gdb_stdlog);
4222   target_debug_print_int (arg1);
4223   fputs_unfiltered (", ", gdb_stdlog);
4224   target_debug_print_gdb_disassembly_flags (arg2);
4225   fputs_unfiltered (")\n", gdb_stdlog);
4226 }
4227
4228 void
4229 target_ops::insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2)
4230 {
4231   this->beneath ()->insn_history_range (arg0, arg1, arg2);
4232 }
4233
4234 void
4235 dummy_target::insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2)
4236 {
4237   tcomplain ();
4238 }
4239
4240 void
4241 debug_target::insn_history_range (ULONGEST arg0, ULONGEST arg1, gdb_disassembly_flags arg2)
4242 {
4243   fprintf_unfiltered (gdb_stdlog, "-> %s->insn_history_range (...)\n", this->beneath ()->shortname ());
4244   this->beneath ()->insn_history_range (arg0, arg1, arg2);
4245   fprintf_unfiltered (gdb_stdlog, "<- %s->insn_history_range (", this->beneath ()->shortname ());
4246   target_debug_print_ULONGEST (arg0);
4247   fputs_unfiltered (", ", gdb_stdlog);
4248   target_debug_print_ULONGEST (arg1);
4249   fputs_unfiltered (", ", gdb_stdlog);
4250   target_debug_print_gdb_disassembly_flags (arg2);
4251   fputs_unfiltered (")\n", gdb_stdlog);
4252 }
4253
4254 void
4255 target_ops::call_history (int arg0, record_print_flags arg1)
4256 {
4257   this->beneath ()->call_history (arg0, arg1);
4258 }
4259
4260 void
4261 dummy_target::call_history (int arg0, record_print_flags arg1)
4262 {
4263   tcomplain ();
4264 }
4265
4266 void
4267 debug_target::call_history (int arg0, record_print_flags arg1)
4268 {
4269   fprintf_unfiltered (gdb_stdlog, "-> %s->call_history (...)\n", this->beneath ()->shortname ());
4270   this->beneath ()->call_history (arg0, arg1);
4271   fprintf_unfiltered (gdb_stdlog, "<- %s->call_history (", this->beneath ()->shortname ());
4272   target_debug_print_int (arg0);
4273   fputs_unfiltered (", ", gdb_stdlog);
4274   target_debug_print_record_print_flags (arg1);
4275   fputs_unfiltered (")\n", gdb_stdlog);
4276 }
4277
4278 void
4279 target_ops::call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2)
4280 {
4281   this->beneath ()->call_history_from (arg0, arg1, arg2);
4282 }
4283
4284 void
4285 dummy_target::call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2)
4286 {
4287   tcomplain ();
4288 }
4289
4290 void
4291 debug_target::call_history_from (ULONGEST arg0, int arg1, record_print_flags arg2)
4292 {
4293   fprintf_unfiltered (gdb_stdlog, "-> %s->call_history_from (...)\n", this->beneath ()->shortname ());
4294   this->beneath ()->call_history_from (arg0, arg1, arg2);
4295   fprintf_unfiltered (gdb_stdlog, "<- %s->call_history_from (", this->beneath ()->shortname ());
4296   target_debug_print_ULONGEST (arg0);
4297   fputs_unfiltered (", ", gdb_stdlog);
4298   target_debug_print_int (arg1);
4299   fputs_unfiltered (", ", gdb_stdlog);
4300   target_debug_print_record_print_flags (arg2);
4301   fputs_unfiltered (")\n", gdb_stdlog);
4302 }
4303
4304 void
4305 target_ops::call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2)
4306 {
4307   this->beneath ()->call_history_range (arg0, arg1, arg2);
4308 }
4309
4310 void
4311 dummy_target::call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2)
4312 {
4313   tcomplain ();
4314 }
4315
4316 void
4317 debug_target::call_history_range (ULONGEST arg0, ULONGEST arg1, record_print_flags arg2)
4318 {
4319   fprintf_unfiltered (gdb_stdlog, "-> %s->call_history_range (...)\n", this->beneath ()->shortname ());
4320   this->beneath ()->call_history_range (arg0, arg1, arg2);
4321   fprintf_unfiltered (gdb_stdlog, "<- %s->call_history_range (", this->beneath ()->shortname ());
4322   target_debug_print_ULONGEST (arg0);
4323   fputs_unfiltered (", ", gdb_stdlog);
4324   target_debug_print_ULONGEST (arg1);
4325   fputs_unfiltered (", ", gdb_stdlog);
4326   target_debug_print_record_print_flags (arg2);
4327   fputs_unfiltered (")\n", gdb_stdlog);
4328 }
4329
4330 bool
4331 target_ops::augmented_libraries_svr4_read ()
4332 {
4333   return this->beneath ()->augmented_libraries_svr4_read ();
4334 }
4335
4336 bool
4337 dummy_target::augmented_libraries_svr4_read ()
4338 {
4339   return false;
4340 }
4341
4342 bool
4343 debug_target::augmented_libraries_svr4_read ()
4344 {
4345   bool result;
4346   fprintf_unfiltered (gdb_stdlog, "-> %s->augmented_libraries_svr4_read (...)\n", this->beneath ()->shortname ());
4347   result = this->beneath ()->augmented_libraries_svr4_read ();
4348   fprintf_unfiltered (gdb_stdlog, "<- %s->augmented_libraries_svr4_read (", this->beneath ()->shortname ());
4349   fputs_unfiltered (") = ", gdb_stdlog);
4350   target_debug_print_bool (result);
4351   fputs_unfiltered ("\n", gdb_stdlog);
4352   return result;
4353 }
4354
4355 const struct frame_unwind *
4356 target_ops::get_unwinder ()
4357 {
4358   return this->beneath ()->get_unwinder ();
4359 }
4360
4361 const struct frame_unwind *
4362 dummy_target::get_unwinder ()
4363 {
4364   return NULL;
4365 }
4366
4367 const struct frame_unwind *
4368 debug_target::get_unwinder ()
4369 {
4370   const struct frame_unwind * result;
4371   fprintf_unfiltered (gdb_stdlog, "-> %s->get_unwinder (...)\n", this->beneath ()->shortname ());
4372   result = this->beneath ()->get_unwinder ();
4373   fprintf_unfiltered (gdb_stdlog, "<- %s->get_unwinder (", this->beneath ()->shortname ());
4374   fputs_unfiltered (") = ", gdb_stdlog);
4375   target_debug_print_const_struct_frame_unwind_p (result);
4376   fputs_unfiltered ("\n", gdb_stdlog);
4377   return result;
4378 }
4379
4380 const struct frame_unwind *
4381 target_ops::get_tailcall_unwinder ()
4382 {
4383   return this->beneath ()->get_tailcall_unwinder ();
4384 }
4385
4386 const struct frame_unwind *
4387 dummy_target::get_tailcall_unwinder ()
4388 {
4389   return NULL;
4390 }
4391
4392 const struct frame_unwind *
4393 debug_target::get_tailcall_unwinder ()
4394 {
4395   const struct frame_unwind * result;
4396   fprintf_unfiltered (gdb_stdlog, "-> %s->get_tailcall_unwinder (...)\n", this->beneath ()->shortname ());
4397   result = this->beneath ()->get_tailcall_unwinder ();
4398   fprintf_unfiltered (gdb_stdlog, "<- %s->get_tailcall_unwinder (", this->beneath ()->shortname ());
4399   fputs_unfiltered (") = ", gdb_stdlog);
4400   target_debug_print_const_struct_frame_unwind_p (result);
4401   fputs_unfiltered ("\n", gdb_stdlog);
4402   return result;
4403 }
4404
4405 void
4406 target_ops::prepare_to_generate_core ()
4407 {
4408   this->beneath ()->prepare_to_generate_core ();
4409 }
4410
4411 void
4412 dummy_target::prepare_to_generate_core ()
4413 {
4414 }
4415
4416 void
4417 debug_target::prepare_to_generate_core ()
4418 {
4419   fprintf_unfiltered (gdb_stdlog, "-> %s->prepare_to_generate_core (...)\n", this->beneath ()->shortname ());
4420   this->beneath ()->prepare_to_generate_core ();
4421   fprintf_unfiltered (gdb_stdlog, "<- %s->prepare_to_generate_core (", this->beneath ()->shortname ());
4422   fputs_unfiltered (")\n", gdb_stdlog);
4423 }
4424
4425 void
4426 target_ops::done_generating_core ()
4427 {
4428   this->beneath ()->done_generating_core ();
4429 }
4430
4431 void
4432 dummy_target::done_generating_core ()
4433 {
4434 }
4435
4436 void
4437 debug_target::done_generating_core ()
4438 {
4439   fprintf_unfiltered (gdb_stdlog, "-> %s->done_generating_core (...)\n", this->beneath ()->shortname ());
4440   this->beneath ()->done_generating_core ();
4441   fprintf_unfiltered (gdb_stdlog, "<- %s->done_generating_core (", this->beneath ()->shortname ());
4442   fputs_unfiltered (")\n", gdb_stdlog);
4443 }
4444
4445 bool
4446 target_ops::supports_memory_tagging ()
4447 {
4448   return this->beneath ()->supports_memory_tagging ();
4449 }
4450
4451 bool
4452 dummy_target::supports_memory_tagging ()
4453 {
4454   return false;
4455 }
4456
4457 bool
4458 debug_target::supports_memory_tagging ()
4459 {
4460   bool result;
4461   fprintf_unfiltered (gdb_stdlog, "-> %s->supports_memory_tagging (...)\n", this->beneath ()->shortname ());
4462   result = this->beneath ()->supports_memory_tagging ();
4463   fprintf_unfiltered (gdb_stdlog, "<- %s->supports_memory_tagging (", this->beneath ()->shortname ());
4464   fputs_unfiltered (") = ", gdb_stdlog);
4465   target_debug_print_bool (result);
4466   fputs_unfiltered ("\n", gdb_stdlog);
4467   return result;
4468 }
4469
4470 bool
4471 target_ops::fetch_memtags (CORE_ADDR arg0, size_t arg1, gdb::byte_vector &arg2, int arg3)
4472 {
4473   return this->beneath ()->fetch_memtags (arg0, arg1, arg2, arg3);
4474 }
4475
4476 bool
4477 dummy_target::fetch_memtags (CORE_ADDR arg0, size_t arg1, gdb::byte_vector &arg2, int arg3)
4478 {
4479   tcomplain ();
4480 }
4481
4482 bool
4483 debug_target::fetch_memtags (CORE_ADDR arg0, size_t arg1, gdb::byte_vector &arg2, int arg3)
4484 {
4485   bool result;
4486   fprintf_unfiltered (gdb_stdlog, "-> %s->fetch_memtags (...)\n", this->beneath ()->shortname ());
4487   result = this->beneath ()->fetch_memtags (arg0, arg1, arg2, arg3);
4488   fprintf_unfiltered (gdb_stdlog, "<- %s->fetch_memtags (", this->beneath ()->shortname ());
4489   target_debug_print_CORE_ADDR (arg0);
4490   fputs_unfiltered (", ", gdb_stdlog);
4491   target_debug_print_size_t (arg1);
4492   fputs_unfiltered (", ", gdb_stdlog);
4493   target_debug_print_gdb_byte_vector_r (arg2);
4494   fputs_unfiltered (", ", gdb_stdlog);
4495   target_debug_print_int (arg3);
4496   fputs_unfiltered (") = ", gdb_stdlog);
4497   target_debug_print_bool (result);
4498   fputs_unfiltered ("\n", gdb_stdlog);
4499   return result;
4500 }
4501
4502 bool
4503 target_ops::store_memtags (CORE_ADDR arg0, size_t arg1, const gdb::byte_vector &arg2, int arg3)
4504 {
4505   return this->beneath ()->store_memtags (arg0, arg1, arg2, arg3);
4506 }
4507
4508 bool
4509 dummy_target::store_memtags (CORE_ADDR arg0, size_t arg1, const gdb::byte_vector &arg2, int arg3)
4510 {
4511   tcomplain ();
4512 }
4513
4514 bool
4515 debug_target::store_memtags (CORE_ADDR arg0, size_t arg1, const gdb::byte_vector &arg2, int arg3)
4516 {
4517   bool result;
4518   fprintf_unfiltered (gdb_stdlog, "-> %s->store_memtags (...)\n", this->beneath ()->shortname ());
4519   result = this->beneath ()->store_memtags (arg0, arg1, arg2, arg3);
4520   fprintf_unfiltered (gdb_stdlog, "<- %s->store_memtags (", this->beneath ()->shortname ());
4521   target_debug_print_CORE_ADDR (arg0);
4522   fputs_unfiltered (", ", gdb_stdlog);
4523   target_debug_print_size_t (arg1);
4524   fputs_unfiltered (", ", gdb_stdlog);
4525   target_debug_print_const_gdb_byte_vector_r (arg2);
4526   fputs_unfiltered (", ", gdb_stdlog);
4527   target_debug_print_int (arg3);
4528   fputs_unfiltered (") = ", gdb_stdlog);
4529   target_debug_print_bool (result);
4530   fputs_unfiltered ("\n", gdb_stdlog);
4531   return result;
4532 }
4533