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