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