GDB (xrefs)

/tmp/gdb-8.1/gdb/target-delegates.c
Go to the documentation of this file.
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 static void
7 delegate_post_attach (struct target_ops *self, int arg1)
8 {
9 self = self->beneath;
10 self->to_post_attach (self, arg1);
11 }
12
13 static void
14 tdefault_post_attach (struct target_ops *self, int arg1)
15 {
16 }
17
18 static void
19 debug_post_attach (struct target_ops *self, int arg1)
20 {
21 fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", debug_target.to_shortname);
22 debug_target.to_post_attach (&debug_target, arg1);
23 fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", debug_target.to_shortname);
24 target_debug_print_struct_target_ops_p (&debug_target);
25 fputs_unfiltered (", ", gdb_stdlog);
26 target_debug_print_int (arg1);
27 fputs_unfiltered (")\n", gdb_stdlog);
28 }
29
30 static void
31 delegate_detach (struct target_ops *self, const char *arg1, int arg2)
32 {
33 self = self->beneath;
34 self->to_detach (self, arg1, arg2);
35 }
36
37 static void
38 tdefault_detach (struct target_ops *self, const char *arg1, int arg2)
39 {
40 }
41
42 static void
43 debug_detach (struct target_ops *self, const char *arg1, int arg2)
44 {
45 fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", debug_target.to_shortname);
46 debug_target.to_detach (&debug_target, arg1, arg2);
47 fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", debug_target.to_shortname);
48 target_debug_print_struct_target_ops_p (&debug_target);
49 fputs_unfiltered (", ", gdb_stdlog);
50 target_debug_print_const_char_p (arg1);
51 fputs_unfiltered (", ", gdb_stdlog);
52 target_debug_print_int (arg2);
53 fputs_unfiltered (")\n", gdb_stdlog);
54 }
55
56 static void
57 delegate_disconnect (struct target_ops *self, const char *arg1, int arg2)
58 {
59 self = self->beneath;
60 self->to_disconnect (self, arg1, arg2);
61 }
62
63 static void
64 tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
65 {
66 tcomplain ();
67 }
68
69 static void
70 debug_disconnect (struct target_ops *self, const char *arg1, int arg2)
71 {
72 fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", debug_target.to_shortname);
73 debug_target.to_disconnect (&debug_target, arg1, arg2);
74 fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", debug_target.to_shortname);
75 target_debug_print_struct_target_ops_p (&debug_target);
76 fputs_unfiltered (", ", gdb_stdlog);
77 target_debug_print_const_char_p (arg1);
78 fputs_unfiltered (", ", gdb_stdlog);
79 target_debug_print_int (arg2);
80 fputs_unfiltered (")\n", gdb_stdlog);
81 }
82
83 static void
84 delegate_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
85 {
86 self = self->beneath;
87 self->to_resume (self, arg1, arg2, arg3);
88 }
89
90 static void
91 tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
92 {
93 noprocess ();
94 }
95
96 static void
97 debug_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
98 {
99 fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", debug_target.to_shortname);
100 debug_target.to_resume (&debug_target, arg1, arg2, arg3);
101 fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", debug_target.to_shortname);
102 target_debug_print_struct_target_ops_p (&debug_target);
103 fputs_unfiltered (", ", gdb_stdlog);
104 target_debug_print_ptid_t (arg1);
105 fputs_unfiltered (", ", gdb_stdlog);
106 target_debug_print_step (arg2);
107 fputs_unfiltered (", ", gdb_stdlog);
108 target_debug_print_enum_gdb_signal (arg3);
109 fputs_unfiltered (")\n", gdb_stdlog);
110 }
111
112 static void
113 delegate_commit_resume (struct target_ops *self)
114 {
115 self = self->beneath;
116 self->to_commit_resume (self);
117 }
118
119 static void
120 tdefault_commit_resume (struct target_ops *self)
121 {
122 }
123
124 static void
125 debug_commit_resume (struct target_ops *self)
126 {
127 fprintf_unfiltered (gdb_stdlog, "-> %s->to_commit_resume (...)\n", debug_target.to_shortname);
128 debug_target.to_commit_resume (&debug_target);
129 fprintf_unfiltered (gdb_stdlog, "<- %s->to_commit_resume (", debug_target.to_shortname);
130 target_debug_print_struct_target_ops_p (&debug_target);
131 fputs_unfiltered (")\n", gdb_stdlog);
132 }
133
134 static ptid_t
135 delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
136 {
137 self = self->beneath;
138 return self->to_wait (self, arg1, arg2, arg3);
139 }
140
141 static ptid_t
142 debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
143 {
144 ptid_t result;
145 fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", debug_target.to_shortname);
146 result = debug_target.to_wait (&debug_target, arg1, arg2, arg3);
147 fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", debug_target.to_shortname);
148 target_debug_print_struct_target_ops_p (&debug_target);
149 fputs_unfiltered (", ", gdb_stdlog);
150 target_debug_print_ptid_t (arg1);
151 fputs_unfiltered (", ", gdb_stdlog);
152 target_debug_print_struct_target_waitstatus_p (arg2);
153 fputs_unfiltered (", ", gdb_stdlog);
154 target_debug_print_options (arg3);
155 fputs_unfiltered (") = ", gdb_stdlog);
156 target_debug_print_ptid_t (result);
157 fputs_unfiltered ("\n", gdb_stdlog);
158 return result;
159 }
160
161 static void
162 delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
163 {
164 self = self->beneath;
165 self->to_fetch_registers (self, arg1, arg2);
166 }
167
168 static void
169 tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
170 {
171 }
172
173 static void
174 debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
175 {
176 fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname);
177 debug_target.to_fetch_registers (&debug_target, arg1, arg2);
178 fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname);
179 target_debug_print_struct_target_ops_p (&debug_target);
180 fputs_unfiltered (", ", gdb_stdlog);
181 target_debug_print_struct_regcache_p (arg1);
182 fputs_unfiltered (", ", gdb_stdlog);
183 target_debug_print_int (arg2);
184 fputs_unfiltered (")\n", gdb_stdlog);
185 }
186
187 static void
188 delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
189 {
190 self = self->beneath;
191 self->to_store_registers (self, arg1, arg2);
192 }
193
194 static void
195 tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
196 {
197 noprocess ();
198 }
199
200 static void
201 debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
202 {
203 fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
204 debug_target.to_store_registers (&debug_target, arg1, arg2);
205 fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname);
206 target_debug_print_struct_target_ops_p (&debug_target);
207 fputs_unfiltered (", ", gdb_stdlog);
208 target_debug_print_struct_regcache_p (arg1);
209 fputs_unfiltered (", ", gdb_stdlog);
210 target_debug_print_int (arg2);
211 fputs_unfiltered (")\n", gdb_stdlog);
212 }
213
214 static void
215 delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
216 {
217 self = self->beneath;
218 self->to_prepare_to_store (self, arg1);
219 }
220
221 static void
222 tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
223 {
224 noprocess ();
225 }
226
227 static void
228 debug_prepare_to_store (struct target_ops *self, struct regcache *arg1)
229 {
230 fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", debug_target.to_shortname);
231 debug_target.to_prepare_to_store (&debug_target, arg1);
232 fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", debug_target.to_shortname);
233 target_debug_print_struct_target_ops_p (&debug_target);
234 fputs_unfiltered (", ", gdb_stdlog);
235 target_debug_print_struct_regcache_p (arg1);
236 fputs_unfiltered (")\n", gdb_stdlog);
237 }
238
239 static void
240 delegate_files_info (struct target_ops *self)
241 {
242 self = self->beneath;
243 self->to_files_info (self);
244 }
245
246 static void
247 tdefault_files_info (struct target_ops *self)
248 {
249 }
250
251 static void
252 debug_files_info (struct target_ops *self)
253 {
254 fprintf_unfiltered (gdb_stdlog, "-> %s->to_files_info (...)\n", debug_target.to_shortname);
255 debug_target.to_files_info (&debug_target);
256 fprintf_unfiltered (gdb_stdlog, "<- %s->to_files_info (", debug_target.to_shortname);
257 target_debug_print_struct_target_ops_p (&debug_target);
258 fputs_unfiltered (")\n", gdb_stdlog);
259 }
260
261 static int
262 delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
263 {
264 self = self->beneath;
265 return self->to_insert_breakpoint (self, arg1, arg2);
266 }
267
268 static int
269 debug_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
270 {
271 int result;
272 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_breakpoint (...)\n", debug_target.to_shortname);
273 result = debug_target.to_insert_breakpoint (&debug_target, arg1, arg2);
274 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_breakpoint (", debug_target.to_shortname);
275 target_debug_print_struct_target_ops_p (&debug_target);
276 fputs_unfiltered (", ", gdb_stdlog);
277 target_debug_print_struct_gdbarch_p (arg1);
278 fputs_unfiltered (", ", gdb_stdlog);
279 target_debug_print_struct_bp_target_info_p (arg2);
280 fputs_unfiltered (") = ", gdb_stdlog);
281 target_debug_print_int (result);
282 fputs_unfiltered ("\n", gdb_stdlog);
283 return result;
284 }
285
286 static int
287 delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2, enum remove_bp_reason arg3)
288 {
289 self = self->beneath;
290 return self->to_remove_breakpoint (self, arg1, arg2, arg3);
291 }
292
293 static int
294 debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2, enum remove_bp_reason arg3)
295 {
296 int result;
297 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", debug_target.to_shortname);
298 result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2, arg3);
299 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", debug_target.to_shortname);
300 target_debug_print_struct_target_ops_p (&debug_target);
301 fputs_unfiltered (", ", gdb_stdlog);
302 target_debug_print_struct_gdbarch_p (arg1);
303 fputs_unfiltered (", ", gdb_stdlog);
304 target_debug_print_struct_bp_target_info_p (arg2);
305 fputs_unfiltered (", ", gdb_stdlog);
306 target_debug_print_enum_remove_bp_reason (arg3);
307 fputs_unfiltered (") = ", gdb_stdlog);
308 target_debug_print_int (result);
309 fputs_unfiltered ("\n", gdb_stdlog);
310 return result;
311 }
312
313 static int
314 delegate_stopped_by_sw_breakpoint (struct target_ops *self)
315 {
316 self = self->beneath;
317 return self->to_stopped_by_sw_breakpoint (self);
318 }
319
320 static int
321 tdefault_stopped_by_sw_breakpoint (struct target_ops *self)
322 {
323 return 0;
324 }
325
326 static int
327 debug_stopped_by_sw_breakpoint (struct target_ops *self)
328 {
329 int result;
330 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname);
331 result = debug_target.to_stopped_by_sw_breakpoint (&debug_target);
332 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_sw_breakpoint (", debug_target.to_shortname);
333 target_debug_print_struct_target_ops_p (&debug_target);
334 fputs_unfiltered (") = ", gdb_stdlog);
335 target_debug_print_int (result);
336 fputs_unfiltered ("\n", gdb_stdlog);
337 return result;
338 }
339
340 static int
341 delegate_supports_stopped_by_sw_breakpoint (struct target_ops *self)
342 {
343 self = self->beneath;
344 return self->to_supports_stopped_by_sw_breakpoint (self);
345 }
346
347 static int
348 tdefault_supports_stopped_by_sw_breakpoint (struct target_ops *self)
349 {
350 return 0;
351 }
352
353 static int
354 debug_supports_stopped_by_sw_breakpoint (struct target_ops *self)
355 {
356 int result;
357 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname);
358 result = debug_target.to_supports_stopped_by_sw_breakpoint (&debug_target);
359 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_sw_breakpoint (", debug_target.to_shortname);
360 target_debug_print_struct_target_ops_p (&debug_target);
361 fputs_unfiltered (") = ", gdb_stdlog);
362 target_debug_print_int (result);
363 fputs_unfiltered ("\n", gdb_stdlog);
364 return result;
365 }
366
367 static int
368 delegate_stopped_by_hw_breakpoint (struct target_ops *self)
369 {
370 self = self->beneath;
371 return self->to_stopped_by_hw_breakpoint (self);
372 }
373
374 static int
375 tdefault_stopped_by_hw_breakpoint (struct target_ops *self)
376 {
377 return 0;
378 }
379
380 static int
381 debug_stopped_by_hw_breakpoint (struct target_ops *self)
382 {
383 int result;
384 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname);
385 result = debug_target.to_stopped_by_hw_breakpoint (&debug_target);
386 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_hw_breakpoint (", debug_target.to_shortname);
387 target_debug_print_struct_target_ops_p (&debug_target);
388 fputs_unfiltered (") = ", gdb_stdlog);
389 target_debug_print_int (result);
390 fputs_unfiltered ("\n", gdb_stdlog);
391 return result;
392 }
393
394 static int
395 delegate_supports_stopped_by_hw_breakpoint (struct target_ops *self)
396 {
397 self = self->beneath;
398 return self->to_supports_stopped_by_hw_breakpoint (self);
399 }
400
401 static int
402 tdefault_supports_stopped_by_hw_breakpoint (struct target_ops *self)
403 {
404 return 0;
405 }
406
407 static int
408 debug_supports_stopped_by_hw_breakpoint (struct target_ops *self)
409 {
410 int result;
411 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname);
412 result = debug_target.to_supports_stopped_by_hw_breakpoint (&debug_target);
413 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_hw_breakpoint (", debug_target.to_shortname);
414 target_debug_print_struct_target_ops_p (&debug_target);
415 fputs_unfiltered (") = ", gdb_stdlog);
416 target_debug_print_int (result);
417 fputs_unfiltered ("\n", gdb_stdlog);
418 return result;
419 }
420
421 static int
422 delegate_can_use_hw_breakpoint (struct target_ops *self, enum bptype arg1, int arg2, int arg3)
423 {
424 self = self->beneath;
425 return self->to_can_use_hw_breakpoint (self, arg1, arg2, arg3);
426 }
427
428 static int
429 tdefault_can_use_hw_breakpoint (struct target_ops *self, enum bptype arg1, int arg2, int arg3)
430 {
431 return 0;
432 }
433
434 static int
435 debug_can_use_hw_breakpoint (struct target_ops *self, enum bptype arg1, int arg2, int arg3)
436 {
437 int result;
438 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", debug_target.to_shortname);
439 result = debug_target.to_can_use_hw_breakpoint (&debug_target, arg1, arg2, arg3);
440 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", debug_target.to_shortname);
441 target_debug_print_struct_target_ops_p (&debug_target);
442 fputs_unfiltered (", ", gdb_stdlog);
443 target_debug_print_enum_bptype (arg1);
444 fputs_unfiltered (", ", gdb_stdlog);
445 target_debug_print_int (arg2);
446 fputs_unfiltered (", ", gdb_stdlog);
447 target_debug_print_int (arg3);
448 fputs_unfiltered (") = ", gdb_stdlog);
449 target_debug_print_int (result);
450 fputs_unfiltered ("\n", gdb_stdlog);
451 return result;
452 }
453
454 static int
455 delegate_ranged_break_num_registers (struct target_ops *self)
456 {
457 self = self->beneath;
458 return self->to_ranged_break_num_registers (self);
459 }
460
461 static int
462 tdefault_ranged_break_num_registers (struct target_ops *self)
463 {
464 return -1;
465 }
466
467 static int
468 debug_ranged_break_num_registers (struct target_ops *self)
469 {
470 int result;
471 fprintf_unfiltered (gdb_stdlog, "-> %s->to_ranged_break_num_registers (...)\n", debug_target.to_shortname);
472 result = debug_target.to_ranged_break_num_registers (&debug_target);
473 fprintf_unfiltered (gdb_stdlog, "<- %s->to_ranged_break_num_registers (", debug_target.to_shortname);
474 target_debug_print_struct_target_ops_p (&debug_target);
475 fputs_unfiltered (") = ", gdb_stdlog);
476 target_debug_print_int (result);
477 fputs_unfiltered ("\n", gdb_stdlog);
478 return result;
479 }
480
481 static int
482 delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
483 {
484 self = self->beneath;
485 return self->to_insert_hw_breakpoint (self, arg1, arg2);
486 }
487
488 static int
489 tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
490 {
491 return -1;
492 }
493
494 static int
495 debug_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
496 {
497 int result;
498 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_hw_breakpoint (...)\n", debug_target.to_shortname);
499 result = debug_target.to_insert_hw_breakpoint (&debug_target, arg1, arg2);
500 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_hw_breakpoint (", debug_target.to_shortname);
501 target_debug_print_struct_target_ops_p (&debug_target);
502 fputs_unfiltered (", ", gdb_stdlog);
503 target_debug_print_struct_gdbarch_p (arg1);
504 fputs_unfiltered (", ", gdb_stdlog);
505 target_debug_print_struct_bp_target_info_p (arg2);
506 fputs_unfiltered (") = ", gdb_stdlog);
507 target_debug_print_int (result);
508 fputs_unfiltered ("\n", gdb_stdlog);
509 return result;
510 }
511
512 static int
513 delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
514 {
515 self = self->beneath;
516 return self->to_remove_hw_breakpoint (self, arg1, arg2);
517 }
518
519 static int
520 tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
521 {
522 return -1;
523 }
524
525 static int
526 debug_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
527 {
528 int result;
529 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_hw_breakpoint (...)\n", debug_target.to_shortname);
530 result = debug_target.to_remove_hw_breakpoint (&debug_target, arg1, arg2);
531 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_hw_breakpoint (", debug_target.to_shortname);
532 target_debug_print_struct_target_ops_p (&debug_target);
533 fputs_unfiltered (", ", gdb_stdlog);
534 target_debug_print_struct_gdbarch_p (arg1);
535 fputs_unfiltered (", ", gdb_stdlog);
536 target_debug_print_struct_bp_target_info_p (arg2);
537 fputs_unfiltered (") = ", gdb_stdlog);
538 target_debug_print_int (result);
539 fputs_unfiltered ("\n", gdb_stdlog);
540 return result;
541 }
542
543 static int
544 delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
545 {
546 self = self->beneath;
547 return self->to_remove_watchpoint (self, arg1, arg2, arg3, arg4);
548 }
549
550 static int
551 tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
552 {
553 return -1;
554 }
555
556 static int
557 debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
558 {
559 int result;
560 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", debug_target.to_shortname);
561 result = debug_target.to_remove_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
562 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", debug_target.to_shortname);
563 target_debug_print_struct_target_ops_p (&debug_target);
564 fputs_unfiltered (", ", gdb_stdlog);
565 target_debug_print_CORE_ADDR (arg1);
566 fputs_unfiltered (", ", gdb_stdlog);
567 target_debug_print_int (arg2);
568 fputs_unfiltered (", ", gdb_stdlog);
569 target_debug_print_enum_target_hw_bp_type (arg3);
570 fputs_unfiltered (", ", gdb_stdlog);
571 target_debug_print_struct_expression_p (arg4);
572 fputs_unfiltered (") = ", gdb_stdlog);
573 target_debug_print_int (result);
574 fputs_unfiltered ("\n", gdb_stdlog);
575 return result;
576 }
577
578 static int
579 delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
580 {
581 self = self->beneath;
582 return self->to_insert_watchpoint (self, arg1, arg2, arg3, arg4);
583 }
584
585 static int
586 tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
587 {
588 return -1;
589 }
590
591 static int
592 debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
593 {
594 int result;
595 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", debug_target.to_shortname);
596 result = debug_target.to_insert_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
597 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", debug_target.to_shortname);
598 target_debug_print_struct_target_ops_p (&debug_target);
599 fputs_unfiltered (", ", gdb_stdlog);
600 target_debug_print_CORE_ADDR (arg1);
601 fputs_unfiltered (", ", gdb_stdlog);
602 target_debug_print_int (arg2);
603 fputs_unfiltered (", ", gdb_stdlog);
604 target_debug_print_enum_target_hw_bp_type (arg3);
605 fputs_unfiltered (", ", gdb_stdlog);
606 target_debug_print_struct_expression_p (arg4);
607 fputs_unfiltered (") = ", gdb_stdlog);
608 target_debug_print_int (result);
609 fputs_unfiltered ("\n", gdb_stdlog);
610 return result;
611 }
612
613 static int
614 delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
615 {
616 self = self->beneath;
617 return self->to_insert_mask_watchpoint (self, arg1, arg2, arg3);
618 }
619
620 static int
621 tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
622 {
623 return 1;
624 }
625
626 static int
627 debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
628 {
629 int result;
630 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_mask_watchpoint (...)\n", debug_target.to_shortname);
631 result = debug_target.to_insert_mask_watchpoint (&debug_target, arg1, arg2, arg3);
632 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_mask_watchpoint (", debug_target.to_shortname);
633 target_debug_print_struct_target_ops_p (&debug_target);
634 fputs_unfiltered (", ", gdb_stdlog);
635 target_debug_print_CORE_ADDR (arg1);
636 fputs_unfiltered (", ", gdb_stdlog);
637 target_debug_print_CORE_ADDR (arg2);
638 fputs_unfiltered (", ", gdb_stdlog);
639 target_debug_print_enum_target_hw_bp_type (arg3);
640 fputs_unfiltered (") = ", gdb_stdlog);
641 target_debug_print_int (result);
642 fputs_unfiltered ("\n", gdb_stdlog);
643 return result;
644 }
645
646 static int
647 delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
648 {
649 self = self->beneath;
650 return self->to_remove_mask_watchpoint (self, arg1, arg2, arg3);
651 }
652
653 static int
654 tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
655 {
656 return 1;
657 }
658
659 static int
660 debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
661 {
662 int result;
663 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_mask_watchpoint (...)\n", debug_target.to_shortname);
664 result = debug_target.to_remove_mask_watchpoint (&debug_target, arg1, arg2, arg3);
665 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_mask_watchpoint (", debug_target.to_shortname);
666 target_debug_print_struct_target_ops_p (&debug_target);
667 fputs_unfiltered (", ", gdb_stdlog);
668 target_debug_print_CORE_ADDR (arg1);
669 fputs_unfiltered (", ", gdb_stdlog);
670 target_debug_print_CORE_ADDR (arg2);
671 fputs_unfiltered (", ", gdb_stdlog);
672 target_debug_print_enum_target_hw_bp_type (arg3);
673 fputs_unfiltered (") = ", gdb_stdlog);
674 target_debug_print_int (result);
675 fputs_unfiltered ("\n", gdb_stdlog);
676 return result;
677 }
678
679 static int
680 delegate_stopped_by_watchpoint (struct target_ops *self)
681 {
682 self = self->beneath;
683 return self->to_stopped_by_watchpoint (self);
684 }
685
686 static int
687 tdefault_stopped_by_watchpoint (struct target_ops *self)
688 {
689 return 0;
690 }
691
692 static int
693 debug_stopped_by_watchpoint (struct target_ops *self)
694 {
695 int result;
696 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_watchpoint (...)\n", debug_target.to_shortname);
697 result = debug_target.to_stopped_by_watchpoint (&debug_target);
698 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_watchpoint (", debug_target.to_shortname);
699 target_debug_print_struct_target_ops_p (&debug_target);
700 fputs_unfiltered (") = ", gdb_stdlog);
701 target_debug_print_int (result);
702 fputs_unfiltered ("\n", gdb_stdlog);
703 return result;
704 }
705
706 static int
707 delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
708 {
709 self = self->beneath;
710 return self->to_stopped_data_address (self, arg1);
711 }
712
713 static int
714 tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
715 {
716 return 0;
717 }
718
719 static int
720 debug_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
721 {
722 int result;
723 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_data_address (...)\n", debug_target.to_shortname);
724 result = debug_target.to_stopped_data_address (&debug_target, arg1);
725 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_data_address (", debug_target.to_shortname);
726 target_debug_print_struct_target_ops_p (&debug_target);
727 fputs_unfiltered (", ", gdb_stdlog);
728 target_debug_print_CORE_ADDR_p (arg1);
729 fputs_unfiltered (") = ", gdb_stdlog);
730 target_debug_print_int (result);
731 fputs_unfiltered ("\n", gdb_stdlog);
732 return result;
733 }
734
735 static int
736 delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
737 {
738 self = self->beneath;
739 return self->to_watchpoint_addr_within_range (self, arg1, arg2, arg3);
740 }
741
742 static int
743 debug_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
744 {
745 int result;
746 fprintf_unfiltered (gdb_stdlog, "-> %s->to_watchpoint_addr_within_range (...)\n", debug_target.to_shortname);
747 result = debug_target.to_watchpoint_addr_within_range (&debug_target, arg1, arg2, arg3);
748 fprintf_unfiltered (gdb_stdlog, "<- %s->to_watchpoint_addr_within_range (", debug_target.to_shortname);
749 target_debug_print_struct_target_ops_p (&debug_target);
750 fputs_unfiltered (", ", gdb_stdlog);
751 target_debug_print_CORE_ADDR (arg1);
752 fputs_unfiltered (", ", gdb_stdlog);
753 target_debug_print_CORE_ADDR (arg2);
754 fputs_unfiltered (", ", gdb_stdlog);
755 target_debug_print_int (arg3);
756 fputs_unfiltered (") = ", gdb_stdlog);
757 target_debug_print_int (result);
758 fputs_unfiltered ("\n", gdb_stdlog);
759 return result;
760 }
761
762 static int
763 delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
764 {
765 self = self->beneath;
766 return self->to_region_ok_for_hw_watchpoint (self, arg1, arg2);
767 }
768
769 static int
770 debug_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
771 {
772 int result;
773 fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", debug_target.to_shortname);
774 result = debug_target.to_region_ok_for_hw_watchpoint (&debug_target, arg1, arg2);
775 fprintf_unfiltered (gdb_stdlog, "<- %s->to_region_ok_for_hw_watchpoint (", debug_target.to_shortname);
776 target_debug_print_struct_target_ops_p (&debug_target);
777 fputs_unfiltered (", ", gdb_stdlog);
778 target_debug_print_CORE_ADDR (arg1);
779 fputs_unfiltered (", ", gdb_stdlog);
780 target_debug_print_int (arg2);
781 fputs_unfiltered (") = ", gdb_stdlog);
782 target_debug_print_int (result);
783 fputs_unfiltered ("\n", gdb_stdlog);
784 return result;
785 }
786
787 static int
788 delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
789 {
790 self = self->beneath;
791 return self->to_can_accel_watchpoint_condition (self, arg1, arg2, arg3, arg4);
792 }
793
794 static int
795 tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
796 {
797 return 0;
798 }
799
800 static int
801 debug_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
802 {
803 int result;
804 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_accel_watchpoint_condition (...)\n", debug_target.to_shortname);
805 result = debug_target.to_can_accel_watchpoint_condition (&debug_target, arg1, arg2, arg3, arg4);
806 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_accel_watchpoint_condition (", debug_target.to_shortname);
807 target_debug_print_struct_target_ops_p (&debug_target);
808 fputs_unfiltered (", ", gdb_stdlog);
809 target_debug_print_CORE_ADDR (arg1);
810 fputs_unfiltered (", ", gdb_stdlog);
811 target_debug_print_int (arg2);
812 fputs_unfiltered (", ", gdb_stdlog);
813 target_debug_print_int (arg3);
814 fputs_unfiltered (", ", gdb_stdlog);
815 target_debug_print_struct_expression_p (arg4);
816 fputs_unfiltered (") = ", gdb_stdlog);
817 target_debug_print_int (result);
818 fputs_unfiltered ("\n", gdb_stdlog);
819 return result;
820 }
821
822 static int
823 delegate_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
824 {
825 self = self->beneath;
826 return self->to_masked_watch_num_registers (self, arg1, arg2);
827 }
828
829 static int
830 tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
831 {
832 return -1;
833 }
834
835 static int
836 debug_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
837 {
838 int result;
839 fprintf_unfiltered (gdb_stdlog, "-> %s->to_masked_watch_num_registers (...)\n", debug_target.to_shortname);
840 result = debug_target.to_masked_watch_num_registers (&debug_target, arg1, arg2);
841 fprintf_unfiltered (gdb_stdlog, "<- %s->to_masked_watch_num_registers (", debug_target.to_shortname);
842 target_debug_print_struct_target_ops_p (&debug_target);
843 fputs_unfiltered (", ", gdb_stdlog);
844 target_debug_print_CORE_ADDR (arg1);
845 fputs_unfiltered (", ", gdb_stdlog);
846 target_debug_print_CORE_ADDR (arg2);
847 fputs_unfiltered (") = ", gdb_stdlog);
848 target_debug_print_int (result);
849 fputs_unfiltered ("\n", gdb_stdlog);
850 return result;
851 }
852
853 static int
854 delegate_can_do_single_step (struct target_ops *self)
855 {
856 self = self->beneath;
857 return self->to_can_do_single_step (self);
858 }
859
860 static int
861 tdefault_can_do_single_step (struct target_ops *self)
862 {
863 return -1;
864 }
865
866 static int
867 debug_can_do_single_step (struct target_ops *self)
868 {
869 int result;
870 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_do_single_step (...)\n", debug_target.to_shortname);
871 result = debug_target.to_can_do_single_step (&debug_target);
872 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_do_single_step (", debug_target.to_shortname);
873 target_debug_print_struct_target_ops_p (&debug_target);
874 fputs_unfiltered (") = ", gdb_stdlog);
875 target_debug_print_int (result);
876 fputs_unfiltered ("\n", gdb_stdlog);
877 return result;
878 }
879
880 static void
881 delegate_terminal_init (struct target_ops *self)
882 {
883 self = self->beneath;
884 self->to_terminal_init (self);
885 }
886
887 static void
888 tdefault_terminal_init (struct target_ops *self)
889 {
890 }
891
892 static void
893 debug_terminal_init (struct target_ops *self)
894 {
895 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_init (...)\n", debug_target.to_shortname);
896 debug_target.to_terminal_init (&debug_target);
897 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_init (", debug_target.to_shortname);
898 target_debug_print_struct_target_ops_p (&debug_target);
899 fputs_unfiltered (")\n", gdb_stdlog);
900 }
901
902 static void
903 delegate_terminal_inferior (struct target_ops *self)
904 {
905 self = self->beneath;
906 self->to_terminal_inferior (self);
907 }
908
909 static void
910 tdefault_terminal_inferior (struct target_ops *self)
911 {
912 }
913
914 static void
915 debug_terminal_inferior (struct target_ops *self)
916 {
917 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_inferior (...)\n", debug_target.to_shortname);
918 debug_target.to_terminal_inferior (&debug_target);
919 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_inferior (", debug_target.to_shortname);
920 target_debug_print_struct_target_ops_p (&debug_target);
921 fputs_unfiltered (")\n", gdb_stdlog);
922 }
923
924 static void
925 delegate_terminal_ours_for_output (struct target_ops *self)
926 {
927 self = self->beneath;
928 self->to_terminal_ours_for_output (self);
929 }
930
931 static void
932 tdefault_terminal_ours_for_output (struct target_ops *self)
933 {
934 }
935
936 static void
937 debug_terminal_ours_for_output (struct target_ops *self)
938 {
939 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours_for_output (...)\n", debug_target.to_shortname);
940 debug_target.to_terminal_ours_for_output (&debug_target);
941 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours_for_output (", debug_target.to_shortname);
942 target_debug_print_struct_target_ops_p (&debug_target);
943 fputs_unfiltered (")\n", gdb_stdlog);
944 }
945
946 static void
947 delegate_terminal_ours (struct target_ops *self)
948 {
949 self = self->beneath;
950 self->to_terminal_ours (self);
951 }
952
953 static void
954 tdefault_terminal_ours (struct target_ops *self)
955 {
956 }
957
958 static void
959 debug_terminal_ours (struct target_ops *self)
960 {
961 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours (...)\n", debug_target.to_shortname);
962 debug_target.to_terminal_ours (&debug_target);
963 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours (", debug_target.to_shortname);
964 target_debug_print_struct_target_ops_p (&debug_target);
965 fputs_unfiltered (")\n", gdb_stdlog);
966 }
967
968 static void
969 delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
970 {
971 self = self->beneath;
972 self->to_terminal_info (self, arg1, arg2);
973 }
974
975 static void
976 debug_terminal_info (struct target_ops *self, const char *arg1, int arg2)
977 {
978 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_info (...)\n", debug_target.to_shortname);
979 debug_target.to_terminal_info (&debug_target, arg1, arg2);
980 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_info (", debug_target.to_shortname);
981 target_debug_print_struct_target_ops_p (&debug_target);
982 fputs_unfiltered (", ", gdb_stdlog);
983 target_debug_print_const_char_p (arg1);
984 fputs_unfiltered (", ", gdb_stdlog);
985 target_debug_print_int (arg2);
986 fputs_unfiltered (")\n", gdb_stdlog);
987 }
988
989 static void
990 delegate_kill (struct target_ops *self)
991 {
992 self = self->beneath;
993 self->to_kill (self);
994 }
995
996 static void
997 tdefault_kill (struct target_ops *self)
998 {
999 noprocess ();
1000 }
1001
1002 static void
1003 debug_kill (struct target_ops *self)
1004 {
1005 fprintf_unfiltered (gdb_stdlog, "-> %s->to_kill (...)\n", debug_target.to_shortname);
1006 debug_target.to_kill (&debug_target);
1007 fprintf_unfiltered (gdb_stdlog, "<- %s->to_kill (", debug_target.to_shortname);
1008 target_debug_print_struct_target_ops_p (&debug_target);
1009 fputs_unfiltered (")\n", gdb_stdlog);
1010 }
1011
1012 static void
1013 delegate_load (struct target_ops *self, const char *arg1, int arg2)
1014 {
1015 self = self->beneath;
1016 self->to_load (self, arg1, arg2);
1017 }
1018
1019 static void
1020 tdefault_load (struct target_ops *self, const char *arg1, int arg2)
1021 {
1022 tcomplain ();
1023 }
1024
1025 static void
1026 debug_load (struct target_ops *self, const char *arg1, int arg2)
1027 {
1028 fprintf_unfiltered (gdb_stdlog, "-> %s->to_load (...)\n", debug_target.to_shortname);
1029 debug_target.to_load (&debug_target, arg1, arg2);
1030 fprintf_unfiltered (gdb_stdlog, "<- %s->to_load (", debug_target.to_shortname);
1031 target_debug_print_struct_target_ops_p (&debug_target);
1032 fputs_unfiltered (", ", gdb_stdlog);
1033 target_debug_print_const_char_p (arg1);
1034 fputs_unfiltered (", ", gdb_stdlog);
1035 target_debug_print_int (arg2);
1036 fputs_unfiltered (")\n", gdb_stdlog);
1037 }
1038
1039 static void
1040 delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1)
1041 {
1042 self = self->beneath;
1043 self->to_post_startup_inferior (self, arg1);
1044 }
1045
1046 static void
1047 tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
1048 {
1049 }
1050
1051 static void
1052 debug_post_startup_inferior (struct target_ops *self, ptid_t arg1)
1053 {
1054 fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_startup_inferior (...)\n", debug_target.to_shortname);
1055 debug_target.to_post_startup_inferior (&debug_target, arg1);
1056 fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_startup_inferior (", debug_target.to_shortname);
1057 target_debug_print_struct_target_ops_p (&debug_target);
1058 fputs_unfiltered (", ", gdb_stdlog);
1059 target_debug_print_ptid_t (arg1);
1060 fputs_unfiltered (")\n", gdb_stdlog);
1061 }
1062
1063 static int
1064 delegate_insert_fork_catchpoint (struct target_ops *self, int arg1)
1065 {
1066 self = self->beneath;
1067 return self->to_insert_fork_catchpoint (self, arg1);
1068 }
1069
1070 static int
1071 tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
1072 {
1073 return 1;
1074 }
1075
1076 static int
1077 debug_insert_fork_catchpoint (struct target_ops *self, int arg1)
1078 {
1079 int result;
1080 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_fork_catchpoint (...)\n", debug_target.to_shortname);
1081 result = debug_target.to_insert_fork_catchpoint (&debug_target, arg1);
1082 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_fork_catchpoint (", debug_target.to_shortname);
1083 target_debug_print_struct_target_ops_p (&debug_target);
1084 fputs_unfiltered (", ", gdb_stdlog);
1085 target_debug_print_int (arg1);
1086 fputs_unfiltered (") = ", gdb_stdlog);
1087 target_debug_print_int (result);
1088 fputs_unfiltered ("\n", gdb_stdlog);
1089 return result;
1090 }
1091
1092 static int
1093 delegate_remove_fork_catchpoint (struct target_ops *self, int arg1)
1094 {
1095 self = self->beneath;
1096 return self->to_remove_fork_catchpoint (self, arg1);
1097 }
1098
1099 static int
1100 tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
1101 {
1102 return 1;
1103 }
1104
1105 static int
1106 debug_remove_fork_catchpoint (struct target_ops *self, int arg1)
1107 {
1108 int result;
1109 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_fork_catchpoint (...)\n", debug_target.to_shortname);
1110 result = debug_target.to_remove_fork_catchpoint (&debug_target, arg1);
1111 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_fork_catchpoint (", debug_target.to_shortname);
1112 target_debug_print_struct_target_ops_p (&debug_target);
1113 fputs_unfiltered (", ", gdb_stdlog);
1114 target_debug_print_int (arg1);
1115 fputs_unfiltered (") = ", gdb_stdlog);
1116 target_debug_print_int (result);
1117 fputs_unfiltered ("\n", gdb_stdlog);
1118 return result;
1119 }
1120
1121 static int
1122 delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1)
1123 {
1124 self = self->beneath;
1125 return self->to_insert_vfork_catchpoint (self, arg1);
1126 }
1127
1128 static int
1129 tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
1130 {
1131 return 1;
1132 }
1133
1134 static int
1135 debug_insert_vfork_catchpoint (struct target_ops *self, int arg1)
1136 {
1137 int result;
1138 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_vfork_catchpoint (...)\n", debug_target.to_shortname);
1139 result = debug_target.to_insert_vfork_catchpoint (&debug_target, arg1);
1140 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_vfork_catchpoint (", debug_target.to_shortname);
1141 target_debug_print_struct_target_ops_p (&debug_target);
1142 fputs_unfiltered (", ", gdb_stdlog);
1143 target_debug_print_int (arg1);
1144 fputs_unfiltered (") = ", gdb_stdlog);
1145 target_debug_print_int (result);
1146 fputs_unfiltered ("\n", gdb_stdlog);
1147 return result;
1148 }
1149
1150 static int
1151 delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1)
1152 {
1153 self = self->beneath;
1154 return self->to_remove_vfork_catchpoint (self, arg1);
1155 }
1156
1157 static int
1158 tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
1159 {
1160 return 1;
1161 }
1162
1163 static int
1164 debug_remove_vfork_catchpoint (struct target_ops *self, int arg1)
1165 {
1166 int result;
1167 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_vfork_catchpoint (...)\n", debug_target.to_shortname);
1168 result = debug_target.to_remove_vfork_catchpoint (&debug_target, arg1);
1169 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_vfork_catchpoint (", debug_target.to_shortname);
1170 target_debug_print_struct_target_ops_p (&debug_target);
1171 fputs_unfiltered (", ", gdb_stdlog);
1172 target_debug_print_int (arg1);
1173 fputs_unfiltered (") = ", gdb_stdlog);
1174 target_debug_print_int (result);
1175 fputs_unfiltered ("\n", gdb_stdlog);
1176 return result;
1177 }
1178
1179 static int
1180 delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
1181 {
1182 self = self->beneath;
1183 return self->to_follow_fork (self, arg1, arg2);
1184 }
1185
1186 static int
1187 debug_follow_fork (struct target_ops *self, int arg1, int arg2)
1188 {
1189 int result;
1190 fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_fork (...)\n", debug_target.to_shortname);
1191 result = debug_target.to_follow_fork (&debug_target, arg1, arg2);
1192 fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_fork (", debug_target.to_shortname);
1193 target_debug_print_struct_target_ops_p (&debug_target);
1194 fputs_unfiltered (", ", gdb_stdlog);
1195 target_debug_print_int (arg1);
1196 fputs_unfiltered (", ", gdb_stdlog);
1197 target_debug_print_int (arg2);
1198 fputs_unfiltered (") = ", gdb_stdlog);
1199 target_debug_print_int (result);
1200 fputs_unfiltered ("\n", gdb_stdlog);
1201 return result;
1202 }
1203
1204 static int
1205 delegate_insert_exec_catchpoint (struct target_ops *self, int arg1)
1206 {
1207 self = self->beneath;
1208 return self->to_insert_exec_catchpoint (self, arg1);
1209 }
1210
1211 static int
1212 tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
1213 {
1214 return 1;
1215 }
1216
1217 static int
1218 debug_insert_exec_catchpoint (struct target_ops *self, int arg1)
1219 {
1220 int result;
1221 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_exec_catchpoint (...)\n", debug_target.to_shortname);
1222 result = debug_target.to_insert_exec_catchpoint (&debug_target, arg1);
1223 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_exec_catchpoint (", debug_target.to_shortname);
1224 target_debug_print_struct_target_ops_p (&debug_target);
1225 fputs_unfiltered (", ", gdb_stdlog);
1226 target_debug_print_int (arg1);
1227 fputs_unfiltered (") = ", gdb_stdlog);
1228 target_debug_print_int (result);
1229 fputs_unfiltered ("\n", gdb_stdlog);
1230 return result;
1231 }
1232
1233 static int
1234 delegate_remove_exec_catchpoint (struct target_ops *self, int arg1)
1235 {
1236 self = self->beneath;
1237 return self->to_remove_exec_catchpoint (self, arg1);
1238 }
1239
1240 static int
1241 tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
1242 {
1243 return 1;
1244 }
1245
1246 static int
1247 debug_remove_exec_catchpoint (struct target_ops *self, int arg1)
1248 {
1249 int result;
1250 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_exec_catchpoint (...)\n", debug_target.to_shortname);
1251 result = debug_target.to_remove_exec_catchpoint (&debug_target, arg1);
1252 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_exec_catchpoint (", debug_target.to_shortname);
1253 target_debug_print_struct_target_ops_p (&debug_target);
1254 fputs_unfiltered (", ", gdb_stdlog);
1255 target_debug_print_int (arg1);
1256 fputs_unfiltered (") = ", gdb_stdlog);
1257 target_debug_print_int (result);
1258 fputs_unfiltered ("\n", gdb_stdlog);
1259 return result;
1260 }
1261
1262 static void
1263 delegate_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
1264 {
1265 self = self->beneath;
1266 self->to_follow_exec (self, arg1, arg2);
1267 }
1268
1269 static void
1270 tdefault_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
1271 {
1272 }
1273
1274 static void
1275 debug_follow_exec (struct target_ops *self, struct inferior *arg1, char *arg2)
1276 {
1277 fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_exec (...)\n", debug_target.to_shortname);
1278 debug_target.to_follow_exec (&debug_target, arg1, arg2);
1279 fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_exec (", debug_target.to_shortname);
1280 target_debug_print_struct_target_ops_p (&debug_target);
1281 fputs_unfiltered (", ", gdb_stdlog);
1282 target_debug_print_struct_inferior_p (arg1);
1283 fputs_unfiltered (", ", gdb_stdlog);
1284 target_debug_print_char_p (arg2);
1285 fputs_unfiltered (")\n", gdb_stdlog);
1286 }
1287
1288 static int
1289 delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view<const int> arg4)
1290 {
1291 self = self->beneath;
1292 return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4);
1293 }
1294
1295 static int
1296 tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view<const int> arg4)
1297 {
1298 return 1;
1299 }
1300
1301 static int
1302 debug_set_syscall_catchpoint (struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view<const int> arg4)
1303 {
1304 int result;
1305 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname);
1306 result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4);
1307 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname);
1308 target_debug_print_struct_target_ops_p (&debug_target);
1309 fputs_unfiltered (", ", gdb_stdlog);
1310 target_debug_print_int (arg1);
1311 fputs_unfiltered (", ", gdb_stdlog);
1312 target_debug_print_bool (arg2);
1313 fputs_unfiltered (", ", gdb_stdlog);
1314 target_debug_print_int (arg3);
1315 fputs_unfiltered (", ", gdb_stdlog);
1316 target_debug_print_gdb_array_view_const_int (arg4);
1317 fputs_unfiltered (") = ", gdb_stdlog);
1318 target_debug_print_int (result);
1319 fputs_unfiltered ("\n", gdb_stdlog);
1320 return result;
1321 }
1322
1323 static int
1324 delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
1325 {
1326 self = self->beneath;
1327 return self->to_has_exited (self, arg1, arg2, arg3);
1328 }
1329
1330 static int
1331 tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
1332 {
1333 return 0;
1334 }
1335
1336 static int
1337 debug_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
1338 {
1339 int result;
1340 fprintf_unfiltered (gdb_stdlog, "-> %s->to_has_exited (...)\n", debug_target.to_shortname);
1341 result = debug_target.to_has_exited (&debug_target, arg1, arg2, arg3);
1342 fprintf_unfiltered (gdb_stdlog, "<- %s->to_has_exited (", debug_target.to_shortname);
1343 target_debug_print_struct_target_ops_p (&debug_target);
1344 fputs_unfiltered (", ", gdb_stdlog);
1345 target_debug_print_int (arg1);
1346 fputs_unfiltered (", ", gdb_stdlog);
1347 target_debug_print_int (arg2);
1348 fputs_unfiltered (", ", gdb_stdlog);
1349 target_debug_print_int_p (arg3);
1350 fputs_unfiltered (") = ", gdb_stdlog);
1351 target_debug_print_int (result);
1352 fputs_unfiltered ("\n", gdb_stdlog);
1353 return result;
1354 }
1355
1356 static void
1357 delegate_mourn_inferior (struct target_ops *self)
1358 {
1359 self = self->beneath;
1360 self->to_mourn_inferior (self);
1361 }
1362
1363 static void
1364 debug_mourn_inferior (struct target_ops *self)
1365 {
1366 fprintf_unfiltered (gdb_stdlog, "-> %s->to_mourn_inferior (...)\n", debug_target.to_shortname);
1367 debug_target.to_mourn_inferior (&debug_target);
1368 fprintf_unfiltered (gdb_stdlog, "<- %s->to_mourn_inferior (", debug_target.to_shortname);
1369 target_debug_print_struct_target_ops_p (&debug_target);
1370 fputs_unfiltered (")\n", gdb_stdlog);
1371 }
1372
1373 static int
1374 delegate_can_run (struct target_ops *self)
1375 {
1376 self = self->beneath;
1377 return self->to_can_run (self);
1378 }
1379
1380 static int
1381 tdefault_can_run (struct target_ops *self)
1382 {
1383 return 0;
1384 }
1385
1386 static int
1387 debug_can_run (struct target_ops *self)
1388 {
1389 int result;
1390 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run (...)\n", debug_target.to_shortname);
1391 result = debug_target.to_can_run (&debug_target);
1392 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run (", debug_target.to_shortname);
1393 target_debug_print_struct_target_ops_p (&debug_target);
1394 fputs_unfiltered (") = ", gdb_stdlog);
1395 target_debug_print_int (result);
1396 fputs_unfiltered ("\n", gdb_stdlog);
1397 return result;
1398 }
1399
1400 static void
1401 delegate_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1402 {
1403 self = self->beneath;
1404 self->to_pass_signals (self, arg1, arg2);
1405 }
1406
1407 static void
1408 tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1409 {
1410 }
1411
1412 static void
1413 debug_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1414 {
1415 fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", debug_target.to_shortname);
1416 debug_target.to_pass_signals (&debug_target, arg1, arg2);
1417 fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", debug_target.to_shortname);
1418 target_debug_print_struct_target_ops_p (&debug_target);
1419 fputs_unfiltered (", ", gdb_stdlog);
1420 target_debug_print_int (arg1);
1421 fputs_unfiltered (", ", gdb_stdlog);
1422 target_debug_print_signals (arg2);
1423 fputs_unfiltered (")\n", gdb_stdlog);
1424 }
1425
1426 static void
1427 delegate_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1428 {
1429 self = self->beneath;
1430 self->to_program_signals (self, arg1, arg2);
1431 }
1432
1433 static void
1434 tdefault_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1435 {
1436 }
1437
1438 static void
1439 debug_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1440 {
1441 fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", debug_target.to_shortname);
1442 debug_target.to_program_signals (&debug_target, arg1, arg2);
1443 fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", debug_target.to_shortname);
1444 target_debug_print_struct_target_ops_p (&debug_target);
1445 fputs_unfiltered (", ", gdb_stdlog);
1446 target_debug_print_int (arg1);
1447 fputs_unfiltered (", ", gdb_stdlog);
1448 target_debug_print_signals (arg2);
1449 fputs_unfiltered (")\n", gdb_stdlog);
1450 }
1451
1452 static int
1453 delegate_thread_alive (struct target_ops *self, ptid_t arg1)
1454 {
1455 self = self->beneath;
1456 return self->to_thread_alive (self, arg1);
1457 }
1458
1459 static int
1460 tdefault_thread_alive (struct target_ops *self, ptid_t arg1)
1461 {
1462 return 0;
1463 }
1464
1465 static int
1466 debug_thread_alive (struct target_ops *self, ptid_t arg1)
1467 {
1468 int result;
1469 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_alive (...)\n", debug_target.to_shortname);
1470 result = debug_target.to_thread_alive (&debug_target, arg1);
1471 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_alive (", debug_target.to_shortname);
1472 target_debug_print_struct_target_ops_p (&debug_target);
1473 fputs_unfiltered (", ", gdb_stdlog);
1474 target_debug_print_ptid_t (arg1);
1475 fputs_unfiltered (") = ", gdb_stdlog);
1476 target_debug_print_int (result);
1477 fputs_unfiltered ("\n", gdb_stdlog);
1478 return result;
1479 }
1480
1481 static void
1482 delegate_update_thread_list (struct target_ops *self)
1483 {
1484 self = self->beneath;
1485 self->to_update_thread_list (self);
1486 }
1487
1488 static void
1489 tdefault_update_thread_list (struct target_ops *self)
1490 {
1491 }
1492
1493 static void
1494 debug_update_thread_list (struct target_ops *self)
1495 {
1496 fprintf_unfiltered (gdb_stdlog, "-> %s->to_update_thread_list (...)\n", debug_target.to_shortname);
1497 debug_target.to_update_thread_list (&debug_target);
1498 fprintf_unfiltered (gdb_stdlog, "<- %s->to_update_thread_list (", debug_target.to_shortname);
1499 target_debug_print_struct_target_ops_p (&debug_target);
1500 fputs_unfiltered (")\n", gdb_stdlog);
1501 }
1502
1503 static const char *
1504 delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
1505 {
1506 self = self->beneath;
1507 return self->to_pid_to_str (self, arg1);
1508 }
1509
1510 static const char *
1511 debug_pid_to_str (struct target_ops *self, ptid_t arg1)
1512 {
1513 const char * result;
1514 fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_str (...)\n", debug_target.to_shortname);
1515 result = debug_target.to_pid_to_str (&debug_target, arg1);
1516 fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_str (", debug_target.to_shortname);
1517 target_debug_print_struct_target_ops_p (&debug_target);
1518 fputs_unfiltered (", ", gdb_stdlog);
1519 target_debug_print_ptid_t (arg1);
1520 fputs_unfiltered (") = ", gdb_stdlog);
1521 target_debug_print_const_char_p (result);
1522 fputs_unfiltered ("\n", gdb_stdlog);
1523 return result;
1524 }
1525
1526 static const char *
1527 delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
1528 {
1529 self = self->beneath;
1530 return self->to_extra_thread_info (self, arg1);
1531 }
1532
1533 static const char *
1534 tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
1535 {
1536 return NULL;
1537 }
1538
1539 static const char *
1540 debug_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
1541 {
1542 const char * result;
1543 fprintf_unfiltered (gdb_stdlog, "-> %s->to_extra_thread_info (...)\n", debug_target.to_shortname);
1544 result = debug_target.to_extra_thread_info (&debug_target, arg1);
1545 fprintf_unfiltered (gdb_stdlog, "<- %s->to_extra_thread_info (", debug_target.to_shortname);
1546 target_debug_print_struct_target_ops_p (&debug_target);
1547 fputs_unfiltered (", ", gdb_stdlog);
1548 target_debug_print_struct_thread_info_p (arg1);
1549 fputs_unfiltered (") = ", gdb_stdlog);
1550 target_debug_print_const_char_p (result);
1551 fputs_unfiltered ("\n", gdb_stdlog);
1552 return result;
1553 }
1554
1555 static const char *
1556 delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
1557 {
1558 self = self->beneath;
1559 return self->to_thread_name (self, arg1);
1560 }
1561
1562 static const char *
1563 tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
1564 {
1565 return NULL;
1566 }
1567
1568 static const char *
1569 debug_thread_name (struct target_ops *self, struct thread_info *arg1)
1570 {
1571 const char * result;
1572 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_name (...)\n", debug_target.to_shortname);
1573 result = debug_target.to_thread_name (&debug_target, arg1);
1574 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_name (", debug_target.to_shortname);
1575 target_debug_print_struct_target_ops_p (&debug_target);
1576 fputs_unfiltered (", ", gdb_stdlog);
1577 target_debug_print_struct_thread_info_p (arg1);
1578 fputs_unfiltered (") = ", gdb_stdlog);
1579 target_debug_print_const_char_p (result);
1580 fputs_unfiltered ("\n", gdb_stdlog);
1581 return result;
1582 }
1583
1584 static struct thread_info *
1585 delegate_thread_handle_to_thread_info (struct target_ops *self, const gdb_byte *arg1, int arg2, struct inferior *arg3)
1586 {
1587 self = self->beneath;
1588 return self->to_thread_handle_to_thread_info (self, arg1, arg2, arg3);
1589 }
1590
1591 static struct thread_info *
1592 tdefault_thread_handle_to_thread_info (struct target_ops *self, const gdb_byte *arg1, int arg2, struct inferior *arg3)
1593 {
1594 return NULL;
1595 }
1596
1597 static struct thread_info *
1598 debug_thread_handle_to_thread_info (struct target_ops *self, const gdb_byte *arg1, int arg2, struct inferior *arg3)
1599 {
1600 struct thread_info * result;
1601 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_handle_to_thread_info (...)\n", debug_target.to_shortname);
1602 result = debug_target.to_thread_handle_to_thread_info (&debug_target, arg1, arg2, arg3);
1603 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_handle_to_thread_info (", debug_target.to_shortname);
1604 target_debug_print_struct_target_ops_p (&debug_target);
1605 fputs_unfiltered (", ", gdb_stdlog);
1606 target_debug_print_const_gdb_byte_p (arg1);
1607 fputs_unfiltered (", ", gdb_stdlog);
1608 target_debug_print_int (arg2);
1609 fputs_unfiltered (", ", gdb_stdlog);
1610 target_debug_print_struct_inferior_p (arg3);
1611 fputs_unfiltered (") = ", gdb_stdlog);
1612 target_debug_print_struct_thread_info_p (result);
1613 fputs_unfiltered ("\n", gdb_stdlog);
1614 return result;
1615 }
1616
1617 static void
1618 delegate_stop (struct target_ops *self, ptid_t arg1)
1619 {
1620 self = self->beneath;
1621 self->to_stop (self, arg1);
1622 }
1623
1624 static void
1625 tdefault_stop (struct target_ops *self, ptid_t arg1)
1626 {
1627 }
1628
1629 static void
1630 debug_stop (struct target_ops *self, ptid_t arg1)
1631 {
1632 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop (...)\n", debug_target.to_shortname);
1633 debug_target.to_stop (&debug_target, arg1);
1634 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop (", debug_target.to_shortname);
1635 target_debug_print_struct_target_ops_p (&debug_target);
1636 fputs_unfiltered (", ", gdb_stdlog);
1637 target_debug_print_ptid_t (arg1);
1638 fputs_unfiltered (")\n", gdb_stdlog);
1639 }
1640
1641 static void
1642 delegate_interrupt (struct target_ops *self, ptid_t arg1)
1643 {
1644 self = self->beneath;
1645 self->to_interrupt (self, arg1);
1646 }
1647
1648 static void
1649 tdefault_interrupt (struct target_ops *self, ptid_t arg1)
1650 {
1651 }
1652
1653 static void
1654 debug_interrupt (struct target_ops *self, ptid_t arg1)
1655 {
1656 fprintf_unfiltered (gdb_stdlog, "-> %s->to_interrupt (...)\n", debug_target.to_shortname);
1657 debug_target.to_interrupt (&debug_target, arg1);
1658 fprintf_unfiltered (gdb_stdlog, "<- %s->to_interrupt (", debug_target.to_shortname);
1659 target_debug_print_struct_target_ops_p (&debug_target);
1660 fputs_unfiltered (", ", gdb_stdlog);
1661 target_debug_print_ptid_t (arg1);
1662 fputs_unfiltered (")\n", gdb_stdlog);
1663 }
1664
1665 static void
1666 delegate_pass_ctrlc (struct target_ops *self)
1667 {
1668 self = self->beneath;
1669 self->to_pass_ctrlc (self);
1670 }
1671
1672 static void
1673 debug_pass_ctrlc (struct target_ops *self)
1674 {
1675 fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_ctrlc (...)\n", debug_target.to_shortname);
1676 debug_target.to_pass_ctrlc (&debug_target);
1677 fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_ctrlc (", debug_target.to_shortname);
1678 target_debug_print_struct_target_ops_p (&debug_target);
1679 fputs_unfiltered (")\n", gdb_stdlog);
1680 }
1681
1682 static void
1683 delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
1684 {
1685 self = self->beneath;
1686 self->to_rcmd (self, arg1, arg2);
1687 }
1688
1689 static void
1690 debug_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
1691 {
1692 fprintf_unfiltered (gdb_stdlog, "-> %s->to_rcmd (...)\n", debug_target.to_shortname);
1693 debug_target.to_rcmd (&debug_target, arg1, arg2);
1694 fprintf_unfiltered (gdb_stdlog, "<- %s->to_rcmd (", debug_target.to_shortname);
1695 target_debug_print_struct_target_ops_p (&debug_target);
1696 fputs_unfiltered (", ", gdb_stdlog);
1697 target_debug_print_const_char_p (arg1);
1698 fputs_unfiltered (", ", gdb_stdlog);
1699 target_debug_print_struct_ui_file_p (arg2);
1700 fputs_unfiltered (")\n", gdb_stdlog);
1701 }
1702
1703 static char *
1704 delegate_pid_to_exec_file (struct target_ops *self, int arg1)
1705 {
1706 self = self->beneath;
1707 return self->to_pid_to_exec_file (self, arg1);
1708 }
1709
1710 static char *
1711 tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
1712 {
1713 return NULL;
1714 }
1715
1716 static char *
1717 debug_pid_to_exec_file (struct target_ops *self, int arg1)
1718 {
1719 char * result;
1720 fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_exec_file (...)\n", debug_target.to_shortname);
1721 result = debug_target.to_pid_to_exec_file (&debug_target, arg1);
1722 fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_exec_file (", debug_target.to_shortname);
1723 target_debug_print_struct_target_ops_p (&debug_target);
1724 fputs_unfiltered (", ", gdb_stdlog);
1725 target_debug_print_int (arg1);
1726 fputs_unfiltered (") = ", gdb_stdlog);
1727 target_debug_print_char_p (result);
1728 fputs_unfiltered ("\n", gdb_stdlog);
1729 return result;
1730 }
1731
1732 static void
1733 delegate_log_command (struct target_ops *self, const char *arg1)
1734 {
1735 self = self->beneath;
1736 self->to_log_command (self, arg1);
1737 }
1738
1739 static void
1740 tdefault_log_command (struct target_ops *self, const char *arg1)
1741 {
1742 }
1743
1744 static void
1745 debug_log_command (struct target_ops *self, const char *arg1)
1746 {
1747 fprintf_unfiltered (gdb_stdlog, "-> %s->to_log_command (...)\n", debug_target.to_shortname);
1748 debug_target.to_log_command (&debug_target, arg1);
1749 fprintf_unfiltered (gdb_stdlog, "<- %s->to_log_command (", debug_target.to_shortname);
1750 target_debug_print_struct_target_ops_p (&debug_target);
1751 fputs_unfiltered (", ", gdb_stdlog);
1752 target_debug_print_const_char_p (arg1);
1753 fputs_unfiltered (")\n", gdb_stdlog);
1754 }
1755
1756 static struct target_section_table *
1757 delegate_get_section_table (struct target_ops *self)
1758 {
1759 self = self->beneath;
1760 return self->to_get_section_table (self);
1761 }
1762
1763 static struct target_section_table *
1764 tdefault_get_section_table (struct target_ops *self)
1765 {
1766 return NULL;
1767 }
1768
1769 static struct target_section_table *
1770 debug_get_section_table (struct target_ops *self)
1771 {
1772 struct target_section_table * result;
1773 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_section_table (...)\n", debug_target.to_shortname);
1774 result = debug_target.to_get_section_table (&debug_target);
1775 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_section_table (", debug_target.to_shortname);
1776 target_debug_print_struct_target_ops_p (&debug_target);
1777 fputs_unfiltered (") = ", gdb_stdlog);
1778 target_debug_print_struct_target_section_table_p (result);
1779 fputs_unfiltered ("\n", gdb_stdlog);
1780 return result;
1781 }
1782
1783 static int
1784 delegate_can_async_p (struct target_ops *self)
1785 {
1786 self = self->beneath;
1787 return self->to_can_async_p (self);
1788 }
1789
1790 static int
1791 tdefault_can_async_p (struct target_ops *self)
1792 {
1793 return 0;
1794 }
1795
1796 static int
1797 debug_can_async_p (struct target_ops *self)
1798 {
1799 int result;
1800 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_async_p (...)\n", debug_target.to_shortname);
1801 result = debug_target.to_can_async_p (&debug_target);
1802 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_async_p (", debug_target.to_shortname);
1803 target_debug_print_struct_target_ops_p (&debug_target);
1804 fputs_unfiltered (") = ", gdb_stdlog);
1805 target_debug_print_int (result);
1806 fputs_unfiltered ("\n", gdb_stdlog);
1807 return result;
1808 }
1809
1810 static int
1811 delegate_is_async_p (struct target_ops *self)
1812 {
1813 self = self->beneath;
1814 return self->to_is_async_p (self);
1815 }
1816
1817 static int
1818 tdefault_is_async_p (struct target_ops *self)
1819 {
1820 return 0;
1821 }
1822
1823 static int
1824 debug_is_async_p (struct target_ops *self)
1825 {
1826 int result;
1827 fprintf_unfiltered (gdb_stdlog, "-> %s->to_is_async_p (...)\n", debug_target.to_shortname);
1828 result = debug_target.to_is_async_p (&debug_target);
1829 fprintf_unfiltered (gdb_stdlog, "<- %s->to_is_async_p (", debug_target.to_shortname);
1830 target_debug_print_struct_target_ops_p (&debug_target);
1831 fputs_unfiltered (") = ", gdb_stdlog);
1832 target_debug_print_int (result);
1833 fputs_unfiltered ("\n", gdb_stdlog);
1834 return result;
1835 }
1836
1837 static void
1838 delegate_async (struct target_ops *self, int arg1)
1839 {
1840 self = self->beneath;
1841 self->to_async (self, arg1);
1842 }
1843
1844 static void
1845 tdefault_async (struct target_ops *self, int arg1)
1846 {
1847 tcomplain ();
1848 }
1849
1850 static void
1851 debug_async (struct target_ops *self, int arg1)
1852 {
1853 fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname);
1854 debug_target.to_async (&debug_target, arg1);
1855 fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", debug_target.to_shortname);
1856 target_debug_print_struct_target_ops_p (&debug_target);
1857 fputs_unfiltered (", ", gdb_stdlog);
1858 target_debug_print_int (arg1);
1859 fputs_unfiltered (")\n", gdb_stdlog);
1860 }
1861
1862 static void
1863 delegate_thread_events (struct target_ops *self, int arg1)
1864 {
1865 self = self->beneath;
1866 self->to_thread_events (self, arg1);
1867 }
1868
1869 static void
1870 tdefault_thread_events (struct target_ops *self, int arg1)
1871 {
1872 }
1873
1874 static void
1875 debug_thread_events (struct target_ops *self, int arg1)
1876 {
1877 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_events (...)\n", debug_target.to_shortname);
1878 debug_target.to_thread_events (&debug_target, arg1);
1879 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_events (", debug_target.to_shortname);
1880 target_debug_print_struct_target_ops_p (&debug_target);
1881 fputs_unfiltered (", ", gdb_stdlog);
1882 target_debug_print_int (arg1);
1883 fputs_unfiltered (")\n", gdb_stdlog);
1884 }
1885
1886 static int
1887 delegate_supports_non_stop (struct target_ops *self)
1888 {
1889 self = self->beneath;
1890 return self->to_supports_non_stop (self);
1891 }
1892
1893 static int
1894 tdefault_supports_non_stop (struct target_ops *self)
1895 {
1896 return 0;
1897 }
1898
1899 static int
1900 debug_supports_non_stop (struct target_ops *self)
1901 {
1902 int result;
1903 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", debug_target.to_shortname);
1904 result = debug_target.to_supports_non_stop (&debug_target);
1905 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", debug_target.to_shortname);
1906 target_debug_print_struct_target_ops_p (&debug_target);
1907 fputs_unfiltered (") = ", gdb_stdlog);
1908 target_debug_print_int (result);
1909 fputs_unfiltered ("\n", gdb_stdlog);
1910 return result;
1911 }
1912
1913 static int
1914 delegate_always_non_stop_p (struct target_ops *self)
1915 {
1916 self = self->beneath;
1917 return self->to_always_non_stop_p (self);
1918 }
1919
1920 static int
1921 tdefault_always_non_stop_p (struct target_ops *self)
1922 {
1923 return 0;
1924 }
1925
1926 static int
1927 debug_always_non_stop_p (struct target_ops *self)
1928 {
1929 int result;
1930 fprintf_unfiltered (gdb_stdlog, "-> %s->to_always_non_stop_p (...)\n", debug_target.to_shortname);
1931 result = debug_target.to_always_non_stop_p (&debug_target);
1932 fprintf_unfiltered (gdb_stdlog, "<- %s->to_always_non_stop_p (", debug_target.to_shortname);
1933 target_debug_print_struct_target_ops_p (&debug_target);
1934 fputs_unfiltered (") = ", gdb_stdlog);
1935 target_debug_print_int (result);
1936 fputs_unfiltered ("\n", gdb_stdlog);
1937 return result;
1938 }
1939
1940 static int
1941 delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
1942 {
1943 self = self->beneath;
1944 return self->to_find_memory_regions (self, arg1, arg2);
1945 }
1946
1947 static int
1948 debug_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
1949 {
1950 int result;
1951 fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", debug_target.to_shortname);
1952 result = debug_target.to_find_memory_regions (&debug_target, arg1, arg2);
1953 fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", debug_target.to_shortname);
1954 target_debug_print_struct_target_ops_p (&debug_target);
1955 fputs_unfiltered (", ", gdb_stdlog);
1956 target_debug_print_find_memory_region_ftype (arg1);
1957 fputs_unfiltered (", ", gdb_stdlog);
1958 target_debug_print_void_p (arg2);
1959 fputs_unfiltered (") = ", gdb_stdlog);
1960 target_debug_print_int (result);
1961 fputs_unfiltered ("\n", gdb_stdlog);
1962 return result;
1963 }
1964
1965 static char *
1966 delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
1967 {
1968 self = self->beneath;
1969 return self->to_make_corefile_notes (self, arg1, arg2);
1970 }
1971
1972 static char *
1973 debug_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
1974 {
1975 char * result;
1976 fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", debug_target.to_shortname);
1977 result = debug_target.to_make_corefile_notes (&debug_target, arg1, arg2);
1978 fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", debug_target.to_shortname);
1979 target_debug_print_struct_target_ops_p (&debug_target);
1980 fputs_unfiltered (", ", gdb_stdlog);
1981 target_debug_print_bfd_p (arg1);
1982 fputs_unfiltered (", ", gdb_stdlog);
1983 target_debug_print_int_p (arg2);
1984 fputs_unfiltered (") = ", gdb_stdlog);
1985 target_debug_print_char_p (result);
1986 fputs_unfiltered ("\n", gdb_stdlog);
1987 return result;
1988 }
1989
1990 static gdb_byte *
1991 delegate_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
1992 {
1993 self = self->beneath;
1994 return self->to_get_bookmark (self, arg1, arg2);
1995 }
1996
1997 static gdb_byte *
1998 tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
1999 {
2000 tcomplain ();
2001 }
2002
2003 static gdb_byte *
2004 debug_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
2005 {
2006 gdb_byte * result;
2007 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", debug_target.to_shortname);
2008 result = debug_target.to_get_bookmark (&debug_target, arg1, arg2);
2009 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", debug_target.to_shortname);
2010 target_debug_print_struct_target_ops_p (&debug_target);
2011 fputs_unfiltered (", ", gdb_stdlog);
2012 target_debug_print_const_char_p (arg1);
2013 fputs_unfiltered (", ", gdb_stdlog);
2014 target_debug_print_int (arg2);
2015 fputs_unfiltered (") = ", gdb_stdlog);
2016 target_debug_print_gdb_byte_p (result);
2017 fputs_unfiltered ("\n", gdb_stdlog);
2018 return result;
2019 }
2020
2021 static void
2022 delegate_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
2023 {
2024 self = self->beneath;
2025 self->to_goto_bookmark (self, arg1, arg2);
2026 }
2027
2028 static void
2029 tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
2030 {
2031 tcomplain ();
2032 }
2033
2034 static void
2035 debug_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
2036 {
2037 fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", debug_target.to_shortname);
2038 debug_target.to_goto_bookmark (&debug_target, arg1, arg2);
2039 fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", debug_target.to_shortname);
2040 target_debug_print_struct_target_ops_p (&debug_target);
2041 fputs_unfiltered (", ", gdb_stdlog);
2042 target_debug_print_const_gdb_byte_p (arg1);
2043 fputs_unfiltered (", ", gdb_stdlog);
2044 target_debug_print_int (arg2);
2045 fputs_unfiltered (")\n", gdb_stdlog);
2046 }
2047
2048 static CORE_ADDR
2049 delegate_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
2050 {
2051 self = self->beneath;
2052 return self->to_get_thread_local_address (self, arg1, arg2, arg3);
2053 }
2054
2055 static CORE_ADDR
2056 tdefault_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
2057 {
2058 generic_tls_error ();
2059 }
2060
2061 static CORE_ADDR
2062 debug_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
2063 {
2064 CORE_ADDR result;
2065 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_thread_local_address (...)\n", debug_target.to_shortname);
2066 result = debug_target.to_get_thread_local_address (&debug_target, arg1, arg2, arg3);
2067 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_thread_local_address (", debug_target.to_shortname);
2068 target_debug_print_struct_target_ops_p (&debug_target);
2069 fputs_unfiltered (", ", gdb_stdlog);
2070 target_debug_print_ptid_t (arg1);
2071 fputs_unfiltered (", ", gdb_stdlog);
2072 target_debug_print_CORE_ADDR (arg2);
2073 fputs_unfiltered (", ", gdb_stdlog);
2074 target_debug_print_CORE_ADDR (arg3);
2075 fputs_unfiltered (") = ", gdb_stdlog);
2076 target_debug_print_CORE_ADDR (result);
2077 fputs_unfiltered ("\n", gdb_stdlog);
2078 return result;
2079 }
2080
2081 static enum target_xfer_status
2082 delegate_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
2083 {
2084 self = self->beneath;
2085 return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2086 }
2087
2088 static enum target_xfer_status
2089 tdefault_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
2090 {
2091 return TARGET_XFER_E_IO;
2092 }
2093
2094 static enum target_xfer_status
2095 debug_xfer_partial (struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
2096 {
2097 enum target_xfer_status result;
2098 fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", debug_target.to_shortname);
2099 result = debug_target.to_xfer_partial (&debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2100 fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", debug_target.to_shortname);
2101 target_debug_print_struct_target_ops_p (&debug_target);
2102 fputs_unfiltered (", ", gdb_stdlog);
2103 target_debug_print_enum_target_object (arg1);
2104 fputs_unfiltered (", ", gdb_stdlog);
2105 target_debug_print_const_char_p (arg2);
2106 fputs_unfiltered (", ", gdb_stdlog);
2107 target_debug_print_gdb_byte_p (arg3);
2108 fputs_unfiltered (", ", gdb_stdlog);
2109 target_debug_print_const_gdb_byte_p (arg4);
2110 fputs_unfiltered (", ", gdb_stdlog);
2111 target_debug_print_ULONGEST (arg5);
2112 fputs_unfiltered (", ", gdb_stdlog);
2113 target_debug_print_ULONGEST (arg6);
2114 fputs_unfiltered (", ", gdb_stdlog);
2115 target_debug_print_ULONGEST_p (arg7);
2116 fputs_unfiltered (") = ", gdb_stdlog);
2117 target_debug_print_enum_target_xfer_status (result);
2118 fputs_unfiltered ("\n", gdb_stdlog);
2119 return result;
2120 }
2121
2122 static ULONGEST
2123 delegate_get_memory_xfer_limit (struct target_ops *self)
2124 {
2125 self = self->beneath;
2126 return self->to_get_memory_xfer_limit (self);
2127 }
2128
2129 static ULONGEST
2130 tdefault_get_memory_xfer_limit (struct target_ops *self)
2131 {
2132 return ULONGEST_MAX;
2133 }
2134
2135 static ULONGEST
2136 debug_get_memory_xfer_limit (struct target_ops *self)
2137 {
2138 ULONGEST result;
2139 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_memory_xfer_limit (...)\n", debug_target.to_shortname);
2140 result = debug_target.to_get_memory_xfer_limit (&debug_target);
2141 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_memory_xfer_limit (", debug_target.to_shortname);
2142 target_debug_print_struct_target_ops_p (&debug_target);
2143 fputs_unfiltered (") = ", gdb_stdlog);
2144 target_debug_print_ULONGEST (result);
2145 fputs_unfiltered ("\n", gdb_stdlog);
2146 return result;
2147 }
2148
2149 static std::vector<mem_region>
2150 delegate_memory_map (struct target_ops *self)
2151 {
2152 self = self->beneath;
2153 return self->to_memory_map (self);
2154 }
2155
2156 static std::vector<mem_region>
2157 tdefault_memory_map (struct target_ops *self)
2158 {
2159 return std::vector<mem_region> ();
2160 }
2161
2162 static std::vector<mem_region>
2163 debug_memory_map (struct target_ops *self)
2164 {
2165 std::vector<mem_region> result;
2166 fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", debug_target.to_shortname);
2167 result = debug_target.to_memory_map (&debug_target);
2168 fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", debug_target.to_shortname);
2169 target_debug_print_struct_target_ops_p (&debug_target);
2170 fputs_unfiltered (") = ", gdb_stdlog);
2171 target_debug_print_std_vector_mem_region (result);
2172 fputs_unfiltered ("\n", gdb_stdlog);
2173 return result;
2174 }
2175
2176 static void
2177 delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
2178 {
2179 self = self->beneath;
2180 self->to_flash_erase (self, arg1, arg2);
2181 }
2182
2183 static void
2184 tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
2185 {
2186 tcomplain ();
2187 }
2188
2189 static void
2190 debug_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
2191 {
2192 fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", debug_target.to_shortname);
2193 debug_target.to_flash_erase (&debug_target, arg1, arg2);
2194 fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", debug_target.to_shortname);
2195 target_debug_print_struct_target_ops_p (&debug_target);
2196 fputs_unfiltered (", ", gdb_stdlog);
2197 target_debug_print_ULONGEST (arg1);
2198 fputs_unfiltered (", ", gdb_stdlog);
2199 target_debug_print_LONGEST (arg2);
2200 fputs_unfiltered (")\n", gdb_stdlog);
2201 }
2202
2203 static void
2204 delegate_flash_done (struct target_ops *self)
2205 {
2206 self = self->beneath;
2207 self->to_flash_done (self);
2208 }
2209
2210 static void
2211 tdefault_flash_done (struct target_ops *self)
2212 {
2213 tcomplain ();
2214 }
2215
2216 static void
2217 debug_flash_done (struct target_ops *self)
2218 {
2219 fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", debug_target.to_shortname);
2220 debug_target.to_flash_done (&debug_target);
2221 fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", debug_target.to_shortname);
2222 target_debug_print_struct_target_ops_p (&debug_target);
2223 fputs_unfiltered (")\n", gdb_stdlog);
2224 }
2225
2226 static const struct target_desc *
2227 delegate_read_description (struct target_ops *self)
2228 {
2229 self = self->beneath;
2230 return self->to_read_description (self);
2231 }
2232
2233 static const struct target_desc *
2234 tdefault_read_description (struct target_ops *self)
2235 {
2236 return NULL;
2237 }
2238
2239 static const struct target_desc *
2240 debug_read_description (struct target_ops *self)
2241 {
2242 const struct target_desc * result;
2243 fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", debug_target.to_shortname);
2244 result = debug_target.to_read_description (&debug_target);
2245 fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", debug_target.to_shortname);
2246 target_debug_print_struct_target_ops_p (&debug_target);
2247 fputs_unfiltered (") = ", gdb_stdlog);
2248 target_debug_print_const_struct_target_desc_p (result);
2249 fputs_unfiltered ("\n", gdb_stdlog);
2250 return result;
2251 }
2252
2253 static ptid_t
2254 delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
2255 {
2256 self = self->beneath;
2257 return self->to_get_ada_task_ptid (self, arg1, arg2);
2258 }
2259
2260 static ptid_t
2261 debug_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
2262 {
2263 ptid_t result;
2264 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", debug_target.to_shortname);
2265 result = debug_target.to_get_ada_task_ptid (&debug_target, arg1, arg2);
2266 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", debug_target.to_shortname);
2267 target_debug_print_struct_target_ops_p (&debug_target);
2268 fputs_unfiltered (", ", gdb_stdlog);
2269 target_debug_print_long (arg1);
2270 fputs_unfiltered (", ", gdb_stdlog);
2271 target_debug_print_long (arg2);
2272 fputs_unfiltered (") = ", gdb_stdlog);
2273 target_debug_print_ptid_t (result);
2274 fputs_unfiltered ("\n", gdb_stdlog);
2275 return result;
2276 }
2277
2278 static int
2279 delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
2280 {
2281 self = self->beneath;
2282 return self->to_auxv_parse (self, arg1, arg2, arg3, arg4);
2283 }
2284
2285 static int
2286 debug_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
2287 {
2288 int result;
2289 fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", debug_target.to_shortname);
2290 result = debug_target.to_auxv_parse (&debug_target, arg1, arg2, arg3, arg4);
2291 fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", debug_target.to_shortname);
2292 target_debug_print_struct_target_ops_p (&debug_target);
2293 fputs_unfiltered (", ", gdb_stdlog);
2294 target_debug_print_gdb_byte_pp (arg1);
2295 fputs_unfiltered (", ", gdb_stdlog);
2296 target_debug_print_gdb_byte_p (arg2);
2297 fputs_unfiltered (", ", gdb_stdlog);
2298 target_debug_print_CORE_ADDR_p (arg3);
2299 fputs_unfiltered (", ", gdb_stdlog);
2300 target_debug_print_CORE_ADDR_p (arg4);
2301 fputs_unfiltered (") = ", gdb_stdlog);
2302 target_debug_print_int (result);
2303 fputs_unfiltered ("\n", gdb_stdlog);
2304 return result;
2305 }
2306
2307 static int
2308 delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
2309 {
2310 self = self->beneath;
2311 return self->to_search_memory (self, arg1, arg2, arg3, arg4, arg5);
2312 }
2313
2314 static int
2315 debug_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
2316 {
2317 int result;
2318 fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", debug_target.to_shortname);
2319 result = debug_target.to_search_memory (&debug_target, arg1, arg2, arg3, arg4, arg5);
2320 fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", debug_target.to_shortname);
2321 target_debug_print_struct_target_ops_p (&debug_target);
2322 fputs_unfiltered (", ", gdb_stdlog);
2323 target_debug_print_CORE_ADDR (arg1);
2324 fputs_unfiltered (", ", gdb_stdlog);
2325 target_debug_print_ULONGEST (arg2);
2326 fputs_unfiltered (", ", gdb_stdlog);
2327 target_debug_print_const_gdb_byte_p (arg3);
2328 fputs_unfiltered (", ", gdb_stdlog);
2329 target_debug_print_ULONGEST (arg4);
2330 fputs_unfiltered (", ", gdb_stdlog);
2331 target_debug_print_CORE_ADDR_p (arg5);
2332 fputs_unfiltered (") = ", gdb_stdlog);
2333 target_debug_print_int (result);
2334 fputs_unfiltered ("\n", gdb_stdlog);
2335 return result;
2336 }
2337
2338 static int
2339 delegate_can_execute_reverse (struct target_ops *self)
2340 {
2341 self = self->beneath;
2342 return self->to_can_execute_reverse (self);
2343 }
2344
2345 static int
2346 tdefault_can_execute_reverse (struct target_ops *self)
2347 {
2348 return 0;
2349 }
2350
2351 static int
2352 debug_can_execute_reverse (struct target_ops *self)
2353 {
2354 int result;
2355 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", debug_target.to_shortname);
2356 result = debug_target.to_can_execute_reverse (&debug_target);
2357 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", debug_target.to_shortname);
2358 target_debug_print_struct_target_ops_p (&debug_target);
2359 fputs_unfiltered (") = ", gdb_stdlog);
2360 target_debug_print_int (result);
2361 fputs_unfiltered ("\n", gdb_stdlog);
2362 return result;
2363 }
2364
2365 static enum exec_direction_kind
2366 delegate_execution_direction (struct target_ops *self)
2367 {
2368 self = self->beneath;
2369 return self->to_execution_direction (self);
2370 }
2371
2372 static enum exec_direction_kind
2373 debug_execution_direction (struct target_ops *self)
2374 {
2375 enum exec_direction_kind result;
2376 fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", debug_target.to_shortname);
2377 result = debug_target.to_execution_direction (&debug_target);
2378 fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", debug_target.to_shortname);
2379 target_debug_print_struct_target_ops_p (&debug_target);
2380 fputs_unfiltered (") = ", gdb_stdlog);
2381 target_debug_print_enum_exec_direction_kind (result);
2382 fputs_unfiltered ("\n", gdb_stdlog);
2383 return result;
2384 }
2385
2386 static int
2387 delegate_supports_multi_process (struct target_ops *self)
2388 {
2389 self = self->beneath;
2390 return self->to_supports_multi_process (self);
2391 }
2392
2393 static int
2394 tdefault_supports_multi_process (struct target_ops *self)
2395 {
2396 return 0;
2397 }
2398
2399 static int
2400 debug_supports_multi_process (struct target_ops *self)
2401 {
2402 int result;
2403 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", debug_target.to_shortname);
2404 result = debug_target.to_supports_multi_process (&debug_target);
2405 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", debug_target.to_shortname);
2406 target_debug_print_struct_target_ops_p (&debug_target);
2407 fputs_unfiltered (") = ", gdb_stdlog);
2408 target_debug_print_int (result);
2409 fputs_unfiltered ("\n", gdb_stdlog);
2410 return result;
2411 }
2412
2413 static int
2414 delegate_supports_enable_disable_tracepoint (struct target_ops *self)
2415 {
2416 self = self->beneath;
2417 return self->to_supports_enable_disable_tracepoint (self);
2418 }
2419
2420 static int
2421 tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
2422 {
2423 return 0;
2424 }
2425
2426 static int
2427 debug_supports_enable_disable_tracepoint (struct target_ops *self)
2428 {
2429 int result;
2430 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", debug_target.to_shortname);
2431 result = debug_target.to_supports_enable_disable_tracepoint (&debug_target);
2432 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", debug_target.to_shortname);
2433 target_debug_print_struct_target_ops_p (&debug_target);
2434 fputs_unfiltered (") = ", gdb_stdlog);
2435 target_debug_print_int (result);
2436 fputs_unfiltered ("\n", gdb_stdlog);
2437 return result;
2438 }
2439
2440 static int
2441 delegate_supports_string_tracing (struct target_ops *self)
2442 {
2443 self = self->beneath;
2444 return self->to_supports_string_tracing (self);
2445 }
2446
2447 static int
2448 tdefault_supports_string_tracing (struct target_ops *self)
2449 {
2450 return 0;
2451 }
2452
2453 static int
2454 debug_supports_string_tracing (struct target_ops *self)
2455 {
2456 int result;
2457 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", debug_target.to_shortname);
2458 result = debug_target.to_supports_string_tracing (&debug_target);
2459 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", debug_target.to_shortname);
2460 target_debug_print_struct_target_ops_p (&debug_target);
2461 fputs_unfiltered (") = ", gdb_stdlog);
2462 target_debug_print_int (result);
2463 fputs_unfiltered ("\n", gdb_stdlog);
2464 return result;
2465 }
2466
2467 static int
2468 delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
2469 {
2470 self = self->beneath;
2471 return self->to_supports_evaluation_of_breakpoint_conditions (self);
2472 }
2473
2474 static int
2475 tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
2476 {
2477 return 0;
2478 }
2479
2480 static int
2481 debug_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
2482 {
2483 int result;
2484 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", debug_target.to_shortname);
2485 result = debug_target.to_supports_evaluation_of_breakpoint_conditions (&debug_target);
2486 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", debug_target.to_shortname);
2487 target_debug_print_struct_target_ops_p (&debug_target);
2488 fputs_unfiltered (") = ", gdb_stdlog);
2489 target_debug_print_int (result);
2490 fputs_unfiltered ("\n", gdb_stdlog);
2491 return result;
2492 }
2493
2494 static int
2495 delegate_can_run_breakpoint_commands (struct target_ops *self)
2496 {
2497 self = self->beneath;
2498 return self->to_can_run_breakpoint_commands (self);
2499 }
2500
2501 static int
2502 tdefault_can_run_breakpoint_commands (struct target_ops *self)
2503 {
2504 return 0;
2505 }
2506
2507 static int
2508 debug_can_run_breakpoint_commands (struct target_ops *self)
2509 {
2510 int result;
2511 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", debug_target.to_shortname);
2512 result = debug_target.to_can_run_breakpoint_commands (&debug_target);
2513 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", debug_target.to_shortname);
2514 target_debug_print_struct_target_ops_p (&debug_target);
2515 fputs_unfiltered (") = ", gdb_stdlog);
2516 target_debug_print_int (result);
2517 fputs_unfiltered ("\n", gdb_stdlog);
2518 return result;
2519 }
2520
2521 static struct gdbarch *
2522 delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
2523 {
2524 self = self->beneath;
2525 return self->to_thread_architecture (self, arg1);
2526 }
2527
2528 static struct gdbarch *
2529 debug_thread_architecture (struct target_ops *self, ptid_t arg1)
2530 {
2531 struct gdbarch * result;
2532 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", debug_target.to_shortname);
2533 result = debug_target.to_thread_architecture (&debug_target, arg1);
2534 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", debug_target.to_shortname);
2535 target_debug_print_struct_target_ops_p (&debug_target);
2536 fputs_unfiltered (", ", gdb_stdlog);
2537 target_debug_print_ptid_t (arg1);
2538 fputs_unfiltered (") = ", gdb_stdlog);
2539 target_debug_print_struct_gdbarch_p (result);
2540 fputs_unfiltered ("\n", gdb_stdlog);
2541 return result;
2542 }
2543
2544 static struct address_space *
2545 delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
2546 {
2547 self = self->beneath;
2548 return self->to_thread_address_space (self, arg1);
2549 }
2550
2551 static struct address_space *
2552 debug_thread_address_space (struct target_ops *self, ptid_t arg1)
2553 {
2554 struct address_space * result;
2555 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", debug_target.to_shortname);
2556 result = debug_target.to_thread_address_space (&debug_target, arg1);
2557 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", debug_target.to_shortname);
2558 target_debug_print_struct_target_ops_p (&debug_target);
2559 fputs_unfiltered (", ", gdb_stdlog);
2560 target_debug_print_ptid_t (arg1);
2561 fputs_unfiltered (") = ", gdb_stdlog);
2562 target_debug_print_struct_address_space_p (result);
2563 fputs_unfiltered ("\n", gdb_stdlog);
2564 return result;
2565 }
2566
2567 static int
2568 delegate_filesystem_is_local (struct target_ops *self)
2569 {
2570 self = self->beneath;
2571 return self->to_filesystem_is_local (self);
2572 }
2573
2574 static int
2575 tdefault_filesystem_is_local (struct target_ops *self)
2576 {
2577 return 1;
2578 }
2579
2580 static int
2581 debug_filesystem_is_local (struct target_ops *self)
2582 {
2583 int result;
2584 fprintf_unfiltered (gdb_stdlog, "-> %s->to_filesystem_is_local (...)\n", debug_target.to_shortname);
2585 result = debug_target.to_filesystem_is_local (&debug_target);
2586 fprintf_unfiltered (gdb_stdlog, "<- %s->to_filesystem_is_local (", debug_target.to_shortname);
2587 target_debug_print_struct_target_ops_p (&debug_target);
2588 fputs_unfiltered (") = ", gdb_stdlog);
2589 target_debug_print_int (result);
2590 fputs_unfiltered ("\n", gdb_stdlog);
2591 return result;
2592 }
2593
2594 static void
2595 delegate_trace_init (struct target_ops *self)
2596 {
2597 self = self->beneath;
2598 self->to_trace_init (self);
2599 }
2600
2601 static void
2602 tdefault_trace_init (struct target_ops *self)
2603 {
2604 tcomplain ();
2605 }
2606
2607 static void
2608 debug_trace_init (struct target_ops *self)
2609 {
2610 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", debug_target.to_shortname);
2611 debug_target.to_trace_init (&debug_target);
2612 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", debug_target.to_shortname);
2613 target_debug_print_struct_target_ops_p (&debug_target);
2614 fputs_unfiltered (")\n", gdb_stdlog);
2615 }
2616
2617 static void
2618 delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
2619 {
2620 self = self->beneath;
2621 self->to_download_tracepoint (self, arg1);
2622 }
2623
2624 static void
2625 tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
2626 {
2627 tcomplain ();
2628 }
2629
2630 static void
2631 debug_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
2632 {
2633 fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", debug_target.to_shortname);
2634 debug_target.to_download_tracepoint (&debug_target, arg1);
2635 fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", debug_target.to_shortname);
2636 target_debug_print_struct_target_ops_p (&debug_target);
2637 fputs_unfiltered (", ", gdb_stdlog);
2638 target_debug_print_struct_bp_location_p (arg1);
2639 fputs_unfiltered (")\n", gdb_stdlog);
2640 }
2641
2642 static int
2643 delegate_can_download_tracepoint (struct target_ops *self)
2644 {
2645 self = self->beneath;
2646 return self->to_can_download_tracepoint (self);
2647 }
2648
2649 static int
2650 tdefault_can_download_tracepoint (struct target_ops *self)
2651 {
2652 return 0;
2653 }
2654
2655 static int
2656 debug_can_download_tracepoint (struct target_ops *self)
2657 {
2658 int result;
2659 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", debug_target.to_shortname);
2660 result = debug_target.to_can_download_tracepoint (&debug_target);
2661 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", debug_target.to_shortname);
2662 target_debug_print_struct_target_ops_p (&debug_target);
2663 fputs_unfiltered (") = ", gdb_stdlog);
2664 target_debug_print_int (result);
2665 fputs_unfiltered ("\n", gdb_stdlog);
2666 return result;
2667 }
2668
2669 static void
2670 delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
2671 {
2672 self = self->beneath;
2673 self->to_download_trace_state_variable (self, arg1);
2674 }
2675
2676 static void
2677 tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
2678 {
2679 tcomplain ();
2680 }
2681
2682 static void
2683 debug_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
2684 {
2685 fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", debug_target.to_shortname);
2686 debug_target.to_download_trace_state_variable (&debug_target, arg1);
2687 fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", debug_target.to_shortname);
2688 target_debug_print_struct_target_ops_p (&debug_target);
2689 fputs_unfiltered (", ", gdb_stdlog);
2690 target_debug_print_struct_trace_state_variable_p (arg1);
2691 fputs_unfiltered (")\n", gdb_stdlog);
2692 }
2693
2694 static void
2695 delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2696 {
2697 self = self->beneath;
2698 self->to_enable_tracepoint (self, arg1);
2699 }
2700
2701 static void
2702 tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2703 {
2704 tcomplain ();
2705 }
2706
2707 static void
2708 debug_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2709 {
2710 fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", debug_target.to_shortname);
2711 debug_target.to_enable_tracepoint (&debug_target, arg1);
2712 fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", debug_target.to_shortname);
2713 target_debug_print_struct_target_ops_p (&debug_target);
2714 fputs_unfiltered (", ", gdb_stdlog);
2715 target_debug_print_struct_bp_location_p (arg1);
2716 fputs_unfiltered (")\n", gdb_stdlog);
2717 }
2718
2719 static void
2720 delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2721 {
2722 self = self->beneath;
2723 self->to_disable_tracepoint (self, arg1);
2724 }
2725
2726 static void
2727 tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2728 {
2729 tcomplain ();
2730 }
2731
2732 static void
2733 debug_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2734 {
2735 fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", debug_target.to_shortname);
2736 debug_target.to_disable_tracepoint (&debug_target, arg1);
2737 fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", debug_target.to_shortname);
2738 target_debug_print_struct_target_ops_p (&debug_target);
2739 fputs_unfiltered (", ", gdb_stdlog);
2740 target_debug_print_struct_bp_location_p (arg1);
2741 fputs_unfiltered (")\n", gdb_stdlog);
2742 }
2743
2744 static void
2745 delegate_trace_set_readonly_regions (struct target_ops *self)
2746 {
2747 self = self->beneath;
2748 self->to_trace_set_readonly_regions (self);
2749 }
2750
2751 static void
2752 tdefault_trace_set_readonly_regions (struct target_ops *self)
2753 {
2754 tcomplain ();
2755 }
2756
2757 static void
2758 debug_trace_set_readonly_regions (struct target_ops *self)
2759 {
2760 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", debug_target.to_shortname);
2761 debug_target.to_trace_set_readonly_regions (&debug_target);
2762 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", debug_target.to_shortname);
2763 target_debug_print_struct_target_ops_p (&debug_target);
2764 fputs_unfiltered (")\n", gdb_stdlog);
2765 }
2766
2767 static void
2768 delegate_trace_start (struct target_ops *self)
2769 {
2770 self = self->beneath;
2771 self->to_trace_start (self);
2772 }
2773
2774 static void
2775 tdefault_trace_start (struct target_ops *self)
2776 {
2777 tcomplain ();
2778 }
2779
2780 static void
2781 debug_trace_start (struct target_ops *self)
2782 {
2783 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", debug_target.to_shortname);
2784 debug_target.to_trace_start (&debug_target);
2785 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", debug_target.to_shortname);
2786 target_debug_print_struct_target_ops_p (&debug_target);
2787 fputs_unfiltered (")\n", gdb_stdlog);
2788 }
2789
2790 static int
2791 delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
2792 {
2793 self = self->beneath;
2794 return self->to_get_trace_status (self, arg1);
2795 }
2796
2797 static int
2798 tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
2799 {
2800 return -1;
2801 }
2802
2803 static int
2804 debug_get_trace_status (struct target_ops *self, struct trace_status *arg1)
2805 {
2806 int result;
2807 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", debug_target.to_shortname);
2808 result = debug_target.to_get_trace_status (&debug_target, arg1);
2809 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", debug_target.to_shortname);
2810 target_debug_print_struct_target_ops_p (&debug_target);
2811 fputs_unfiltered (", ", gdb_stdlog);
2812 target_debug_print_struct_trace_status_p (arg1);
2813 fputs_unfiltered (") = ", gdb_stdlog);
2814 target_debug_print_int (result);
2815 fputs_unfiltered ("\n", gdb_stdlog);
2816 return result;
2817 }
2818
2819 static void
2820 delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2821 {
2822 self = self->beneath;
2823 self->to_get_tracepoint_status (self, arg1, arg2);
2824 }
2825
2826 static void
2827 tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2828 {
2829 tcomplain ();
2830 }
2831
2832 static void
2833 debug_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2834 {
2835 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", debug_target.to_shortname);
2836 debug_target.to_get_tracepoint_status (&debug_target, arg1, arg2);
2837 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", debug_target.to_shortname);
2838 target_debug_print_struct_target_ops_p (&debug_target);
2839 fputs_unfiltered (", ", gdb_stdlog);
2840 target_debug_print_struct_breakpoint_p (arg1);
2841 fputs_unfiltered (", ", gdb_stdlog);
2842 target_debug_print_struct_uploaded_tp_p (arg2);
2843 fputs_unfiltered (")\n", gdb_stdlog);
2844 }
2845
2846 static void
2847 delegate_trace_stop (struct target_ops *self)
2848 {
2849 self = self->beneath;
2850 self->to_trace_stop (self);
2851 }
2852
2853 static void
2854 tdefault_trace_stop (struct target_ops *self)
2855 {
2856 tcomplain ();
2857 }
2858
2859 static void
2860 debug_trace_stop (struct target_ops *self)
2861 {
2862 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", debug_target.to_shortname);
2863 debug_target.to_trace_stop (&debug_target);
2864 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", debug_target.to_shortname);
2865 target_debug_print_struct_target_ops_p (&debug_target);
2866 fputs_unfiltered (")\n", gdb_stdlog);
2867 }
2868
2869 static int
2870 delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
2871 {
2872 self = self->beneath;
2873 return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5);
2874 }
2875
2876 static int
2877 tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
2878 {
2879 return -1;
2880 }
2881
2882 static int
2883 debug_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
2884 {
2885 int result;
2886 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", debug_target.to_shortname);
2887 result = debug_target.to_trace_find (&debug_target, arg1, arg2, arg3, arg4, arg5);
2888 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", debug_target.to_shortname);
2889 target_debug_print_struct_target_ops_p (&debug_target);
2890 fputs_unfiltered (", ", gdb_stdlog);
2891 target_debug_print_enum_trace_find_type (arg1);
2892 fputs_unfiltered (", ", gdb_stdlog);
2893 target_debug_print_int (arg2);
2894 fputs_unfiltered (", ", gdb_stdlog);
2895 target_debug_print_CORE_ADDR (arg3);
2896 fputs_unfiltered (", ", gdb_stdlog);
2897 target_debug_print_CORE_ADDR (arg4);
2898 fputs_unfiltered (", ", gdb_stdlog);
2899 target_debug_print_int_p (arg5);
2900 fputs_unfiltered (") = ", gdb_stdlog);
2901 target_debug_print_int (result);
2902 fputs_unfiltered ("\n", gdb_stdlog);
2903 return result;
2904 }
2905
2906 static int
2907 delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
2908 {
2909 self = self->beneath;
2910 return self->to_get_trace_state_variable_value (self, arg1, arg2);
2911 }
2912
2913 static int
2914 tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
2915 {
2916 return 0;
2917 }
2918
2919 static int
2920 debug_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
2921 {
2922 int result;
2923 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", debug_target.to_shortname);
2924 result = debug_target.to_get_trace_state_variable_value (&debug_target, arg1, arg2);
2925 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", debug_target.to_shortname);
2926 target_debug_print_struct_target_ops_p (&debug_target);
2927 fputs_unfiltered (", ", gdb_stdlog);
2928 target_debug_print_int (arg1);
2929 fputs_unfiltered (", ", gdb_stdlog);
2930 target_debug_print_LONGEST_p (arg2);
2931 fputs_unfiltered (") = ", gdb_stdlog);
2932 target_debug_print_int (result);
2933 fputs_unfiltered ("\n", gdb_stdlog);
2934 return result;
2935 }
2936
2937 static int
2938 delegate_save_trace_data (struct target_ops *self, const char *arg1)
2939 {
2940 self = self->beneath;
2941 return self->to_save_trace_data (self, arg1);
2942 }
2943
2944 static int
2945 tdefault_save_trace_data (struct target_ops *self, const char *arg1)
2946 {
2947 tcomplain ();
2948 }
2949
2950 static int
2951 debug_save_trace_data (struct target_ops *self, const char *arg1)
2952 {
2953 int result;
2954 fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", debug_target.to_shortname);
2955 result = debug_target.to_save_trace_data (&debug_target, arg1);
2956 fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", debug_target.to_shortname);
2957 target_debug_print_struct_target_ops_p (&debug_target);
2958 fputs_unfiltered (", ", gdb_stdlog);
2959 target_debug_print_const_char_p (arg1);
2960 fputs_unfiltered (") = ", gdb_stdlog);
2961 target_debug_print_int (result);
2962 fputs_unfiltered ("\n", gdb_stdlog);
2963 return result;
2964 }
2965
2966 static int
2967 delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
2968 {
2969 self = self->beneath;
2970 return self->to_upload_tracepoints (self, arg1);
2971 }
2972
2973 static int
2974 tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
2975 {
2976 return 0;
2977 }
2978
2979 static int
2980 debug_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
2981 {
2982 int result;
2983 fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", debug_target.to_shortname);
2984 result = debug_target.to_upload_tracepoints (&debug_target, arg1);
2985 fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", debug_target.to_shortname);
2986 target_debug_print_struct_target_ops_p (&debug_target);
2987 fputs_unfiltered (", ", gdb_stdlog);
2988 target_debug_print_struct_uploaded_tp_pp (arg1);
2989 fputs_unfiltered (") = ", gdb_stdlog);
2990 target_debug_print_int (result);
2991 fputs_unfiltered ("\n", gdb_stdlog);
2992 return result;
2993 }
2994
2995 static int
2996 delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
2997 {
2998 self = self->beneath;
2999 return self->to_upload_trace_state_variables (self, arg1);
3000 }
3001
3002 static int
3003 tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
3004 {
3005 return 0;
3006 }
3007
3008 static int
3009 debug_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
3010 {
3011 int result;
3012 fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", debug_target.to_shortname);
3013 result = debug_target.to_upload_trace_state_variables (&debug_target, arg1);
3014 fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", debug_target.to_shortname);
3015 target_debug_print_struct_target_ops_p (&debug_target);
3016 fputs_unfiltered (", ", gdb_stdlog);
3017 target_debug_print_struct_uploaded_tsv_pp (arg1);
3018 fputs_unfiltered (") = ", gdb_stdlog);
3019 target_debug_print_int (result);
3020 fputs_unfiltered ("\n", gdb_stdlog);
3021 return result;
3022 }
3023
3024 static LONGEST
3025 delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
3026 {
3027 self = self->beneath;
3028 return self->to_get_raw_trace_data (self, arg1, arg2, arg3);
3029 }
3030
3031 static LONGEST
3032 tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
3033 {
3034 tcomplain ();
3035 }
3036
3037 static LONGEST
3038 debug_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
3039 {
3040 LONGEST result;
3041 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", debug_target.to_shortname);
3042 result = debug_target.to_get_raw_trace_data (&debug_target, arg1, arg2, arg3);
3043 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", debug_target.to_shortname);
3044 target_debug_print_struct_target_ops_p (&debug_target);
3045 fputs_unfiltered (", ", gdb_stdlog);
3046 target_debug_print_gdb_byte_p (arg1);
3047 fputs_unfiltered (", ", gdb_stdlog);
3048 target_debug_print_ULONGEST (arg2);
3049 fputs_unfiltered (", ", gdb_stdlog);
3050 target_debug_print_LONGEST (arg3);
3051 fputs_unfiltered (") = ", gdb_stdlog);
3052 target_debug_print_LONGEST (result);
3053 fputs_unfiltered ("\n", gdb_stdlog);
3054 return result;
3055 }
3056
3057 static int
3058 delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
3059 {
3060 self = self->beneath;
3061 return self->to_get_min_fast_tracepoint_insn_len (self);
3062 }
3063
3064 static int
3065 tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
3066 {
3067 return -1;
3068 }
3069
3070 static int
3071 debug_get_min_fast_tracepoint_insn_len (struct target_ops *self)
3072 {
3073 int result;
3074 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", debug_target.to_shortname);
3075 result = debug_target.to_get_min_fast_tracepoint_insn_len (&debug_target);
3076 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", debug_target.to_shortname);
3077 target_debug_print_struct_target_ops_p (&debug_target);
3078 fputs_unfiltered (") = ", gdb_stdlog);
3079 target_debug_print_int (result);
3080 fputs_unfiltered ("\n", gdb_stdlog);
3081 return result;
3082 }
3083
3084 static void
3085 delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
3086 {
3087 self = self->beneath;
3088 self->to_set_disconnected_tracing (self, arg1);
3089 }
3090
3091 static void
3092 tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
3093 {
3094 }
3095
3096 static void
3097 debug_set_disconnected_tracing (struct target_ops *self, int arg1)
3098 {
3099 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", debug_target.to_shortname);
3100 debug_target.to_set_disconnected_tracing (&debug_target, arg1);
3101 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", debug_target.to_shortname);
3102 target_debug_print_struct_target_ops_p (&debug_target);
3103 fputs_unfiltered (", ", gdb_stdlog);
3104 target_debug_print_int (arg1);
3105 fputs_unfiltered (")\n", gdb_stdlog);
3106 }
3107
3108 static void
3109 delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
3110 {
3111 self = self->beneath;
3112 self->to_set_circular_trace_buffer (self, arg1);
3113 }
3114
3115 static void
3116 tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
3117 {
3118 }
3119
3120 static void
3121 debug_set_circular_trace_buffer (struct target_ops *self, int arg1)
3122 {
3123 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", debug_target.to_shortname);
3124 debug_target.to_set_circular_trace_buffer (&debug_target, arg1);
3125 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", debug_target.to_shortname);
3126 target_debug_print_struct_target_ops_p (&debug_target);
3127 fputs_unfiltered (", ", gdb_stdlog);
3128 target_debug_print_int (arg1);
3129 fputs_unfiltered (")\n", gdb_stdlog);
3130 }
3131
3132 static void
3133 delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
3134 {
3135 self = self->beneath;
3136 self->to_set_trace_buffer_size (self, arg1);
3137 }
3138
3139 static void
3140 tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
3141 {
3142 }
3143
3144 static void
3145 debug_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
3146 {
3147 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", debug_target.to_shortname);
3148 debug_target.to_set_trace_buffer_size (&debug_target, arg1);
3149 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", debug_target.to_shortname);
3150 target_debug_print_struct_target_ops_p (&debug_target);
3151 fputs_unfiltered (", ", gdb_stdlog);
3152 target_debug_print_LONGEST (arg1);
3153 fputs_unfiltered (")\n", gdb_stdlog);
3154 }
3155
3156 static int
3157 delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
3158 {
3159 self = self->beneath;
3160 return self->to_set_trace_notes (self, arg1, arg2, arg3);
3161 }
3162
3163 static int
3164 tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
3165 {
3166 return 0;
3167 }
3168
3169 static int
3170 debug_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
3171 {
3172 int result;
3173 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", debug_target.to_shortname);
3174 result = debug_target.to_set_trace_notes (&debug_target, arg1, arg2, arg3);
3175 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", debug_target.to_shortname);
3176 target_debug_print_struct_target_ops_p (&debug_target);
3177 fputs_unfiltered (", ", gdb_stdlog);
3178 target_debug_print_const_char_p (arg1);
3179 fputs_unfiltered (", ", gdb_stdlog);
3180 target_debug_print_const_char_p (arg2);
3181 fputs_unfiltered (", ", gdb_stdlog);
3182 target_debug_print_const_char_p (arg3);
3183 fputs_unfiltered (") = ", gdb_stdlog);
3184 target_debug_print_int (result);
3185 fputs_unfiltered ("\n", gdb_stdlog);
3186 return result;
3187 }
3188
3189 static int
3190 delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
3191 {
3192 self = self->beneath;
3193 return self->to_core_of_thread (self, arg1);
3194 }
3195
3196 static int
3197 tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
3198 {
3199 return -1;
3200 }
3201
3202 static int
3203 debug_core_of_thread (struct target_ops *self, ptid_t arg1)
3204 {
3205 int result;
3206 fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", debug_target.to_shortname);
3207 result = debug_target.to_core_of_thread (&debug_target, arg1);
3208 fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", debug_target.to_shortname);
3209 target_debug_print_struct_target_ops_p (&debug_target);
3210 fputs_unfiltered (", ", gdb_stdlog);
3211 target_debug_print_ptid_t (arg1);
3212 fputs_unfiltered (") = ", gdb_stdlog);
3213 target_debug_print_int (result);
3214 fputs_unfiltered ("\n", gdb_stdlog);
3215 return result;
3216 }
3217
3218 static int
3219 delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
3220 {
3221 self = self->beneath;
3222 return self->to_verify_memory (self, arg1, arg2, arg3);
3223 }
3224
3225 static int
3226 debug_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
3227 {
3228 int result;
3229 fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", debug_target.to_shortname);
3230 result = debug_target.to_verify_memory (&debug_target, arg1, arg2, arg3);
3231 fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", debug_target.to_shortname);
3232 target_debug_print_struct_target_ops_p (&debug_target);
3233 fputs_unfiltered (", ", gdb_stdlog);
3234 target_debug_print_const_gdb_byte_p (arg1);
3235 fputs_unfiltered (", ", gdb_stdlog);
3236 target_debug_print_CORE_ADDR (arg2);
3237 fputs_unfiltered (", ", gdb_stdlog);
3238 target_debug_print_ULONGEST (arg3);
3239 fputs_unfiltered (") = ", gdb_stdlog);
3240 target_debug_print_int (result);
3241 fputs_unfiltered ("\n", gdb_stdlog);
3242 return result;
3243 }
3244
3245 static int
3246 delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
3247 {
3248 self = self->beneath;
3249 return self->to_get_tib_address (self, arg1, arg2);
3250 }
3251
3252 static int
3253 tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
3254 {
3255 tcomplain ();
3256 }
3257
3258 static int
3259 debug_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
3260 {
3261 int result;
3262 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", debug_target.to_shortname);
3263 result = debug_target.to_get_tib_address (&debug_target, arg1, arg2);
3264 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_address (", debug_target.to_shortname);
3265 target_debug_print_struct_target_ops_p (&debug_target);
3266 fputs_unfiltered (", ", gdb_stdlog);
3267 target_debug_print_ptid_t (arg1);
3268 fputs_unfiltered (", ", gdb_stdlog);
3269 target_debug_print_CORE_ADDR_p (arg2);
3270 fputs_unfiltered (") = ", gdb_stdlog);
3271 target_debug_print_int (result);
3272 fputs_unfiltered ("\n", gdb_stdlog);
3273 return result;
3274 }
3275
3276 static void
3277 delegate_set_permissions (struct target_ops *self)
3278 {
3279 self = self->beneath;
3280 self->to_set_permissions (self);
3281 }
3282
3283 static void
3284 tdefault_set_permissions (struct target_ops *self)
3285 {
3286 }
3287
3288 static void
3289 debug_set_permissions (struct target_ops *self)
3290 {
3291 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", debug_target.to_shortname);
3292 debug_target.to_set_permissions (&debug_target);
3293 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", debug_target.to_shortname);
3294 target_debug_print_struct_target_ops_p (&debug_target);
3295 fputs_unfiltered (")\n", gdb_stdlog);
3296 }
3297
3298 static int
3299 delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
3300 {
3301 self = self->beneath;
3302 return self->to_static_tracepoint_marker_at (self, arg1, arg2);
3303 }
3304
3305 static int
3306 tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
3307 {
3308 return 0;
3309 }
3310
3311 static int
3312 debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
3313 {
3314 int result;
3315 fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", debug_target.to_shortname);
3316 result = debug_target.to_static_tracepoint_marker_at (&debug_target, arg1, arg2);
3317 fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", debug_target.to_shortname);
3318 target_debug_print_struct_target_ops_p (&debug_target);
3319 fputs_unfiltered (", ", gdb_stdlog);
3320 target_debug_print_CORE_ADDR (arg1);
3321 fputs_unfiltered (", ", gdb_stdlog);
3322 target_debug_print_struct_static_tracepoint_marker_p (arg2);
3323 fputs_unfiltered (") = ", gdb_stdlog);
3324 target_debug_print_int (result);
3325 fputs_unfiltered ("\n", gdb_stdlog);
3326 return result;
3327 }
3328
3329 static VEC(static_tracepoint_marker_p) *
3330 delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
3331 {
3332 self = self->beneath;
3333 return self->to_static_tracepoint_markers_by_strid (self, arg1);
3334 }
3335
3336 static VEC(static_tracepoint_marker_p) *
3337 tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
3338 {
3339 tcomplain ();
3340 }
3341
3342 static VEC(static_tracepoint_marker_p) *
3343 debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
3344 {
3345 VEC(static_tracepoint_marker_p) * result;
3346 fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", debug_target.to_shortname);
3347 result = debug_target.to_static_tracepoint_markers_by_strid (&debug_target, arg1);
3348 fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", debug_target.to_shortname);
3349 target_debug_print_struct_target_ops_p (&debug_target);
3350 fputs_unfiltered (", ", gdb_stdlog);
3351 target_debug_print_const_char_p (arg1);
3352 fputs_unfiltered (") = ", gdb_stdlog);
3353 target_debug_print_VEC_static_tracepoint_marker_p_p (result);
3354 fputs_unfiltered ("\n", gdb_stdlog);
3355 return result;
3356 }
3357
3358 static traceframe_info_up
3359 delegate_traceframe_info (struct target_ops *self)
3360 {
3361 self = self->beneath;
3362 return self->to_traceframe_info (self);
3363 }
3364
3365 static traceframe_info_up
3366 tdefault_traceframe_info (struct target_ops *self)
3367 {
3368 tcomplain ();
3369 }
3370
3371 static traceframe_info_up
3372 debug_traceframe_info (struct target_ops *self)
3373 {
3374 traceframe_info_up result;
3375 fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", debug_target.to_shortname);
3376 result = debug_target.to_traceframe_info (&debug_target);
3377 fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", debug_target.to_shortname);
3378 target_debug_print_struct_target_ops_p (&debug_target);
3379 fputs_unfiltered (") = ", gdb_stdlog);
3380 target_debug_print_traceframe_info_up (result);
3381 fputs_unfiltered ("\n", gdb_stdlog);
3382 return result;
3383 }
3384
3385 static int
3386 delegate_use_agent (struct target_ops *self, int arg1)
3387 {
3388 self = self->beneath;
3389 return self->to_use_agent (self, arg1);
3390 }
3391
3392 static int
3393 tdefault_use_agent (struct target_ops *self, int arg1)
3394 {
3395 tcomplain ();
3396 }
3397
3398 static int
3399 debug_use_agent (struct target_ops *self, int arg1)
3400 {
3401 int result;
3402 fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", debug_target.to_shortname);
3403 result = debug_target.to_use_agent (&debug_target, arg1);
3404 fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", debug_target.to_shortname);
3405 target_debug_print_struct_target_ops_p (&debug_target);
3406 fputs_unfiltered (", ", gdb_stdlog);
3407 target_debug_print_int (arg1);
3408 fputs_unfiltered (") = ", gdb_stdlog);
3409 target_debug_print_int (result);
3410 fputs_unfiltered ("\n", gdb_stdlog);
3411 return result;
3412 }
3413
3414 static int
3415 delegate_can_use_agent (struct target_ops *self)
3416 {
3417 self = self->beneath;
3418 return self->to_can_use_agent (self);
3419 }
3420
3421 static int
3422 tdefault_can_use_agent (struct target_ops *self)
3423 {
3424 return 0;
3425 }
3426
3427 static int
3428 debug_can_use_agent (struct target_ops *self)
3429 {
3430 int result;
3431 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", debug_target.to_shortname);
3432 result = debug_target.to_can_use_agent (&debug_target);
3433 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", debug_target.to_shortname);
3434 target_debug_print_struct_target_ops_p (&debug_target);
3435 fputs_unfiltered (") = ", gdb_stdlog);
3436 target_debug_print_int (result);
3437 fputs_unfiltered ("\n", gdb_stdlog);
3438 return result;
3439 }
3440
3441 static int
3442 delegate_supports_btrace (struct target_ops *self, enum btrace_format arg1)
3443 {
3444 self = self->beneath;
3445 return self->to_supports_btrace (self, arg1);
3446 }
3447
3448 static int
3449 tdefault_supports_btrace (struct target_ops *self, enum btrace_format arg1)
3450 {
3451 return 0;
3452 }
3453
3454 static int
3455 debug_supports_btrace (struct target_ops *self, enum btrace_format arg1)
3456 {
3457 int result;
3458 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
3459 result = debug_target.to_supports_btrace (&debug_target, arg1);
3460 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname);
3461 target_debug_print_struct_target_ops_p (&debug_target);
3462 fputs_unfiltered (", ", gdb_stdlog);
3463 target_debug_print_enum_btrace_format (arg1);
3464 fputs_unfiltered (") = ", gdb_stdlog);
3465 target_debug_print_int (result);
3466 fputs_unfiltered ("\n", gdb_stdlog);
3467 return result;
3468 }
3469
3470 static struct btrace_target_info *
3471 delegate_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3472 {
3473 self = self->beneath;
3474 return self->to_enable_btrace (self, arg1, arg2);
3475 }
3476
3477 static struct btrace_target_info *
3478 tdefault_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3479 {
3480 tcomplain ();
3481 }
3482
3483 static struct btrace_target_info *
3484 debug_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3485 {
3486 struct btrace_target_info * result;
3487 fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname);
3488 result = debug_target.to_enable_btrace (&debug_target, arg1, arg2);
3489 fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname);
3490 target_debug_print_struct_target_ops_p (&debug_target);
3491 fputs_unfiltered (", ", gdb_stdlog);
3492 target_debug_print_ptid_t (arg1);
3493 fputs_unfiltered (", ", gdb_stdlog);
3494 target_debug_print_const_struct_btrace_config_p (arg2);
3495 fputs_unfiltered (") = ", gdb_stdlog);
3496 target_debug_print_struct_btrace_target_info_p (result);
3497 fputs_unfiltered ("\n", gdb_stdlog);
3498 return result;
3499 }
3500
3501 static void
3502 delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3503 {
3504 self = self->beneath;
3505 self->to_disable_btrace (self, arg1);
3506 }
3507
3508 static void
3509 tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3510 {
3511 tcomplain ();
3512 }
3513
3514 static void
3515 debug_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3516 {
3517 fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname);
3518 debug_target.to_disable_btrace (&debug_target, arg1);
3519 fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname);
3520 target_debug_print_struct_target_ops_p (&debug_target);
3521 fputs_unfiltered (", ", gdb_stdlog);
3522 target_debug_print_struct_btrace_target_info_p (arg1);
3523 fputs_unfiltered (")\n", gdb_stdlog);
3524 }
3525
3526 static void
3527 delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3528 {
3529 self = self->beneath;
3530 self->to_teardown_btrace (self, arg1);
3531 }
3532
3533 static void
3534 tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3535 {
3536 tcomplain ();
3537 }
3538
3539 static void
3540 debug_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3541 {
3542 fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname);
3543 debug_target.to_teardown_btrace (&debug_target, arg1);
3544 fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname);
3545 target_debug_print_struct_target_ops_p (&debug_target);
3546 fputs_unfiltered (", ", gdb_stdlog);
3547 target_debug_print_struct_btrace_target_info_p (arg1);
3548 fputs_unfiltered (")\n", gdb_stdlog);
3549 }
3550
3551 static enum btrace_error
3552 delegate_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3553 {
3554 self = self->beneath;
3555 return self->to_read_btrace (self, arg1, arg2, arg3);
3556 }
3557
3558 static enum btrace_error
3559 tdefault_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3560 {
3561 tcomplain ();
3562 }
3563
3564 static enum btrace_error
3565 debug_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3566 {
3567 enum btrace_error result;
3568 fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname);
3569 result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3);
3570 fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname);
3571 target_debug_print_struct_target_ops_p (&debug_target);
3572 fputs_unfiltered (", ", gdb_stdlog);
3573 target_debug_print_struct_btrace_data_p (arg1);
3574 fputs_unfiltered (", ", gdb_stdlog);
3575 target_debug_print_struct_btrace_target_info_p (arg2);
3576 fputs_unfiltered (", ", gdb_stdlog);
3577 target_debug_print_enum_btrace_read_type (arg3);
3578 fputs_unfiltered (") = ", gdb_stdlog);
3579 target_debug_print_enum_btrace_error (result);
3580 fputs_unfiltered ("\n", gdb_stdlog);
3581 return result;
3582 }
3583
3584 static const struct btrace_config *
3585 delegate_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3586 {
3587 self = self->beneath;
3588 return self->to_btrace_conf (self, arg1);
3589 }
3590
3591 static const struct btrace_config *
3592 tdefault_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3593 {
3594 return NULL;
3595 }
3596
3597 static const struct btrace_config *
3598 debug_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3599 {
3600 const struct btrace_config * result;
3601 fprintf_unfiltered (gdb_stdlog, "-> %s->to_btrace_conf (...)\n", debug_target.to_shortname);
3602 result = debug_target.to_btrace_conf (&debug_target, arg1);
3603 fprintf_unfiltered (gdb_stdlog, "<- %s->to_btrace_conf (", debug_target.to_shortname);
3604 target_debug_print_struct_target_ops_p (&debug_target);
3605 fputs_unfiltered (", ", gdb_stdlog);
3606 target_debug_print_const_struct_btrace_target_info_p (arg1);
3607 fputs_unfiltered (") = ", gdb_stdlog);
3608 target_debug_print_const_struct_btrace_config_p (result);
3609 fputs_unfiltered ("\n", gdb_stdlog);
3610 return result;
3611 }
3612
3613 static enum record_method
3614 delegate_record_method (struct target_ops *self, ptid_t arg1)
3615 {
3616 self = self->beneath;
3617 return self->to_record_method (self, arg1);
3618 }
3619
3620 static enum record_method
3621 tdefault_record_method (struct target_ops *self, ptid_t arg1)
3622 {
3623 return RECORD_METHOD_NONE;
3624 }
3625
3626 static enum record_method
3627 debug_record_method (struct target_ops *self, ptid_t arg1)
3628 {
3629 enum record_method result;
3630 fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_method (...)\n", debug_target.to_shortname);
3631 result = debug_target.to_record_method (&debug_target, arg1);
3632 fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_method (", debug_target.to_shortname);
3633 target_debug_print_struct_target_ops_p (&debug_target);
3634 fputs_unfiltered (", ", gdb_stdlog);
3635 target_debug_print_ptid_t (arg1);
3636 fputs_unfiltered (") = ", gdb_stdlog);
3637 target_debug_print_enum_record_method (result);
3638 fputs_unfiltered ("\n", gdb_stdlog);
3639 return result;
3640 }
3641
3642 static void
3643 delegate_stop_recording (struct target_ops *self)
3644 {
3645 self = self->beneath;
3646 self->to_stop_recording (self);
3647 }
3648
3649 static void
3650 tdefault_stop_recording (struct target_ops *self)
3651 {
3652 }
3653
3654 static void
3655 debug_stop_recording (struct target_ops *self)
3656 {
3657 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname);
3658 debug_target.to_stop_recording (&debug_target);
3659 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname);
3660 target_debug_print_struct_target_ops_p (&debug_target);
3661 fputs_unfiltered (")\n", gdb_stdlog);
3662 }
3663
3664 static void
3665 delegate_info_record (struct target_ops *self)
3666 {
3667 self = self->beneath;
3668 self->to_info_record (self);
3669 }
3670
3671 static void
3672 tdefault_info_record (struct target_ops *self)
3673 {
3674 }
3675
3676 static void
3677 debug_info_record (struct target_ops *self)
3678 {
3679 fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", debug_target.to_shortname);
3680 debug_target.to_info_record (&debug_target);
3681 fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", debug_target.to_shortname);
3682 target_debug_print_struct_target_ops_p (&debug_target);
3683 fputs_unfiltered (")\n", gdb_stdlog);
3684 }
3685
3686 static void
3687 delegate_save_record (struct target_ops *self, const char *arg1)
3688 {
3689 self = self->beneath;
3690 self->to_save_record (self, arg1);
3691 }
3692
3693 static void
3694 tdefault_save_record (struct target_ops *self, const char *arg1)
3695 {
3696 tcomplain ();
3697 }
3698
3699 static void
3700 debug_save_record (struct target_ops *self, const char *arg1)
3701 {
3702 fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname);
3703 debug_target.to_save_record (&debug_target, arg1);
3704 fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", debug_target.to_shortname);
3705 target_debug_print_struct_target_ops_p (&debug_target);
3706 fputs_unfiltered (", ", gdb_stdlog);
3707 target_debug_print_const_char_p (arg1);
3708 fputs_unfiltered (")\n", gdb_stdlog);
3709 }
3710
3711 static void
3712 delegate_delete_record (struct target_ops *self)
3713 {
3714 self = self->beneath;
3715 self->to_delete_record (self);
3716 }
3717
3718 static void
3719 tdefault_delete_record (struct target_ops *self)
3720 {
3721 tcomplain ();
3722 }
3723
3724 static void
3725 debug_delete_record (struct target_ops *self)
3726 {
3727 fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname);
3728 debug_target.to_delete_record (&debug_target);
3729 fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname);
3730 target_debug_print_struct_target_ops_p (&debug_target);
3731 fputs_unfiltered (")\n", gdb_stdlog);
3732 }
3733
3734 static int
3735 delegate_record_is_replaying (struct target_ops *self, ptid_t arg1)
3736 {
3737 self = self->beneath;
3738 return self->to_record_is_replaying (self, arg1);
3739 }
3740
3741 static int
3742 tdefault_record_is_replaying (struct target_ops *self, ptid_t arg1)
3743 {
3744 return 0;
3745 }
3746
3747 static int
3748 debug_record_is_replaying (struct target_ops *self, ptid_t arg1)
3749 {
3750 int result;
3751 fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
3752 result = debug_target.to_record_is_replaying (&debug_target, arg1);
3753 fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
3754 target_debug_print_struct_target_ops_p (&debug_target);
3755 fputs_unfiltered (", ", gdb_stdlog);
3756 target_debug_print_ptid_t (arg1);
3757 fputs_unfiltered (") = ", gdb_stdlog);
3758 target_debug_print_int (result);
3759 fputs_unfiltered ("\n", gdb_stdlog);
3760 return result;
3761 }
3762
3763 static int
3764 delegate_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
3765 {
3766 self = self->beneath;
3767 return self->to_record_will_replay (self, arg1, arg2);
3768 }
3769
3770 static int
3771 tdefault_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
3772 {
3773 return 0;
3774 }
3775
3776 static int
3777 debug_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
3778 {
3779 int result;
3780 fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_will_replay (...)\n", debug_target.to_shortname);
3781 result = debug_target.to_record_will_replay (&debug_target, arg1, arg2);
3782 fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_will_replay (", debug_target.to_shortname);
3783 target_debug_print_struct_target_ops_p (&debug_target);
3784 fputs_unfiltered (", ", gdb_stdlog);
3785 target_debug_print_ptid_t (arg1);
3786 fputs_unfiltered (", ", gdb_stdlog);
3787 target_debug_print_int (arg2);
3788 fputs_unfiltered (") = ", gdb_stdlog);
3789 target_debug_print_int (result);
3790 fputs_unfiltered ("\n", gdb_stdlog);
3791 return result;
3792 }
3793
3794 static void
3795 delegate_record_stop_replaying (struct target_ops *self)
3796 {
3797 self = self->beneath;
3798 self->to_record_stop_replaying (self);
3799 }
3800
3801 static void
3802 tdefault_record_stop_replaying (struct target_ops *self)
3803 {
3804 }
3805
3806 static void
3807 debug_record_stop_replaying (struct target_ops *self)
3808 {
3809 fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_stop_replaying (...)\n", debug_target.to_shortname);
3810 debug_target.to_record_stop_replaying (&debug_target);
3811 fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_stop_replaying (", debug_target.to_shortname);
3812 target_debug_print_struct_target_ops_p (&debug_target);
3813 fputs_unfiltered (")\n", gdb_stdlog);
3814 }
3815
3816 static void
3817 delegate_goto_record_begin (struct target_ops *self)
3818 {
3819 self = self->beneath;
3820 self->to_goto_record_begin (self);
3821 }
3822
3823 static void
3824 tdefault_goto_record_begin (struct target_ops *self)
3825 {
3826 tcomplain ();
3827 }
3828
3829 static void
3830 debug_goto_record_begin (struct target_ops *self)
3831 {
3832 fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname);
3833 debug_target.to_goto_record_begin (&debug_target);
3834 fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname);
3835 target_debug_print_struct_target_ops_p (&debug_target);
3836 fputs_unfiltered (")\n", gdb_stdlog);
3837 }
3838
3839 static void
3840 delegate_goto_record_end (struct target_ops *self)
3841 {
3842 self = self->beneath;
3843 self->to_goto_record_end (self);
3844 }
3845
3846 static void
3847 tdefault_goto_record_end (struct target_ops *self)
3848 {
3849 tcomplain ();
3850 }
3851
3852 static void
3853 debug_goto_record_end (struct target_ops *self)
3854 {
3855 fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname);
3856 debug_target.to_goto_record_end (&debug_target);
3857 fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname);
3858 target_debug_print_struct_target_ops_p (&debug_target);
3859 fputs_unfiltered (")\n", gdb_stdlog);
3860 }
3861
3862 static void
3863 delegate_goto_record (struct target_ops *self, ULONGEST arg1)
3864 {
3865 self = self->beneath;
3866 self->to_goto_record (self, arg1);
3867 }
3868
3869 static void
3870 tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
3871 {
3872 tcomplain ();
3873 }
3874
3875 static void
3876 debug_goto_record (struct target_ops *self, ULONGEST arg1)
3877 {
3878 fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname);
3879 debug_target.to_goto_record (&debug_target, arg1);
3880 fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname);
3881 target_debug_print_struct_target_ops_p (&debug_target);
3882 fputs_unfiltered (", ", gdb_stdlog);
3883 target_debug_print_ULONGEST (arg1);
3884 fputs_unfiltered (")\n", gdb_stdlog);
3885 }
3886
3887 static void
3888 delegate_insn_history (struct target_ops *self, int arg1, gdb_disassembly_flags arg2)
3889 {
3890 self = self->beneath;
3891 self->to_insn_history (self, arg1, arg2);
3892 }
3893
3894 static void
3895 tdefault_insn_history (struct target_ops *self, int arg1, gdb_disassembly_flags arg2)
3896 {
3897 tcomplain ();
3898 }
3899
3900 static void
3901 debug_insn_history (struct target_ops *self, int arg1, gdb_disassembly_flags arg2)
3902 {
3903 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
3904 debug_target.to_insn_history (&debug_target, arg1, arg2);
3905 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", debug_target.to_shortname);
3906 target_debug_print_struct_target_ops_p (&debug_target);
3907 fputs_unfiltered (", ", gdb_stdlog);
3908 target_debug_print_int (arg1);
3909 fputs_unfiltered (", ", gdb_stdlog);
3910 target_debug_print_gdb_disassembly_flags (arg2);
3911 fputs_unfiltered (")\n", gdb_stdlog);
3912 }
3913
3914 static void
3915 delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, gdb_disassembly_flags arg3)
3916 {
3917 self = self->beneath;
3918 self->to_insn_history_from (self, arg1, arg2, arg3);
3919 }
3920
3921 static void
3922 tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, gdb_disassembly_flags arg3)
3923 {
3924 tcomplain ();
3925 }
3926
3927 static void
3928 debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, gdb_disassembly_flags arg3)
3929 {
3930 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname);
3931 debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3);
3932 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", debug_target.to_shortname);
3933 target_debug_print_struct_target_ops_p (&debug_target);
3934 fputs_unfiltered (", ", gdb_stdlog);
3935 target_debug_print_ULONGEST (arg1);
3936 fputs_unfiltered (", ", gdb_stdlog);
3937 target_debug_print_int (arg2);
3938 fputs_unfiltered (", ", gdb_stdlog);
3939 target_debug_print_gdb_disassembly_flags (arg3);
3940 fputs_unfiltered (")\n", gdb_stdlog);
3941 }
3942
3943 static void
3944 delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, gdb_disassembly_flags arg3)
3945 {
3946 self = self->beneath;
3947 self->to_insn_history_range (self, arg1, arg2, arg3);
3948 }
3949
3950 static void
3951 tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, gdb_disassembly_flags arg3)
3952 {
3953 tcomplain ();
3954 }
3955
3956 static void
3957 debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, gdb_disassembly_flags arg3)
3958 {
3959 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname);
3960 debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3);
3961 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", debug_target.to_shortname);
3962 target_debug_print_struct_target_ops_p (&debug_target);
3963 fputs_unfiltered (", ", gdb_stdlog);
3964 target_debug_print_ULONGEST (arg1);
3965 fputs_unfiltered (", ", gdb_stdlog);
3966 target_debug_print_ULONGEST (arg2);
3967 fputs_unfiltered (", ", gdb_stdlog);
3968 target_debug_print_gdb_disassembly_flags (arg3);
3969 fputs_unfiltered (")\n", gdb_stdlog);
3970 }
3971
3972 static void
3973 delegate_call_history (struct target_ops *self, int arg1, int arg2)
3974 {
3975 self = self->beneath;
3976 self->to_call_history (self, arg1, arg2);
3977 }
3978
3979 static void
3980 tdefault_call_history (struct target_ops *self, int arg1, int arg2)
3981 {
3982 tcomplain ();
3983 }
3984
3985 static void
3986 debug_call_history (struct target_ops *self, int arg1, int arg2)
3987 {
3988 fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
3989 debug_target.to_call_history (&debug_target, arg1, arg2);
3990 fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", debug_target.to_shortname);
3991 target_debug_print_struct_target_ops_p (&debug_target);
3992 fputs_unfiltered (", ", gdb_stdlog);
3993 target_debug_print_int (arg1);
3994 fputs_unfiltered (", ", gdb_stdlog);
3995 target_debug_print_int (arg2);
3996 fputs_unfiltered (")\n", gdb_stdlog);
3997 }
3998
3999 static void
4000 delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
4001 {
4002 self = self->beneath;
4003 self->to_call_history_from (self, arg1, arg2, arg3);
4004 }
4005
4006 static void
4007 tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
4008 {
4009 tcomplain ();
4010 }
4011
4012 static void
4013 debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
4014 {
4015 fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname);
4016 debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3);
4017 fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", debug_target.to_shortname);
4018 target_debug_print_struct_target_ops_p (&debug_target);
4019 fputs_unfiltered (", ", gdb_stdlog);
4020 target_debug_print_ULONGEST (arg1);
4021 fputs_unfiltered (", ", gdb_stdlog);
4022 target_debug_print_int (arg2);
4023 fputs_unfiltered (", ", gdb_stdlog);
4024 target_debug_print_int (arg3);
4025 fputs_unfiltered (")\n", gdb_stdlog);
4026 }
4027
4028 static void
4029 delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
4030 {
4031 self = self->beneath;
4032 self->to_call_history_range (self, arg1, arg2, arg3);
4033 }
4034
4035 static void
4036 tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
4037 {
4038 tcomplain ();
4039 }
4040
4041 static void
4042 debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
4043 {
4044 fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname);
4045 debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3);
4046 fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", debug_target.to_shortname);
4047 target_debug_print_struct_target_ops_p (&debug_target);
4048 fputs_unfiltered (", ", gdb_stdlog);
4049 target_debug_print_ULONGEST (arg1);
4050 fputs_unfiltered (", ", gdb_stdlog);
4051 target_debug_print_ULONGEST (arg2);
4052 fputs_unfiltered (", ", gdb_stdlog);
4053 target_debug_print_int (arg3);
4054 fputs_unfiltered (")\n", gdb_stdlog);
4055 }
4056
4057 static int
4058 delegate_augmented_libraries_svr4_read (struct target_ops *self)
4059 {
4060 self = self->beneath;
4061 return self->to_augmented_libraries_svr4_read (self);
4062 }
4063
4064 static int
4065 tdefault_augmented_libraries_svr4_read (struct target_ops *self)
4066 {
4067 return 0;
4068 }
4069
4070 static int
4071 debug_augmented_libraries_svr4_read (struct target_ops *self)
4072 {
4073 int result;
4074 fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname);
4075 result = debug_target.to_augmented_libraries_svr4_read (&debug_target);
4076 fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", debug_target.to_shortname);
4077 target_debug_print_struct_target_ops_p (&debug_target);
4078 fputs_unfiltered (") = ", gdb_stdlog);
4079 target_debug_print_int (result);
4080 fputs_unfiltered ("\n", gdb_stdlog);
4081 return result;
4082 }
4083
4084 static const struct frame_unwind *
4085 delegate_get_unwinder (struct target_ops *self)
4086 {
4087 self = self->beneath;
4088 return self->to_get_unwinder (self);
4089 }
4090
4091 static const struct frame_unwind *
4092 tdefault_get_unwinder (struct target_ops *self)
4093 {
4094 return NULL;
4095 }
4096
4097 static const struct frame_unwind *
4098 debug_get_unwinder (struct target_ops *self)
4099 {
4100 const struct frame_unwind * result;
4101 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname);
4102 result = debug_target.to_get_unwinder (&debug_target);
4103 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname);
4104 target_debug_print_struct_target_ops_p (&debug_target);
4105 fputs_unfiltered (") = ", gdb_stdlog);
4106 target_debug_print_const_struct_frame_unwind_p (result);
4107 fputs_unfiltered ("\n", gdb_stdlog);
4108 return result;
4109 }
4110
4111 static const struct frame_unwind *
4112 delegate_get_tailcall_unwinder (struct target_ops *self)
4113 {
4114 self = self->beneath;
4115 return self->to_get_tailcall_unwinder (self);
4116 }
4117
4118 static const struct frame_unwind *
4119 tdefault_get_tailcall_unwinder (struct target_ops *self)
4120 {
4121 return NULL;
4122 }
4123
4124 static const struct frame_unwind *
4125 debug_get_tailcall_unwinder (struct target_ops *self)
4126 {
4127 const struct frame_unwind * result;
4128 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname);
4129 result = debug_target.to_get_tailcall_unwinder (&debug_target);
4130 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname);
4131 target_debug_print_struct_target_ops_p (&debug_target);
4132 fputs_unfiltered (") = ", gdb_stdlog);
4133 target_debug_print_const_struct_frame_unwind_p (result);
4134 fputs_unfiltered ("\n", gdb_stdlog);
4135 return result;
4136 }
4137
4138 static void
4139 delegate_prepare_to_generate_core (struct target_ops *self)
4140 {
4141 self = self->beneath;
4142 self->to_prepare_to_generate_core (self);
4143 }
4144
4145 static void
4146 tdefault_prepare_to_generate_core (struct target_ops *self)
4147 {
4148 }
4149
4150 static void
4151 debug_prepare_to_generate_core (struct target_ops *self)
4152 {
4153 fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", debug_target.to_shortname);
4154 debug_target.to_prepare_to_generate_core (&debug_target);
4155 fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", debug_target.to_shortname);
4156 target_debug_print_struct_target_ops_p (&debug_target);
4157 fputs_unfiltered (")\n", gdb_stdlog);
4158 }
4159
4160 static void
4161 delegate_done_generating_core (struct target_ops *self)
4162 {
4163 self = self->beneath;
4164 self->to_done_generating_core (self);
4165 }
4166
4167 static void
4168 tdefault_done_generating_core (struct target_ops *self)
4169 {
4170 }
4171
4172 static void
4173 debug_done_generating_core (struct target_ops *self)
4174 {
4175 fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", debug_target.to_shortname);
4176 debug_target.to_done_generating_core (&debug_target);
4177 fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", debug_target.to_shortname);
4178 target_debug_print_struct_target_ops_p (&debug_target);
4179 fputs_unfiltered (")\n", gdb_stdlog);
4180 }
4181
4182 static void
4183 install_delegators (struct target_ops *ops)
4184 {
4185 if (ops->to_post_attach == NULL)
4186 ops->to_post_attach = delegate_post_attach;
4187 if (ops->to_detach == NULL)
4188 ops->to_detach = delegate_detach;
4189 if (ops->to_disconnect == NULL)
4190 ops->to_disconnect = delegate_disconnect;
4191 if (ops->to_resume == NULL)
4192 ops->to_resume = delegate_resume;
4193 if (ops->to_commit_resume == NULL)
4194 ops->to_commit_resume = delegate_commit_resume;
4195 if (ops->to_wait == NULL)
4196 ops->to_wait = delegate_wait;
4197 if (ops->to_fetch_registers == NULL)
4198 ops->to_fetch_registers = delegate_fetch_registers;
4199 if (ops->to_store_registers == NULL)
4200 ops->to_store_registers = delegate_store_registers;
4201 if (ops->to_prepare_to_store == NULL)
4202 ops->to_prepare_to_store = delegate_prepare_to_store;
4203 if (ops->to_files_info == NULL)
4204 ops->to_files_info = delegate_files_info;
4205 if (ops->to_insert_breakpoint == NULL)
4206 ops->to_insert_breakpoint = delegate_insert_breakpoint;
4207 if (ops->to_remove_breakpoint == NULL)
4208 ops->to_remove_breakpoint = delegate_remove_breakpoint;
4209 if (ops->to_stopped_by_sw_breakpoint == NULL)
4210 ops->to_stopped_by_sw_breakpoint = delegate_stopped_by_sw_breakpoint;
4211 if (ops->to_supports_stopped_by_sw_breakpoint == NULL)
4212 ops->to_supports_stopped_by_sw_breakpoint = delegate_supports_stopped_by_sw_breakpoint;
4213 if (ops->to_stopped_by_hw_breakpoint == NULL)
4214 ops->to_stopped_by_hw_breakpoint = delegate_stopped_by_hw_breakpoint;
4215 if (ops->to_supports_stopped_by_hw_breakpoint == NULL)
4216 ops->to_supports_stopped_by_hw_breakpoint = delegate_supports_stopped_by_hw_breakpoint;
4217 if (ops->to_can_use_hw_breakpoint == NULL)
4218 ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint;
4219 if (ops->to_ranged_break_num_registers == NULL)
4220 ops->to_ranged_break_num_registers = delegate_ranged_break_num_registers;
4221 if (ops->to_insert_hw_breakpoint == NULL)
4222 ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint;
4223 if (ops->to_remove_hw_breakpoint == NULL)
4224 ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint;
4225 if (ops->to_remove_watchpoint == NULL)
4226 ops->to_remove_watchpoint = delegate_remove_watchpoint;
4227 if (ops->to_insert_watchpoint == NULL)
4228 ops->to_insert_watchpoint = delegate_insert_watchpoint;
4229 if (ops->to_insert_mask_watchpoint == NULL)
4230 ops->to_insert_mask_watchpoint = delegate_insert_mask_watchpoint;
4231 if (ops->to_remove_mask_watchpoint == NULL)
4232 ops->to_remove_mask_watchpoint = delegate_remove_mask_watchpoint;
4233 if (ops->to_stopped_by_watchpoint == NULL)
4234 ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint;
4235 if (ops->to_stopped_data_address == NULL)
4236 ops->to_stopped_data_address = delegate_stopped_data_address;
4237 if (ops->to_watchpoint_addr_within_range == NULL)
4238 ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range;
4239 if (ops->to_region_ok_for_hw_watchpoint == NULL)
4240 ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint;
4241 if (ops->to_can_accel_watchpoint_condition == NULL)
4242 ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
4243 if (ops->to_masked_watch_num_registers == NULL)
4244 ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers;
4245 if (ops->to_can_do_single_step == NULL)
4246 ops->to_can_do_single_step = delegate_can_do_single_step;
4247 if (ops->to_terminal_init == NULL)
4248 ops->to_terminal_init = delegate_terminal_init;
4249 if (ops->to_terminal_inferior == NULL)
4250 ops->to_terminal_inferior = delegate_terminal_inferior;
4251 if (ops->to_terminal_ours_for_output == NULL)
4252 ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
4253 if (ops->to_terminal_ours == NULL)
4254 ops->to_terminal_ours = delegate_terminal_ours;
4255 if (ops->to_terminal_info == NULL)
4256 ops->to_terminal_info = delegate_terminal_info;
4257 if (ops->to_kill == NULL)
4258 ops->to_kill = delegate_kill;
4259 if (ops->to_load == NULL)
4260 ops->to_load = delegate_load;
4261 if (ops->to_post_startup_inferior == NULL)
4262 ops->to_post_startup_inferior = delegate_post_startup_inferior;
4263 if (ops->to_insert_fork_catchpoint == NULL)
4264 ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint;
4265 if (ops->to_remove_fork_catchpoint == NULL)
4266 ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint;
4267 if (ops->to_insert_vfork_catchpoint == NULL)
4268 ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint;
4269 if (ops->to_remove_vfork_catchpoint == NULL)
4270 ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint;
4271 if (ops->to_follow_fork == NULL)
4272 ops->to_follow_fork = delegate_follow_fork;
4273 if (ops->to_insert_exec_catchpoint == NULL)
4274 ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
4275 if (ops->to_remove_exec_catchpoint == NULL)
4276 ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
4277 if (ops->to_follow_exec == NULL)
4278 ops->to_follow_exec = delegate_follow_exec;
4279 if (ops->to_set_syscall_catchpoint == NULL)
4280 ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
4281 if (ops->to_has_exited == NULL)
4282 ops->to_has_exited = delegate_has_exited;
4283 if (ops->to_mourn_inferior == NULL)
4284 ops->to_mourn_inferior = delegate_mourn_inferior;
4285 if (ops->to_can_run == NULL)
4286 ops->to_can_run = delegate_can_run;
4287 if (ops->to_pass_signals == NULL)
4288 ops->to_pass_signals = delegate_pass_signals;
4289 if (ops->to_program_signals == NULL)
4290 ops->to_program_signals = delegate_program_signals;
4291 if (ops->to_thread_alive == NULL)
4292 ops->to_thread_alive = delegate_thread_alive;
4293 if (ops->to_update_thread_list == NULL)
4294 ops->to_update_thread_list = delegate_update_thread_list;
4295 if (ops->to_pid_to_str == NULL)
4296 ops->to_pid_to_str = delegate_pid_to_str;
4297 if (ops->to_extra_thread_info == NULL)
4298 ops->to_extra_thread_info = delegate_extra_thread_info;
4299 if (ops->to_thread_name == NULL)
4300 ops->to_thread_name = delegate_thread_name;
4301 if (ops->to_thread_handle_to_thread_info == NULL)
4302 ops->to_thread_handle_to_thread_info = delegate_thread_handle_to_thread_info;
4303 if (ops->to_stop == NULL)
4304 ops->to_stop = delegate_stop;
4305 if (ops->to_interrupt == NULL)
4306 ops->to_interrupt = delegate_interrupt;
4307 if (ops->to_pass_ctrlc == NULL)
4308 ops->to_pass_ctrlc = delegate_pass_ctrlc;
4309 if (ops->to_rcmd == NULL)
4310 ops->to_rcmd = delegate_rcmd;
4311 if (ops->to_pid_to_exec_file == NULL)
4312 ops->to_pid_to_exec_file = delegate_pid_to_exec_file;
4313 if (ops->to_log_command == NULL)
4314 ops->to_log_command = delegate_log_command;
4315 if (ops->to_get_section_table == NULL)
4316 ops->to_get_section_table = delegate_get_section_table;
4317 if (ops->to_can_async_p == NULL)
4318 ops->to_can_async_p = delegate_can_async_p;
4319 if (ops->to_is_async_p == NULL)
4320 ops->to_is_async_p = delegate_is_async_p;
4321 if (ops->to_async == NULL)
4322 ops->to_async = delegate_async;
4323 if (ops->to_thread_events == NULL)
4324 ops->to_thread_events = delegate_thread_events;
4325 if (ops->to_supports_non_stop == NULL)
4326 ops->to_supports_non_stop = delegate_supports_non_stop;
4327 if (ops->to_always_non_stop_p == NULL)
4328 ops->to_always_non_stop_p = delegate_always_non_stop_p;
4329 if (ops->to_find_memory_regions == NULL)
4330 ops->to_find_memory_regions = delegate_find_memory_regions;
4331 if (ops->to_make_corefile_notes == NULL)
4332 ops->to_make_corefile_notes = delegate_make_corefile_notes;
4333 if (ops->to_get_bookmark == NULL)
4334 ops->to_get_bookmark = delegate_get_bookmark;
4335 if (ops->to_goto_bookmark == NULL)
4336 ops->to_goto_bookmark = delegate_goto_bookmark;
4337 if (ops->to_get_thread_local_address == NULL)
4338 ops->to_get_thread_local_address = delegate_get_thread_local_address;
4339 if (ops->to_xfer_partial == NULL)
4340 ops->to_xfer_partial = delegate_xfer_partial;
4341 if (ops->to_get_memory_xfer_limit == NULL)
4342 ops->to_get_memory_xfer_limit = delegate_get_memory_xfer_limit;
4343 if (ops->to_memory_map == NULL)
4344 ops->to_memory_map = delegate_memory_map;
4345 if (ops->to_flash_erase == NULL)
4346 ops->to_flash_erase = delegate_flash_erase;
4347 if (ops->to_flash_done == NULL)
4348 ops->to_flash_done = delegate_flash_done;
4349 if (ops->to_read_description == NULL)
4350 ops->to_read_description = delegate_read_description;
4351 if (ops->to_get_ada_task_ptid == NULL)
4352 ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid;
4353 if (ops->to_auxv_parse == NULL)
4354 ops->to_auxv_parse = delegate_auxv_parse;
4355 if (ops->to_search_memory == NULL)
4356 ops->to_search_memory = delegate_search_memory;
4357 if (ops->to_can_execute_reverse == NULL)
4358 ops->to_can_execute_reverse = delegate_can_execute_reverse;
4359 if (ops->to_execution_direction == NULL)
4360 ops->to_execution_direction = delegate_execution_direction;
4361 if (ops->to_supports_multi_process == NULL)
4362 ops->to_supports_multi_process = delegate_supports_multi_process;
4363 if (ops->to_supports_enable_disable_tracepoint == NULL)
4364 ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint;
4365 if (ops->to_supports_string_tracing == NULL)
4366 ops->to_supports_string_tracing = delegate_supports_string_tracing;
4367 if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL)
4368 ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions;
4369 if (ops->to_can_run_breakpoint_commands == NULL)
4370 ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands;
4371 if (ops->to_thread_architecture == NULL)
4372 ops->to_thread_architecture = delegate_thread_architecture;
4373 if (ops->to_thread_address_space == NULL)
4374 ops->to_thread_address_space = delegate_thread_address_space;
4375 if (ops->to_filesystem_is_local == NULL)
4376 ops->to_filesystem_is_local = delegate_filesystem_is_local;
4377 if (ops->to_trace_init == NULL)
4378 ops->to_trace_init = delegate_trace_init;
4379 if (ops->to_download_tracepoint == NULL)
4380 ops->to_download_tracepoint = delegate_download_tracepoint;
4381 if (ops->to_can_download_tracepoint == NULL)
4382 ops->to_can_download_tracepoint = delegate_can_download_tracepoint;
4383 if (ops->to_download_trace_state_variable == NULL)
4384 ops->to_download_trace_state_variable = delegate_download_trace_state_variable;
4385 if (ops->to_enable_tracepoint == NULL)
4386 ops->to_enable_tracepoint = delegate_enable_tracepoint;
4387 if (ops->to_disable_tracepoint == NULL)
4388 ops->to_disable_tracepoint = delegate_disable_tracepoint;
4389 if (ops->to_trace_set_readonly_regions == NULL)
4390 ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions;
4391 if (ops->to_trace_start == NULL)
4392 ops->to_trace_start = delegate_trace_start;
4393 if (ops->to_get_trace_status == NULL)
4394 ops->to_get_trace_status = delegate_get_trace_status;
4395 if (ops->to_get_tracepoint_status == NULL)
4396 ops->to_get_tracepoint_status = delegate_get_tracepoint_status;
4397 if (ops->to_trace_stop == NULL)
4398 ops->to_trace_stop = delegate_trace_stop;
4399 if (ops->to_trace_find == NULL)
4400 ops->to_trace_find = delegate_trace_find;
4401 if (ops->to_get_trace_state_variable_value == NULL)
4402 ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value;
4403 if (ops->to_save_trace_data == NULL)
4404 ops->to_save_trace_data = delegate_save_trace_data;
4405 if (ops->to_upload_tracepoints == NULL)
4406 ops->to_upload_tracepoints = delegate_upload_tracepoints;
4407 if (ops->to_upload_trace_state_variables == NULL)
4408 ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables;
4409 if (ops->to_get_raw_trace_data == NULL)
4410 ops->to_get_raw_trace_data = delegate_get_raw_trace_data;
4411 if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
4412 ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len;
4413 if (ops->to_set_disconnected_tracing == NULL)
4414 ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing;
4415 if (ops->to_set_circular_trace_buffer == NULL)
4416 ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer;
4417 if (ops->to_set_trace_buffer_size == NULL)
4418 ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size;
4419 if (ops->to_set_trace_notes == NULL)
4420 ops->to_set_trace_notes = delegate_set_trace_notes;
4421 if (ops->to_core_of_thread == NULL)
4422 ops->to_core_of_thread = delegate_core_of_thread;
4423 if (ops->to_verify_memory == NULL)
4424 ops->to_verify_memory = delegate_verify_memory;
4425 if (ops->to_get_tib_address == NULL)
4426 ops->to_get_tib_address = delegate_get_tib_address;
4427 if (ops->to_set_permissions == NULL)
4428 ops->to_set_permissions = delegate_set_permissions;
4429 if (ops->to_static_tracepoint_marker_at == NULL)
4430 ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at;
4431 if (ops->to_static_tracepoint_markers_by_strid == NULL)
4432 ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
4433 if (ops->to_traceframe_info == NULL)
4434 ops->to_traceframe_info = delegate_traceframe_info;
4435 if (ops->to_use_agent == NULL)
4436 ops->to_use_agent = delegate_use_agent;
4437 if (ops->to_can_use_agent == NULL)
4438 ops->to_can_use_agent = delegate_can_use_agent;
4439 if (ops->to_supports_btrace == NULL)
4440 ops->to_supports_btrace = delegate_supports_btrace;
4441 if (ops->to_enable_btrace == NULL)
4442 ops->to_enable_btrace = delegate_enable_btrace;
4443 if (ops->to_disable_btrace == NULL)
4444 ops->to_disable_btrace = delegate_disable_btrace;
4445 if (ops->to_teardown_btrace == NULL)
4446 ops->to_teardown_btrace = delegate_teardown_btrace;
4447 if (ops->to_read_btrace == NULL)
4448 ops->to_read_btrace = delegate_read_btrace;
4449 if (ops->to_btrace_conf == NULL)
4450 ops->to_btrace_conf = delegate_btrace_conf;
4451 if (ops->to_record_method == NULL)
4452 ops->to_record_method = delegate_record_method;
4453 if (ops->to_stop_recording == NULL)
4454 ops->to_stop_recording = delegate_stop_recording;
4455 if (ops->to_info_record == NULL)
4456 ops->to_info_record = delegate_info_record;
4457 if (ops->to_save_record == NULL)
4458 ops->to_save_record = delegate_save_record;
4459 if (ops->to_delete_record == NULL)
4460 ops->to_delete_record = delegate_delete_record;
4461 if (ops->to_record_is_replaying == NULL)
4462 ops->to_record_is_replaying = delegate_record_is_replaying;
4463 if (ops->to_record_will_replay == NULL)
4464 ops->to_record_will_replay = delegate_record_will_replay;
4465 if (ops->to_record_stop_replaying == NULL)
4466 ops->to_record_stop_replaying = delegate_record_stop_replaying;
4467 if (ops->to_goto_record_begin == NULL)
4468 ops->to_goto_record_begin = delegate_goto_record_begin;
4469 if (ops->to_goto_record_end == NULL)
4470 ops->to_goto_record_end = delegate_goto_record_end;
4471 if (ops->to_goto_record == NULL)
4472 ops->to_goto_record = delegate_goto_record;
4473 if (ops->to_insn_history == NULL)
4474 ops->to_insn_history = delegate_insn_history;
4475 if (ops->to_insn_history_from == NULL)
4476 ops->to_insn_history_from = delegate_insn_history_from;
4477 if (ops->to_insn_history_range == NULL)
4478 ops->to_insn_history_range = delegate_insn_history_range;
4479 if (ops->to_call_history == NULL)
4480 ops->to_call_history = delegate_call_history;
4481 if (ops->to_call_history_from == NULL)
4482 ops->to_call_history_from = delegate_call_history_from;
4483 if (ops->to_call_history_range == NULL)
4484 ops->to_call_history_range = delegate_call_history_range;
4485 if (ops->to_augmented_libraries_svr4_read == NULL)
4486 ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read;
4487 if (ops->to_get_unwinder == NULL)
4488 ops->to_get_unwinder = delegate_get_unwinder;
4489 if (ops->to_get_tailcall_unwinder == NULL)
4490 ops->to_get_tailcall_unwinder = delegate_get_tailcall_unwinder;
4491 if (ops->to_prepare_to_generate_core == NULL)
4492 ops->to_prepare_to_generate_core = delegate_prepare_to_generate_core;
4493 if (ops->to_done_generating_core == NULL)
4494 ops->to_done_generating_core = delegate_done_generating_core;
4495 }
4496
4497 static void
4498 install_dummy_methods (struct target_ops *ops)
4499 {
4500 ops->to_post_attach = tdefault_post_attach;
4501 ops->to_detach = tdefault_detach;
4502 ops->to_disconnect = tdefault_disconnect;
4503 ops->to_resume = tdefault_resume;
4504 ops->to_commit_resume = tdefault_commit_resume;
4505 ops->to_wait = default_target_wait;
4506 ops->to_fetch_registers = tdefault_fetch_registers;
4507 ops->to_store_registers = tdefault_store_registers;
4508 ops->to_prepare_to_store = tdefault_prepare_to_store;
4509 ops->to_files_info = tdefault_files_info;
4510 ops->to_insert_breakpoint = memory_insert_breakpoint;
4511 ops->to_remove_breakpoint = memory_remove_breakpoint;
4512 ops->to_stopped_by_sw_breakpoint = tdefault_stopped_by_sw_breakpoint;
4513 ops->to_supports_stopped_by_sw_breakpoint = tdefault_supports_stopped_by_sw_breakpoint;
4514 ops->to_stopped_by_hw_breakpoint = tdefault_stopped_by_hw_breakpoint;
4515 ops->to_supports_stopped_by_hw_breakpoint = tdefault_supports_stopped_by_hw_breakpoint;
4516 ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint;
4517 ops->to_ranged_break_num_registers = tdefault_ranged_break_num_registers;
4518 ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint;
4519 ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint;
4520 ops->to_remove_watchpoint = tdefault_remove_watchpoint;
4521 ops->to_insert_watchpoint = tdefault_insert_watchpoint;
4522 ops->to_insert_mask_watchpoint = tdefault_insert_mask_watchpoint;
4523 ops->to_remove_mask_watchpoint = tdefault_remove_mask_watchpoint;
4524 ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint;
4525 ops->to_stopped_data_address = tdefault_stopped_data_address;
4526 ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range;
4527 ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
4528 ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
4529 ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers;
4530 ops->to_can_do_single_step = tdefault_can_do_single_step;
4531 ops->to_terminal_init = tdefault_terminal_init;
4532 ops->to_terminal_inferior = tdefault_terminal_inferior;
4533 ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
4534 ops->to_terminal_ours = tdefault_terminal_ours;
4535 ops->to_terminal_info = default_terminal_info;
4536 ops->to_kill = tdefault_kill;
4537 ops->to_load = tdefault_load;
4538 ops->to_post_startup_inferior = tdefault_post_startup_inferior;
4539 ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint;
4540 ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint;
4541 ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint;
4542 ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint;
4543 ops->to_follow_fork = default_follow_fork;
4544 ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
4545 ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
4546 ops->to_follow_exec = tdefault_follow_exec;
4547 ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
4548 ops->to_has_exited = tdefault_has_exited;
4549 ops->to_mourn_inferior = default_mourn_inferior;
4550 ops->to_can_run = tdefault_can_run;
4551 ops->to_pass_signals = tdefault_pass_signals;
4552 ops->to_program_signals = tdefault_program_signals;
4553 ops->to_thread_alive = tdefault_thread_alive;
4554 ops->to_update_thread_list = tdefault_update_thread_list;
4555 ops->to_pid_to_str = default_pid_to_str;
4556 ops->to_extra_thread_info = tdefault_extra_thread_info;
4557 ops->to_thread_name = tdefault_thread_name;
4558 ops->to_thread_handle_to_thread_info = tdefault_thread_handle_to_thread_info;
4559 ops->to_stop = tdefault_stop;
4560 ops->to_interrupt = tdefault_interrupt;
4561 ops->to_pass_ctrlc = default_target_pass_ctrlc;
4562 ops->to_rcmd = default_rcmd;
4563 ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
4564 ops->to_log_command = tdefault_log_command;
4565 ops->to_get_section_table = tdefault_get_section_table;
4566 ops->to_can_async_p = tdefault_can_async_p;
4567 ops->to_is_async_p = tdefault_is_async_p;
4568 ops->to_async = tdefault_async;
4569 ops->to_thread_events = tdefault_thread_events;
4570 ops->to_supports_non_stop = tdefault_supports_non_stop;
4571 ops->to_always_non_stop_p = tdefault_always_non_stop_p;
4572 ops->to_find_memory_regions = dummy_find_memory_regions;
4573 ops->to_make_corefile_notes = dummy_make_corefile_notes;
4574 ops->to_get_bookmark = tdefault_get_bookmark;
4575 ops->to_goto_bookmark = tdefault_goto_bookmark;
4576 ops->to_get_thread_local_address = tdefault_get_thread_local_address;
4577 ops->to_xfer_partial = tdefault_xfer_partial;
4578 ops->to_get_memory_xfer_limit = tdefault_get_memory_xfer_limit;
4579 ops->to_memory_map = tdefault_memory_map;
4580 ops->to_flash_erase = tdefault_flash_erase;
4581 ops->to_flash_done = tdefault_flash_done;
4582 ops->to_read_description = tdefault_read_description;
4583 ops->to_get_ada_task_ptid = default_get_ada_task_ptid;
4584 ops->to_auxv_parse = default_auxv_parse;
4585 ops->to_search_memory = default_search_memory;
4586 ops->to_can_execute_reverse = tdefault_can_execute_reverse;
4587 ops->to_execution_direction = default_execution_direction;
4588 ops->to_supports_multi_process = tdefault_supports_multi_process;
4589 ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint;
4590 ops->to_supports_string_tracing = tdefault_supports_string_tracing;
4591 ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions;
4592 ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands;
4593 ops->to_thread_architecture = default_thread_architecture;
4594 ops->to_thread_address_space = default_thread_address_space;
4595 ops->to_filesystem_is_local = tdefault_filesystem_is_local;
4596 ops->to_trace_init = tdefault_trace_init;
4597 ops->to_download_tracepoint = tdefault_download_tracepoint;
4598 ops->to_can_download_tracepoint = tdefault_can_download_tracepoint;
4599 ops->to_download_trace_state_variable = tdefault_download_trace_state_variable;
4600 ops->to_enable_tracepoint = tdefault_enable_tracepoint;
4601 ops->to_disable_tracepoint = tdefault_disable_tracepoint;
4602 ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions;
4603 ops->to_trace_start = tdefault_trace_start;
4604 ops->to_get_trace_status = tdefault_get_trace_status;
4605 ops->to_get_tracepoint_status = tdefault_get_tracepoint_status;
4606 ops->to_trace_stop = tdefault_trace_stop;
4607 ops->to_trace_find = tdefault_trace_find;
4608 ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value;
4609 ops->to_save_trace_data = tdefault_save_trace_data;
4610 ops->to_upload_tracepoints = tdefault_upload_tracepoints;
4611 ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables;
4612 ops->to_get_raw_trace_data = tdefault_get_raw_trace_data;
4613 ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len;
4614 ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing;
4615 ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer;
4616 ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size;
4617 ops->to_set_trace_notes = tdefault_set_trace_notes;
4618 ops->to_core_of_thread = tdefault_core_of_thread;
4619 ops->to_verify_memory = default_verify_memory;
4620 ops->to_get_tib_address = tdefault_get_tib_address;
4621 ops->to_set_permissions = tdefault_set_permissions;
4622 ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at;
4623 ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
4624 ops->to_traceframe_info = tdefault_traceframe_info;
4625 ops->to_use_agent = tdefault_use_agent;
4626 ops->to_can_use_agent = tdefault_can_use_agent;
4627 ops->to_supports_btrace = tdefault_supports_btrace;
4628 ops->to_enable_btrace = tdefault_enable_btrace;
4629 ops->to_disable_btrace = tdefault_disable_btrace;
4630 ops->to_teardown_btrace = tdefault_teardown_btrace;
4631 ops->to_read_btrace = tdefault_read_btrace;
4632 ops->to_btrace_conf = tdefault_btrace_conf;
4633 ops->to_record_method = tdefault_record_method;
4634 ops->to_stop_recording = tdefault_stop_recording;
4635 ops->to_info_record = tdefault_info_record;
4636 ops->to_save_record = tdefault_save_record;
4637 ops->to_delete_record = tdefault_delete_record;
4638 ops->to_record_is_replaying = tdefault_record_is_replaying;
4639 ops->to_record_will_replay = tdefault_record_will_replay;
4640 ops->to_record_stop_replaying = tdefault_record_stop_replaying;
4641 ops->to_goto_record_begin = tdefault_goto_record_begin;
4642 ops->to_goto_record_end = tdefault_goto_record_end;
4643 ops->to_goto_record = tdefault_goto_record;
4644 ops->to_insn_history = tdefault_insn_history;
4645 ops->to_insn_history_from = tdefault_insn_history_from;
4646 ops->to_insn_history_range = tdefault_insn_history_range;
4647 ops->to_call_history = tdefault_call_history;
4648 ops->to_call_history_from = tdefault_call_history_from;
4649 ops->to_call_history_range = tdefault_call_history_range;
4650 ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read;
4651 ops->to_get_unwinder = tdefault_get_unwinder;
4652 ops->to_get_tailcall_unwinder = tdefault_get_tailcall_unwinder;
4653 ops->to_prepare_to_generate_core = tdefault_prepare_to_generate_core;
4654 ops->to_done_generating_core = tdefault_done_generating_core;
4655 }
4656
4657 static void
4658 init_debug_target (struct target_ops *ops)
4659 {
4660 ops->to_post_attach = debug_post_attach;
4661 ops->to_detach = debug_detach;
4662 ops->to_disconnect = debug_disconnect;
4663 ops->to_resume = debug_resume;
4664 ops->to_commit_resume = debug_commit_resume;
4665 ops->to_wait = debug_wait;
4666 ops->to_fetch_registers = debug_fetch_registers;
4667 ops->to_store_registers = debug_store_registers;
4668 ops->to_prepare_to_store = debug_prepare_to_store;
4669 ops->to_files_info = debug_files_info;
4670 ops->to_insert_breakpoint = debug_insert_breakpoint;
4671 ops->to_remove_breakpoint = debug_remove_breakpoint;
4672 ops->to_stopped_by_sw_breakpoint = debug_stopped_by_sw_breakpoint;
4673 ops->to_supports_stopped_by_sw_breakpoint = debug_supports_stopped_by_sw_breakpoint;
4674 ops->to_stopped_by_hw_breakpoint = debug_stopped_by_hw_breakpoint;
4675 ops->to_supports_stopped_by_hw_breakpoint = debug_supports_stopped_by_hw_breakpoint;
4676 ops->to_can_use_hw_breakpoint = debug_can_use_hw_breakpoint;
4677 ops->to_ranged_break_num_registers = debug_ranged_break_num_registers;
4678 ops->to_insert_hw_breakpoint = debug_insert_hw_breakpoint;
4679 ops->to_remove_hw_breakpoint = debug_remove_hw_breakpoint;
4680 ops->to_remove_watchpoint = debug_remove_watchpoint;
4681 ops->to_insert_watchpoint = debug_insert_watchpoint;
4682 ops->to_insert_mask_watchpoint = debug_insert_mask_watchpoint;
4683 ops->to_remove_mask_watchpoint = debug_remove_mask_watchpoint;
4684 ops->to_stopped_by_watchpoint = debug_stopped_by_watchpoint;
4685 ops->to_stopped_data_address = debug_stopped_data_address;
4686 ops->to_watchpoint_addr_within_range = debug_watchpoint_addr_within_range;
4687 ops->to_region_ok_for_hw_watchpoint = debug_region_ok_for_hw_watchpoint;
4688 ops->to_can_accel_watchpoint_condition = debug_can_accel_watchpoint_condition;
4689 ops->to_masked_watch_num_registers = debug_masked_watch_num_registers;
4690 ops->to_can_do_single_step = debug_can_do_single_step;
4691 ops->to_terminal_init = debug_terminal_init;
4692 ops->to_terminal_inferior = debug_terminal_inferior;
4693 ops->to_terminal_ours_for_output = debug_terminal_ours_for_output;
4694 ops->to_terminal_ours = debug_terminal_ours;
4695 ops->to_terminal_info = debug_terminal_info;
4696 ops->to_kill = debug_kill;
4697 ops->to_load = debug_load;
4698 ops->to_post_startup_inferior = debug_post_startup_inferior;
4699 ops->to_insert_fork_catchpoint = debug_insert_fork_catchpoint;
4700 ops->to_remove_fork_catchpoint = debug_remove_fork_catchpoint;
4701 ops->to_insert_vfork_catchpoint = debug_insert_vfork_catchpoint;
4702 ops->to_remove_vfork_catchpoint = debug_remove_vfork_catchpoint;
4703 ops->to_follow_fork = debug_follow_fork;
4704 ops->to_insert_exec_catchpoint = debug_insert_exec_catchpoint;
4705 ops->to_remove_exec_catchpoint = debug_remove_exec_catchpoint;
4706 ops->to_follow_exec = debug_follow_exec;
4707 ops->to_set_syscall_catchpoint = debug_set_syscall_catchpoint;
4708 ops->to_has_exited = debug_has_exited;
4709 ops->to_mourn_inferior = debug_mourn_inferior;
4710 ops->to_can_run = debug_can_run;
4711 ops->to_pass_signals = debug_pass_signals;
4712 ops->to_program_signals = debug_program_signals;
4713 ops->to_thread_alive = debug_thread_alive;
4714 ops->to_update_thread_list = debug_update_thread_list;
4715 ops->to_pid_to_str = debug_pid_to_str;
4716 ops->to_extra_thread_info = debug_extra_thread_info;
4717 ops->to_thread_name = debug_thread_name;
4718 ops->to_thread_handle_to_thread_info = debug_thread_handle_to_thread_info;
4719 ops->to_stop = debug_stop;
4720 ops->to_interrupt = debug_interrupt;
4721 ops->to_pass_ctrlc = debug_pass_ctrlc;
4722 ops->to_rcmd = debug_rcmd;
4723 ops->to_pid_to_exec_file = debug_pid_to_exec_file;
4724 ops->to_log_command = debug_log_command;
4725 ops->to_get_section_table = debug_get_section_table;
4726 ops->to_can_async_p = debug_can_async_p;
4727 ops->to_is_async_p = debug_is_async_p;
4728 ops->to_async = debug_async;
4729 ops->to_thread_events = debug_thread_events;
4730 ops->to_supports_non_stop = debug_supports_non_stop;
4731 ops->to_always_non_stop_p = debug_always_non_stop_p;
4732 ops->to_find_memory_regions = debug_find_memory_regions;
4733 ops->to_make_corefile_notes = debug_make_corefile_notes;
4734 ops->to_get_bookmark = debug_get_bookmark;
4735 ops->to_goto_bookmark = debug_goto_bookmark;
4736 ops->to_get_thread_local_address = debug_get_thread_local_address;
4737 ops->to_xfer_partial = debug_xfer_partial;
4738 ops->to_get_memory_xfer_limit = debug_get_memory_xfer_limit;
4739 ops->to_memory_map = debug_memory_map;
4740 ops->to_flash_erase = debug_flash_erase;
4741 ops->to_flash_done = debug_flash_done;
4742 ops->to_read_description = debug_read_description;
4743 ops->to_get_ada_task_ptid = debug_get_ada_task_ptid;
4744 ops->to_auxv_parse = debug_auxv_parse;
4745 ops->to_search_memory = debug_search_memory;
4746 ops->to_can_execute_reverse = debug_can_execute_reverse;
4747 ops->to_execution_direction = debug_execution_direction;
4748 ops->to_supports_multi_process = debug_supports_multi_process;
4749 ops->to_supports_enable_disable_tracepoint = debug_supports_enable_disable_tracepoint;
4750 ops->to_supports_string_tracing = debug_supports_string_tracing;
4751 ops->to_supports_evaluation_of_breakpoint_conditions = debug_supports_evaluation_of_breakpoint_conditions;
4752 ops->to_can_run_breakpoint_commands = debug_can_run_breakpoint_commands;
4753 ops->to_thread_architecture = debug_thread_architecture;
4754 ops->to_thread_address_space = debug_thread_address_space;
4755 ops->to_filesystem_is_local = debug_filesystem_is_local;
4756 ops->to_trace_init = debug_trace_init;
4757 ops->to_download_tracepoint = debug_download_tracepoint;
4758 ops->to_can_download_tracepoint = debug_can_download_tracepoint;
4759 ops->to_download_trace_state_variable = debug_download_trace_state_variable;
4760 ops->to_enable_tracepoint = debug_enable_tracepoint;
4761 ops->to_disable_tracepoint = debug_disable_tracepoint;
4762 ops->to_trace_set_readonly_regions = debug_trace_set_readonly_regions;
4763 ops->to_trace_start = debug_trace_start;
4764 ops->to_get_trace_status = debug_get_trace_status;
4765 ops->to_get_tracepoint_status = debug_get_tracepoint_status;
4766 ops->to_trace_stop = debug_trace_stop;
4767 ops->to_trace_find = debug_trace_find;
4768 ops->to_get_trace_state_variable_value = debug_get_trace_state_variable_value;
4769 ops->to_save_trace_data = debug_save_trace_data;
4770 ops->to_upload_tracepoints = debug_upload_tracepoints;
4771 ops->to_upload_trace_state_variables = debug_upload_trace_state_variables;
4772 ops->to_get_raw_trace_data = debug_get_raw_trace_data;
4773 ops->to_get_min_fast_tracepoint_insn_len = debug_get_min_fast_tracepoint_insn_len;
4774 ops->to_set_disconnected_tracing = debug_set_disconnected_tracing;
4775 ops->to_set_circular_trace_buffer = debug_set_circular_trace_buffer;
4776 ops->to_set_trace_buffer_size = debug_set_trace_buffer_size;
4777 ops->to_set_trace_notes = debug_set_trace_notes;
4778 ops->to_core_of_thread = debug_core_of_thread;
4779 ops->to_verify_memory = debug_verify_memory;
4780 ops->to_get_tib_address = debug_get_tib_address;
4781 ops->to_set_permissions = debug_set_permissions;
4782 ops->to_static_tracepoint_marker_at = debug_static_tracepoint_marker_at;
4783 ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid;
4784 ops->to_traceframe_info = debug_traceframe_info;
4785 ops->to_use_agent = debug_use_agent;
4786 ops->to_can_use_agent = debug_can_use_agent;
4787 ops->to_supports_btrace = debug_supports_btrace;
4788 ops->to_enable_btrace = debug_enable_btrace;
4789 ops->to_disable_btrace = debug_disable_btrace;
4790 ops->to_teardown_btrace = debug_teardown_btrace;
4791 ops->to_read_btrace = debug_read_btrace;
4792 ops->to_btrace_conf = debug_btrace_conf;
4793 ops->to_record_method = debug_record_method;
4794 ops->to_stop_recording = debug_stop_recording;
4795 ops->to_info_record = debug_info_record;
4796 ops->to_save_record = debug_save_record;
4797 ops->to_delete_record = debug_delete_record;
4798 ops->to_record_is_replaying = debug_record_is_replaying;
4799 ops->to_record_will_replay = debug_record_will_replay;
4800 ops->to_record_stop_replaying = debug_record_stop_replaying;
4801 ops->to_goto_record_begin = debug_goto_record_begin;
4802 ops->to_goto_record_end = debug_goto_record_end;
4803 ops->to_goto_record = debug_goto_record;
4804 ops->to_insn_history = debug_insn_history;
4805 ops->to_insn_history_from = debug_insn_history_from;
4806 ops->to_insn_history_range = debug_insn_history_range;
4807 ops->to_call_history = debug_call_history;
4808 ops->to_call_history_from = debug_call_history_from;
4809 ops->to_call_history_range = debug_call_history_range;
4810 ops->to_augmented_libraries_svr4_read = debug_augmented_libraries_svr4_read;
4811 ops->to_get_unwinder = debug_get_unwinder;
4812 ops->to_get_tailcall_unwinder = debug_get_tailcall_unwinder;
4813 ops->to_prepare_to_generate_core = debug_prepare_to_generate_core;
4814 ops->to_done_generating_core = debug_done_generating_core;
4815 }
tdefault_has_exited
static int tdefault_has_exited(struct target_ops *self, int arg1, int arg2, int *arg3)
Definition: target-delegates.c:1331
gdbarch
Definition: gdbarch.c:127
tdefault_get_tib_address
static int tdefault_get_tib_address(struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
Definition: target-delegates.c:3253
target_ops::to_thread_address_space
struct address_space *(* to_thread_address_space)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_thread_address_space)
Definition: target.h:875
delegate_stopped_by_watchpoint
static int delegate_stopped_by_watchpoint(struct target_ops *self)
Definition: target-delegates.c:680
delegate_xfer_partial
static enum target_xfer_status delegate_xfer_partial(struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
Definition: target-delegates.c:2082
debug_can_async_p
static int debug_can_async_p(struct target_ops *self)
Definition: target-delegates.c:1797
tdefault_follow_exec
static void tdefault_follow_exec(struct target_ops *self, struct inferior *arg1, char *arg2)
Definition: target-delegates.c:1270
tdefault_insert_fork_catchpoint
static int tdefault_insert_fork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1071
delegate_can_use_hw_breakpoint
static int delegate_can_use_hw_breakpoint(struct target_ops *self, enum bptype arg1, int arg2, int arg3)
Definition: target-delegates.c:422
target_debug_print_bool
#define target_debug_print_bool(X)
Definition: target-debug.h:59
debug_verify_memory
static int debug_verify_memory(struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
Definition: target-delegates.c:3226
debug_delete_record
static void debug_delete_record(struct target_ops *self)
Definition: target-delegates.c:3725
default_target_wait
ptid_t default_target_wait(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
Definition: target.c:2185
debug_done_generating_core
static void debug_done_generating_core(struct target_ops *self)
Definition: target-delegates.c:4173
debug_commit_resume
static void debug_commit_resume(struct target_ops *self)
Definition: target-delegates.c:125
delegate_disable_tracepoint
static void delegate_disable_tracepoint(struct target_ops *self, struct bp_location *arg1)
Definition: target-delegates.c:2720
delegate_get_tailcall_unwinder
static const struct frame_unwind * delegate_get_tailcall_unwinder(struct target_ops *self)
Definition: target-delegates.c:4112
debug_pass_signals
static void debug_pass_signals(struct target_ops *self, int arg1, unsigned char *arg2)
Definition: target-delegates.c:1413
tdefault_resume
static void tdefault_resume(struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
Definition: target-delegates.c:91
delegate_prepare_to_generate_core
static void delegate_prepare_to_generate_core(struct target_ops *self)
Definition: target-delegates.c:4139
target_ops::to_delete_record
void(* to_delete_record)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1167
delegate_insert_vfork_catchpoint
static int delegate_insert_vfork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1122
tdefault_thread_alive
static int tdefault_thread_alive(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1460
tdefault_get_trace_status
static int tdefault_get_trace_status(struct target_ops *self, struct trace_status *arg1)
Definition: target-delegates.c:2798
target_ops::to_supports_stopped_by_hw_breakpoint
int(* to_supports_stopped_by_hw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:499
delegate_record_stop_replaying
static void delegate_record_stop_replaying(struct target_ops *self)
Definition: target-delegates.c:3795
delegate_insn_history
static void delegate_insn_history(struct target_ops *self, int arg1, gdb_disassembly_flags arg2)
Definition: target-delegates.c:3888
target_ops::to_read_description
const struct target_desc *(* to_read_description)(struct target_ops *ops) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:790
target_ops::to_is_async_p
int(* to_is_async_p)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:668
tdefault_load
static void tdefault_load(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:1020
debug_make_corefile_notes
static char * debug_make_corefile_notes(struct target_ops *self, bfd *arg1, int *arg2)
Definition: target-delegates.c:1973
target_ops::to_upload_tracepoints
int(* to_upload_tracepoints)(struct target_ops *, struct uploaded_tp **utpp) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1020
target_ops::to_trace_init
void(* to_trace_init)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:949
delegate_commit_resume
static void delegate_commit_resume(struct target_ops *self)
Definition: target-delegates.c:113
debug_follow_exec
static void debug_follow_exec(struct target_ops *self, struct inferior *arg1, char *arg2)
Definition: target-delegates.c:1275
tdefault_insert_hw_breakpoint
static int tdefault_insert_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
Definition: target-delegates.c:489
target_ops::to_supports_evaluation_of_breakpoint_conditions
int(* to_supports_evaluation_of_breakpoint_conditions)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:850
tdefault_record_method
static enum record_method tdefault_record_method(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:3621
default_target_pass_ctrlc
void default_target_pass_ctrlc(struct target_ops *ops)
Definition: target.c:3350
delegate_follow_exec
static void delegate_follow_exec(struct target_ops *self, struct inferior *arg1, char *arg2)
Definition: target-delegates.c:1263
target_ops::to_program_signals
void(* to_program_signals)(struct target_ops *, int, unsigned char *TARGET_DEBUG_PRINTER(target_debug_print_signals)) TARGET_DEFAULT_IGNORE()
Definition: target.h:622
debug_insn_history_from
static void debug_insn_history_from(struct target_ops *self, ULONGEST arg1, int arg2, gdb_disassembly_flags arg3)
Definition: target-delegates.c:3928
target_ops::to_goto_bookmark
void(* to_goto_bookmark)(struct target_ops *, const gdb_byte *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:693
delegate_thread_address_space
static struct address_space * delegate_thread_address_space(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:2545
install_dummy_methods
static void install_dummy_methods(struct target_ops *ops)
Definition: target-delegates.c:4498
target_ops::to_goto_record_begin
void(* to_goto_record_begin)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1184
tdefault_insert_exec_catchpoint
static int tdefault_insert_exec_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1212
delegate_supports_enable_disable_tracepoint
static int delegate_supports_enable_disable_tracepoint(struct target_ops *self)
Definition: target-delegates.c:2414
tdefault_goto_record
static void tdefault_goto_record(struct target_ops *self, ULONGEST arg1)
Definition: target-delegates.c:3870
tdefault_filesystem_is_local
static int tdefault_filesystem_is_local(struct target_ops *self)
Definition: target-delegates.c:2575
tdefault_get_trace_state_variable_value
static int tdefault_get_trace_state_variable_value(struct target_ops *self, int arg1, LONGEST *arg2)
Definition: target-delegates.c:2914
btrace_target_info
Definition: linux-btrace.h:85
tdefault_record_stop_replaying
static void tdefault_record_stop_replaying(struct target_ops *self)
Definition: target-delegates.c:3802
delegate_insn_history_from
static void delegate_insn_history_from(struct target_ops *self, ULONGEST arg1, int arg2, gdb_disassembly_flags arg3)
Definition: target-delegates.c:3915
target_ops::to_save_record
void(* to_save_record)(struct target_ops *, const char *filename) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1162
target_waitstatus
Definition: waitstatus.h:104
debug_supports_enable_disable_tracepoint
static int debug_supports_enable_disable_tracepoint(struct target_ops *self)
Definition: target-delegates.c:2427
tdefault_program_signals
static void tdefault_program_signals(struct target_ops *self, int arg1, unsigned char *arg2)
Definition: target-delegates.c:1434
target_debug_print_struct_breakpoint_p
#define target_debug_print_struct_breakpoint_p(X)
Definition: target-debug.h:131
debug_call_history_range
static void debug_call_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
Definition: target-delegates.c:4042
target_ops::to_find_memory_regions
int(* to_find_memory_regions)(struct target_ops *, find_memory_region_ftype func, void *data) TARGET_DEFAULT_FUNC(dummy_find_memory_regions)
Definition: target.h:683
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
target_ops::to_insert_mask_watchpoint
int(* to_insert_mask_watchpoint)(struct target_ops *, CORE_ADDR, CORE_ADDR, enum target_hw_bp_type) TARGET_DEFAULT_RETURN(1)
Definition: target.h:523
tdefault_post_startup_inferior
static void tdefault_post_startup_inferior(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1047
debug_get_section_table
static struct target_section_table * debug_get_section_table(struct target_ops *self)
Definition: target-delegates.c:1770
debug_post_startup_inferior
static void debug_post_startup_inferior(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1052
debug_can_do_single_step
static int debug_can_do_single_step(struct target_ops *self)
Definition: target-delegates.c:867
target_debug_print_enum_bptype
#define target_debug_print_enum_bptype(X)
Definition: target-debug.h:161
delegate_get_trace_status
static int delegate_get_trace_status(struct target_ops *self, struct trace_status *arg1)
Definition: target-delegates.c:2791
delegate_program_signals
static void delegate_program_signals(struct target_ops *self, int arg1, unsigned char *arg2)
Definition: target-delegates.c:1427
tdefault_static_tracepoint_marker_at
static int tdefault_static_tracepoint_marker_at(struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
Definition: target-delegates.c:3306
tdefault_remove_exec_catchpoint
static int tdefault_remove_exec_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1241
fputs_unfiltered
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:127
target_debug_print_struct_bp_target_info_p
#define target_debug_print_struct_bp_target_info_p(X)
Definition: target-debug.h:95
debug_stop_recording
static void debug_stop_recording(struct target_ops *self)
Definition: target-delegates.c:3655
delegate_get_raw_trace_data
static LONGEST delegate_get_raw_trace_data(struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
Definition: target-delegates.c:3025
debug_terminal_ours
static void debug_terminal_ours(struct target_ops *self)
Definition: target-delegates.c:959
debug_record_method
static enum record_method debug_record_method(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:3627
debug_prepare_to_generate_core
static void debug_prepare_to_generate_core(struct target_ops *self)
Definition: target-delegates.c:4151
debug_disable_btrace
static void debug_disable_btrace(struct target_ops *self, struct btrace_target_info *arg1)
Definition: target-delegates.c:3515
debug_ranged_break_num_registers
static int debug_ranged_break_num_registers(struct target_ops *self)
Definition: target-delegates.c:468
delegate_can_accel_watchpoint_condition
static int delegate_can_accel_watchpoint_condition(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
Definition: target-delegates.c:788
tdefault_get_min_fast_tracepoint_insn_len
static int tdefault_get_min_fast_tracepoint_insn_len(struct target_ops *self)
Definition: target-delegates.c:3065
debug_goto_record_end
static void debug_goto_record_end(struct target_ops *self)
Definition: target-delegates.c:3853
tdefault_detach
static void tdefault_detach(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:38
target_debug_print_struct_bp_location_p
#define target_debug_print_struct_bp_location_p(X)
Definition: target-debug.h:125
debug_load
static void debug_load(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:1026
debug_log_command
static void debug_log_command(struct target_ops *self, const char *arg1)
Definition: target-delegates.c:1745
debug_has_exited
static int debug_has_exited(struct target_ops *self, int arg1, int arg2, int *arg3)
Definition: target-delegates.c:1337
target_debug_print_VEC_static_tracepoint_marker_p_p
#define target_debug_print_VEC_static_tracepoint_marker_p_p(X)
Definition: target-debug.h:121
delegate_remove_vfork_catchpoint
static int delegate_remove_vfork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1151
delegate_save_trace_data
static int delegate_save_trace_data(struct target_ops *self, const char *arg1)
Definition: target-delegates.c:2938
debug_post_attach
static void debug_post_attach(struct target_ops *self, int arg1)
Definition: target-delegates.c:19
target_ops::to_trace_start
void(* to_trace_start)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:984
delegate_supports_string_tracing
static int delegate_supports_string_tracing(struct target_ops *self)
Definition: target-delegates.c:2441
target_ops::to_flash_done
void(* to_flash_done)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:783
target_debug_print_struct_trace_state_variable_p
#define target_debug_print_struct_trace_state_variable_p(X)
Definition: target-debug.h:127
delegate_flash_erase
static void delegate_flash_erase(struct target_ops *self, ULONGEST arg1, LONGEST arg2)
Definition: target-delegates.c:2177
target_ops::to_stop_recording
void(* to_stop_recording)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1154
target_debug_print_enum_target_xfer_status
#define target_debug_print_enum_target_xfer_status(X)
Definition: target-debug.h:63
debug_remove_vfork_catchpoint
static int debug_remove_vfork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1164
debug_execution_direction
static enum exec_direction_kind debug_execution_direction(struct target_ops *self)
Definition: target-delegates.c:2373
debug_follow_fork
static int debug_follow_fork(struct target_ops *self, int arg1, int arg2)
Definition: target-delegates.c:1187
debug_thread_architecture
static struct gdbarch * debug_thread_architecture(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:2529
target_debug_print_ptid_t
#define target_debug_print_ptid_t(X)
Definition: target-debug.h:73
delegate_download_tracepoint
static void delegate_download_tracepoint(struct target_ops *self, struct bp_location *arg1)
Definition: target-delegates.c:2618
default_get_ada_task_ptid
static ptid_t default_get_ada_task_ptid(struct target_ops *self, long lwp, long tid)
Definition: target.c:566
target_ops::to_terminal_init
void(* to_terminal_init)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:560
target_debug_print_char_p
#define target_debug_print_char_p(X)
Definition: target-debug.h:55
delegate_has_exited
static int delegate_has_exited(struct target_ops *self, int arg1, int arg2, int *arg3)
Definition: target-delegates.c:1324
target_ops::to_has_exited
int(* to_has_exited)(struct target_ops *, int, int, int *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:604
debug_supports_evaluation_of_breakpoint_conditions
static int debug_supports_evaluation_of_breakpoint_conditions(struct target_ops *self)
Definition: target-delegates.c:2481
target_ops::to_record_stop_replaying
void(* to_record_stop_replaying)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1180
target_ops::to_insert_breakpoint
int(* to_insert_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_insert_breakpoint)
Definition: target.h:466
tdefault_trace_start
static void tdefault_trace_start(struct target_ops *self)
Definition: target-delegates.c:2775
delegate_set_permissions
static void delegate_set_permissions(struct target_ops *self)
Definition: target-delegates.c:3277
delegate_can_do_single_step
static int delegate_can_do_single_step(struct target_ops *self)
Definition: target-delegates.c:854
delegate_terminal_info
static void delegate_terminal_info(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:969
delegate_fetch_registers
static void delegate_fetch_registers(struct target_ops *self, struct regcache *arg1, int arg2)
Definition: target-delegates.c:162
target_ops::to_rcmd
void(* to_rcmd)(struct target_ops *, const char *command, struct ui_file *output) TARGET_DEFAULT_FUNC(default_rcmd)
Definition: target.h:647
target_debug_print_gdb_byte_pp
#define target_debug_print_gdb_byte_pp(X)
Definition: target-debug.h:81
tdefault_remove_fork_catchpoint
static int tdefault_remove_fork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1100
delegate_call_history_from
static void delegate_call_history_from(struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
Definition: target-delegates.c:4000
tdefault_get_tracepoint_status
static void tdefault_get_tracepoint_status(struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
Definition: target-delegates.c:2827
debug_record_will_replay
static int debug_record_will_replay(struct target_ops *self, ptid_t arg1, int arg2)
Definition: target-delegates.c:3777
target_ops::to_core_of_thread
int(* to_core_of_thread)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:1063
target_debug_print_struct_expression_p
#define target_debug_print_struct_expression_p(X)
Definition: target-debug.h:97
target_ops::to_follow_fork
int(* to_follow_fork)(struct target_ops *, int, int) TARGET_DEFAULT_FUNC(default_follow_fork)
Definition: target.h:592
target_ops::to_set_syscall_catchpoint
int(* to_set_syscall_catchpoint)(struct target_ops *, int, bool, int, gdb::array_view< const int >) TARGET_DEFAULT_RETURN(1)
Definition: target.h:600
debug_get_trace_state_variable_value
static int debug_get_trace_state_variable_value(struct target_ops *self, int arg1, LONGEST *arg2)
Definition: target-delegates.c:2920
target_ops::to_terminal_ours_for_output
void(* to_terminal_ours_for_output)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:564
delegate_download_trace_state_variable
static void delegate_download_trace_state_variable(struct target_ops *self, struct trace_state_variable *arg1)
Definition: target-delegates.c:2670
tdefault_goto_record_begin
static void tdefault_goto_record_begin(struct target_ops *self)
Definition: target-delegates.c:3824
delegate_extra_thread_info
static const char * delegate_extra_thread_info(struct target_ops *self, struct thread_info *arg1)
Definition: target-delegates.c:1527
target_ops::to_call_history
void(* to_call_history)(struct target_ops *, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1222
delegate_read_btrace
static enum btrace_error delegate_read_btrace(struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
Definition: target-delegates.c:3552
target_debug_print_enum_gdb_signal
#define target_debug_print_enum_gdb_signal(X)
Definition: target-debug.h:83
delegate_done_generating_core
static void delegate_done_generating_core(struct target_ops *self)
Definition: target-delegates.c:4161
debug_trace_set_readonly_regions
static void debug_trace_set_readonly_regions(struct target_ops *self)
Definition: target-delegates.c:2758
debug_upload_trace_state_variables
static int debug_upload_trace_state_variables(struct target_ops *self, struct uploaded_tsv **arg1)
Definition: target-delegates.c:3009
inferior
Definition: inferior.h:310
tdefault_extra_thread_info
static const char * tdefault_extra_thread_info(struct target_ops *self, struct thread_info *arg1)
Definition: target-delegates.c:1534
debug_upload_tracepoints
static int debug_upload_tracepoints(struct target_ops *self, struct uploaded_tp **arg1)
Definition: target-delegates.c:2980
target_ops::to_pid_to_str
const char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:630
tdefault_stop
static void tdefault_stop(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1625
target_debug_print_struct_btrace_data_p
#define target_debug_print_struct_btrace_data_p(X)
Definition: target-debug.h:149
debug_get_raw_trace_data
static LONGEST debug_get_raw_trace_data(struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
Definition: target-delegates.c:3038
target_ops::to_thread_handle_to_thread_info
struct thread_info *(* to_thread_handle_to_thread_info)(struct target_ops *, const gdb_byte *, int, struct inferior *inf) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:636
tdefault_remove_hw_breakpoint
static int tdefault_remove_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
Definition: target-delegates.c:520
delegate_btrace_conf
static const struct btrace_config * delegate_btrace_conf(struct target_ops *self, const struct btrace_target_info *arg1)
Definition: target-delegates.c:3585
tdefault_disconnect
static void tdefault_disconnect(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:64
tdefault_prepare_to_store
static void tdefault_prepare_to_store(struct target_ops *self, struct regcache *arg1)
Definition: target-delegates.c:222
debug_program_signals
static void debug_program_signals(struct target_ops *self, int arg1, unsigned char *arg2)
Definition: target-delegates.c:1439
target_debug_print_std_vector_mem_region
#define target_debug_print_std_vector_mem_region(X)
Definition: target-debug.h:119
target_debug_print_int
#define target_debug_print_int(X)
Definition: target-debug.h:57
target_ops::to_get_tailcall_unwinder
const struct frame_unwind *(* to_get_tailcall_unwinder)(struct target_ops *self) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:1250
target_ops::to_insn_history
void(* to_insn_history)(struct target_ops *, int size, gdb_disassembly_flags flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1199
debug_find_memory_regions
static int debug_find_memory_regions(struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
Definition: target-delegates.c:1948
delegate_get_ada_task_ptid
static ptid_t delegate_get_ada_task_ptid(struct target_ops *self, long arg1, long arg2)
Definition: target-delegates.c:2254
delegate_stop
static void delegate_stop(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1618
tdefault_insert_watchpoint
static int tdefault_insert_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
Definition: target-delegates.c:586
tdefault_upload_tracepoints
static int tdefault_upload_tracepoints(struct target_ops *self, struct uploaded_tp **arg1)
Definition: target-delegates.c:2974
target_debug_print_struct_address_space_p
#define target_debug_print_struct_address_space_p(X)
Definition: target-debug.h:93
tdefault_stopped_by_sw_breakpoint
static int tdefault_stopped_by_sw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:321
target_ops::to_set_disconnected_tracing
void(* to_set_disconnected_tracing)(struct target_ops *, int val) TARGET_DEFAULT_IGNORE()
Definition: target.h:1041
delegate_record_method
static enum record_method delegate_record_method(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:3614
debug_supports_string_tracing
static int debug_supports_string_tracing(struct target_ops *self)
Definition: target-delegates.c:2454
tdefault_thread_name
static const char * tdefault_thread_name(struct target_ops *self, struct thread_info *arg1)
Definition: target-delegates.c:1563
target_debug_print_CORE_ADDR
#define target_debug_print_CORE_ADDR(X)
Definition: target-debug.h:51
tdefault_interrupt
static void tdefault_interrupt(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1649
delegate_always_non_stop_p
static int delegate_always_non_stop_p(struct target_ops *self)
Definition: target-delegates.c:1914
delegate_can_run_breakpoint_commands
static int delegate_can_run_breakpoint_commands(struct target_ops *self)
Definition: target-delegates.c:2495
target_ops::to_supports_enable_disable_tracepoint
int(* to_supports_enable_disable_tracepoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:838
target_ops::to_remove_watchpoint
int(* to_remove_watchpoint)(struct target_ops *, CORE_ADDR, int, enum target_hw_bp_type, struct expression *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:516
target_ops::to_insn_history_range
void(* to_insn_history_range)(struct target_ops *, ULONGEST begin, ULONGEST end, gdb_disassembly_flags flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1214
target_ops::to_region_ok_for_hw_watchpoint
int(* to_region_ok_for_hw_watchpoint)(struct target_ops *, CORE_ADDR, int) TARGET_DEFAULT_FUNC(default_region_ok_for_hw_watchpoint)
Definition: target.h:543
target_ops::to_info_record
void(* to_info_record)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1158
debug_can_execute_reverse
static int debug_can_execute_reverse(struct target_ops *self)
Definition: target-delegates.c:2352
tdefault_flash_erase
static void tdefault_flash_erase(struct target_ops *self, ULONGEST arg1, LONGEST arg2)
Definition: target-delegates.c:2184
delegate_log_command
static void delegate_log_command(struct target_ops *self, const char *arg1)
Definition: target-delegates.c:1733
target_ops::to_can_use_hw_breakpoint
int(* to_can_use_hw_breakpoint)(struct target_ops *, enum bptype, int, int) TARGET_DEFAULT_RETURN(0)
Definition: target.h:502
debug_disable_tracepoint
static void debug_disable_tracepoint(struct target_ops *self, struct bp_location *arg1)
Definition: target-delegates.c:2733
delegate_get_memory_xfer_limit
static ULONGEST delegate_get_memory_xfer_limit(struct target_ops *self)
Definition: target-delegates.c:2123
delegate_stopped_data_address
static int delegate_stopped_data_address(struct target_ops *self, CORE_ADDR *arg1)
Definition: target-delegates.c:707
ui_file
Definition: ui-file.h:26
debug_wait
static ptid_t debug_wait(struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
Definition: target-delegates.c:142
debug_get_tracepoint_status
static void debug_get_tracepoint_status(struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
Definition: target-delegates.c:2833
debug_watchpoint_addr_within_range
static int debug_watchpoint_addr_within_range(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
Definition: target-delegates.c:743
target_ops::to_trace_stop
void(* to_trace_stop)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:997
tdefault_trace_init
static void tdefault_trace_init(struct target_ops *self)
Definition: target-delegates.c:2602
target_ops::to_flash_erase
std::vector< mem_region >(*) to_memory_map(struct target_ops *) TARGET_DEFAULT_RETURN(std void(* to_flash_erase)(struct target_ops *, ULONGEST address, LONGEST length) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:775
target_ops::to_get_memory_xfer_limit
ULONGEST(* to_get_memory_xfer_limit)(struct target_ops *) TARGET_DEFAULT_RETURN(ULONGEST_MAX)
Definition: target.h:751
tdefault_supports_evaluation_of_breakpoint_conditions
static int tdefault_supports_evaluation_of_breakpoint_conditions(struct target_ops *self)
Definition: target-delegates.c:2475
debug_record_stop_replaying
static void debug_record_stop_replaying(struct target_ops *self)
Definition: target-delegates.c:3807
default_follow_fork
static int default_follow_fork(struct target_ops *self, int follow_child, int detach_fork)
Definition: target.c:2264
target_ops::to_supports_string_tracing
int(* to_supports_string_tracing)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:845
debug_flash_erase
static void debug_flash_erase(struct target_ops *self, ULONGEST arg1, LONGEST arg2)
Definition: target-delegates.c:2190
delegate_get_min_fast_tracepoint_insn_len
static int delegate_get_min_fast_tracepoint_insn_len(struct target_ops *self)
Definition: target-delegates.c:3058
btrace_format
btrace_format
Definition: btrace-common.h:54
tdefault_get_bookmark
static gdb_byte * tdefault_get_bookmark(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:1998
ULONGEST_MAX
#define ULONGEST_MAX
Definition: defs.h:493
debug_get_memory_xfer_limit
static ULONGEST debug_get_memory_xfer_limit(struct target_ops *self)
Definition: target-delegates.c:2136
target_ops::to_set_trace_buffer_size
void(* to_set_trace_buffer_size)(struct target_ops *, LONGEST val) TARGET_DEFAULT_IGNORE()
Definition: target.h:1046
delegate_stop_recording
static void delegate_stop_recording(struct target_ops *self)
Definition: target-delegates.c:3643
tdefault_can_run_breakpoint_commands
static int tdefault_can_run_breakpoint_commands(struct target_ops *self)
Definition: target-delegates.c:2502
tdefault_supports_btrace
static int tdefault_supports_btrace(struct target_ops *self, enum btrace_format arg1)
Definition: target-delegates.c:3449
debug_stop
static void debug_stop(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1630
target_ops::to_get_trace_state_variable_value
int(* to_get_trace_state_variable_value)(struct target_ops *, int tsv, LONGEST *val) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1013
tdefault_supports_stopped_by_sw_breakpoint
static int tdefault_supports_stopped_by_sw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:348
delegate_get_bookmark
static gdb_byte * delegate_get_bookmark(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:1991
delegate_disable_btrace
static void delegate_disable_btrace(struct target_ops *self, struct btrace_target_info *arg1)
Definition: target-delegates.c:3502
tdefault_set_circular_trace_buffer
static void tdefault_set_circular_trace_buffer(struct target_ops *self, int arg1)
Definition: target-delegates.c:3116
target_ops::to_remove_exec_catchpoint
int(* to_remove_exec_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:596
tdefault_insn_history_range
static void tdefault_insn_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, gdb_disassembly_flags arg3)
Definition: target-delegates.c:3951
delegate_remove_mask_watchpoint
static int delegate_remove_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
Definition: target-delegates.c:647
target_debug_print_struct_inferior_p
#define target_debug_print_struct_inferior_p(X)
Definition: target-debug.h:163
trace_find_type
trace_find_type
Definition: tracepoint.h:384
debug_enable_tracepoint
static void debug_enable_tracepoint(struct target_ops *self, struct bp_location *arg1)
Definition: target-delegates.c:2708
debug_filesystem_is_local
static int debug_filesystem_is_local(struct target_ops *self)
Definition: target-delegates.c:2581
tdefault_call_history_range
static void tdefault_call_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
Definition: target-delegates.c:4036
target_ops::to_files_info
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:464
tdefault_record_is_replaying
static int tdefault_record_is_replaying(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:3742
default_auxv_parse
int default_auxv_parse(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition: auxv.c:258
debug_pass_ctrlc
static void debug_pass_ctrlc(struct target_ops *self)
Definition: target-delegates.c:1673
tdefault_masked_watch_num_registers
static int tdefault_masked_watch_num_registers(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
Definition: target-delegates.c:830
debug_search_memory
static int debug_search_memory(struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
Definition: target-delegates.c:2315
debug_insert_exec_catchpoint
static int debug_insert_exec_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1218
target_ops::to_thread_events
void(* to_thread_events)(struct target_ops *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:672
delegate_supports_multi_process
static int delegate_supports_multi_process(struct target_ops *self)
Definition: target-delegates.c:2387
tdefault_get_raw_trace_data
static LONGEST tdefault_get_raw_trace_data(struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
Definition: target-delegates.c:3032
bp_target_info
Definition: breakpoint.h:238
tdefault_can_accel_watchpoint_condition
static int tdefault_can_accel_watchpoint_condition(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
Definition: target-delegates.c:795
debug_masked_watch_num_registers
static int debug_masked_watch_num_registers(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
Definition: target-delegates.c:836
debug_update_thread_list
static void debug_update_thread_list(struct target_ops *self)
Definition: target-delegates.c:1494
target_debug_print_struct_target_waitstatus_p
static void target_debug_print_struct_target_waitstatus_p(struct target_waitstatus *status)
Definition: target-debug.h:175
target_ops::to_remove_fork_catchpoint
int(* to_remove_fork_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:586
target_ops::to_disable_tracepoint
void(* to_disable_tracepoint)(struct target_ops *, struct bp_location *location) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:973
target_ops::to_record_is_replaying
int(* to_record_is_replaying)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1171
target_ops::to_can_do_single_step
int(* to_can_do_single_step)(struct target_ops *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:557
default_terminal_info
static void default_terminal_info(struct target_ops *self, const char *args, int from_tty)
Definition: target.c:554
debug_core_of_thread
static int debug_core_of_thread(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:3203
debug_terminal_init
static void debug_terminal_init(struct target_ops *self)
Definition: target-delegates.c:893
delegate_can_run
static int delegate_can_run(struct target_ops *self)
Definition: target-delegates.c:1374
debug_remove_fork_catchpoint
static int debug_remove_fork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1106
debug_resume
static void debug_resume(struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
Definition: target-delegates.c:97
debug_can_download_tracepoint
static int debug_can_download_tracepoint(struct target_ops *self)
Definition: target-delegates.c:2656
target_ops::to_insn_history_from
void(* to_insn_history_from)(struct target_ops *, ULONGEST from, int size, gdb_disassembly_flags flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1207
debug_insert_breakpoint
static int debug_insert_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
Definition: target-delegates.c:269
tdefault_set_disconnected_tracing
static void tdefault_set_disconnected_tracing(struct target_ops *self, int arg1)
Definition: target-delegates.c:3092
tdefault_kill
static void tdefault_kill(struct target_ops *self)
Definition: target-delegates.c:997
target_ops::to_prepare_to_generate_core
void(* to_prepare_to_generate_core)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1254
debug_teardown_btrace
static void debug_teardown_btrace(struct target_ops *self, struct btrace_target_info *arg1)
Definition: target-delegates.c:3540
target_debug_print_struct_uploaded_tsv_pp
#define target_debug_print_struct_uploaded_tsv_pp(X)
Definition: target-debug.h:137
delegate_goto_record_begin
static void delegate_goto_record_begin(struct target_ops *self)
Definition: target-delegates.c:3817
debug_static_tracepoint_marker_at
static int debug_static_tracepoint_marker_at(struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
Definition: target-delegates.c:3312
debug_get_tailcall_unwinder
static const struct frame_unwind * debug_get_tailcall_unwinder(struct target_ops *self)
Definition: target-delegates.c:4125
debug_async
static void debug_async(struct target_ops *self, int arg1)
Definition: target-delegates.c:1851
debug_supports_non_stop
static int debug_supports_non_stop(struct target_ops *self)
Definition: target-delegates.c:1900
target_ops::to_call_history_range
void(* to_call_history_range)(struct target_ops *, ULONGEST begin, ULONGEST end, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1235
debug_prepare_to_store
static void debug_prepare_to_store(struct target_ops *self, struct regcache *arg1)
Definition: target-delegates.c:228
debug_save_trace_data
static int debug_save_trace_data(struct target_ops *self, const char *arg1)
Definition: target-delegates.c:2951
delegate_pass_signals
static void delegate_pass_signals(struct target_ops *self, int arg1, unsigned char *arg2)
Definition: target-delegates.c:1401
target_debug_print_step
#define target_debug_print_step(X)
Definition: target-debug.h:186
delegate_record_is_replaying
static int delegate_record_is_replaying(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:3735
debug_always_non_stop_p
static int debug_always_non_stop_p(struct target_ops *self)
Definition: target-delegates.c:1927
tdefault_remove_mask_watchpoint
static int tdefault_remove_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
Definition: target-delegates.c:654
target_ops::to_trace_find
int(* to_trace_find)(struct target_ops *, enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:1005
default_region_ok_for_hw_watchpoint
static int default_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR addr, int len)
Definition: target.c:3114
delegate_record_will_replay
static int delegate_record_will_replay(struct target_ops *self, ptid_t arg1, int arg2)
Definition: target-delegates.c:3764
tdefault_insert_vfork_catchpoint
static int tdefault_insert_vfork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1129
delegate_detach
static void delegate_detach(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:31
delegate_rcmd
static void delegate_rcmd(struct target_ops *self, const char *arg1, struct ui_file *arg2)
Definition: target-delegates.c:1683
delegate_flash_done
static void delegate_flash_done(struct target_ops *self)
Definition: target-delegates.c:2204
delegate_kill
static void delegate_kill(struct target_ops *self)
Definition: target-delegates.c:990
debug_set_disconnected_tracing
static void debug_set_disconnected_tracing(struct target_ops *self, int arg1)
Definition: target-delegates.c:3097
target_debug_print_struct_static_tracepoint_marker_p
#define target_debug_print_struct_static_tracepoint_marker_p(X)
Definition: target-debug.h:139
debug_memory_map
static std::vector< mem_region > debug_memory_map(struct target_ops *self)
Definition: target-delegates.c:2163
delegate_remove_breakpoint
static int delegate_remove_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2, enum remove_bp_reason arg3)
Definition: target-delegates.c:287
target_ops
Definition: target.h:412
trace_status
Definition: tracepoint.h:88
debug_kill
static void debug_kill(struct target_ops *self)
Definition: target-delegates.c:1003
target_ops::to_watchpoint_addr_within_range
int(* to_watchpoint_addr_within_range)(struct target_ops *, CORE_ADDR, CORE_ADDR, int) TARGET_DEFAULT_FUNC(default_watchpoint_addr_within_range)
Definition: target.h:537
target_ops::to_get_raw_trace_data
LONGEST(* to_get_raw_trace_data)(struct target_ops *, gdb_byte *buf, ULONGEST offset, LONGEST len) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1028
target_ops::to_record_will_replay
int(* to_record_will_replay)(struct target_ops *, ptid_t ptid, int dir) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1176
tdefault_enable_tracepoint
static void tdefault_enable_tracepoint(struct target_ops *self, struct bp_location *arg1)
Definition: target-delegates.c:2702
tdefault_supports_string_tracing
static int tdefault_supports_string_tracing(struct target_ops *self)
Definition: target-delegates.c:2448
delegate_trace_start
static void delegate_trace_start(struct target_ops *self)
Definition: target-delegates.c:2768
target_debug_print_enum_remove_bp_reason
#define target_debug_print_enum_remove_bp_reason(X)
Definition: target-debug.h:165
tdefault_call_history_from
static void tdefault_call_history_from(struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
Definition: target-delegates.c:4007
delegate_files_info
static void delegate_files_info(struct target_ops *self)
Definition: target-delegates.c:240
target_debug_print_const_struct_frame_unwind_p
#define target_debug_print_const_struct_frame_unwind_p(X)
Definition: target-debug.h:147
delegate_insert_hw_breakpoint
static int delegate_insert_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
Definition: target-delegates.c:482
delegate_get_section_table
static struct target_section_table * delegate_get_section_table(struct target_ops *self)
Definition: target-delegates.c:1757
generic_tls_error
static void generic_tls_error(void)
Definition: target.c:51
debug_is_async_p
static int debug_is_async_p(struct target_ops *self)
Definition: target-delegates.c:1824
tdefault_get_section_table
static struct target_section_table * tdefault_get_section_table(struct target_ops *self)
Definition: target-delegates.c:1764
target_ops::to_remove_vfork_catchpoint
int(* to_remove_vfork_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:590
ptid_t
Definition: ptid.h:35
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
debug_enable_btrace
static struct btrace_target_info * debug_enable_btrace(struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
Definition: target-delegates.c:3484
target_ops::to_supports_stopped_by_sw_breakpoint
int(* to_supports_stopped_by_sw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:486
target_ops::to_resume
void(* to_resume)(struct target_ops *, ptid_t, int TARGET_DEBUG_PRINTER(target_debug_print_step), enum gdb_signal) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:447
target_debug_print_struct_btrace_target_info_p
#define target_debug_print_struct_btrace_target_info_p(X)
Definition: target-debug.h:143
tdefault_save_trace_data
static int tdefault_save_trace_data(struct target_ops *self, const char *arg1)
Definition: target-delegates.c:2945
delegate_watchpoint_addr_within_range
static int delegate_watchpoint_addr_within_range(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
Definition: target-delegates.c:736
delegate_post_attach
static void delegate_post_attach(struct target_ops *self, int arg1)
Definition: target-delegates.c:7
tdefault_memory_map
static std::vector< mem_region > tdefault_memory_map(struct target_ops *self)
Definition: target-delegates.c:2157
expression
Definition: expression.h:78
target_ops::to_get_min_fast_tracepoint_insn_len
int(* to_get_min_fast_tracepoint_insn_len)(struct target_ops *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:1036
delegate_enable_btrace
static struct btrace_target_info * delegate_enable_btrace(struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
Definition: target-delegates.c:3471
target_ops::to_get_section_table
struct target_section_table *(* to_get_section_table)(struct target_ops *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:654
default_thread_architecture
static struct gdbarch * default_thread_architecture(struct target_ops *ops, ptid_t ptid)
Definition: target.c:3129
static_tracepoint_marker
Definition: tracepoint.h:215
tdefault_remove_vfork_catchpoint
static int tdefault_remove_vfork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1158
debug_remove_hw_breakpoint
static int debug_remove_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
Definition: target-delegates.c:526
target_ops::to_can_run
int(* to_can_run)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:611
delegate_trace_init
static void delegate_trace_init(struct target_ops *self)
Definition: target-delegates.c:2595
default_watchpoint_addr_within_range
static int default_watchpoint_addr_within_range(struct target_ops *target, CORE_ADDR addr, CORE_ADDR start, int length)
Definition: target.c:3121
delegate_insert_breakpoint
static int delegate_insert_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
Definition: target-delegates.c:262
btrace_read_type
btrace_read_type
Definition: btrace-common.h:184
debug_download_tracepoint
static void debug_download_tracepoint(struct target_ops *self, struct bp_location *arg1)
Definition: target-delegates.c:2631
delegate_remove_exec_catchpoint
static int delegate_remove_exec_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1234
target_ops::to_get_thread_local_address
CORE_ADDR(* to_get_thread_local_address)(struct target_ops *ops, ptid_t ptid, CORE_ADDR load_module_addr, CORE_ADDR offset) TARGET_DEFAULT_NORETURN(generic_tls_error())
Definition: target.h:701
debug_call_history
static void debug_call_history(struct target_ops *self, int arg1, int arg2)
Definition: target-delegates.c:3986
target_ops::to_insert_exec_catchpoint
int(* to_insert_exec_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:594
tdefault_stopped_data_address
static int tdefault_stopped_data_address(struct target_ops *self, CORE_ADDR *arg1)
Definition: target-delegates.c:714
target_debug_print_gdb_disassembly_flags
#define target_debug_print_gdb_disassembly_flags(X)
Definition: target-debug.h:167
breakpoint
Definition: breakpoint.h:684
target_debug_print_enum_target_object
#define target_debug_print_enum_target_object(X)
Definition: target-debug.h:49
debug_goto_record_begin
static void debug_goto_record_begin(struct target_ops *self)
Definition: target-delegates.c:3830
delegate_update_thread_list
static void delegate_update_thread_list(struct target_ops *self)
Definition: target-delegates.c:1482
target_ops::to_set_permissions
void(* to_set_permissions)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1081
target_xfer_status
target_xfer_status
Definition: target.h:206
target_debug_print_bfd_p
#define target_debug_print_bfd_p(X)
Definition: target-debug.h:117
target_ops::to_enable_btrace
struct btrace_target_info *(* to_enable_btrace)(struct target_ops *, ptid_t ptid, const struct btrace_config *conf) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1118
target_ops::to_masked_watch_num_registers
int(* to_masked_watch_num_registers)(struct target_ops *, CORE_ADDR, CORE_ADDR) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:551
delegate_region_ok_for_hw_watchpoint
static int delegate_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2)
Definition: target-delegates.c:763
target_ops::to_remove_mask_watchpoint
int(* to_remove_mask_watchpoint)(struct target_ops *, CORE_ADDR, CORE_ADDR, enum target_hw_bp_type) TARGET_DEFAULT_RETURN(1)
Definition: target.h:527
tdefault_trace_set_readonly_regions
static void tdefault_trace_set_readonly_regions(struct target_ops *self)
Definition: target-delegates.c:2752
tdefault_can_download_tracepoint
static int tdefault_can_download_tracepoint(struct target_ops *self)
Definition: target-delegates.c:2650
tdefault_prepare_to_generate_core
static void tdefault_prepare_to_generate_core(struct target_ops *self)
Definition: target-delegates.c:4146
tdefault_update_thread_list
static void tdefault_update_thread_list(struct target_ops *self)
Definition: target-delegates.c:1489
delegate_terminal_ours
static void delegate_terminal_ours(struct target_ops *self)
Definition: target-delegates.c:947
target_ops::to_trace_set_readonly_regions
void(* to_trace_set_readonly_regions)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:980
default_thread_address_space
static struct address_space * default_thread_address_space(struct target_ops *self, ptid_t ptid)
Definition: target.c:2670
target_debug_print_find_memory_region_ftype
#define target_debug_print_find_memory_region_ftype(X)
Definition: target-debug.h:115
tdefault_teardown_btrace
static void tdefault_teardown_btrace(struct target_ops *self, struct btrace_target_info *arg1)
Definition: target-delegates.c:3534
tdefault_ranged_break_num_registers
static int tdefault_ranged_break_num_registers(struct target_ops *self)
Definition: target-delegates.c:462
debug_can_accel_watchpoint_condition
static int debug_can_accel_watchpoint_condition(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
Definition: target-delegates.c:801
delegate_wait
static ptid_t delegate_wait(struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
Definition: target-delegates.c:135
delegate_thread_name
static const char * delegate_thread_name(struct target_ops *self, struct thread_info *arg1)
Definition: target-delegates.c:1556
debug_trace_init
static void debug_trace_init(struct target_ops *self)
Definition: target-delegates.c:2608
target_debug_print_struct_target_ops_p
#define target_debug_print_struct_target_ops_p(X)
Definition: target-debug.h:47
tdefault_record_will_replay
static int tdefault_record_will_replay(struct target_ops *self, ptid_t arg1, int arg2)
Definition: target-delegates.c:3771
tdefault_insn_history_from
static void tdefault_insn_history_from(struct target_ops *self, ULONGEST arg1, int arg2, gdb_disassembly_flags arg3)
Definition: target-delegates.c:3922
delegate_thread_events
static void delegate_thread_events(struct target_ops *self, int arg1)
Definition: target-delegates.c:1863
tdefault_can_async_p
static int tdefault_can_async_p(struct target_ops *self)
Definition: target-delegates.c:1791
delegate_set_circular_trace_buffer
static void delegate_set_circular_trace_buffer(struct target_ops *self, int arg1)
Definition: target-delegates.c:3109
delegate_thread_alive
static int delegate_thread_alive(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1453
delegate_remove_hw_breakpoint
static int delegate_remove_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
Definition: target-delegates.c:513
exec_direction_kind
exec_direction_kind
Definition: infrun.h:67
target_ops::to_get_tracepoint_status
void(* to_get_tracepoint_status)(struct target_ops *, struct breakpoint *tp, struct uploaded_tp *utp) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:991
target_debug_print_CORE_ADDR_p
#define target_debug_print_CORE_ADDR_p(X)
Definition: target-debug.h:99
tdefault_stop_recording
static void tdefault_stop_recording(struct target_ops *self)
Definition: target-delegates.c:3650
target_debug_print_struct_trace_status_p
#define target_debug_print_struct_trace_status_p(X)
Definition: target-debug.h:129
target_ops::to_upload_trace_state_variables
int(* to_upload_trace_state_variables)(struct target_ops *, struct uploaded_tsv **utsvp) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1024
target_debug_print_struct_regcache_p
#define target_debug_print_struct_regcache_p(X)
Definition: target-debug.h:103
debug_insert_vfork_catchpoint
static int debug_insert_vfork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1135
tdefault_get_memory_xfer_limit
static ULONGEST tdefault_get_memory_xfer_limit(struct target_ops *self)
Definition: target-delegates.c:2130
target_debug_print_enum_btrace_format
#define target_debug_print_enum_btrace_format(X)
Definition: target-debug.h:151
debug_get_trace_status
static int debug_get_trace_status(struct target_ops *self, struct trace_status *arg1)
Definition: target-delegates.c:2804
delegate_can_execute_reverse
static int delegate_can_execute_reverse(struct target_ops *self)
Definition: target-delegates.c:2339
debug_mourn_inferior
static void debug_mourn_inferior(struct target_ops *self)
Definition: target-delegates.c:1364
target_ops::to_augmented_libraries_svr4_read
int(* to_augmented_libraries_svr4_read)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1241
debug_use_agent
static int debug_use_agent(struct target_ops *self, int arg1)
Definition: target-delegates.c:3399
tdefault_terminal_ours_for_output
static void tdefault_terminal_ours_for_output(struct target_ops *self)
Definition: target-delegates.c:932
target_ops::to_insert_fork_catchpoint
int(* to_insert_fork_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:584
delegate_insert_watchpoint
static int delegate_insert_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
Definition: target-delegates.c:579
target_ops::to_insert_watchpoint
int(* to_insert_watchpoint)(struct target_ops *, CORE_ADDR, int, enum target_hw_bp_type, struct expression *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:519
debug_augmented_libraries_svr4_read
static int debug_augmented_libraries_svr4_read(struct target_ops *self)
Definition: target-delegates.c:4071
tdefault_augmented_libraries_svr4_read
static int tdefault_augmented_libraries_svr4_read(struct target_ops *self)
Definition: target-delegates.c:4065
debug_supports_multi_process
static int debug_supports_multi_process(struct target_ops *self)
Definition: target-delegates.c:2400
tdefault_can_execute_reverse
static int tdefault_can_execute_reverse(struct target_ops *self)
Definition: target-delegates.c:2346
tdefault_use_agent
static int tdefault_use_agent(struct target_ops *self, int arg1)
Definition: target-delegates.c:3393
target_ops::to_btrace_conf
const struct btrace_config *(* to_btrace_conf)(struct target_ops *self, const struct btrace_target_info *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:1145
btrace_error
btrace_error
Definition: btrace-common.h:199
debug_traceframe_info
static traceframe_info_up debug_traceframe_info(struct target_ops *self)
Definition: target-delegates.c:3372
delegate_pid_to_str
static const char * delegate_pid_to_str(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1504
target_ops::to_xfer_partial
enum target_xfer_status(* to_xfer_partial)(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
Definition: target.h:739
delegate_verify_memory
static int delegate_verify_memory(struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
Definition: target-delegates.c:3219
tdefault_save_record
static void tdefault_save_record(struct target_ops *self, const char *arg1)
Definition: target-delegates.c:3694
target_ops::to_search_memory
int(* to_search_memory)(struct target_ops *ops, CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp) TARGET_DEFAULT_FUNC(default_search_memory)
Definition: target.h:815
debug_terminal_ours_for_output
static void debug_terminal_ours_for_output(struct target_ops *self)
Definition: target-delegates.c:937
target_section_table
Definition: target.h:2332
delegate_set_disconnected_tracing
static void delegate_set_disconnected_tracing(struct target_ops *self, int arg1)
Definition: target-delegates.c:3085
tdefault_supports_multi_process
static int tdefault_supports_multi_process(struct target_ops *self)
Definition: target-delegates.c:2394
delegate_interrupt
static void delegate_interrupt(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1642
debug_pid_to_exec_file
static char * debug_pid_to_exec_file(struct target_ops *self, int arg1)
Definition: target-delegates.c:1717
target_ops::to_get_tib_address
int(* to_get_tib_address)(struct target_ops *, ptid_t ptid, CORE_ADDR *addr) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1076
delegate_core_of_thread
static int delegate_core_of_thread(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:3190
tdefault_fetch_registers
static void tdefault_fetch_registers(struct target_ops *self, struct regcache *arg1, int arg2)
Definition: target-delegates.c:169
target_ops::to_traceframe_info
traceframe_info_up(* to_traceframe_info)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1099
target_ops::to_detach
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:443
delegate_disconnect
static void delegate_disconnect(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:57
delegate_traceframe_info
static traceframe_info_up delegate_traceframe_info(struct target_ops *self)
Definition: target-delegates.c:3359
delegate_insert_fork_catchpoint
static int delegate_insert_fork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1064
delegate_stopped_by_hw_breakpoint
static int delegate_stopped_by_hw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:368
delegate_mourn_inferior
static void delegate_mourn_inferior(struct target_ops *self)
Definition: target-delegates.c:1357
target_ops::to_async
void(* to_async)(struct target_ops *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:670
target_debug_print_enum_target_hw_bp_type
#define target_debug_print_enum_target_hw_bp_type(X)
Definition: target-debug.h:159
debug_fetch_registers
static void debug_fetch_registers(struct target_ops *self, struct regcache *arg1, int arg2)
Definition: target-delegates.c:174
tdefault_xfer_partial
static enum target_xfer_status tdefault_xfer_partial(struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
Definition: target-delegates.c:2089
debug_terminal_info
static void debug_terminal_info(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:976
delegate_terminal_inferior
static void delegate_terminal_inferior(struct target_ops *self)
Definition: target-delegates.c:903
default_execution_direction
static enum exec_direction_kind default_execution_direction(struct target_ops *self)
Definition: target.c:572
target_debug_print_const_struct_target_desc_p
#define target_debug_print_const_struct_target_desc_p(X)
Definition: target-debug.h:123
target_ops::to_make_corefile_notes
char *(* to_make_corefile_notes)(struct target_ops *, bfd *, int *) TARGET_DEFAULT_FUNC(dummy_make_corefile_notes)
Definition: target.h:687
RECORD_METHOD_NONE
Definition: record.h:44
delegate_pid_to_exec_file
static char * delegate_pid_to_exec_file(struct target_ops *self, int arg1)
Definition: target-delegates.c:1704
tdefault_download_trace_state_variable
static void tdefault_download_trace_state_variable(struct target_ops *self, struct trace_state_variable *arg1)
Definition: target-delegates.c:2677
target_object
target_object
Definition: target.h:132
target_ops::to_insert_hw_breakpoint
int(* to_insert_hw_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:507
debug_can_run
static int debug_can_run(struct target_ops *self)
Definition: target-delegates.c:1387
record_method
record_method
Definition: record.h:41
delegate_trace_stop
static void delegate_trace_stop(struct target_ops *self)
Definition: target-delegates.c:2847
target_debug_print_enum_record_method
#define target_debug_print_enum_record_method(X)
Definition: target-debug.h:153
target_ops::to_pid_to_exec_file
char *(* to_pid_to_exec_file)(struct target_ops *, int pid) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:650
bptype
bptype
Definition: breakpoint.h:67
delegate_delete_record
static void delegate_delete_record(struct target_ops *self)
Definition: target-delegates.c:3712
target_ops::to_can_run_breakpoint_commands
int(* to_can_run_breakpoint_commands)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:855
install_delegators
static void install_delegators(struct target_ops *ops)
Definition: target-delegates.c:4183
tdefault_async
static void tdefault_async(struct target_ops *self, int arg1)
Definition: target-delegates.c:1845
delegate_supports_stopped_by_sw_breakpoint
static int delegate_supports_stopped_by_sw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:341
delegate_store_registers
static void delegate_store_registers(struct target_ops *self, struct regcache *arg1, int arg2)
Definition: target-delegates.c:188
tdefault_commit_resume
static void tdefault_commit_resume(struct target_ops *self)
Definition: target-delegates.c:120
dummy_find_memory_regions
static int dummy_find_memory_regions(struct target_ops *self, find_memory_region_ftype ignore1, void *ignore2)
Definition: target.c:3250
tdefault_get_unwinder
static const struct frame_unwind * tdefault_get_unwinder(struct target_ops *self)
Definition: target-delegates.c:4092
target_debug_print_signals
static void target_debug_print_signals(unsigned char *sigs)
Definition: target-debug.h:199
delegate_get_unwinder
static const struct frame_unwind * delegate_get_unwinder(struct target_ops *self)
Definition: target-delegates.c:4085
target_ops::to_commit_resume
void(* to_commit_resume)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:451
target_ops::to_disconnect
void(* to_disconnect)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:445
delegate_thread_handle_to_thread_info
static struct thread_info * delegate_thread_handle_to_thread_info(struct target_ops *self, const gdb_byte *arg1, int arg2, struct inferior *arg3)
Definition: target-delegates.c:1585
debug_get_tib_address
static int debug_get_tib_address(struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
Definition: target-delegates.c:3259
target_ops::to_can_download_tracepoint
int(* to_can_download_tracepoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:959
tdefault_log_command
static void tdefault_log_command(struct target_ops *self, const char *arg1)
Definition: target-delegates.c:1740
debug_trace_start
static void debug_trace_start(struct target_ops *self)
Definition: target-delegates.c:2781
target_ops::to_log_command
void(* to_log_command)(struct target_ops *, const char *) TARGET_DEFAULT_IGNORE()
Definition: target.h:652
target_debug_print_long
#define target_debug_print_long(X)
Definition: target-debug.h:61
delegate_call_history_range
static void delegate_call_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
Definition: target-delegates.c:4029
delegate_augmented_libraries_svr4_read
static int delegate_augmented_libraries_svr4_read(struct target_ops *self)
Definition: target-delegates.c:4058
target_debug_print_enum_btrace_read_type
#define target_debug_print_enum_btrace_read_type(X)
Definition: target-debug.h:69
target_ops::to_always_non_stop_p
int(* to_always_non_stop_p)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:680
tdefault_thread_events
static void tdefault_thread_events(struct target_ops *self, int arg1)
Definition: target-delegates.c:1870
target_ops::to_read_btrace
enum btrace_error(* to_read_btrace)(struct target_ops *self, struct btrace_data *data, struct btrace_target_info *btinfo, enum btrace_read_type type) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1138
target_ops::to_auxv_parse
int(* to_auxv_parse)(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) TARGET_DEFAULT_FUNC(default_auxv_parse)
Definition: target.h:805
delegate_set_trace_notes
static int delegate_set_trace_notes(struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
Definition: target-delegates.c:3157
target_ops::to_verify_memory
int(* to_verify_memory)(struct target_ops *, const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size) TARGET_DEFAULT_FUNC(default_verify_memory)
Definition: target.h:1070
delegate_get_thread_local_address
static CORE_ADDR delegate_get_thread_local_address(struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
Definition: target-delegates.c:2049
delegate_save_record
static void delegate_save_record(struct target_ops *self, const char *arg1)
Definition: target-delegates.c:3687
delegate_supports_evaluation_of_breakpoint_conditions
static int delegate_supports_evaluation_of_breakpoint_conditions(struct target_ops *self)
Definition: target-delegates.c:2468
tdefault_terminal_init
static void tdefault_terminal_init(struct target_ops *self)
Definition: target-delegates.c:888
target_ops::to_download_tracepoint
void(* to_download_tracepoint)(struct target_ops *, struct bp_location *location) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:953
delegate_use_agent
static int delegate_use_agent(struct target_ops *self, int arg1)
Definition: target-delegates.c:3386
target_debug_print_LONGEST_p
#define target_debug_print_LONGEST_p(X)
Definition: target-debug.h:91
delegate_read_description
static const struct target_desc * delegate_read_description(struct target_ops *self)
Definition: target-delegates.c:2227
debug_record_is_replaying
static int debug_record_is_replaying(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:3748
default_mourn_inferior
static void default_mourn_inferior(struct target_ops *self)
Definition: target.c:2291
target_ops::to_remove_hw_breakpoint
int(* to_remove_hw_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:510
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
tdefault_call_history
static void tdefault_call_history(struct target_ops *self, int arg1, int arg2)
Definition: target-delegates.c:3980
target_ops::to_execution_direction
enum exec_direction_kind(* to_execution_direction)(struct target_ops *) TARGET_DEFAULT_FUNC(default_execution_direction)
Definition: target.h:828
tdefault_upload_trace_state_variables
static int tdefault_upload_trace_state_variables(struct target_ops *self, struct uploaded_tsv **arg1)
Definition: target-delegates.c:3003
target_debug_print_const_char_p
#define target_debug_print_const_char_p(X)
Definition: target-debug.h:53
target_debug_print_struct_ui_file_p
#define target_debug_print_struct_ui_file_p(X)
Definition: target-debug.h:107
debug_read_description
static const struct target_desc * debug_read_description(struct target_ops *self)
Definition: target-delegates.c:2240
debug_rcmd
static void debug_rcmd(struct target_ops *self, const char *arg1, struct ui_file *arg2)
Definition: target-delegates.c:1690
delegate_info_record
static void delegate_info_record(struct target_ops *self)
Definition: target-delegates.c:3665
debug_stopped_by_hw_breakpoint
static int debug_stopped_by_hw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:381
traceframe_info_up
std::unique_ptr< traceframe_info > traceframe_info_up
Definition: tracepoint.h:40
delegate_auxv_parse
static int delegate_auxv_parse(struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
Definition: target-delegates.c:2279
debug_get_bookmark
static gdb_byte * debug_get_bookmark(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:2004
debug_can_use_agent
static int debug_can_use_agent(struct target_ops *self)
Definition: target-delegates.c:3428
target_debug_print_ULONGEST_p
#define target_debug_print_ULONGEST_p(X)
Definition: target-debug.h:87
btrace_config
Definition: btrace-common.h:124
target_debug_print_struct_uploaded_tp_pp
#define target_debug_print_struct_uploaded_tp_pp(X)
Definition: target-debug.h:135
target_debug_print_struct_target_section_table_p
#define target_debug_print_struct_target_section_table_p(X)
Definition: target-debug.h:109
delegate_trace_find
static int delegate_trace_find(struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
Definition: target-delegates.c:2870
debug_store_registers
static void debug_store_registers(struct target_ops *self, struct regcache *arg1, int arg2)
Definition: target-delegates.c:201
delegate_get_tracepoint_status
static void delegate_get_tracepoint_status(struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
Definition: target-delegates.c:2820
delegate_set_syscall_catchpoint
static int delegate_set_syscall_catchpoint(struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view< const int > arg4)
Definition: target-delegates.c:1289
target_ops::to_fetch_registers
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:457
target_ops::to_mourn_inferior
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
Definition: target.h:606
target_ops::to_get_unwinder
const struct frame_unwind *(* to_get_unwinder)(struct target_ops *self) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:1247
target_ops::to_extra_thread_info
const char *(* to_extra_thread_info)(struct target_ops *, struct thread_info *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:632
tdefault_can_use_agent
static int tdefault_can_use_agent(struct target_ops *self)
Definition: target-delegates.c:3422
target_debug_print_int_p
#define target_debug_print_int_p(X)
Definition: target-debug.h:101
tdefault_set_trace_notes
static int tdefault_set_trace_notes(struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
Definition: target-delegates.c:3164
target_ops::to_set_trace_notes
int(* to_set_trace_notes)(struct target_ops *, const char *user, const char *notes, const char *stopnotes) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1051
debug_remove_watchpoint
static int debug_remove_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
Definition: target-delegates.c:557
debug_can_use_hw_breakpoint
static int debug_can_use_hw_breakpoint(struct target_ops *self, enum bptype arg1, int arg2, int arg3)
Definition: target-delegates.c:435
delegate_upload_tracepoints
static int delegate_upload_tracepoints(struct target_ops *self, struct uploaded_tp **arg1)
Definition: target-delegates.c:2967
tdefault_goto_bookmark
static void tdefault_goto_bookmark(struct target_ops *self, const gdb_byte *arg1, int arg2)
Definition: target-delegates.c:2029
debug_insert_watchpoint
static int debug_insert_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
Definition: target-delegates.c:592
address_space
Definition: progspace.h:216
default_search_memory
static int default_search_memory(struct target_ops *self, CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp)
Definition: target.c:2422
tdefault_thread_handle_to_thread_info
static struct thread_info * tdefault_thread_handle_to_thread_info(struct target_ops *self, const gdb_byte *arg1, int arg2, struct inferior *arg3)
Definition: target-delegates.c:1592
target_ops::to_pass_signals
void(* to_pass_signals)(struct target_ops *, int, unsigned char *TARGET_DEBUG_PRINTER(target_debug_print_signals)) TARGET_DEFAULT_IGNORE()
Definition: target.h:616
target_ops::to_stop
void(* to_stop)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:641
target_debug_print_const_struct_btrace_config_p
#define target_debug_print_const_struct_btrace_config_p(X)
Definition: target-debug.h:155
target_ops::to_teardown_btrace
void(* to_teardown_btrace)(struct target_ops *, struct btrace_target_info *tinfo) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1132
target_ops::to_record_method
enum record_method(* to_record_method)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(RECORD_METHOD_NONE)
Definition: target.h:1150
delegate_supports_stopped_by_hw_breakpoint
static int delegate_supports_stopped_by_hw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:395
target_ops::to_save_trace_data
int(* to_save_trace_data)(struct target_ops *, const char *filename) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1017
target_ops::to_download_trace_state_variable
void(* to_download_trace_state_variable)(struct target_ops *, struct trace_state_variable *tsv) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:963
target_debug_print_const_gdb_byte_p
#define target_debug_print_const_gdb_byte_p(X)
Definition: target-debug.h:77
delegate_resume
static void delegate_resume(struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
Definition: target-delegates.c:84
debug_flash_done
static void debug_flash_done(struct target_ops *self)
Definition: target-delegates.c:2217
target_debug_print_LONGEST
#define target_debug_print_LONGEST(X)
Definition: target-debug.h:89
debug_insert_mask_watchpoint
static int debug_insert_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
Definition: target-delegates.c:627
debug_remove_exec_catchpoint
static int debug_remove_exec_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1247
target_ops::to_kill
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:570
target_desc
Definition: target-descriptions.c:591
target_ops::to_get_bookmark
gdb_byte *(* to_get_bookmark)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:690
debug_disconnect
static void debug_disconnect(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:70
delegate_upload_trace_state_variables
static int delegate_upload_trace_state_variables(struct target_ops *self, struct uploaded_tsv **arg1)
Definition: target-delegates.c:2996
target_ops::to_can_accel_watchpoint_condition
int(* to_can_accel_watchpoint_condition)(struct target_ops *, CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:547
debug_can_run_breakpoint_commands
static int debug_can_run_breakpoint_commands(struct target_ops *self)
Definition: target-delegates.c:2508
tdefault_can_do_single_step
static int tdefault_can_do_single_step(struct target_ops *self)
Definition: target-delegates.c:861
debug_set_permissions
static void debug_set_permissions(struct target_ops *self)
Definition: target-delegates.c:3289
target_debug_print_void_p
#define target_debug_print_void_p(X)
Definition: target-debug.h:113
trace_state_variable
Definition: tracepoint.h:49
target_ops::to_stopped_by_sw_breakpoint
int(* to_stopped_by_sw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:483
uploaded_tsv
Definition: tracepoint.h:204
debug_insert_fork_catchpoint
static int debug_insert_fork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1077
debug_xfer_partial
static enum target_xfer_status debug_xfer_partial(struct target_ops *self, enum target_object arg1, const char *arg2, gdb_byte *arg3, const gdb_byte *arg4, ULONGEST arg5, ULONGEST arg6, ULONGEST *arg7)
Definition: target-delegates.c:2095
delegate_memory_map
static std::vector< mem_region > delegate_memory_map(struct target_ops *self)
Definition: target-delegates.c:2150
target_ops::to_goto_record_end
void(* to_goto_record_end)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1188
target_ops::to_set_circular_trace_buffer
void(* to_set_circular_trace_buffer)(struct target_ops *, int val) TARGET_DEFAULT_IGNORE()
Definition: target.h:1043
dummy_make_corefile_notes
static char * dummy_make_corefile_notes(struct target_ops *self, bfd *ignore1, int *ignore2)
Definition: target.c:3259
debug_thread_address_space
static struct address_space * debug_thread_address_space(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:2552
tdefault_supports_non_stop
static int tdefault_supports_non_stop(struct target_ops *self)
Definition: target-delegates.c:1894
target_debug_print_ULONGEST
#define target_debug_print_ULONGEST(X)
Definition: target-debug.h:85
debug_terminal_inferior
static void debug_terminal_inferior(struct target_ops *self)
Definition: target-delegates.c:915
tdefault_insn_history
static void tdefault_insn_history(struct target_ops *self, int arg1, gdb_disassembly_flags arg2)
Definition: target-delegates.c:3895
debug_remove_mask_watchpoint
static int debug_remove_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
Definition: target-delegates.c:660
target_ops::to_ranged_break_num_registers
int(* to_ranged_break_num_registers)(struct target_ops *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:505
debug_get_thread_local_address
static CORE_ADDR debug_get_thread_local_address(struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
Definition: target-delegates.c:2062
target_ops::to_call_history_from
void(* to_call_history_from)(struct target_ops *, ULONGEST begin, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1229
target_ops::to_post_attach
void(* to_post_attach)(struct target_ops *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:441
delegate_call_history
static void delegate_call_history(struct target_ops *self, int arg1, int arg2)
Definition: target-delegates.c:3973
debug_goto_record
static void debug_goto_record(struct target_ops *self, ULONGEST arg1)
Definition: target-delegates.c:3876
target_ops::to_can_async_p
int(* to_can_async_p)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:666
delegate_terminal_ours_for_output
static void delegate_terminal_ours_for_output(struct target_ops *self)
Definition: target-delegates.c:925
delegate_remove_fork_catchpoint
static int delegate_remove_fork_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1093
target_ops::to_static_tracepoint_marker_at
int(* to_static_tracepoint_marker_at)(struct target_ops *, CORE_ADDR, struct static_tracepoint_marker *marker) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1086
tdefault_supports_enable_disable_tracepoint
static int tdefault_supports_enable_disable_tracepoint(struct target_ops *self)
Definition: target-delegates.c:2421
delegate_goto_record
static void delegate_goto_record(struct target_ops *self, ULONGEST arg1)
Definition: target-delegates.c:3863
target_ops::to_remove_breakpoint
int(* to_remove_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *, enum remove_bp_reason) TARGET_DEFAULT_FUNC(memory_remove_breakpoint)
Definition: target.h:469
tdefault_is_async_p
static int tdefault_is_async_p(struct target_ops *self)
Definition: target-delegates.c:1818
debug_insn_history
static void debug_insn_history(struct target_ops *self, int arg1, gdb_disassembly_flags arg2)
Definition: target-delegates.c:3901
tdefault_traceframe_info
static traceframe_info_up tdefault_traceframe_info(struct target_ops *self)
Definition: target-delegates.c:3366
target_ops::to_thread_architecture
struct gdbarch *(* to_thread_architecture)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_thread_architecture)
Definition: target.h:868
debug_supports_stopped_by_hw_breakpoint
static int debug_supports_stopped_by_hw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:408
target_ops::to_stopped_by_watchpoint
int(* to_stopped_by_watchpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:531
target_ops::to_get_trace_status
int(* to_get_trace_status)(struct target_ops *, struct trace_status *ts) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:988
delegate_execution_direction
static enum exec_direction_kind delegate_execution_direction(struct target_ops *self)
Definition: target-delegates.c:2366
delegate_supports_non_stop
static int delegate_supports_non_stop(struct target_ops *self)
Definition: target-delegates.c:1887
delegate_set_trace_buffer_size
static void delegate_set_trace_buffer_size(struct target_ops *self, LONGEST arg1)
Definition: target-delegates.c:3133
debug_set_syscall_catchpoint
static int debug_set_syscall_catchpoint(struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view< const int > arg4)
Definition: target-delegates.c:1302
frame_unwind
Definition: frame-unwind.h:144
tdefault_terminal_ours
static void tdefault_terminal_ours(struct target_ops *self)
Definition: target-delegates.c:954
debug_supports_stopped_by_sw_breakpoint
static int debug_supports_stopped_by_sw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:354
target_hw_bp_type
target_hw_bp_type
Definition: break-common.h:22
delegate_stopped_by_sw_breakpoint
static int delegate_stopped_by_sw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:314
tdefault_store_registers
static void tdefault_store_registers(struct target_ops *self, struct regcache *arg1, int arg2)
Definition: target-delegates.c:195
uploaded_tp
Definition: tracepoint.h:166
delegate_prepare_to_store
static void delegate_prepare_to_store(struct target_ops *self, struct regcache *arg1)
Definition: target-delegates.c:215
delegate_goto_record_end
static void delegate_goto_record_end(struct target_ops *self)
Definition: target-delegates.c:3840
delegate_can_download_tracepoint
static int delegate_can_download_tracepoint(struct target_ops *self)
Definition: target-delegates.c:2643
target_ops::to_terminal_ours
void(* to_terminal_ours)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:566
target_ops::to_stopped_by_hw_breakpoint
int(* to_stopped_by_hw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:496
target_ops::to_enable_tracepoint
void(* to_enable_tracepoint)(struct target_ops *, struct bp_location *location) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:968
delegate_remove_watchpoint
static int delegate_remove_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
Definition: target-delegates.c:544
default_verify_memory
static int default_verify_memory(struct target_ops *self, const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
Definition: target.c:3494
tdefault_trace_stop
static void tdefault_trace_stop(struct target_ops *self)
Definition: target-delegates.c:2854
tdefault_read_btrace
static enum btrace_error tdefault_read_btrace(struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
Definition: target-delegates.c:3559
target_ops::to_terminal_inferior
void(* to_terminal_inferior)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:562
default_rcmd
static void default_rcmd(struct target_ops *self, const char *command, struct ui_file *output)
Definition: target.c:3792
debug_set_trace_notes
static int debug_set_trace_notes(struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
Definition: target-delegates.c:3170
debug_get_ada_task_ptid
static ptid_t debug_get_ada_task_ptid(struct target_ops *self, long arg1, long arg2)
Definition: target-delegates.c:2261
delegate_insert_exec_catchpoint
static int delegate_insert_exec_catchpoint(struct target_ops *self, int arg1)
Definition: target-delegates.c:1205
tdefault_pid_to_exec_file
static char * tdefault_pid_to_exec_file(struct target_ops *self, int arg1)
Definition: target-delegates.c:1711
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
delegate_supports_btrace
static int delegate_supports_btrace(struct target_ops *self, enum btrace_format arg1)
Definition: target-delegates.c:3442
tdefault_disable_tracepoint
static void tdefault_disable_tracepoint(struct target_ops *self, struct bp_location *arg1)
Definition: target-delegates.c:2727
debug_insert_hw_breakpoint
static int debug_insert_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
Definition: target-delegates.c:495
delegate_get_tib_address
static int delegate_get_tib_address(struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
Definition: target-delegates.c:3246
delegate_goto_bookmark
static void delegate_goto_bookmark(struct target_ops *self, const gdb_byte *arg1, int arg2)
Definition: target-delegates.c:2022
gdb::array_view
Definition: array-view.h:69
delegate_load
static void delegate_load(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:1013
regcache
Definition: regcache.h:232
debug_pid_to_str
static const char * debug_pid_to_str(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1511
delegate_find_memory_regions
static int delegate_find_memory_regions(struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
Definition: target-delegates.c:1941
delegate_thread_architecture
static struct gdbarch * delegate_thread_architecture(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:2522
tdefault_set_syscall_catchpoint
static int tdefault_set_syscall_catchpoint(struct target_ops *self, int arg1, bool arg2, int arg3, gdb::array_view< const int > arg4)
Definition: target-delegates.c:1296
debug_interrupt
static void debug_interrupt(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1654
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
target_ops::to_supports_non_stop
int(* to_supports_non_stop)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:676
default_pid_to_str
static const char * default_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: target.c:3243
memory_insert_breakpoint
int memory_insert_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: mem-break.c:87
debug_btrace_conf
static const struct btrace_config * debug_btrace_conf(struct target_ops *self, const struct btrace_target_info *arg1)
Definition: target-delegates.c:3598
debug_remove_breakpoint
static int debug_remove_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2, enum remove_bp_reason arg3)
Definition: target-delegates.c:294
VEC
static VEC(static_tracepoint_marker_p)
Definition: target-delegates.c:3329
tdefault_download_tracepoint
static void tdefault_download_tracepoint(struct target_ops *self, struct bp_location *arg1)
Definition: target-delegates.c:2625
target_ops::to_interrupt
void(* to_interrupt)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:643
debug_extra_thread_info
static const char * debug_extra_thread_info(struct target_ops *self, struct thread_info *arg1)
Definition: target-delegates.c:1540
target_ops::to_done_generating_core
void(* to_done_generating_core)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1258
delegate_search_memory
static int delegate_search_memory(struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
Definition: target-delegates.c:2308
tdefault_files_info
static void tdefault_files_info(struct target_ops *self)
Definition: target-delegates.c:247
target_debug_print_enum_exec_direction_kind
#define target_debug_print_enum_exec_direction_kind(X)
Definition: target-debug.h:65
debug_trace_stop
static void debug_trace_stop(struct target_ops *self)
Definition: target-delegates.c:2860
target_debug_print_enum_trace_find_type
#define target_debug_print_enum_trace_find_type(X)
Definition: target-debug.h:67
tdefault_read_description
static const struct target_desc * tdefault_read_description(struct target_ops *self)
Definition: target-delegates.c:2234
target_debug_print_struct_gdbarch_p
#define target_debug_print_struct_gdbarch_p(X)
Definition: target-debug.h:75
delegate_static_tracepoint_marker_at
static int delegate_static_tracepoint_marker_at(struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
Definition: target-delegates.c:3299
delegate_filesystem_is_local
static int delegate_filesystem_is_local(struct target_ops *self)
Definition: target-delegates.c:2568
target_debug_print_traceframe_info_up
#define target_debug_print_traceframe_info_up(X)
Definition: target-debug.h:169
debug_stopped_by_sw_breakpoint
static int debug_stopped_by_sw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:327
tdefault_done_generating_core
static void tdefault_done_generating_core(struct target_ops *self)
Definition: target-delegates.c:4168
tdefault_can_run
static int tdefault_can_run(struct target_ops *self)
Definition: target-delegates.c:1381
target_ops::to_insert_vfork_catchpoint
int(* to_insert_vfork_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:588
target_ops::to_thread_alive
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:626
debug_get_unwinder
static const struct frame_unwind * debug_get_unwinder(struct target_ops *self)
Definition: target-delegates.c:4098
target_debug_print_gdb_array_view_const_int
#define target_debug_print_gdb_array_view_const_int(X)
Definition: target-debug.h:171
target_debug_print_const_struct_btrace_target_info_p
#define target_debug_print_const_struct_btrace_target_info_p(X)
Definition: target-debug.h:157
delegate_masked_watch_num_registers
static int delegate_masked_watch_num_registers(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
Definition: target-delegates.c:823
tdefault_get_thread_local_address
static CORE_ADDR tdefault_get_thread_local_address(struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
Definition: target-delegates.c:2056
debug_thread_handle_to_thread_info
static struct thread_info * debug_thread_handle_to_thread_info(struct target_ops *self, const gdb_byte *arg1, int arg2, struct inferior *arg3)
Definition: target-delegates.c:1598
debug_stopped_by_watchpoint
static int debug_stopped_by_watchpoint(struct target_ops *self)
Definition: target-delegates.c:693
target_ops::to_follow_exec
void(* to_follow_exec)(struct target_ops *, struct inferior *, char *) TARGET_DEFAULT_IGNORE()
Definition: target.h:598
delegate_teardown_btrace
static void delegate_teardown_btrace(struct target_ops *self, struct btrace_target_info *arg1)
Definition: target-delegates.c:3527
debug_thread_name
static const char * debug_thread_name(struct target_ops *self, struct thread_info *arg1)
Definition: target-delegates.c:1569
init_debug_target
static void init_debug_target(struct target_ops *ops)
Definition: target-delegates.c:4658
tdefault_always_non_stop_p
static int tdefault_always_non_stop_p(struct target_ops *self)
Definition: target-delegates.c:1921
target_ops::to_use_agent
int(* to_use_agent)(struct target_ops *, int use) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1104
delegate_ranged_break_num_registers
static int delegate_ranged_break_num_registers(struct target_ops *self)
Definition: target-delegates.c:455
target_ops::to_pass_ctrlc
void(* to_pass_ctrlc)(struct target_ops *) TARGET_DEFAULT_FUNC(default_target_pass_ctrlc)
Definition: target.h:645
debug_set_trace_buffer_size
static void debug_set_trace_buffer_size(struct target_ops *self, LONGEST arg1)
Definition: target-delegates.c:3145
target_ops::to_supports_btrace
int(* to_supports_btrace)(struct target_ops *, enum btrace_format) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1112
tdefault_terminal_inferior
static void tdefault_terminal_inferior(struct target_ops *self)
Definition: target-delegates.c:910
target_ops::to_stopped_data_address
int(* to_stopped_data_address)(struct target_ops *, CORE_ADDR *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:535
debug_trace_find
static int debug_trace_find(struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
Definition: target-delegates.c:2883
debug_save_record
static void debug_save_record(struct target_ops *self, const char *arg1)
Definition: target-delegates.c:3700
debug_download_trace_state_variable
static void debug_download_trace_state_variable(struct target_ops *self, struct trace_state_variable *arg1)
Definition: target-delegates.c:2683
target_ops::to_update_thread_list
void(* to_update_thread_list)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:628
debug_auxv_parse
static int debug_auxv_parse(struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
Definition: target-delegates.c:2286
debug_thread_events
static void debug_thread_events(struct target_ops *self, int arg1)
Definition: target-delegates.c:1875
tdefault_insert_mask_watchpoint
static int tdefault_insert_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
Definition: target-delegates.c:621
tdefault_can_use_hw_breakpoint
static int tdefault_can_use_hw_breakpoint(struct target_ops *self, enum bptype arg1, int arg2, int arg3)
Definition: target-delegates.c:429
debug_info_record
static void debug_info_record(struct target_ops *self)
Definition: target-delegates.c:3677
target_ops::to_prepare_to_store
void(* to_prepare_to_store)(struct target_ops *, struct regcache *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:461
target_ops::to_store_registers
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:459
find_memory_region_ftype
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, void *data)
Definition: defs.h:371
delegate_terminal_init
static void delegate_terminal_init(struct target_ops *self)
Definition: target-delegates.c:881
tdefault_post_attach
static void tdefault_post_attach(struct target_ops *self, int arg1)
Definition: target-delegates.c:14
memory_remove_breakpoint
int memory_remove_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt, enum remove_bp_reason reason)
Definition: mem-break.c:94
noprocess
void noprocess(void)
Definition: target.c:548
delegate_can_use_agent
static int delegate_can_use_agent(struct target_ops *self)
Definition: target-delegates.c:3415
target_ops::to_wait
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_FUNC(default_target_wait)
Definition: target.h:453
debug_thread_alive
static int debug_thread_alive(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1466
tdefault_btrace_conf
static const struct btrace_config * tdefault_btrace_conf(struct target_ops *self, const struct btrace_target_info *arg1)
Definition: target-delegates.c:3592
debug_region_ok_for_hw_watchpoint
static int debug_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2)
Definition: target-delegates.c:770
target_debug_print_options
static void target_debug_print_options(int options)
Definition: target-debug.h:190
tdefault_supports_stopped_by_hw_breakpoint
static int tdefault_supports_stopped_by_hw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:402
target_ops::to_get_ada_task_ptid
ptid_t(* to_get_ada_task_ptid)(struct target_ops *, long lwp, long thread) TARGET_DEFAULT_FUNC(default_get_ada_task_ptid)
Definition: target.h:797
tdefault_set_trace_buffer_size
static void tdefault_set_trace_buffer_size(struct target_ops *self, LONGEST arg1)
Definition: target-delegates.c:3140
debug_stopped_data_address
static int debug_stopped_data_address(struct target_ops *self, CORE_ADDR *arg1)
Definition: target-delegates.c:720
tdefault_delete_record
static void tdefault_delete_record(struct target_ops *self)
Definition: target-delegates.c:3719
delegate_is_async_p
static int delegate_is_async_p(struct target_ops *self)
Definition: target-delegates.c:1811
tcomplain
static void tcomplain(void)
Definition: target.c:541
debug_call_history_from
static void debug_call_history_from(struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
Definition: target-delegates.c:4013
tdefault_goto_record_end
static void tdefault_goto_record_end(struct target_ops *self)
Definition: target-delegates.c:3847
target_ops::to_disable_btrace
void(* to_disable_btrace)(struct target_ops *, struct btrace_target_info *tinfo) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1124
debug_insn_history_range
static void debug_insn_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, gdb_disassembly_flags arg3)
Definition: target-delegates.c:3957
delegate_enable_tracepoint
static void delegate_enable_tracepoint(struct target_ops *self, struct bp_location *arg1)
Definition: target-delegates.c:2695
tdefault_stopped_by_hw_breakpoint
static int tdefault_stopped_by_hw_breakpoint(struct target_ops *self)
Definition: target-delegates.c:375
thread_info
Definition: gdbthread.h:205
tdefault_set_permissions
static void tdefault_set_permissions(struct target_ops *self)
Definition: target-delegates.c:3284
debug_goto_bookmark
static void debug_goto_bookmark(struct target_ops *self, const gdb_byte *arg1, int arg2)
Definition: target-delegates.c:2035
target_ops::to_thread_name
const char *(* to_thread_name)(struct target_ops *, struct thread_info *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:634
tdefault_core_of_thread
static int tdefault_core_of_thread(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:3197
target_debug_print_gdb_byte_p
#define target_debug_print_gdb_byte_p(X)
Definition: target-debug.h:79
tdefault_get_tailcall_unwinder
static const struct frame_unwind * tdefault_get_tailcall_unwinder(struct target_ops *self)
Definition: target-delegates.c:4119
delegate_insert_mask_watchpoint
static int delegate_insert_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, enum target_hw_bp_type arg3)
Definition: target-delegates.c:614
delegate_trace_set_readonly_regions
static void delegate_trace_set_readonly_regions(struct target_ops *self)
Definition: target-delegates.c:2745
remove_bp_reason
remove_bp_reason
Definition: breakpoint.h:47
tdefault_remove_watchpoint
static int tdefault_remove_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, enum target_hw_bp_type arg3, struct expression *arg4)
Definition: target-delegates.c:551
target_debug_print_struct_uploaded_tp_p
#define target_debug_print_struct_uploaded_tp_p(X)
Definition: target-debug.h:133
tdefault_stopped_by_watchpoint
static int tdefault_stopped_by_watchpoint(struct target_ops *self)
Definition: target-delegates.c:687
delegate_make_corefile_notes
static char * delegate_make_corefile_notes(struct target_ops *self, bfd *arg1, int *arg2)
Definition: target-delegates.c:1966
TARGET_XFER_E_IO
Definition: target.h:220
tdefault_trace_find
static int tdefault_trace_find(struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
Definition: target-delegates.c:2877
debug_files_info
static void debug_files_info(struct target_ops *self)
Definition: target-delegates.c:252
LONGEST
long long LONGEST
Definition: common-types.h:52
tdefault_disable_btrace
static void tdefault_disable_btrace(struct target_ops *self, struct btrace_target_info *arg1)
Definition: target-delegates.c:3509
target_ops::to_can_execute_reverse
int(* to_can_execute_reverse)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:822
target_ops::to_load
void(* to_load)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:572
tdefault_flash_done
static void tdefault_flash_done(struct target_ops *self)
Definition: target-delegates.c:2211
target_ops::to_terminal_info
void(* to_terminal_info)(struct target_ops *, const char *, int) TARGET_DEFAULT_FUNC(default_terminal_info)
Definition: target.h:568
target_debug_print_enum_btrace_error
#define target_debug_print_enum_btrace_error(X)
Definition: target-debug.h:71
delegate_can_async_p
static int delegate_can_async_p(struct target_ops *self)
Definition: target-delegates.c:1784
target_ops::to_filesystem_is_local
int(* to_filesystem_is_local)(struct target_ops *) TARGET_DEFAULT_RETURN(1)
Definition: target.h:883
target_ops::to_supports_multi_process
int(* to_supports_multi_process)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:833
debug_get_min_fast_tracepoint_insn_len
static int debug_get_min_fast_tracepoint_insn_len(struct target_ops *self)
Definition: target-delegates.c:3071
debug_set_circular_trace_buffer
static void debug_set_circular_trace_buffer(struct target_ops *self, int arg1)
Definition: target-delegates.c:3121
target_debug_print_struct_thread_info_p
#define target_debug_print_struct_thread_info_p(X)
Definition: target-debug.h:105
target_ops::to_post_startup_inferior
void(* to_post_startup_inferior)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:582
bp_location
Definition: breakpoint.h:315
target_ops::to_can_use_agent
int(* to_can_use_agent)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1108
delegate_follow_fork
static int delegate_follow_fork(struct target_ops *self, int arg1, int arg2)
Definition: target-delegates.c:1180
delegate_post_startup_inferior
static void delegate_post_startup_inferior(struct target_ops *self, ptid_t arg1)
Definition: target-delegates.c:1040
debug_detach
static void debug_detach(struct target_ops *self, const char *arg1, int arg2)
Definition: target-delegates.c:43
target_ops::to_goto_record
void(* to_goto_record)(struct target_ops *, ULONGEST insn) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1192
debug_supports_btrace
static int debug_supports_btrace(struct target_ops *self, enum btrace_format arg1)
Definition: target-delegates.c:3455
tdefault_enable_btrace
static struct btrace_target_info * tdefault_enable_btrace(struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
Definition: target-delegates.c:3478
delegate_get_trace_state_variable_value
static int delegate_get_trace_state_variable_value(struct target_ops *self, int arg1, LONGEST *arg2)
Definition: target-delegates.c:2907
delegate_pass_ctrlc
static void delegate_pass_ctrlc(struct target_ops *self)
Definition: target-delegates.c:1666
btrace_data
Definition: btrace-common.h:165
delegate_insn_history_range
static void delegate_insn_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, gdb_disassembly_flags arg3)
Definition: target-delegates.c:3944
debug_read_btrace
static enum btrace_error debug_read_btrace(struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
Definition: target-delegates.c:3565
tdefault_info_record
static void tdefault_info_record(struct target_ops *self)
Definition: target-delegates.c:3672
tdefault_pass_signals
static void tdefault_pass_signals(struct target_ops *self, int arg1, unsigned char *arg2)
Definition: target-delegates.c:1408
delegate_async
static void delegate_async(struct target_ops *self, int arg1)
Definition: target-delegates.c:1838