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