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