GDB (xrefs)
/tmp/gdb-7.10/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);
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);
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);
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);
109  fputs_unfiltered (")\n", gdb_stdlog);
110 }
111 
112 static ptid_t
113 delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
114 {
115  self = self->beneath;
116  return self->to_wait (self, arg1, arg2, arg3);
117 }
118 
119 static ptid_t
120 tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
121 {
122  noprocess ();
123 }
124 
125 static ptid_t
126 debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
127 {
128  ptid_t result;
129  fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", debug_target.to_shortname);
130  result = debug_target.to_wait (&debug_target, arg1, arg2, arg3);
131  fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", debug_target.to_shortname);
139  fputs_unfiltered (") = ", gdb_stdlog);
140  target_debug_print_ptid_t (result);
142  return result;
143 }
144 
145 static void
146 delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
147 {
148  self = self->beneath;
149  self->to_fetch_registers (self, arg1, arg2);
150 }
151 
152 static void
153 tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
154 {
155 }
156 
157 static void
158 debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
159 {
160  fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname);
161  debug_target.to_fetch_registers (&debug_target, arg1, arg2);
162  fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname);
167  target_debug_print_int (arg2);
168  fputs_unfiltered (")\n", gdb_stdlog);
169 }
170 
171 static void
172 delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
173 {
174  self = self->beneath;
175  self->to_store_registers (self, arg1, arg2);
176 }
177 
178 static void
179 tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
180 {
181  noprocess ();
182 }
183 
184 static void
185 debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
186 {
187  fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
188  debug_target.to_store_registers (&debug_target, arg1, arg2);
189  fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname);
194  target_debug_print_int (arg2);
195  fputs_unfiltered (")\n", gdb_stdlog);
196 }
197 
198 static void
199 delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
200 {
201  self = self->beneath;
202  self->to_prepare_to_store (self, arg1);
203 }
204 
205 static void
206 tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
207 {
208  noprocess ();
209 }
210 
211 static void
212 debug_prepare_to_store (struct target_ops *self, struct regcache *arg1)
213 {
214  fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", debug_target.to_shortname);
215  debug_target.to_prepare_to_store (&debug_target, arg1);
216  fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", debug_target.to_shortname);
220  fputs_unfiltered (")\n", gdb_stdlog);
221 }
222 
223 static void
225 {
226  self = self->beneath;
227  self->to_files_info (self);
228 }
229 
230 static void
232 {
233 }
234 
235 static void
237 {
238  fprintf_unfiltered (gdb_stdlog, "-> %s->to_files_info (...)\n", debug_target.to_shortname);
239  debug_target.to_files_info (&debug_target);
240  fprintf_unfiltered (gdb_stdlog, "<- %s->to_files_info (", debug_target.to_shortname);
242  fputs_unfiltered (")\n", gdb_stdlog);
243 }
244 
245 static int
246 delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
247 {
248  self = self->beneath;
249  return self->to_insert_breakpoint (self, arg1, arg2);
250 }
251 
252 static int
253 debug_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
254 {
255  int result;
256  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_breakpoint (...)\n", debug_target.to_shortname);
257  result = debug_target.to_insert_breakpoint (&debug_target, arg1, arg2);
258  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_breakpoint (", debug_target.to_shortname);
264  fputs_unfiltered (") = ", gdb_stdlog);
265  target_debug_print_int (result);
267  return result;
268 }
269 
270 static int
271 delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
272 {
273  self = self->beneath;
274  return self->to_remove_breakpoint (self, arg1, arg2);
275 }
276 
277 static int
278 debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
279 {
280  int result;
281  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", debug_target.to_shortname);
282  result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2);
283  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", debug_target.to_shortname);
289  fputs_unfiltered (") = ", gdb_stdlog);
290  target_debug_print_int (result);
292  return result;
293 }
294 
295 static int
297 {
298  self = self->beneath;
299  return self->to_stopped_by_sw_breakpoint (self);
300 }
301 
302 static int
304 {
305  return 0;
306 }
307 
308 static int
310 {
311  int result;
312  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname);
313  result = debug_target.to_stopped_by_sw_breakpoint (&debug_target);
314  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_sw_breakpoint (", debug_target.to_shortname);
316  fputs_unfiltered (") = ", gdb_stdlog);
317  target_debug_print_int (result);
319  return result;
320 }
321 
322 static int
324 {
325  self = self->beneath;
326  return self->to_supports_stopped_by_sw_breakpoint (self);
327 }
328 
329 static int
331 {
332  return 0;
333 }
334 
335 static int
337 {
338  int result;
339  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname);
340  result = debug_target.to_supports_stopped_by_sw_breakpoint (&debug_target);
341  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_sw_breakpoint (", debug_target.to_shortname);
343  fputs_unfiltered (") = ", gdb_stdlog);
344  target_debug_print_int (result);
346  return result;
347 }
348 
349 static int
351 {
352  self = self->beneath;
353  return self->to_stopped_by_hw_breakpoint (self);
354 }
355 
356 static int
358 {
359  return 0;
360 }
361 
362 static int
364 {
365  int result;
366  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname);
367  result = debug_target.to_stopped_by_hw_breakpoint (&debug_target);
368  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_hw_breakpoint (", debug_target.to_shortname);
370  fputs_unfiltered (") = ", gdb_stdlog);
371  target_debug_print_int (result);
373  return result;
374 }
375 
376 static int
378 {
379  self = self->beneath;
380  return self->to_supports_stopped_by_hw_breakpoint (self);
381 }
382 
383 static int
385 {
386  return 0;
387 }
388 
389 static int
391 {
392  int result;
393  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname);
394  result = debug_target.to_supports_stopped_by_hw_breakpoint (&debug_target);
395  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_hw_breakpoint (", debug_target.to_shortname);
397  fputs_unfiltered (") = ", gdb_stdlog);
398  target_debug_print_int (result);
400  return result;
401 }
402 
403 static int
404 delegate_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
405 {
406  self = self->beneath;
407  return self->to_can_use_hw_breakpoint (self, arg1, arg2, arg3);
408 }
409 
410 static int
411 tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
412 {
413  return 0;
414 }
415 
416 static int
417 debug_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
418 {
419  int result;
420  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", debug_target.to_shortname);
421  result = debug_target.to_can_use_hw_breakpoint (&debug_target, arg1, arg2, arg3);
422  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", debug_target.to_shortname);
425  target_debug_print_int (arg1);
427  target_debug_print_int (arg2);
429  target_debug_print_int (arg3);
430  fputs_unfiltered (") = ", gdb_stdlog);
431  target_debug_print_int (result);
433  return result;
434 }
435 
436 static int
438 {
439  self = self->beneath;
440  return self->to_ranged_break_num_registers (self);
441 }
442 
443 static int
445 {
446  return -1;
447 }
448 
449 static int
451 {
452  int result;
453  fprintf_unfiltered (gdb_stdlog, "-> %s->to_ranged_break_num_registers (...)\n", debug_target.to_shortname);
454  result = debug_target.to_ranged_break_num_registers (&debug_target);
455  fprintf_unfiltered (gdb_stdlog, "<- %s->to_ranged_break_num_registers (", debug_target.to_shortname);
457  fputs_unfiltered (") = ", gdb_stdlog);
458  target_debug_print_int (result);
460  return result;
461 }
462 
463 static int
464 delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
465 {
466  self = self->beneath;
467  return self->to_insert_hw_breakpoint (self, arg1, arg2);
468 }
469 
470 static int
471 tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
472 {
473  return -1;
474 }
475 
476 static int
477 debug_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
478 {
479  int result;
480  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_hw_breakpoint (...)\n", debug_target.to_shortname);
481  result = debug_target.to_insert_hw_breakpoint (&debug_target, arg1, arg2);
482  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_hw_breakpoint (", debug_target.to_shortname);
488  fputs_unfiltered (") = ", gdb_stdlog);
489  target_debug_print_int (result);
491  return result;
492 }
493 
494 static int
495 delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
496 {
497  self = self->beneath;
498  return self->to_remove_hw_breakpoint (self, arg1, arg2);
499 }
500 
501 static int
502 tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
503 {
504  return -1;
505 }
506 
507 static int
508 debug_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
509 {
510  int result;
511  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_hw_breakpoint (...)\n", debug_target.to_shortname);
512  result = debug_target.to_remove_hw_breakpoint (&debug_target, arg1, arg2);
513  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_hw_breakpoint (", debug_target.to_shortname);
519  fputs_unfiltered (") = ", gdb_stdlog);
520  target_debug_print_int (result);
522  return result;
523 }
524 
525 static int
526 delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
527 {
528  self = self->beneath;
529  return self->to_remove_watchpoint (self, arg1, arg2, arg3, arg4);
530 }
531 
532 static int
533 tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
534 {
535  return -1;
536 }
537 
538 static int
539 debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
540 {
541  int result;
542  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", debug_target.to_shortname);
543  result = debug_target.to_remove_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
544  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", debug_target.to_shortname);
549  target_debug_print_int (arg2);
551  target_debug_print_int (arg3);
554  fputs_unfiltered (") = ", gdb_stdlog);
555  target_debug_print_int (result);
557  return result;
558 }
559 
560 static int
561 delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
562 {
563  self = self->beneath;
564  return self->to_insert_watchpoint (self, arg1, arg2, arg3, arg4);
565 }
566 
567 static int
568 tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
569 {
570  return -1;
571 }
572 
573 static int
574 debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
575 {
576  int result;
577  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", debug_target.to_shortname);
578  result = debug_target.to_insert_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
579  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", debug_target.to_shortname);
584  target_debug_print_int (arg2);
586  target_debug_print_int (arg3);
589  fputs_unfiltered (") = ", gdb_stdlog);
590  target_debug_print_int (result);
592  return result;
593 }
594 
595 static int
596 delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
597 {
598  self = self->beneath;
599  return self->to_insert_mask_watchpoint (self, arg1, arg2, arg3);
600 }
601 
602 static int
603 tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
604 {
605  return 1;
606 }
607 
608 static int
609 debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
610 {
611  int result;
612  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_mask_watchpoint (...)\n", debug_target.to_shortname);
613  result = debug_target.to_insert_mask_watchpoint (&debug_target, arg1, arg2, arg3);
614  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_mask_watchpoint (", debug_target.to_shortname);
621  target_debug_print_int (arg3);
622  fputs_unfiltered (") = ", gdb_stdlog);
623  target_debug_print_int (result);
625  return result;
626 }
627 
628 static int
629 delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
630 {
631  self = self->beneath;
632  return self->to_remove_mask_watchpoint (self, arg1, arg2, arg3);
633 }
634 
635 static int
636 tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
637 {
638  return 1;
639 }
640 
641 static int
642 debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
643 {
644  int result;
645  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_mask_watchpoint (...)\n", debug_target.to_shortname);
646  result = debug_target.to_remove_mask_watchpoint (&debug_target, arg1, arg2, arg3);
647  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_mask_watchpoint (", debug_target.to_shortname);
654  target_debug_print_int (arg3);
655  fputs_unfiltered (") = ", gdb_stdlog);
656  target_debug_print_int (result);
658  return result;
659 }
660 
661 static int
663 {
664  self = self->beneath;
665  return self->to_stopped_by_watchpoint (self);
666 }
667 
668 static int
670 {
671  return 0;
672 }
673 
674 static int
676 {
677  int result;
678  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_watchpoint (...)\n", debug_target.to_shortname);
679  result = debug_target.to_stopped_by_watchpoint (&debug_target);
680  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_watchpoint (", debug_target.to_shortname);
682  fputs_unfiltered (") = ", gdb_stdlog);
683  target_debug_print_int (result);
685  return result;
686 }
687 
688 static int
690 {
691  self = self->beneath;
692  return self->to_stopped_data_address (self, arg1);
693 }
694 
695 static int
697 {
698  return 0;
699 }
700 
701 static int
703 {
704  int result;
705  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_data_address (...)\n", debug_target.to_shortname);
706  result = debug_target.to_stopped_data_address (&debug_target, arg1);
707  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_data_address (", debug_target.to_shortname);
711  fputs_unfiltered (") = ", gdb_stdlog);
712  target_debug_print_int (result);
714  return result;
715 }
716 
717 static int
719 {
720  self = self->beneath;
721  return self->to_watchpoint_addr_within_range (self, arg1, arg2, arg3);
722 }
723 
724 static int
726 {
727  int result;
728  fprintf_unfiltered (gdb_stdlog, "-> %s->to_watchpoint_addr_within_range (...)\n", debug_target.to_shortname);
729  result = debug_target.to_watchpoint_addr_within_range (&debug_target, arg1, arg2, arg3);
730  fprintf_unfiltered (gdb_stdlog, "<- %s->to_watchpoint_addr_within_range (", debug_target.to_shortname);
737  target_debug_print_int (arg3);
738  fputs_unfiltered (") = ", gdb_stdlog);
739  target_debug_print_int (result);
741  return result;
742 }
743 
744 static int
746 {
747  self = self->beneath;
748  return self->to_region_ok_for_hw_watchpoint (self, arg1, arg2);
749 }
750 
751 static int
753 {
754  int result;
755  fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", debug_target.to_shortname);
756  result = debug_target.to_region_ok_for_hw_watchpoint (&debug_target, arg1, arg2);
757  fprintf_unfiltered (gdb_stdlog, "<- %s->to_region_ok_for_hw_watchpoint (", debug_target.to_shortname);
762  target_debug_print_int (arg2);
763  fputs_unfiltered (") = ", gdb_stdlog);
764  target_debug_print_int (result);
766  return result;
767 }
768 
769 static int
770 delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
771 {
772  self = self->beneath;
773  return self->to_can_accel_watchpoint_condition (self, arg1, arg2, arg3, arg4);
774 }
775 
776 static int
777 tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
778 {
779  return 0;
780 }
781 
782 static int
783 debug_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
784 {
785  int result;
786  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_accel_watchpoint_condition (...)\n", debug_target.to_shortname);
787  result = debug_target.to_can_accel_watchpoint_condition (&debug_target, arg1, arg2, arg3, arg4);
788  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_accel_watchpoint_condition (", debug_target.to_shortname);
793  target_debug_print_int (arg2);
795  target_debug_print_int (arg3);
798  fputs_unfiltered (") = ", gdb_stdlog);
799  target_debug_print_int (result);
801  return result;
802 }
803 
804 static int
806 {
807  self = self->beneath;
808  return self->to_masked_watch_num_registers (self, arg1, arg2);
809 }
810 
811 static int
813 {
814  return -1;
815 }
816 
817 static int
819 {
820  int result;
821  fprintf_unfiltered (gdb_stdlog, "-> %s->to_masked_watch_num_registers (...)\n", debug_target.to_shortname);
822  result = debug_target.to_masked_watch_num_registers (&debug_target, arg1, arg2);
823  fprintf_unfiltered (gdb_stdlog, "<- %s->to_masked_watch_num_registers (", debug_target.to_shortname);
829  fputs_unfiltered (") = ", gdb_stdlog);
830  target_debug_print_int (result);
832  return result;
833 }
834 
835 static void
837 {
838  self = self->beneath;
839  self->to_terminal_init (self);
840 }
841 
842 static void
844 {
845 }
846 
847 static void
849 {
850  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_init (...)\n", debug_target.to_shortname);
851  debug_target.to_terminal_init (&debug_target);
852  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_init (", debug_target.to_shortname);
854  fputs_unfiltered (")\n", gdb_stdlog);
855 }
856 
857 static void
859 {
860  self = self->beneath;
861  self->to_terminal_inferior (self);
862 }
863 
864 static void
866 {
867 }
868 
869 static void
871 {
872  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_inferior (...)\n", debug_target.to_shortname);
873  debug_target.to_terminal_inferior (&debug_target);
874  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_inferior (", debug_target.to_shortname);
876  fputs_unfiltered (")\n", gdb_stdlog);
877 }
878 
879 static void
881 {
882  self = self->beneath;
883  self->to_terminal_ours_for_output (self);
884 }
885 
886 static void
888 {
889 }
890 
891 static void
893 {
894  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours_for_output (...)\n", debug_target.to_shortname);
895  debug_target.to_terminal_ours_for_output (&debug_target);
896  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours_for_output (", debug_target.to_shortname);
898  fputs_unfiltered (")\n", gdb_stdlog);
899 }
900 
901 static void
903 {
904  self = self->beneath;
905  self->to_terminal_ours (self);
906 }
907 
908 static void
910 {
911 }
912 
913 static void
915 {
916  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours (...)\n", debug_target.to_shortname);
917  debug_target.to_terminal_ours (&debug_target);
918  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours (", debug_target.to_shortname);
920  fputs_unfiltered (")\n", gdb_stdlog);
921 }
922 
923 static void
924 delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
925 {
926  self = self->beneath;
927  self->to_terminal_info (self, arg1, arg2);
928 }
929 
930 static void
931 debug_terminal_info (struct target_ops *self, const char *arg1, int arg2)
932 {
933  fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_info (...)\n", debug_target.to_shortname);
934  debug_target.to_terminal_info (&debug_target, arg1, arg2);
935  fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_info (", debug_target.to_shortname);
940  target_debug_print_int (arg2);
941  fputs_unfiltered (")\n", gdb_stdlog);
942 }
943 
944 static void
945 delegate_kill (struct target_ops *self)
946 {
947  self = self->beneath;
948  self->to_kill (self);
949 }
950 
951 static void
952 tdefault_kill (struct target_ops *self)
953 {
954  noprocess ();
955 }
956 
957 static void
958 debug_kill (struct target_ops *self)
959 {
960  fprintf_unfiltered (gdb_stdlog, "-> %s->to_kill (...)\n", debug_target.to_shortname);
961  debug_target.to_kill (&debug_target);
962  fprintf_unfiltered (gdb_stdlog, "<- %s->to_kill (", debug_target.to_shortname);
964  fputs_unfiltered (")\n", gdb_stdlog);
965 }
966 
967 static void
968 delegate_load (struct target_ops *self, const char *arg1, int arg2)
969 {
970  self = self->beneath;
971  self->to_load (self, arg1, arg2);
972 }
973 
974 static void
975 tdefault_load (struct target_ops *self, const char *arg1, int arg2)
976 {
977  tcomplain ();
978 }
979 
980 static void
981 debug_load (struct target_ops *self, const char *arg1, int arg2)
982 {
983  fprintf_unfiltered (gdb_stdlog, "-> %s->to_load (...)\n", debug_target.to_shortname);
984  debug_target.to_load (&debug_target, arg1, arg2);
985  fprintf_unfiltered (gdb_stdlog, "<- %s->to_load (", debug_target.to_shortname);
990  target_debug_print_int (arg2);
991  fputs_unfiltered (")\n", gdb_stdlog);
992 }
993 
994 static void
996 {
997  self = self->beneath;
998  self->to_post_startup_inferior (self, arg1);
999 }
1000 
1001 static void
1003 {
1004 }
1005 
1006 static void
1008 {
1009  fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_startup_inferior (...)\n", debug_target.to_shortname);
1010  debug_target.to_post_startup_inferior (&debug_target, arg1);
1011  fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_startup_inferior (", debug_target.to_shortname);
1013  fputs_unfiltered (", ", gdb_stdlog);
1015  fputs_unfiltered (")\n", gdb_stdlog);
1016 }
1017 
1018 static int
1020 {
1021  self = self->beneath;
1022  return self->to_insert_fork_catchpoint (self, arg1);
1023 }
1024 
1025 static int
1027 {
1028  return 1;
1029 }
1030 
1031 static int
1033 {
1034  int result;
1035  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_fork_catchpoint (...)\n", debug_target.to_shortname);
1036  result = debug_target.to_insert_fork_catchpoint (&debug_target, arg1);
1037  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_fork_catchpoint (", debug_target.to_shortname);
1039  fputs_unfiltered (", ", gdb_stdlog);
1040  target_debug_print_int (arg1);
1041  fputs_unfiltered (") = ", gdb_stdlog);
1042  target_debug_print_int (result);
1043  fputs_unfiltered ("\n", gdb_stdlog);
1044  return result;
1045 }
1046 
1047 static int
1049 {
1050  self = self->beneath;
1051  return self->to_remove_fork_catchpoint (self, arg1);
1052 }
1053 
1054 static int
1056 {
1057  return 1;
1058 }
1059 
1060 static int
1062 {
1063  int result;
1064  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_fork_catchpoint (...)\n", debug_target.to_shortname);
1065  result = debug_target.to_remove_fork_catchpoint (&debug_target, arg1);
1066  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_fork_catchpoint (", debug_target.to_shortname);
1068  fputs_unfiltered (", ", gdb_stdlog);
1069  target_debug_print_int (arg1);
1070  fputs_unfiltered (") = ", gdb_stdlog);
1071  target_debug_print_int (result);
1072  fputs_unfiltered ("\n", gdb_stdlog);
1073  return result;
1074 }
1075 
1076 static int
1078 {
1079  self = self->beneath;
1080  return self->to_insert_vfork_catchpoint (self, arg1);
1081 }
1082 
1083 static int
1085 {
1086  return 1;
1087 }
1088 
1089 static int
1091 {
1092  int result;
1093  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_vfork_catchpoint (...)\n", debug_target.to_shortname);
1094  result = debug_target.to_insert_vfork_catchpoint (&debug_target, arg1);
1095  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_vfork_catchpoint (", debug_target.to_shortname);
1097  fputs_unfiltered (", ", gdb_stdlog);
1098  target_debug_print_int (arg1);
1099  fputs_unfiltered (") = ", gdb_stdlog);
1100  target_debug_print_int (result);
1101  fputs_unfiltered ("\n", gdb_stdlog);
1102  return result;
1103 }
1104 
1105 static int
1107 {
1108  self = self->beneath;
1109  return self->to_remove_vfork_catchpoint (self, arg1);
1110 }
1111 
1112 static int
1114 {
1115  return 1;
1116 }
1117 
1118 static int
1120 {
1121  int result;
1122  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_vfork_catchpoint (...)\n", debug_target.to_shortname);
1123  result = debug_target.to_remove_vfork_catchpoint (&debug_target, arg1);
1124  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_vfork_catchpoint (", debug_target.to_shortname);
1126  fputs_unfiltered (", ", gdb_stdlog);
1127  target_debug_print_int (arg1);
1128  fputs_unfiltered (") = ", gdb_stdlog);
1129  target_debug_print_int (result);
1130  fputs_unfiltered ("\n", gdb_stdlog);
1131  return result;
1132 }
1133 
1134 static int
1135 delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
1136 {
1137  self = self->beneath;
1138  return self->to_follow_fork (self, arg1, arg2);
1139 }
1140 
1141 static int
1142 debug_follow_fork (struct target_ops *self, int arg1, int arg2)
1143 {
1144  int result;
1145  fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_fork (...)\n", debug_target.to_shortname);
1146  result = debug_target.to_follow_fork (&debug_target, arg1, arg2);
1147  fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_fork (", debug_target.to_shortname);
1149  fputs_unfiltered (", ", gdb_stdlog);
1150  target_debug_print_int (arg1);
1151  fputs_unfiltered (", ", gdb_stdlog);
1152  target_debug_print_int (arg2);
1153  fputs_unfiltered (") = ", gdb_stdlog);
1154  target_debug_print_int (result);
1155  fputs_unfiltered ("\n", gdb_stdlog);
1156  return result;
1157 }
1158 
1159 static int
1161 {
1162  self = self->beneath;
1163  return self->to_insert_exec_catchpoint (self, arg1);
1164 }
1165 
1166 static int
1168 {
1169  return 1;
1170 }
1171 
1172 static int
1174 {
1175  int result;
1176  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_exec_catchpoint (...)\n", debug_target.to_shortname);
1177  result = debug_target.to_insert_exec_catchpoint (&debug_target, arg1);
1178  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_exec_catchpoint (", debug_target.to_shortname);
1180  fputs_unfiltered (", ", gdb_stdlog);
1181  target_debug_print_int (arg1);
1182  fputs_unfiltered (") = ", gdb_stdlog);
1183  target_debug_print_int (result);
1184  fputs_unfiltered ("\n", gdb_stdlog);
1185  return result;
1186 }
1187 
1188 static int
1190 {
1191  self = self->beneath;
1192  return self->to_remove_exec_catchpoint (self, arg1);
1193 }
1194 
1195 static int
1197 {
1198  return 1;
1199 }
1200 
1201 static int
1203 {
1204  int result;
1205  fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_exec_catchpoint (...)\n", debug_target.to_shortname);
1206  result = debug_target.to_remove_exec_catchpoint (&debug_target, arg1);
1207  fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_exec_catchpoint (", debug_target.to_shortname);
1209  fputs_unfiltered (", ", gdb_stdlog);
1210  target_debug_print_int (arg1);
1211  fputs_unfiltered (") = ", gdb_stdlog);
1212  target_debug_print_int (result);
1213  fputs_unfiltered ("\n", gdb_stdlog);
1214  return result;
1215 }
1216 
1217 static int
1218 delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
1219 {
1220  self = self->beneath;
1221  return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4, arg5);
1222 }
1223 
1224 static int
1225 tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
1226 {
1227  return 1;
1228 }
1229 
1230 static int
1231 debug_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
1232 {
1233  int result;
1234  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname);
1235  result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4, arg5);
1236  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname);
1238  fputs_unfiltered (", ", gdb_stdlog);
1239  target_debug_print_int (arg1);
1240  fputs_unfiltered (", ", gdb_stdlog);
1241  target_debug_print_int (arg2);
1242  fputs_unfiltered (", ", gdb_stdlog);
1243  target_debug_print_int (arg3);
1244  fputs_unfiltered (", ", gdb_stdlog);
1245  target_debug_print_int (arg4);
1246  fputs_unfiltered (", ", gdb_stdlog);
1247  target_debug_print_int_p (arg5);
1248  fputs_unfiltered (") = ", gdb_stdlog);
1249  target_debug_print_int (result);
1250  fputs_unfiltered ("\n", gdb_stdlog);
1251  return result;
1252 }
1253 
1254 static int
1255 delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
1256 {
1257  self = self->beneath;
1258  return self->to_has_exited (self, arg1, arg2, arg3);
1259 }
1260 
1261 static int
1262 tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
1263 {
1264  return 0;
1265 }
1266 
1267 static int
1268 debug_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
1269 {
1270  int result;
1271  fprintf_unfiltered (gdb_stdlog, "-> %s->to_has_exited (...)\n", debug_target.to_shortname);
1272  result = debug_target.to_has_exited (&debug_target, arg1, arg2, arg3);
1273  fprintf_unfiltered (gdb_stdlog, "<- %s->to_has_exited (", debug_target.to_shortname);
1275  fputs_unfiltered (", ", gdb_stdlog);
1276  target_debug_print_int (arg1);
1277  fputs_unfiltered (", ", gdb_stdlog);
1278  target_debug_print_int (arg2);
1279  fputs_unfiltered (", ", gdb_stdlog);
1280  target_debug_print_int_p (arg3);
1281  fputs_unfiltered (") = ", gdb_stdlog);
1282  target_debug_print_int (result);
1283  fputs_unfiltered ("\n", gdb_stdlog);
1284  return result;
1285 }
1286 
1287 static void
1289 {
1290  self = self->beneath;
1291  self->to_mourn_inferior (self);
1292 }
1293 
1294 static void
1296 {
1297  fprintf_unfiltered (gdb_stdlog, "-> %s->to_mourn_inferior (...)\n", debug_target.to_shortname);
1298  debug_target.to_mourn_inferior (&debug_target);
1299  fprintf_unfiltered (gdb_stdlog, "<- %s->to_mourn_inferior (", debug_target.to_shortname);
1301  fputs_unfiltered (")\n", gdb_stdlog);
1302 }
1303 
1304 static int
1306 {
1307  self = self->beneath;
1308  return self->to_can_run (self);
1309 }
1310 
1311 static int
1313 {
1314  return 0;
1315 }
1316 
1317 static int
1319 {
1320  int result;
1321  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run (...)\n", debug_target.to_shortname);
1322  result = debug_target.to_can_run (&debug_target);
1323  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run (", debug_target.to_shortname);
1325  fputs_unfiltered (") = ", gdb_stdlog);
1326  target_debug_print_int (result);
1327  fputs_unfiltered ("\n", gdb_stdlog);
1328  return result;
1329 }
1330 
1331 static void
1332 delegate_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1333 {
1334  self = self->beneath;
1335  self->to_pass_signals (self, arg1, arg2);
1336 }
1337 
1338 static void
1339 tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1340 {
1341 }
1342 
1343 static void
1344 debug_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1345 {
1346  fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", debug_target.to_shortname);
1347  debug_target.to_pass_signals (&debug_target, arg1, arg2);
1348  fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", debug_target.to_shortname);
1350  fputs_unfiltered (", ", gdb_stdlog);
1351  target_debug_print_int (arg1);
1352  fputs_unfiltered (", ", gdb_stdlog);
1354  fputs_unfiltered (")\n", gdb_stdlog);
1355 }
1356 
1357 static void
1358 delegate_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1359 {
1360  self = self->beneath;
1361  self->to_program_signals (self, arg1, arg2);
1362 }
1363 
1364 static void
1365 tdefault_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1366 {
1367 }
1368 
1369 static void
1370 debug_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1371 {
1372  fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", debug_target.to_shortname);
1373  debug_target.to_program_signals (&debug_target, arg1, arg2);
1374  fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", debug_target.to_shortname);
1376  fputs_unfiltered (", ", gdb_stdlog);
1377  target_debug_print_int (arg1);
1378  fputs_unfiltered (", ", gdb_stdlog);
1380  fputs_unfiltered (")\n", gdb_stdlog);
1381 }
1382 
1383 static int
1385 {
1386  self = self->beneath;
1387  return self->to_thread_alive (self, arg1);
1388 }
1389 
1390 static int
1392 {
1393  return 0;
1394 }
1395 
1396 static int
1398 {
1399  int result;
1400  fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_alive (...)\n", debug_target.to_shortname);
1401  result = debug_target.to_thread_alive (&debug_target, arg1);
1402  fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_alive (", debug_target.to_shortname);
1404  fputs_unfiltered (", ", gdb_stdlog);
1406  fputs_unfiltered (") = ", gdb_stdlog);
1407  target_debug_print_int (result);
1408  fputs_unfiltered ("\n", gdb_stdlog);
1409  return result;
1410 }
1411 
1412 static void
1414 {
1415  self = self->beneath;
1416  self->to_update_thread_list (self);
1417 }
1418 
1419 static void
1421 {
1422 }
1423 
1424 static void
1426 {
1427  fprintf_unfiltered (gdb_stdlog, "-> %s->to_update_thread_list (...)\n", debug_target.to_shortname);
1428  debug_target.to_update_thread_list (&debug_target);
1429  fprintf_unfiltered (gdb_stdlog, "<- %s->to_update_thread_list (", debug_target.to_shortname);
1431  fputs_unfiltered (")\n", gdb_stdlog);
1432 }
1433 
1434 static char *
1436 {
1437  self = self->beneath;
1438  return self->to_pid_to_str (self, arg1);
1439 }
1440 
1441 static char *
1442 debug_pid_to_str (struct target_ops *self, ptid_t arg1)
1443 {
1444  char * result;
1445  fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_str (...)\n", debug_target.to_shortname);
1446  result = debug_target.to_pid_to_str (&debug_target, arg1);
1447  fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_str (", debug_target.to_shortname);
1449  fputs_unfiltered (", ", gdb_stdlog);
1451  fputs_unfiltered (") = ", gdb_stdlog);
1452  target_debug_print_char_p (result);
1453  fputs_unfiltered ("\n", gdb_stdlog);
1454  return result;
1455 }
1456 
1457 static char *
1459 {
1460  self = self->beneath;
1461  return self->to_extra_thread_info (self, arg1);
1462 }
1463 
1464 static char *
1466 {
1467  return NULL;
1468 }
1469 
1470 static char *
1471 debug_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
1472 {
1473  char * result;
1474  fprintf_unfiltered (gdb_stdlog, "-> %s->to_extra_thread_info (...)\n", debug_target.to_shortname);
1475  result = debug_target.to_extra_thread_info (&debug_target, arg1);
1476  fprintf_unfiltered (gdb_stdlog, "<- %s->to_extra_thread_info (", debug_target.to_shortname);
1478  fputs_unfiltered (", ", gdb_stdlog);
1480  fputs_unfiltered (") = ", gdb_stdlog);
1481  target_debug_print_char_p (result);
1482  fputs_unfiltered ("\n", gdb_stdlog);
1483  return result;
1484 }
1485 
1486 static char *
1487 delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
1488 {
1489  self = self->beneath;
1490  return self->to_thread_name (self, arg1);
1491 }
1492 
1493 static char *
1494 tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
1495 {
1496  return NULL;
1497 }
1498 
1499 static char *
1500 debug_thread_name (struct target_ops *self, struct thread_info *arg1)
1501 {
1502  char * result;
1503  fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_name (...)\n", debug_target.to_shortname);
1504  result = debug_target.to_thread_name (&debug_target, arg1);
1505  fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_name (", debug_target.to_shortname);
1507  fputs_unfiltered (", ", gdb_stdlog);
1509  fputs_unfiltered (") = ", gdb_stdlog);
1510  target_debug_print_char_p (result);
1511  fputs_unfiltered ("\n", gdb_stdlog);
1512  return result;
1513 }
1514 
1515 static void
1516 delegate_stop (struct target_ops *self, ptid_t arg1)
1517 {
1518  self = self->beneath;
1519  self->to_stop (self, arg1);
1520 }
1521 
1522 static void
1523 tdefault_stop (struct target_ops *self, ptid_t arg1)
1524 {
1525 }
1526 
1527 static void
1528 debug_stop (struct target_ops *self, ptid_t arg1)
1529 {
1530  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop (...)\n", debug_target.to_shortname);
1531  debug_target.to_stop (&debug_target, arg1);
1532  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop (", debug_target.to_shortname);
1534  fputs_unfiltered (", ", gdb_stdlog);
1536  fputs_unfiltered (")\n", gdb_stdlog);
1537 }
1538 
1539 static void
1541 {
1542  self = self->beneath;
1543  self->to_check_pending_interrupt (self);
1544 }
1545 
1546 static void
1548 {
1549 }
1550 
1551 static void
1553 {
1554  fprintf_unfiltered (gdb_stdlog, "-> %s->to_check_pending_interrupt (...)\n", debug_target.to_shortname);
1555  debug_target.to_check_pending_interrupt (&debug_target);
1556  fprintf_unfiltered (gdb_stdlog, "<- %s->to_check_pending_interrupt (", debug_target.to_shortname);
1558  fputs_unfiltered (")\n", gdb_stdlog);
1559 }
1560 
1561 static void
1562 delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
1563 {
1564  self = self->beneath;
1565  self->to_rcmd (self, arg1, arg2);
1566 }
1567 
1568 static void
1569 debug_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
1570 {
1571  fprintf_unfiltered (gdb_stdlog, "-> %s->to_rcmd (...)\n", debug_target.to_shortname);
1572  debug_target.to_rcmd (&debug_target, arg1, arg2);
1573  fprintf_unfiltered (gdb_stdlog, "<- %s->to_rcmd (", debug_target.to_shortname);
1575  fputs_unfiltered (", ", gdb_stdlog);
1577  fputs_unfiltered (", ", gdb_stdlog);
1579  fputs_unfiltered (")\n", gdb_stdlog);
1580 }
1581 
1582 static char *
1583 delegate_pid_to_exec_file (struct target_ops *self, int arg1)
1584 {
1585  self = self->beneath;
1586  return self->to_pid_to_exec_file (self, arg1);
1587 }
1588 
1589 static char *
1590 tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
1591 {
1592  return NULL;
1593 }
1594 
1595 static char *
1596 debug_pid_to_exec_file (struct target_ops *self, int arg1)
1597 {
1598  char * result;
1599  fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_exec_file (...)\n", debug_target.to_shortname);
1600  result = debug_target.to_pid_to_exec_file (&debug_target, arg1);
1601  fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_exec_file (", debug_target.to_shortname);
1603  fputs_unfiltered (", ", gdb_stdlog);
1604  target_debug_print_int (arg1);
1605  fputs_unfiltered (") = ", gdb_stdlog);
1606  target_debug_print_char_p (result);
1607  fputs_unfiltered ("\n", gdb_stdlog);
1608  return result;
1609 }
1610 
1611 static void
1612 delegate_log_command (struct target_ops *self, const char *arg1)
1613 {
1614  self = self->beneath;
1615  self->to_log_command (self, arg1);
1616 }
1617 
1618 static void
1619 tdefault_log_command (struct target_ops *self, const char *arg1)
1620 {
1621 }
1622 
1623 static void
1624 debug_log_command (struct target_ops *self, const char *arg1)
1625 {
1626  fprintf_unfiltered (gdb_stdlog, "-> %s->to_log_command (...)\n", debug_target.to_shortname);
1627  debug_target.to_log_command (&debug_target, arg1);
1628  fprintf_unfiltered (gdb_stdlog, "<- %s->to_log_command (", debug_target.to_shortname);
1630  fputs_unfiltered (", ", gdb_stdlog);
1632  fputs_unfiltered (")\n", gdb_stdlog);
1633 }
1634 
1635 static struct target_section_table *
1637 {
1638  self = self->beneath;
1639  return self->to_get_section_table (self);
1640 }
1641 
1642 static struct target_section_table *
1644 {
1645  return NULL;
1646 }
1647 
1648 static struct target_section_table *
1650 {
1651  struct target_section_table * result;
1652  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_section_table (...)\n", debug_target.to_shortname);
1653  result = debug_target.to_get_section_table (&debug_target);
1654  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_section_table (", debug_target.to_shortname);
1656  fputs_unfiltered (") = ", gdb_stdlog);
1658  fputs_unfiltered ("\n", gdb_stdlog);
1659  return result;
1660 }
1661 
1662 static int
1664 {
1665  self = self->beneath;
1666  return self->to_can_async_p (self);
1667 }
1668 
1669 static int
1671 {
1672  return 0;
1673 }
1674 
1675 static int
1677 {
1678  int result;
1679  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_async_p (...)\n", debug_target.to_shortname);
1680  result = debug_target.to_can_async_p (&debug_target);
1681  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_async_p (", debug_target.to_shortname);
1683  fputs_unfiltered (") = ", gdb_stdlog);
1684  target_debug_print_int (result);
1685  fputs_unfiltered ("\n", gdb_stdlog);
1686  return result;
1687 }
1688 
1689 static int
1691 {
1692  self = self->beneath;
1693  return self->to_is_async_p (self);
1694 }
1695 
1696 static int
1698 {
1699  return 0;
1700 }
1701 
1702 static int
1704 {
1705  int result;
1706  fprintf_unfiltered (gdb_stdlog, "-> %s->to_is_async_p (...)\n", debug_target.to_shortname);
1707  result = debug_target.to_is_async_p (&debug_target);
1708  fprintf_unfiltered (gdb_stdlog, "<- %s->to_is_async_p (", debug_target.to_shortname);
1710  fputs_unfiltered (") = ", gdb_stdlog);
1711  target_debug_print_int (result);
1712  fputs_unfiltered ("\n", gdb_stdlog);
1713  return result;
1714 }
1715 
1716 static void
1717 delegate_async (struct target_ops *self, int arg1)
1718 {
1719  self = self->beneath;
1720  self->to_async (self, arg1);
1721 }
1722 
1723 static void
1724 tdefault_async (struct target_ops *self, int arg1)
1725 {
1726  tcomplain ();
1727 }
1728 
1729 static void
1730 debug_async (struct target_ops *self, int arg1)
1731 {
1732  fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname);
1733  debug_target.to_async (&debug_target, arg1);
1734  fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", debug_target.to_shortname);
1736  fputs_unfiltered (", ", gdb_stdlog);
1737  target_debug_print_int (arg1);
1738  fputs_unfiltered (")\n", gdb_stdlog);
1739 }
1740 
1741 static int
1743 {
1744  self = self->beneath;
1745  return self->to_supports_non_stop (self);
1746 }
1747 
1748 static int
1750 {
1751  return 0;
1752 }
1753 
1754 static int
1756 {
1757  int result;
1758  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", debug_target.to_shortname);
1759  result = debug_target.to_supports_non_stop (&debug_target);
1760  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", debug_target.to_shortname);
1762  fputs_unfiltered (") = ", gdb_stdlog);
1763  target_debug_print_int (result);
1764  fputs_unfiltered ("\n", gdb_stdlog);
1765  return result;
1766 }
1767 
1768 static int
1770 {
1771  self = self->beneath;
1772  return self->to_find_memory_regions (self, arg1, arg2);
1773 }
1774 
1775 static int
1777 {
1778  int result;
1779  fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", debug_target.to_shortname);
1780  result = debug_target.to_find_memory_regions (&debug_target, arg1, arg2);
1781  fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", debug_target.to_shortname);
1783  fputs_unfiltered (", ", gdb_stdlog);
1785  fputs_unfiltered (", ", gdb_stdlog);
1787  fputs_unfiltered (") = ", gdb_stdlog);
1788  target_debug_print_int (result);
1789  fputs_unfiltered ("\n", gdb_stdlog);
1790  return result;
1791 }
1792 
1793 static char *
1794 delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
1795 {
1796  self = self->beneath;
1797  return self->to_make_corefile_notes (self, arg1, arg2);
1798 }
1799 
1800 static char *
1801 debug_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
1802 {
1803  char * result;
1804  fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", debug_target.to_shortname);
1805  result = debug_target.to_make_corefile_notes (&debug_target, arg1, arg2);
1806  fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", debug_target.to_shortname);
1808  fputs_unfiltered (", ", gdb_stdlog);
1809  target_debug_print_bfd_p (arg1);
1810  fputs_unfiltered (", ", gdb_stdlog);
1811  target_debug_print_int_p (arg2);
1812  fputs_unfiltered (") = ", gdb_stdlog);
1813  target_debug_print_char_p (result);
1814  fputs_unfiltered ("\n", gdb_stdlog);
1815  return result;
1816 }
1817 
1818 static gdb_byte *
1819 delegate_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
1820 {
1821  self = self->beneath;
1822  return self->to_get_bookmark (self, arg1, arg2);
1823 }
1824 
1825 static gdb_byte *
1826 tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
1827 {
1828  tcomplain ();
1829 }
1830 
1831 static gdb_byte *
1832 debug_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
1833 {
1834  gdb_byte * result;
1835  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", debug_target.to_shortname);
1836  result = debug_target.to_get_bookmark (&debug_target, arg1, arg2);
1837  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", debug_target.to_shortname);
1839  fputs_unfiltered (", ", gdb_stdlog);
1841  fputs_unfiltered (", ", gdb_stdlog);
1842  target_debug_print_int (arg2);
1843  fputs_unfiltered (") = ", gdb_stdlog);
1845  fputs_unfiltered ("\n", gdb_stdlog);
1846  return result;
1847 }
1848 
1849 static void
1850 delegate_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
1851 {
1852  self = self->beneath;
1853  self->to_goto_bookmark (self, arg1, arg2);
1854 }
1855 
1856 static void
1857 tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
1858 {
1859  tcomplain ();
1860 }
1861 
1862 static void
1863 debug_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
1864 {
1865  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", debug_target.to_shortname);
1866  debug_target.to_goto_bookmark (&debug_target, arg1, arg2);
1867  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", debug_target.to_shortname);
1869  fputs_unfiltered (", ", gdb_stdlog);
1871  fputs_unfiltered (", ", gdb_stdlog);
1872  target_debug_print_int (arg2);
1873  fputs_unfiltered (")\n", gdb_stdlog);
1874 }
1875 
1876 static CORE_ADDR
1878 {
1879  self = self->beneath;
1880  return self->to_get_thread_local_address (self, arg1, arg2, arg3);
1881 }
1882 
1883 static CORE_ADDR
1885 {
1886  generic_tls_error ();
1887 }
1888 
1889 static CORE_ADDR
1891 {
1892  CORE_ADDR result;
1893  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_thread_local_address (...)\n", debug_target.to_shortname);
1894  result = debug_target.to_get_thread_local_address (&debug_target, arg1, arg2, arg3);
1895  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_thread_local_address (", debug_target.to_shortname);
1897  fputs_unfiltered (", ", gdb_stdlog);
1899  fputs_unfiltered (", ", gdb_stdlog);
1901  fputs_unfiltered (", ", gdb_stdlog);
1903  fputs_unfiltered (") = ", gdb_stdlog);
1905  fputs_unfiltered ("\n", gdb_stdlog);
1906  return result;
1907 }
1908 
1909 static enum target_xfer_status
1910 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)
1911 {
1912  self = self->beneath;
1913  return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1914 }
1915 
1916 static enum target_xfer_status
1917 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)
1918 {
1919  return TARGET_XFER_E_IO;
1920 }
1921 
1922 static enum target_xfer_status
1923 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)
1924 {
1925  enum target_xfer_status result;
1926  fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", debug_target.to_shortname);
1927  result = debug_target.to_xfer_partial (&debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1928  fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", debug_target.to_shortname);
1930  fputs_unfiltered (", ", gdb_stdlog);
1932  fputs_unfiltered (", ", gdb_stdlog);
1934  fputs_unfiltered (", ", gdb_stdlog);
1936  fputs_unfiltered (", ", gdb_stdlog);
1938  fputs_unfiltered (", ", gdb_stdlog);
1940  fputs_unfiltered (", ", gdb_stdlog);
1942  fputs_unfiltered (", ", gdb_stdlog);
1944  fputs_unfiltered (") = ", gdb_stdlog);
1946  fputs_unfiltered ("\n", gdb_stdlog);
1947  return result;
1948 }
1949 
1951 delegate_memory_map (struct target_ops *self)
1952 {
1953  self = self->beneath;
1954  return self->to_memory_map (self);
1955 }
1956 
1957 static VEC(mem_region_s) *
1958 tdefault_memory_map (struct target_ops *self)
1959 {
1960  return NULL;
1961 }
1962 
1963 static VEC(mem_region_s) *
1964 debug_memory_map (struct target_ops *self)
1965 {
1966  VEC(mem_region_s) * result;
1967  fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", debug_target.to_shortname);
1968  result = debug_target.to_memory_map (&debug_target);
1969  fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", debug_target.to_shortname);
1971  fputs_unfiltered (") = ", gdb_stdlog);
1973  fputs_unfiltered ("\n", gdb_stdlog);
1974  return result;
1975 }
1976 
1977 static void
1979 {
1980  self = self->beneath;
1981  self->to_flash_erase (self, arg1, arg2);
1982 }
1983 
1984 static void
1986 {
1987  tcomplain ();
1988 }
1989 
1990 static void
1991 debug_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
1992 {
1993  fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", debug_target.to_shortname);
1994  debug_target.to_flash_erase (&debug_target, arg1, arg2);
1995  fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", debug_target.to_shortname);
1997  fputs_unfiltered (", ", gdb_stdlog);
1999  fputs_unfiltered (", ", gdb_stdlog);
2001  fputs_unfiltered (")\n", gdb_stdlog);
2002 }
2003 
2004 static void
2006 {
2007  self = self->beneath;
2008  self->to_flash_done (self);
2009 }
2010 
2011 static void
2013 {
2014  tcomplain ();
2015 }
2016 
2017 static void
2019 {
2020  fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", debug_target.to_shortname);
2021  debug_target.to_flash_done (&debug_target);
2022  fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", debug_target.to_shortname);
2024  fputs_unfiltered (")\n", gdb_stdlog);
2025 }
2026 
2027 static const struct target_desc *
2029 {
2030  self = self->beneath;
2031  return self->to_read_description (self);
2032 }
2033 
2034 static const struct target_desc *
2036 {
2037  return NULL;
2038 }
2039 
2040 static const struct target_desc *
2042 {
2043  const struct target_desc * result;
2044  fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", debug_target.to_shortname);
2045  result = debug_target.to_read_description (&debug_target);
2046  fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", debug_target.to_shortname);
2048  fputs_unfiltered (") = ", gdb_stdlog);
2050  fputs_unfiltered ("\n", gdb_stdlog);
2051  return result;
2052 }
2053 
2054 static ptid_t
2055 delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
2056 {
2057  self = self->beneath;
2058  return self->to_get_ada_task_ptid (self, arg1, arg2);
2059 }
2060 
2061 static ptid_t
2062 debug_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
2063 {
2064  ptid_t result;
2065  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", debug_target.to_shortname);
2066  result = debug_target.to_get_ada_task_ptid (&debug_target, arg1, arg2);
2067  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", debug_target.to_shortname);
2069  fputs_unfiltered (", ", gdb_stdlog);
2070  target_debug_print_long (arg1);
2071  fputs_unfiltered (", ", gdb_stdlog);
2072  target_debug_print_long (arg2);
2073  fputs_unfiltered (") = ", gdb_stdlog);
2074  target_debug_print_ptid_t (result);
2075  fputs_unfiltered ("\n", gdb_stdlog);
2076  return result;
2077 }
2078 
2079 static int
2080 delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
2081 {
2082  self = self->beneath;
2083  return self->to_auxv_parse (self, arg1, arg2, arg3, arg4);
2084 }
2085 
2086 static int
2087 debug_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
2088 {
2089  int result;
2090  fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", debug_target.to_shortname);
2091  result = debug_target.to_auxv_parse (&debug_target, arg1, arg2, arg3, arg4);
2092  fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", debug_target.to_shortname);
2094  fputs_unfiltered (", ", gdb_stdlog);
2096  fputs_unfiltered (", ", gdb_stdlog);
2098  fputs_unfiltered (", ", gdb_stdlog);
2100  fputs_unfiltered (", ", gdb_stdlog);
2102  fputs_unfiltered (") = ", gdb_stdlog);
2103  target_debug_print_int (result);
2104  fputs_unfiltered ("\n", gdb_stdlog);
2105  return result;
2106 }
2107 
2108 static int
2109 delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
2110 {
2111  self = self->beneath;
2112  return self->to_search_memory (self, arg1, arg2, arg3, arg4, arg5);
2113 }
2114 
2115 static int
2116 debug_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
2117 {
2118  int result;
2119  fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", debug_target.to_shortname);
2120  result = debug_target.to_search_memory (&debug_target, arg1, arg2, arg3, arg4, arg5);
2121  fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", debug_target.to_shortname);
2123  fputs_unfiltered (", ", gdb_stdlog);
2125  fputs_unfiltered (", ", gdb_stdlog);
2127  fputs_unfiltered (", ", gdb_stdlog);
2129  fputs_unfiltered (", ", gdb_stdlog);
2131  fputs_unfiltered (", ", gdb_stdlog);
2133  fputs_unfiltered (") = ", gdb_stdlog);
2134  target_debug_print_int (result);
2135  fputs_unfiltered ("\n", gdb_stdlog);
2136  return result;
2137 }
2138 
2139 static int
2141 {
2142  self = self->beneath;
2143  return self->to_can_execute_reverse (self);
2144 }
2145 
2146 static int
2148 {
2149  return 0;
2150 }
2151 
2152 static int
2154 {
2155  int result;
2156  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", debug_target.to_shortname);
2157  result = debug_target.to_can_execute_reverse (&debug_target);
2158  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", debug_target.to_shortname);
2160  fputs_unfiltered (") = ", gdb_stdlog);
2161  target_debug_print_int (result);
2162  fputs_unfiltered ("\n", gdb_stdlog);
2163  return result;
2164 }
2165 
2166 static enum exec_direction_kind
2168 {
2169  self = self->beneath;
2170  return self->to_execution_direction (self);
2171 }
2172 
2173 static enum exec_direction_kind
2175 {
2176  enum exec_direction_kind result;
2177  fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", debug_target.to_shortname);
2178  result = debug_target.to_execution_direction (&debug_target);
2179  fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", debug_target.to_shortname);
2181  fputs_unfiltered (") = ", gdb_stdlog);
2183  fputs_unfiltered ("\n", gdb_stdlog);
2184  return result;
2185 }
2186 
2187 static int
2189 {
2190  self = self->beneath;
2191  return self->to_supports_multi_process (self);
2192 }
2193 
2194 static int
2196 {
2197  return 0;
2198 }
2199 
2200 static int
2202 {
2203  int result;
2204  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", debug_target.to_shortname);
2205  result = debug_target.to_supports_multi_process (&debug_target);
2206  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", debug_target.to_shortname);
2208  fputs_unfiltered (") = ", gdb_stdlog);
2209  target_debug_print_int (result);
2210  fputs_unfiltered ("\n", gdb_stdlog);
2211  return result;
2212 }
2213 
2214 static int
2216 {
2217  self = self->beneath;
2218  return self->to_supports_enable_disable_tracepoint (self);
2219 }
2220 
2221 static int
2223 {
2224  return 0;
2225 }
2226 
2227 static int
2229 {
2230  int result;
2231  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", debug_target.to_shortname);
2232  result = debug_target.to_supports_enable_disable_tracepoint (&debug_target);
2233  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", debug_target.to_shortname);
2235  fputs_unfiltered (") = ", gdb_stdlog);
2236  target_debug_print_int (result);
2237  fputs_unfiltered ("\n", gdb_stdlog);
2238  return result;
2239 }
2240 
2241 static int
2243 {
2244  self = self->beneath;
2245  return self->to_supports_string_tracing (self);
2246 }
2247 
2248 static int
2250 {
2251  return 0;
2252 }
2253 
2254 static int
2256 {
2257  int result;
2258  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", debug_target.to_shortname);
2259  result = debug_target.to_supports_string_tracing (&debug_target);
2260  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", debug_target.to_shortname);
2262  fputs_unfiltered (") = ", gdb_stdlog);
2263  target_debug_print_int (result);
2264  fputs_unfiltered ("\n", gdb_stdlog);
2265  return result;
2266 }
2267 
2268 static int
2270 {
2271  self = self->beneath;
2272  return self->to_supports_evaluation_of_breakpoint_conditions (self);
2273 }
2274 
2275 static int
2277 {
2278  return 0;
2279 }
2280 
2281 static int
2283 {
2284  int result;
2285  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", debug_target.to_shortname);
2286  result = debug_target.to_supports_evaluation_of_breakpoint_conditions (&debug_target);
2287  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", debug_target.to_shortname);
2289  fputs_unfiltered (") = ", gdb_stdlog);
2290  target_debug_print_int (result);
2291  fputs_unfiltered ("\n", gdb_stdlog);
2292  return result;
2293 }
2294 
2295 static int
2297 {
2298  self = self->beneath;
2299  return self->to_can_run_breakpoint_commands (self);
2300 }
2301 
2302 static int
2304 {
2305  return 0;
2306 }
2307 
2308 static int
2310 {
2311  int result;
2312  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", debug_target.to_shortname);
2313  result = debug_target.to_can_run_breakpoint_commands (&debug_target);
2314  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", debug_target.to_shortname);
2316  fputs_unfiltered (") = ", gdb_stdlog);
2317  target_debug_print_int (result);
2318  fputs_unfiltered ("\n", gdb_stdlog);
2319  return result;
2320 }
2321 
2322 static struct gdbarch *
2324 {
2325  self = self->beneath;
2326  return self->to_thread_architecture (self, arg1);
2327 }
2328 
2329 static struct gdbarch *
2331 {
2332  struct gdbarch * result;
2333  fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", debug_target.to_shortname);
2334  result = debug_target.to_thread_architecture (&debug_target, arg1);
2335  fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", debug_target.to_shortname);
2337  fputs_unfiltered (", ", gdb_stdlog);
2339  fputs_unfiltered (") = ", gdb_stdlog);
2341  fputs_unfiltered ("\n", gdb_stdlog);
2342  return result;
2343 }
2344 
2345 static struct address_space *
2347 {
2348  self = self->beneath;
2349  return self->to_thread_address_space (self, arg1);
2350 }
2351 
2352 static struct address_space *
2354 {
2355  struct address_space * result;
2356  fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", debug_target.to_shortname);
2357  result = debug_target.to_thread_address_space (&debug_target, arg1);
2358  fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", debug_target.to_shortname);
2360  fputs_unfiltered (", ", gdb_stdlog);
2362  fputs_unfiltered (") = ", gdb_stdlog);
2364  fputs_unfiltered ("\n", gdb_stdlog);
2365  return result;
2366 }
2367 
2368 static int
2370 {
2371  self = self->beneath;
2372  return self->to_filesystem_is_local (self);
2373 }
2374 
2375 static int
2377 {
2378  return 1;
2379 }
2380 
2381 static int
2383 {
2384  int result;
2385  fprintf_unfiltered (gdb_stdlog, "-> %s->to_filesystem_is_local (...)\n", debug_target.to_shortname);
2386  result = debug_target.to_filesystem_is_local (&debug_target);
2387  fprintf_unfiltered (gdb_stdlog, "<- %s->to_filesystem_is_local (", debug_target.to_shortname);
2389  fputs_unfiltered (") = ", gdb_stdlog);
2390  target_debug_print_int (result);
2391  fputs_unfiltered ("\n", gdb_stdlog);
2392  return result;
2393 }
2394 
2395 static void
2397 {
2398  self = self->beneath;
2399  self->to_trace_init (self);
2400 }
2401 
2402 static void
2404 {
2405  tcomplain ();
2406 }
2407 
2408 static void
2410 {
2411  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", debug_target.to_shortname);
2412  debug_target.to_trace_init (&debug_target);
2413  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", debug_target.to_shortname);
2415  fputs_unfiltered (")\n", gdb_stdlog);
2416 }
2417 
2418 static void
2420 {
2421  self = self->beneath;
2422  self->to_download_tracepoint (self, arg1);
2423 }
2424 
2425 static void
2427 {
2428  tcomplain ();
2429 }
2430 
2431 static void
2433 {
2434  fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", debug_target.to_shortname);
2435  debug_target.to_download_tracepoint (&debug_target, arg1);
2436  fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", debug_target.to_shortname);
2438  fputs_unfiltered (", ", gdb_stdlog);
2440  fputs_unfiltered (")\n", gdb_stdlog);
2441 }
2442 
2443 static int
2445 {
2446  self = self->beneath;
2447  return self->to_can_download_tracepoint (self);
2448 }
2449 
2450 static int
2452 {
2453  return 0;
2454 }
2455 
2456 static int
2458 {
2459  int result;
2460  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", debug_target.to_shortname);
2461  result = debug_target.to_can_download_tracepoint (&debug_target);
2462  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", debug_target.to_shortname);
2464  fputs_unfiltered (") = ", gdb_stdlog);
2465  target_debug_print_int (result);
2466  fputs_unfiltered ("\n", gdb_stdlog);
2467  return result;
2468 }
2469 
2470 static void
2472 {
2473  self = self->beneath;
2474  self->to_download_trace_state_variable (self, arg1);
2475 }
2476 
2477 static void
2479 {
2480  tcomplain ();
2481 }
2482 
2483 static void
2485 {
2486  fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", debug_target.to_shortname);
2487  debug_target.to_download_trace_state_variable (&debug_target, arg1);
2488  fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", debug_target.to_shortname);
2490  fputs_unfiltered (", ", gdb_stdlog);
2492  fputs_unfiltered (")\n", gdb_stdlog);
2493 }
2494 
2495 static void
2497 {
2498  self = self->beneath;
2499  self->to_enable_tracepoint (self, arg1);
2500 }
2501 
2502 static void
2504 {
2505  tcomplain ();
2506 }
2507 
2508 static void
2509 debug_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2510 {
2511  fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", debug_target.to_shortname);
2512  debug_target.to_enable_tracepoint (&debug_target, arg1);
2513  fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", debug_target.to_shortname);
2515  fputs_unfiltered (", ", gdb_stdlog);
2517  fputs_unfiltered (")\n", gdb_stdlog);
2518 }
2519 
2520 static void
2522 {
2523  self = self->beneath;
2524  self->to_disable_tracepoint (self, arg1);
2525 }
2526 
2527 static void
2529 {
2530  tcomplain ();
2531 }
2532 
2533 static void
2535 {
2536  fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", debug_target.to_shortname);
2537  debug_target.to_disable_tracepoint (&debug_target, arg1);
2538  fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", debug_target.to_shortname);
2540  fputs_unfiltered (", ", gdb_stdlog);
2542  fputs_unfiltered (")\n", gdb_stdlog);
2543 }
2544 
2545 static void
2547 {
2548  self = self->beneath;
2549  self->to_trace_set_readonly_regions (self);
2550 }
2551 
2552 static void
2554 {
2555  tcomplain ();
2556 }
2557 
2558 static void
2560 {
2561  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", debug_target.to_shortname);
2562  debug_target.to_trace_set_readonly_regions (&debug_target);
2563  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", debug_target.to_shortname);
2565  fputs_unfiltered (")\n", gdb_stdlog);
2566 }
2567 
2568 static void
2570 {
2571  self = self->beneath;
2572  self->to_trace_start (self);
2573 }
2574 
2575 static void
2577 {
2578  tcomplain ();
2579 }
2580 
2581 static void
2583 {
2584  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", debug_target.to_shortname);
2585  debug_target.to_trace_start (&debug_target);
2586  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", debug_target.to_shortname);
2588  fputs_unfiltered (")\n", gdb_stdlog);
2589 }
2590 
2591 static int
2593 {
2594  self = self->beneath;
2595  return self->to_get_trace_status (self, arg1);
2596 }
2597 
2598 static int
2600 {
2601  return -1;
2602 }
2603 
2604 static int
2605 debug_get_trace_status (struct target_ops *self, struct trace_status *arg1)
2606 {
2607  int result;
2608  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", debug_target.to_shortname);
2609  result = debug_target.to_get_trace_status (&debug_target, arg1);
2610  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", debug_target.to_shortname);
2612  fputs_unfiltered (", ", gdb_stdlog);
2614  fputs_unfiltered (") = ", gdb_stdlog);
2615  target_debug_print_int (result);
2616  fputs_unfiltered ("\n", gdb_stdlog);
2617  return result;
2618 }
2619 
2620 static void
2621 delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2622 {
2623  self = self->beneath;
2624  self->to_get_tracepoint_status (self, arg1, arg2);
2625 }
2626 
2627 static void
2628 tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2629 {
2630  tcomplain ();
2631 }
2632 
2633 static void
2634 debug_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2635 {
2636  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", debug_target.to_shortname);
2637  debug_target.to_get_tracepoint_status (&debug_target, arg1, arg2);
2638  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", debug_target.to_shortname);
2640  fputs_unfiltered (", ", gdb_stdlog);
2642  fputs_unfiltered (", ", gdb_stdlog);
2644  fputs_unfiltered (")\n", gdb_stdlog);
2645 }
2646 
2647 static void
2649 {
2650  self = self->beneath;
2651  self->to_trace_stop (self);
2652 }
2653 
2654 static void
2656 {
2657  tcomplain ();
2658 }
2659 
2660 static void
2662 {
2663  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", debug_target.to_shortname);
2664  debug_target.to_trace_stop (&debug_target);
2665  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", debug_target.to_shortname);
2667  fputs_unfiltered (")\n", gdb_stdlog);
2668 }
2669 
2670 static int
2671 delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
2672 {
2673  self = self->beneath;
2674  return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5);
2675 }
2676 
2677 static int
2678 tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
2679 {
2680  return -1;
2681 }
2682 
2683 static int
2684 debug_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
2685 {
2686  int result;
2687  fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", debug_target.to_shortname);
2688  result = debug_target.to_trace_find (&debug_target, arg1, arg2, arg3, arg4, arg5);
2689  fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", debug_target.to_shortname);
2691  fputs_unfiltered (", ", gdb_stdlog);
2693  fputs_unfiltered (", ", gdb_stdlog);
2694  target_debug_print_int (arg2);
2695  fputs_unfiltered (", ", gdb_stdlog);
2697  fputs_unfiltered (", ", gdb_stdlog);
2699  fputs_unfiltered (", ", gdb_stdlog);
2700  target_debug_print_int_p (arg5);
2701  fputs_unfiltered (") = ", gdb_stdlog);
2702  target_debug_print_int (result);
2703  fputs_unfiltered ("\n", gdb_stdlog);
2704  return result;
2705 }
2706 
2707 static int
2709 {
2710  self = self->beneath;
2711  return self->to_get_trace_state_variable_value (self, arg1, arg2);
2712 }
2713 
2714 static int
2716 {
2717  return 0;
2718 }
2719 
2720 static int
2722 {
2723  int result;
2724  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", debug_target.to_shortname);
2725  result = debug_target.to_get_trace_state_variable_value (&debug_target, arg1, arg2);
2726  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", debug_target.to_shortname);
2728  fputs_unfiltered (", ", gdb_stdlog);
2729  target_debug_print_int (arg1);
2730  fputs_unfiltered (", ", gdb_stdlog);
2732  fputs_unfiltered (") = ", gdb_stdlog);
2733  target_debug_print_int (result);
2734  fputs_unfiltered ("\n", gdb_stdlog);
2735  return result;
2736 }
2737 
2738 static int
2739 delegate_save_trace_data (struct target_ops *self, const char *arg1)
2740 {
2741  self = self->beneath;
2742  return self->to_save_trace_data (self, arg1);
2743 }
2744 
2745 static int
2746 tdefault_save_trace_data (struct target_ops *self, const char *arg1)
2747 {
2748  tcomplain ();
2749 }
2750 
2751 static int
2752 debug_save_trace_data (struct target_ops *self, const char *arg1)
2753 {
2754  int result;
2755  fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", debug_target.to_shortname);
2756  result = debug_target.to_save_trace_data (&debug_target, arg1);
2757  fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", debug_target.to_shortname);
2759  fputs_unfiltered (", ", gdb_stdlog);
2761  fputs_unfiltered (") = ", gdb_stdlog);
2762  target_debug_print_int (result);
2763  fputs_unfiltered ("\n", gdb_stdlog);
2764  return result;
2765 }
2766 
2767 static int
2769 {
2770  self = self->beneath;
2771  return self->to_upload_tracepoints (self, arg1);
2772 }
2773 
2774 static int
2776 {
2777  return 0;
2778 }
2779 
2780 static int
2781 debug_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
2782 {
2783  int result;
2784  fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", debug_target.to_shortname);
2785  result = debug_target.to_upload_tracepoints (&debug_target, arg1);
2786  fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", debug_target.to_shortname);
2788  fputs_unfiltered (", ", gdb_stdlog);
2790  fputs_unfiltered (") = ", gdb_stdlog);
2791  target_debug_print_int (result);
2792  fputs_unfiltered ("\n", gdb_stdlog);
2793  return result;
2794 }
2795 
2796 static int
2798 {
2799  self = self->beneath;
2800  return self->to_upload_trace_state_variables (self, arg1);
2801 }
2802 
2803 static int
2805 {
2806  return 0;
2807 }
2808 
2809 static int
2811 {
2812  int result;
2813  fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", debug_target.to_shortname);
2814  result = debug_target.to_upload_trace_state_variables (&debug_target, arg1);
2815  fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", debug_target.to_shortname);
2817  fputs_unfiltered (", ", gdb_stdlog);
2819  fputs_unfiltered (") = ", gdb_stdlog);
2820  target_debug_print_int (result);
2821  fputs_unfiltered ("\n", gdb_stdlog);
2822  return result;
2823 }
2824 
2825 static LONGEST
2827 {
2828  self = self->beneath;
2829  return self->to_get_raw_trace_data (self, arg1, arg2, arg3);
2830 }
2831 
2832 static LONGEST
2834 {
2835  tcomplain ();
2836 }
2837 
2838 static LONGEST
2840 {
2841  LONGEST result;
2842  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", debug_target.to_shortname);
2843  result = debug_target.to_get_raw_trace_data (&debug_target, arg1, arg2, arg3);
2844  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", debug_target.to_shortname);
2846  fputs_unfiltered (", ", gdb_stdlog);
2848  fputs_unfiltered (", ", gdb_stdlog);
2850  fputs_unfiltered (", ", gdb_stdlog);
2852  fputs_unfiltered (") = ", gdb_stdlog);
2853  target_debug_print_LONGEST (result);
2854  fputs_unfiltered ("\n", gdb_stdlog);
2855  return result;
2856 }
2857 
2858 static int
2860 {
2861  self = self->beneath;
2862  return self->to_get_min_fast_tracepoint_insn_len (self);
2863 }
2864 
2865 static int
2867 {
2868  return -1;
2869 }
2870 
2871 static int
2873 {
2874  int result;
2875  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", debug_target.to_shortname);
2876  result = debug_target.to_get_min_fast_tracepoint_insn_len (&debug_target);
2877  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", debug_target.to_shortname);
2879  fputs_unfiltered (") = ", gdb_stdlog);
2880  target_debug_print_int (result);
2881  fputs_unfiltered ("\n", gdb_stdlog);
2882  return result;
2883 }
2884 
2885 static void
2887 {
2888  self = self->beneath;
2889  self->to_set_disconnected_tracing (self, arg1);
2890 }
2891 
2892 static void
2894 {
2895 }
2896 
2897 static void
2899 {
2900  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", debug_target.to_shortname);
2901  debug_target.to_set_disconnected_tracing (&debug_target, arg1);
2902  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", debug_target.to_shortname);
2904  fputs_unfiltered (", ", gdb_stdlog);
2905  target_debug_print_int (arg1);
2906  fputs_unfiltered (")\n", gdb_stdlog);
2907 }
2908 
2909 static void
2911 {
2912  self = self->beneath;
2913  self->to_set_circular_trace_buffer (self, arg1);
2914 }
2915 
2916 static void
2918 {
2919 }
2920 
2921 static void
2923 {
2924  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", debug_target.to_shortname);
2925  debug_target.to_set_circular_trace_buffer (&debug_target, arg1);
2926  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", debug_target.to_shortname);
2928  fputs_unfiltered (", ", gdb_stdlog);
2929  target_debug_print_int (arg1);
2930  fputs_unfiltered (")\n", gdb_stdlog);
2931 }
2932 
2933 static void
2935 {
2936  self = self->beneath;
2937  self->to_set_trace_buffer_size (self, arg1);
2938 }
2939 
2940 static void
2942 {
2943 }
2944 
2945 static void
2947 {
2948  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", debug_target.to_shortname);
2949  debug_target.to_set_trace_buffer_size (&debug_target, arg1);
2950  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", debug_target.to_shortname);
2952  fputs_unfiltered (", ", gdb_stdlog);
2954  fputs_unfiltered (")\n", gdb_stdlog);
2955 }
2956 
2957 static int
2958 delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
2959 {
2960  self = self->beneath;
2961  return self->to_set_trace_notes (self, arg1, arg2, arg3);
2962 }
2963 
2964 static int
2965 tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
2966 {
2967  return 0;
2968 }
2969 
2970 static int
2971 debug_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
2972 {
2973  int result;
2974  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", debug_target.to_shortname);
2975  result = debug_target.to_set_trace_notes (&debug_target, arg1, arg2, arg3);
2976  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", debug_target.to_shortname);
2978  fputs_unfiltered (", ", gdb_stdlog);
2980  fputs_unfiltered (", ", gdb_stdlog);
2982  fputs_unfiltered (", ", gdb_stdlog);
2984  fputs_unfiltered (") = ", gdb_stdlog);
2985  target_debug_print_int (result);
2986  fputs_unfiltered ("\n", gdb_stdlog);
2987  return result;
2988 }
2989 
2990 static int
2992 {
2993  self = self->beneath;
2994  return self->to_core_of_thread (self, arg1);
2995 }
2996 
2997 static int
2999 {
3000  return -1;
3001 }
3002 
3003 static int
3005 {
3006  int result;
3007  fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", debug_target.to_shortname);
3008  result = debug_target.to_core_of_thread (&debug_target, arg1);
3009  fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", debug_target.to_shortname);
3011  fputs_unfiltered (", ", gdb_stdlog);
3013  fputs_unfiltered (") = ", gdb_stdlog);
3014  target_debug_print_int (result);
3015  fputs_unfiltered ("\n", gdb_stdlog);
3016  return result;
3017 }
3018 
3019 static int
3020 delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
3021 {
3022  self = self->beneath;
3023  return self->to_verify_memory (self, arg1, arg2, arg3);
3024 }
3025 
3026 static int
3027 debug_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
3028 {
3029  int result;
3030  fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", debug_target.to_shortname);
3031  result = debug_target.to_verify_memory (&debug_target, arg1, arg2, arg3);
3032  fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", debug_target.to_shortname);
3034  fputs_unfiltered (", ", gdb_stdlog);
3036  fputs_unfiltered (", ", gdb_stdlog);
3038  fputs_unfiltered (", ", gdb_stdlog);
3040  fputs_unfiltered (") = ", gdb_stdlog);
3041  target_debug_print_int (result);
3042  fputs_unfiltered ("\n", gdb_stdlog);
3043  return result;
3044 }
3045 
3046 static int
3048 {
3049  self = self->beneath;
3050  return self->to_get_tib_address (self, arg1, arg2);
3051 }
3052 
3053 static int
3055 {
3056  tcomplain ();
3057 }
3058 
3059 static int
3061 {
3062  int result;
3063  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", debug_target.to_shortname);
3064  result = debug_target.to_get_tib_address (&debug_target, arg1, arg2);
3065  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_address (", debug_target.to_shortname);
3067  fputs_unfiltered (", ", gdb_stdlog);
3069  fputs_unfiltered (", ", gdb_stdlog);
3071  fputs_unfiltered (") = ", gdb_stdlog);
3072  target_debug_print_int (result);
3073  fputs_unfiltered ("\n", gdb_stdlog);
3074  return result;
3075 }
3076 
3077 static void
3079 {
3080  self = self->beneath;
3081  self->to_set_permissions (self);
3082 }
3083 
3084 static void
3086 {
3087 }
3088 
3089 static void
3091 {
3092  fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", debug_target.to_shortname);
3093  debug_target.to_set_permissions (&debug_target);
3094  fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", debug_target.to_shortname);
3096  fputs_unfiltered (")\n", gdb_stdlog);
3097 }
3098 
3099 static int
3101 {
3102  self = self->beneath;
3103  return self->to_static_tracepoint_marker_at (self, arg1, arg2);
3104 }
3105 
3106 static int
3108 {
3109  return 0;
3110 }
3111 
3112 static int
3114 {
3115  int result;
3116  fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", debug_target.to_shortname);
3117  result = debug_target.to_static_tracepoint_marker_at (&debug_target, arg1, arg2);
3118  fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", debug_target.to_shortname);
3120  fputs_unfiltered (", ", gdb_stdlog);
3122  fputs_unfiltered (", ", gdb_stdlog);
3124  fputs_unfiltered (") = ", gdb_stdlog);
3125  target_debug_print_int (result);
3126  fputs_unfiltered ("\n", gdb_stdlog);
3127  return result;
3128 }
3129 
3131 delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
3132 {
3133  self = self->beneath;
3134  return self->to_static_tracepoint_markers_by_strid (self, arg1);
3135 }
3136 
3138 tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
3139 {
3140  tcomplain ();
3141 }
3142 
3144 debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
3145 {
3146  VEC(static_tracepoint_marker_p) * result;
3147  fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", debug_target.to_shortname);
3148  result = debug_target.to_static_tracepoint_markers_by_strid (&debug_target, arg1);
3149  fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", debug_target.to_shortname);
3151  fputs_unfiltered (", ", gdb_stdlog);
3153  fputs_unfiltered (") = ", gdb_stdlog);
3155  fputs_unfiltered ("\n", gdb_stdlog);
3156  return result;
3157 }
3158 
3159 static struct traceframe_info *
3161 {
3162  self = self->beneath;
3163  return self->to_traceframe_info (self);
3164 }
3165 
3166 static struct traceframe_info *
3168 {
3169  tcomplain ();
3170 }
3171 
3172 static struct traceframe_info *
3174 {
3175  struct traceframe_info * result;
3176  fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", debug_target.to_shortname);
3177  result = debug_target.to_traceframe_info (&debug_target);
3178  fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", debug_target.to_shortname);
3180  fputs_unfiltered (") = ", gdb_stdlog);
3182  fputs_unfiltered ("\n", gdb_stdlog);
3183  return result;
3184 }
3185 
3186 static int
3187 delegate_use_agent (struct target_ops *self, int arg1)
3188 {
3189  self = self->beneath;
3190  return self->to_use_agent (self, arg1);
3191 }
3192 
3193 static int
3194 tdefault_use_agent (struct target_ops *self, int arg1)
3195 {
3196  tcomplain ();
3197 }
3198 
3199 static int
3200 debug_use_agent (struct target_ops *self, int arg1)
3201 {
3202  int result;
3203  fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", debug_target.to_shortname);
3204  result = debug_target.to_use_agent (&debug_target, arg1);
3205  fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", debug_target.to_shortname);
3207  fputs_unfiltered (", ", gdb_stdlog);
3208  target_debug_print_int (arg1);
3209  fputs_unfiltered (") = ", gdb_stdlog);
3210  target_debug_print_int (result);
3211  fputs_unfiltered ("\n", gdb_stdlog);
3212  return result;
3213 }
3214 
3215 static int
3217 {
3218  self = self->beneath;
3219  return self->to_can_use_agent (self);
3220 }
3221 
3222 static int
3224 {
3225  return 0;
3226 }
3227 
3228 static int
3230 {
3231  int result;
3232  fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", debug_target.to_shortname);
3233  result = debug_target.to_can_use_agent (&debug_target);
3234  fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", debug_target.to_shortname);
3236  fputs_unfiltered (") = ", gdb_stdlog);
3237  target_debug_print_int (result);
3238  fputs_unfiltered ("\n", gdb_stdlog);
3239  return result;
3240 }
3241 
3242 static int
3244 {
3245  self = self->beneath;
3246  return self->to_supports_btrace (self, arg1);
3247 }
3248 
3249 static int
3251 {
3252  return 0;
3253 }
3254 
3255 static int
3257 {
3258  int result;
3259  fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
3260  result = debug_target.to_supports_btrace (&debug_target, arg1);
3261  fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname);
3263  fputs_unfiltered (", ", gdb_stdlog);
3265  fputs_unfiltered (") = ", gdb_stdlog);
3266  target_debug_print_int (result);
3267  fputs_unfiltered ("\n", gdb_stdlog);
3268  return result;
3269 }
3270 
3271 static struct btrace_target_info *
3272 delegate_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3273 {
3274  self = self->beneath;
3275  return self->to_enable_btrace (self, arg1, arg2);
3276 }
3277 
3278 static struct btrace_target_info *
3279 tdefault_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3280 {
3281  tcomplain ();
3282 }
3283 
3284 static struct btrace_target_info *
3285 debug_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3286 {
3287  struct btrace_target_info * result;
3288  fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname);
3289  result = debug_target.to_enable_btrace (&debug_target, arg1, arg2);
3290  fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname);
3292  fputs_unfiltered (", ", gdb_stdlog);
3294  fputs_unfiltered (", ", gdb_stdlog);
3296  fputs_unfiltered (") = ", gdb_stdlog);
3298  fputs_unfiltered ("\n", gdb_stdlog);
3299  return result;
3300 }
3301 
3302 static void
3304 {
3305  self = self->beneath;
3306  self->to_disable_btrace (self, arg1);
3307 }
3308 
3309 static void
3311 {
3312  tcomplain ();
3313 }
3314 
3315 static void
3317 {
3318  fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname);
3319  debug_target.to_disable_btrace (&debug_target, arg1);
3320  fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname);
3322  fputs_unfiltered (", ", gdb_stdlog);
3324  fputs_unfiltered (")\n", gdb_stdlog);
3325 }
3326 
3327 static void
3329 {
3330  self = self->beneath;
3331  self->to_teardown_btrace (self, arg1);
3332 }
3333 
3334 static void
3336 {
3337  tcomplain ();
3338 }
3339 
3340 static void
3342 {
3343  fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname);
3344  debug_target.to_teardown_btrace (&debug_target, arg1);
3345  fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname);
3347  fputs_unfiltered (", ", gdb_stdlog);
3349  fputs_unfiltered (")\n", gdb_stdlog);
3350 }
3351 
3352 static enum btrace_error
3353 delegate_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3354 {
3355  self = self->beneath;
3356  return self->to_read_btrace (self, arg1, arg2, arg3);
3357 }
3358 
3359 static enum btrace_error
3360 tdefault_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3361 {
3362  tcomplain ();
3363 }
3364 
3365 static enum btrace_error
3366 debug_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3367 {
3368  enum btrace_error result;
3369  fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname);
3370  result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3);
3371  fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname);
3373  fputs_unfiltered (", ", gdb_stdlog);
3375  fputs_unfiltered (", ", gdb_stdlog);
3377  fputs_unfiltered (", ", gdb_stdlog);
3379  fputs_unfiltered (") = ", gdb_stdlog);
3381  fputs_unfiltered ("\n", gdb_stdlog);
3382  return result;
3383 }
3384 
3385 static const struct btrace_config *
3386 delegate_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3387 {
3388  self = self->beneath;
3389  return self->to_btrace_conf (self, arg1);
3390 }
3391 
3392 static const struct btrace_config *
3393 tdefault_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3394 {
3395  return NULL;
3396 }
3397 
3398 static const struct btrace_config *
3399 debug_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3400 {
3401  const struct btrace_config * result;
3402  fprintf_unfiltered (gdb_stdlog, "-> %s->to_btrace_conf (...)\n", debug_target.to_shortname);
3403  result = debug_target.to_btrace_conf (&debug_target, arg1);
3404  fprintf_unfiltered (gdb_stdlog, "<- %s->to_btrace_conf (", debug_target.to_shortname);
3406  fputs_unfiltered (", ", gdb_stdlog);
3408  fputs_unfiltered (") = ", gdb_stdlog);
3410  fputs_unfiltered ("\n", gdb_stdlog);
3411  return result;
3412 }
3413 
3414 static void
3416 {
3417  self = self->beneath;
3418  self->to_stop_recording (self);
3419 }
3420 
3421 static void
3423 {
3424 }
3425 
3426 static void
3428 {
3429  fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname);
3430  debug_target.to_stop_recording (&debug_target);
3431  fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname);
3433  fputs_unfiltered (")\n", gdb_stdlog);
3434 }
3435 
3436 static void
3438 {
3439  self = self->beneath;
3440  self->to_info_record (self);
3441 }
3442 
3443 static void
3445 {
3446 }
3447 
3448 static void
3450 {
3451  fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", debug_target.to_shortname);
3452  debug_target.to_info_record (&debug_target);
3453  fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", debug_target.to_shortname);
3455  fputs_unfiltered (")\n", gdb_stdlog);
3456 }
3457 
3458 static void
3459 delegate_save_record (struct target_ops *self, const char *arg1)
3460 {
3461  self = self->beneath;
3462  self->to_save_record (self, arg1);
3463 }
3464 
3465 static void
3466 tdefault_save_record (struct target_ops *self, const char *arg1)
3467 {
3468  tcomplain ();
3469 }
3470 
3471 static void
3472 debug_save_record (struct target_ops *self, const char *arg1)
3473 {
3474  fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname);
3475  debug_target.to_save_record (&debug_target, arg1);
3476  fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", debug_target.to_shortname);
3478  fputs_unfiltered (", ", gdb_stdlog);
3480  fputs_unfiltered (")\n", gdb_stdlog);
3481 }
3482 
3483 static void
3485 {
3486  self = self->beneath;
3487  self->to_delete_record (self);
3488 }
3489 
3490 static void
3492 {
3493  tcomplain ();
3494 }
3495 
3496 static void
3498 {
3499  fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname);
3500  debug_target.to_delete_record (&debug_target);
3501  fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname);
3503  fputs_unfiltered (")\n", gdb_stdlog);
3504 }
3505 
3506 static int
3508 {
3509  self = self->beneath;
3510  return self->to_record_is_replaying (self);
3511 }
3512 
3513 static int
3515 {
3516  return 0;
3517 }
3518 
3519 static int
3521 {
3522  int result;
3523  fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
3524  result = debug_target.to_record_is_replaying (&debug_target);
3525  fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
3527  fputs_unfiltered (") = ", gdb_stdlog);
3528  target_debug_print_int (result);
3529  fputs_unfiltered ("\n", gdb_stdlog);
3530  return result;
3531 }
3532 
3533 static void
3535 {
3536  self = self->beneath;
3537  self->to_goto_record_begin (self);
3538 }
3539 
3540 static void
3542 {
3543  tcomplain ();
3544 }
3545 
3546 static void
3548 {
3549  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname);
3550  debug_target.to_goto_record_begin (&debug_target);
3551  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname);
3553  fputs_unfiltered (")\n", gdb_stdlog);
3554 }
3555 
3556 static void
3558 {
3559  self = self->beneath;
3560  self->to_goto_record_end (self);
3561 }
3562 
3563 static void
3565 {
3566  tcomplain ();
3567 }
3568 
3569 static void
3571 {
3572  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname);
3573  debug_target.to_goto_record_end (&debug_target);
3574  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname);
3576  fputs_unfiltered (")\n", gdb_stdlog);
3577 }
3578 
3579 static void
3581 {
3582  self = self->beneath;
3583  self->to_goto_record (self, arg1);
3584 }
3585 
3586 static void
3588 {
3589  tcomplain ();
3590 }
3591 
3592 static void
3594 {
3595  fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname);
3596  debug_target.to_goto_record (&debug_target, arg1);
3597  fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname);
3599  fputs_unfiltered (", ", gdb_stdlog);
3601  fputs_unfiltered (")\n", gdb_stdlog);
3602 }
3603 
3604 static void
3605 delegate_insn_history (struct target_ops *self, int arg1, int arg2)
3606 {
3607  self = self->beneath;
3608  self->to_insn_history (self, arg1, arg2);
3609 }
3610 
3611 static void
3612 tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
3613 {
3614  tcomplain ();
3615 }
3616 
3617 static void
3618 debug_insn_history (struct target_ops *self, int arg1, int arg2)
3619 {
3620  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
3621  debug_target.to_insn_history (&debug_target, arg1, arg2);
3622  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", debug_target.to_shortname);
3624  fputs_unfiltered (", ", gdb_stdlog);
3625  target_debug_print_int (arg1);
3626  fputs_unfiltered (", ", gdb_stdlog);
3627  target_debug_print_int (arg2);
3628  fputs_unfiltered (")\n", gdb_stdlog);
3629 }
3630 
3631 static void
3632 delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3633 {
3634  self = self->beneath;
3635  self->to_insn_history_from (self, arg1, arg2, arg3);
3636 }
3637 
3638 static void
3639 tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3640 {
3641  tcomplain ();
3642 }
3643 
3644 static void
3645 debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3646 {
3647  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname);
3648  debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3);
3649  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", debug_target.to_shortname);
3651  fputs_unfiltered (", ", gdb_stdlog);
3653  fputs_unfiltered (", ", gdb_stdlog);
3654  target_debug_print_int (arg2);
3655  fputs_unfiltered (", ", gdb_stdlog);
3656  target_debug_print_int (arg3);
3657  fputs_unfiltered (")\n", gdb_stdlog);
3658 }
3659 
3660 static void
3661 delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3662 {
3663  self = self->beneath;
3664  self->to_insn_history_range (self, arg1, arg2, arg3);
3665 }
3666 
3667 static void
3668 tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3669 {
3670  tcomplain ();
3671 }
3672 
3673 static void
3674 debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3675 {
3676  fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname);
3677  debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3);
3678  fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", debug_target.to_shortname);
3680  fputs_unfiltered (", ", gdb_stdlog);
3682  fputs_unfiltered (", ", gdb_stdlog);
3684  fputs_unfiltered (", ", gdb_stdlog);
3685  target_debug_print_int (arg3);
3686  fputs_unfiltered (")\n", gdb_stdlog);
3687 }
3688 
3689 static void
3690 delegate_call_history (struct target_ops *self, int arg1, int arg2)
3691 {
3692  self = self->beneath;
3693  self->to_call_history (self, arg1, arg2);
3694 }
3695 
3696 static void
3697 tdefault_call_history (struct target_ops *self, int arg1, int arg2)
3698 {
3699  tcomplain ();
3700 }
3701 
3702 static void
3703 debug_call_history (struct target_ops *self, int arg1, int arg2)
3704 {
3705  fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
3706  debug_target.to_call_history (&debug_target, arg1, arg2);
3707  fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", debug_target.to_shortname);
3709  fputs_unfiltered (", ", gdb_stdlog);
3710  target_debug_print_int (arg1);
3711  fputs_unfiltered (", ", gdb_stdlog);
3712  target_debug_print_int (arg2);
3713  fputs_unfiltered (")\n", gdb_stdlog);
3714 }
3715 
3716 static void
3717 delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3718 {
3719  self = self->beneath;
3720  self->to_call_history_from (self, arg1, arg2, arg3);
3721 }
3722 
3723 static void
3724 tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3725 {
3726  tcomplain ();
3727 }
3728 
3729 static void
3730 debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3731 {
3732  fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname);
3733  debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3);
3734  fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", debug_target.to_shortname);
3736  fputs_unfiltered (", ", gdb_stdlog);
3738  fputs_unfiltered (", ", gdb_stdlog);
3739  target_debug_print_int (arg2);
3740  fputs_unfiltered (", ", gdb_stdlog);
3741  target_debug_print_int (arg3);
3742  fputs_unfiltered (")\n", gdb_stdlog);
3743 }
3744 
3745 static void
3746 delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3747 {
3748  self = self->beneath;
3749  self->to_call_history_range (self, arg1, arg2, arg3);
3750 }
3751 
3752 static void
3753 tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3754 {
3755  tcomplain ();
3756 }
3757 
3758 static void
3759 debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3760 {
3761  fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname);
3762  debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3);
3763  fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", debug_target.to_shortname);
3765  fputs_unfiltered (", ", gdb_stdlog);
3767  fputs_unfiltered (", ", gdb_stdlog);
3769  fputs_unfiltered (", ", gdb_stdlog);
3770  target_debug_print_int (arg3);
3771  fputs_unfiltered (")\n", gdb_stdlog);
3772 }
3773 
3774 static int
3776 {
3777  self = self->beneath;
3778  return self->to_augmented_libraries_svr4_read (self);
3779 }
3780 
3781 static int
3783 {
3784  return 0;
3785 }
3786 
3787 static int
3789 {
3790  int result;
3791  fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname);
3792  result = debug_target.to_augmented_libraries_svr4_read (&debug_target);
3793  fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", debug_target.to_shortname);
3795  fputs_unfiltered (") = ", gdb_stdlog);
3796  target_debug_print_int (result);
3797  fputs_unfiltered ("\n", gdb_stdlog);
3798  return result;
3799 }
3800 
3801 static const struct frame_unwind *
3803 {
3804  self = self->beneath;
3805  return self->to_get_unwinder (self);
3806 }
3807 
3808 static const struct frame_unwind *
3810 {
3811  return NULL;
3812 }
3813 
3814 static const struct frame_unwind *
3816 {
3817  const struct frame_unwind * result;
3818  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname);
3819  result = debug_target.to_get_unwinder (&debug_target);
3820  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname);
3822  fputs_unfiltered (") = ", gdb_stdlog);
3824  fputs_unfiltered ("\n", gdb_stdlog);
3825  return result;
3826 }
3827 
3828 static const struct frame_unwind *
3830 {
3831  self = self->beneath;
3832  return self->to_get_tailcall_unwinder (self);
3833 }
3834 
3835 static const struct frame_unwind *
3837 {
3838  return NULL;
3839 }
3840 
3841 static const struct frame_unwind *
3843 {
3844  const struct frame_unwind * result;
3845  fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname);
3846  result = debug_target.to_get_tailcall_unwinder (&debug_target);
3847  fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname);
3849  fputs_unfiltered (") = ", gdb_stdlog);
3851  fputs_unfiltered ("\n", gdb_stdlog);
3852  return result;
3853 }
3854 
3855 static void
3857 {
3858  self = self->beneath;
3859  self->to_prepare_to_generate_core (self);
3860 }
3861 
3862 static void
3864 {
3865 }
3866 
3867 static void
3869 {
3870  fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", debug_target.to_shortname);
3871  debug_target.to_prepare_to_generate_core (&debug_target);
3872  fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", debug_target.to_shortname);
3874  fputs_unfiltered (")\n", gdb_stdlog);
3875 }
3876 
3877 static void
3879 {
3880  self = self->beneath;
3881  self->to_done_generating_core (self);
3882 }
3883 
3884 static void
3886 {
3887 }
3888 
3889 static void
3891 {
3892  fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", debug_target.to_shortname);
3893  debug_target.to_done_generating_core (&debug_target);
3894  fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", debug_target.to_shortname);
3896  fputs_unfiltered (")\n", gdb_stdlog);
3897 }
3898 
3899 static void
3901 {
3902  if (ops->to_post_attach == NULL)
3904  if (ops->to_detach == NULL)
3905  ops->to_detach = delegate_detach;
3906  if (ops->to_disconnect == NULL)
3908  if (ops->to_resume == NULL)
3909  ops->to_resume = delegate_resume;
3910  if (ops->to_wait == NULL)
3911  ops->to_wait = delegate_wait;
3912  if (ops->to_fetch_registers == NULL)
3914  if (ops->to_store_registers == NULL)
3916  if (ops->to_prepare_to_store == NULL)
3918  if (ops->to_files_info == NULL)
3920  if (ops->to_insert_breakpoint == NULL)
3922  if (ops->to_remove_breakpoint == NULL)
3924  if (ops->to_stopped_by_sw_breakpoint == NULL)
3926  if (ops->to_supports_stopped_by_sw_breakpoint == NULL)
3928  if (ops->to_stopped_by_hw_breakpoint == NULL)
3930  if (ops->to_supports_stopped_by_hw_breakpoint == NULL)
3932  if (ops->to_can_use_hw_breakpoint == NULL)
3934  if (ops->to_ranged_break_num_registers == NULL)
3936  if (ops->to_insert_hw_breakpoint == NULL)
3938  if (ops->to_remove_hw_breakpoint == NULL)
3940  if (ops->to_remove_watchpoint == NULL)
3942  if (ops->to_insert_watchpoint == NULL)
3944  if (ops->to_insert_mask_watchpoint == NULL)
3946  if (ops->to_remove_mask_watchpoint == NULL)
3948  if (ops->to_stopped_by_watchpoint == NULL)
3950  if (ops->to_stopped_data_address == NULL)
3952  if (ops->to_watchpoint_addr_within_range == NULL)
3954  if (ops->to_region_ok_for_hw_watchpoint == NULL)
3956  if (ops->to_can_accel_watchpoint_condition == NULL)
3958  if (ops->to_masked_watch_num_registers == NULL)
3960  if (ops->to_terminal_init == NULL)
3962  if (ops->to_terminal_inferior == NULL)
3964  if (ops->to_terminal_ours_for_output == NULL)
3966  if (ops->to_terminal_ours == NULL)
3968  if (ops->to_terminal_info == NULL)
3970  if (ops->to_kill == NULL)
3971  ops->to_kill = delegate_kill;
3972  if (ops->to_load == NULL)
3973  ops->to_load = delegate_load;
3974  if (ops->to_post_startup_inferior == NULL)
3976  if (ops->to_insert_fork_catchpoint == NULL)
3978  if (ops->to_remove_fork_catchpoint == NULL)
3980  if (ops->to_insert_vfork_catchpoint == NULL)
3982  if (ops->to_remove_vfork_catchpoint == NULL)
3984  if (ops->to_follow_fork == NULL)
3986  if (ops->to_insert_exec_catchpoint == NULL)
3988  if (ops->to_remove_exec_catchpoint == NULL)
3990  if (ops->to_set_syscall_catchpoint == NULL)
3992  if (ops->to_has_exited == NULL)
3994  if (ops->to_mourn_inferior == NULL)
3996  if (ops->to_can_run == NULL)
3998  if (ops->to_pass_signals == NULL)
4000  if (ops->to_program_signals == NULL)
4002  if (ops->to_thread_alive == NULL)
4004  if (ops->to_update_thread_list == NULL)
4006  if (ops->to_pid_to_str == NULL)
4008  if (ops->to_extra_thread_info == NULL)
4010  if (ops->to_thread_name == NULL)
4012  if (ops->to_stop == NULL)
4013  ops->to_stop = delegate_stop;
4014  if (ops->to_check_pending_interrupt == NULL)
4016  if (ops->to_rcmd == NULL)
4017  ops->to_rcmd = delegate_rcmd;
4018  if (ops->to_pid_to_exec_file == NULL)
4020  if (ops->to_log_command == NULL)
4022  if (ops->to_get_section_table == NULL)
4024  if (ops->to_can_async_p == NULL)
4026  if (ops->to_is_async_p == NULL)
4028  if (ops->to_async == NULL)
4029  ops->to_async = delegate_async;
4030  if (ops->to_supports_non_stop == NULL)
4032  if (ops->to_find_memory_regions == NULL)
4034  if (ops->to_make_corefile_notes == NULL)
4036  if (ops->to_get_bookmark == NULL)
4038  if (ops->to_goto_bookmark == NULL)
4040  if (ops->to_get_thread_local_address == NULL)
4042  if (ops->to_xfer_partial == NULL)
4044  if (ops->to_memory_map == NULL)
4045  ops->to_memory_map = delegate_memory_map;
4046  if (ops->to_flash_erase == NULL)
4048  if (ops->to_flash_done == NULL)
4050  if (ops->to_read_description == NULL)
4052  if (ops->to_get_ada_task_ptid == NULL)
4054  if (ops->to_auxv_parse == NULL)
4056  if (ops->to_search_memory == NULL)
4058  if (ops->to_can_execute_reverse == NULL)
4060  if (ops->to_execution_direction == NULL)
4062  if (ops->to_supports_multi_process == NULL)
4064  if (ops->to_supports_enable_disable_tracepoint == NULL)
4066  if (ops->to_supports_string_tracing == NULL)
4070  if (ops->to_can_run_breakpoint_commands == NULL)
4072  if (ops->to_thread_architecture == NULL)
4074  if (ops->to_thread_address_space == NULL)
4076  if (ops->to_filesystem_is_local == NULL)
4078  if (ops->to_trace_init == NULL)
4080  if (ops->to_download_tracepoint == NULL)
4082  if (ops->to_can_download_tracepoint == NULL)
4084  if (ops->to_download_trace_state_variable == NULL)
4086  if (ops->to_enable_tracepoint == NULL)
4088  if (ops->to_disable_tracepoint == NULL)
4090  if (ops->to_trace_set_readonly_regions == NULL)
4092  if (ops->to_trace_start == NULL)
4094  if (ops->to_get_trace_status == NULL)
4096  if (ops->to_get_tracepoint_status == NULL)
4098  if (ops->to_trace_stop == NULL)
4100  if (ops->to_trace_find == NULL)
4102  if (ops->to_get_trace_state_variable_value == NULL)
4104  if (ops->to_save_trace_data == NULL)
4106  if (ops->to_upload_tracepoints == NULL)
4108  if (ops->to_upload_trace_state_variables == NULL)
4110  if (ops->to_get_raw_trace_data == NULL)
4112  if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
4114  if (ops->to_set_disconnected_tracing == NULL)
4116  if (ops->to_set_circular_trace_buffer == NULL)
4118  if (ops->to_set_trace_buffer_size == NULL)
4120  if (ops->to_set_trace_notes == NULL)
4122  if (ops->to_core_of_thread == NULL)
4124  if (ops->to_verify_memory == NULL)
4126  if (ops->to_get_tib_address == NULL)
4128  if (ops->to_set_permissions == NULL)
4130  if (ops->to_static_tracepoint_marker_at == NULL)
4132  if (ops->to_static_tracepoint_markers_by_strid == NULL)
4133  ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
4134  if (ops->to_traceframe_info == NULL)
4136  if (ops->to_use_agent == NULL)
4138  if (ops->to_can_use_agent == NULL)
4140  if (ops->to_supports_btrace == NULL)
4142  if (ops->to_enable_btrace == NULL)
4144  if (ops->to_disable_btrace == NULL)
4146  if (ops->to_teardown_btrace == NULL)
4148  if (ops->to_read_btrace == NULL)
4150  if (ops->to_btrace_conf == NULL)
4152  if (ops->to_stop_recording == NULL)
4154  if (ops->to_info_record == NULL)
4156  if (ops->to_save_record == NULL)
4158  if (ops->to_delete_record == NULL)
4160  if (ops->to_record_is_replaying == NULL)
4162  if (ops->to_goto_record_begin == NULL)
4164  if (ops->to_goto_record_end == NULL)
4166  if (ops->to_goto_record == NULL)
4168  if (ops->to_insn_history == NULL)
4170  if (ops->to_insn_history_from == NULL)
4172  if (ops->to_insn_history_range == NULL)
4174  if (ops->to_call_history == NULL)
4176  if (ops->to_call_history_from == NULL)
4178  if (ops->to_call_history_range == NULL)
4180  if (ops->to_augmented_libraries_svr4_read == NULL)
4182  if (ops->to_get_unwinder == NULL)
4184  if (ops->to_get_tailcall_unwinder == NULL)
4186  if (ops->to_prepare_to_generate_core == NULL)
4188  if (ops->to_done_generating_core == NULL)
4190 }
4191 
4192 static void
4194 {
4196  ops->to_detach = tdefault_detach;
4198  ops->to_resume = tdefault_resume;
4199  ops->to_wait = tdefault_wait;
4229  ops->to_kill = tdefault_kill;
4230  ops->to_load = tdefault_load;
4250  ops->to_stop = tdefault_stop;
4252  ops->to_rcmd = default_rcmd;
4258  ops->to_async = tdefault_async;
4266  ops->to_memory_map = tdefault_memory_map;
4310  ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
4339 }
4340 
4341 static void
4343 {
4345  ops->to_detach = debug_detach;
4347  ops->to_resume = debug_resume;
4348  ops->to_wait = debug_wait;
4378  ops->to_kill = debug_kill;
4379  ops->to_load = debug_load;
4391  ops->to_can_run = debug_can_run;
4399  ops->to_stop = debug_stop;
4401  ops->to_rcmd = debug_rcmd;
4407  ops->to_async = debug_async;
4415  ops->to_memory_map = debug_memory_map;
4459  ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid;
4488 }
static char * delegate_extra_thread_info(struct target_ops *self, struct thread_info *arg1)
static int tdefault_has_exited(struct target_ops *self, int arg1, int arg2, int *arg3)
static int tdefault_get_tib_address(struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
struct address_space *(* to_thread_address_space)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_thread_address_space)
Definition: target.h:854
static int delegate_stopped_by_watchpoint(struct target_ops *self)
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)
static int debug_can_async_p(struct target_ops *self)
static ptid_t tdefault_wait(struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
static int tdefault_insert_fork_catchpoint(struct target_ops *self, int arg1)
static void debug_insn_history_from(struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
static int debug_verify_memory(struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
static void debug_delete_record(struct target_ops *self)
static char * tdefault_extra_thread_info(struct target_ops *self, struct thread_info *arg1)
static void debug_done_generating_core(struct target_ops *self)
static void delegate_disable_tracepoint(struct target_ops *self, struct bp_location *arg1)
static const struct frame_unwind * delegate_get_tailcall_unwinder(struct target_ops *self)
static void debug_pass_signals(struct target_ops *self, int arg1, unsigned char *arg2)
static void tdefault_resume(struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
static void delegate_prepare_to_generate_core(struct target_ops *self)
static int delegate_remove_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
void(* to_delete_record)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1142
static int delegate_insert_vfork_catchpoint(struct target_ops *self, int arg1)
static int tdefault_thread_alive(struct target_ops *self, ptid_t arg1)
static int tdefault_get_trace_status(struct target_ops *self, struct trace_status *arg1)
int(* to_supports_stopped_by_hw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:513
const struct target_desc *(* to_read_description)(struct target_ops *ops) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:769
int(* to_is_async_p)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:662
static void tdefault_load(struct target_ops *self, const char *arg1, int arg2)
static char * debug_make_corefile_notes(struct target_ops *self, bfd *arg1, int *arg2)
int(* to_upload_tracepoints)(struct target_ops *, struct uploaded_tp **utpp) TARGET_DEFAULT_RETURN(0)
Definition: target.h:999
void(* to_trace_init)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:928
static int tdefault_insert_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
int(* to_supports_evaluation_of_breakpoint_conditions)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:829
static void delegate_insn_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
void(* to_program_signals)(struct target_ops *, int, unsigned char *TARGET_DEBUG_PRINTER(target_debug_print_signals)) TARGET_DEFAULT_IGNORE()
Definition: target.h:623
void(* to_goto_bookmark)(struct target_ops *, const gdb_byte *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:681
static struct address_space * delegate_thread_address_space(struct target_ops *self, ptid_t arg1)
static void install_dummy_methods(struct target_ops *ops)
static int tdefault_remove_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
void(* to_goto_record_begin)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1150
static int tdefault_insert_exec_catchpoint(struct target_ops *self, int arg1)
static int delegate_supports_enable_disable_tracepoint(struct target_ops *self)
static void tdefault_goto_record(struct target_ops *self, ULONGEST arg1)
static int tdefault_record_is_replaying(struct target_ops *self)
static int tdefault_filesystem_is_local(struct target_ops *self)
static int tdefault_get_trace_state_variable_value(struct target_ops *self, int arg1, LONGEST *arg2)
void(* to_save_record)(struct target_ops *, const char *filename) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1137
static int debug_supports_enable_disable_tracepoint(struct target_ops *self)
static void tdefault_program_signals(struct target_ops *self, int arg1, unsigned char *arg2)
#define target_debug_print_struct_breakpoint_p(X)
Definition: target-debug.h:129
static void debug_call_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
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:671
bfd_vma CORE_ADDR
Definition: common-types.h:41
static void tdefault_post_startup_inferior(struct target_ops *self, ptid_t arg1)
static struct target_section_table * debug_get_section_table(struct target_ops *self)
static void debug_post_startup_inferior(struct target_ops *self, ptid_t arg1)
static int delegate_get_trace_status(struct target_ops *self, struct trace_status *arg1)
static void delegate_program_signals(struct target_ops *self, int arg1, unsigned char *arg2)
static int tdefault_static_tracepoint_marker_at(struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
static int tdefault_remove_exec_catchpoint(struct target_ops *self, int arg1)
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
#define target_debug_print_struct_bp_target_info_p(X)
Definition: target-debug.h:93
static void debug_stop_recording(struct target_ops *self)
static LONGEST delegate_get_raw_trace_data(struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
static void debug_terminal_ours(struct target_ops *self)
static void debug_prepare_to_generate_core(struct target_ops *self)
static void debug_disable_btrace(struct target_ops *self, struct btrace_target_info *arg1)
static int debug_ranged_break_num_registers(struct target_ops *self)
static int delegate_can_accel_watchpoint_condition(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
static int tdefault_get_min_fast_tracepoint_insn_len(struct target_ops *self)
static void debug_goto_record_end(struct target_ops *self)
static void tdefault_detach(struct target_ops *self, const char *arg1, int arg2)
static int debug_remove_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
#define target_debug_print_struct_bp_location_p(X)
Definition: target-debug.h:123
static void tdefault_insn_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
static void debug_load(struct target_ops *self, const char *arg1, int arg2)
static void debug_log_command(struct target_ops *self, const char *arg1)
static int debug_has_exited(struct target_ops *self, int arg1, int arg2, int *arg3)
static int delegate_remove_vfork_catchpoint(struct target_ops *self, int arg1)
static int delegate_save_trace_data(struct target_ops *self, const char *arg1)
static void debug_post_attach(struct target_ops *self, int arg1)
void(* to_trace_start)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:963
char *(* to_pid_to_str)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_pid_to_str)
Definition: target.h:631
static int delegate_supports_string_tracing(struct target_ops *self)
void(* to_flash_done)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:762
#define target_debug_print_struct_trace_state_variable_p(X)
Definition: target-debug.h:125
static void delegate_flash_erase(struct target_ops *self, ULONGEST arg1, LONGEST arg2)
static int delegate_insert_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
void(* to_stop_recording)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1129
#define target_debug_print_enum_target_xfer_status(X)
Definition: target-debug.h:61
static char * debug_pid_to_str(struct target_ops *self, ptid_t arg1)
static int debug_remove_vfork_catchpoint(struct target_ops *self, int arg1)
static enum exec_direction_kind debug_execution_direction(struct target_ops *self)
static int debug_follow_fork(struct target_ops *self, int arg1, int arg2)
static struct gdbarch * debug_thread_architecture(struct target_ops *self, ptid_t arg1)
#define target_debug_print_ptid_t(X)
Definition: target-debug.h:71
static void delegate_download_tracepoint(struct target_ops *self, struct bp_location *arg1)
static ptid_t default_get_ada_task_ptid(struct target_ops *self, long lwp, long tid)
Definition: target.c:588
void(* to_terminal_init)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:565
#define target_debug_print_char_p(X)
Definition: target-debug.h:55
static int delegate_has_exited(struct target_ops *self, int arg1, int arg2, int *arg3)
int(* to_has_exited)(struct target_ops *, int, int, int *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:605
static int debug_supports_evaluation_of_breakpoint_conditions(struct target_ops *self)
int(* to_insert_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_insert_breakpoint)
Definition: target.h:481
static void tdefault_trace_start(struct target_ops *self)
static void delegate_set_permissions(struct target_ops *self)
static void delegate_terminal_info(struct target_ops *self, const char *arg1, int arg2)
char *(* to_extra_thread_info)(struct target_ops *, struct thread_info *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:633
static void delegate_fetch_registers(struct target_ops *self, struct regcache *arg1, int arg2)
static void delegate_insn_history_from(struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
void(* to_rcmd)(struct target_ops *, const char *command, struct ui_file *output) TARGET_DEFAULT_FUNC(default_rcmd)
Definition: target.h:641
#define target_debug_print_gdb_byte_pp(X)
Definition: target-debug.h:79
static int tdefault_remove_fork_catchpoint(struct target_ops *self, int arg1)
static void delegate_call_history_from(struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
static void tdefault_get_tracepoint_status(struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
void(* to_insn_history_from)(struct target_ops *, ULONGEST from, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1172
int(* to_core_of_thread)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:1042
#define target_debug_print_struct_expression_p(X)
Definition: target-debug.h:95
int(* to_follow_fork)(struct target_ops *, int, int) TARGET_DEFAULT_FUNC(default_follow_fork)
Definition: target.h:596
static int debug_get_trace_state_variable_value(struct target_ops *self, int arg1, LONGEST *arg2)
void(* to_terminal_ours_for_output)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:569
static void delegate_download_trace_state_variable(struct target_ops *self, struct trace_state_variable *arg1)
static void tdefault_goto_record_begin(struct target_ops *self)
void(* to_call_history)(struct target_ops *, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1185
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)
#define target_debug_print_enum_gdb_signal(X)
Definition: target-debug.h:81
static void delegate_done_generating_core(struct target_ops *self)
static void debug_trace_set_readonly_regions(struct target_ops *self)
static int debug_upload_trace_state_variables(struct target_ops *self, struct uploaded_tsv **arg1)
static int debug_upload_tracepoints(struct target_ops *self, struct uploaded_tp **arg1)
static void tdefault_stop(struct target_ops *self, ptid_t arg1)
static int tdefault_insert_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
#define target_debug_print_struct_btrace_data_p(X)
Definition: target-debug.h:147
static LONGEST debug_get_raw_trace_data(struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
static int tdefault_remove_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
static const struct btrace_config * delegate_btrace_conf(struct target_ops *self, const struct btrace_target_info *arg1)
static void tdefault_disconnect(struct target_ops *self, const char *arg1, int arg2)
static void tdefault_prepare_to_store(struct target_ops *self, struct regcache *arg1)
static void debug_program_signals(struct target_ops *self, int arg1, unsigned char *arg2)
#define target_debug_print_int(X)
Definition: target-debug.h:57
static int tdefault_can_use_hw_breakpoint(struct target_ops *self, int arg1, int arg2, int arg3)
const struct frame_unwind *(* to_get_tailcall_unwinder)(struct target_ops *self) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:1213
static int debug_find_memory_regions(struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
static ptid_t delegate_get_ada_task_ptid(struct target_ops *self, long arg1, long arg2)
static void delegate_stop(struct target_ops *self, ptid_t arg1)
static int tdefault_upload_tracepoints(struct target_ops *self, struct uploaded_tp **arg1)
#define target_debug_print_struct_address_space_p(X)
Definition: target-debug.h:91
static int tdefault_stopped_by_sw_breakpoint(struct target_ops *self)
void(* to_set_disconnected_tracing)(struct target_ops *, int val) TARGET_DEFAULT_IGNORE()
Definition: target.h:1020
void(* to_check_pending_interrupt)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:639
static int debug_supports_string_tracing(struct target_ops *self)
int(* to_remove_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_FUNC(memory_remove_breakpoint)
Definition: target.h:484
#define target_debug_print_CORE_ADDR(X)
Definition: target-debug.h:51
static int delegate_can_run_breakpoint_commands(struct target_ops *self)
int(* to_supports_enable_disable_tracepoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:817
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:554
ptid_t(* to_wait)(struct target_ops *, ptid_t, struct target_waitstatus *, int TARGET_DEBUG_PRINTER(target_debug_print_options)) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:468
void(* to_info_record)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1133
static int debug_can_execute_reverse(struct target_ops *self)
static void tdefault_flash_erase(struct target_ops *self, ULONGEST arg1, LONGEST arg2)
static void delegate_log_command(struct target_ops *self, const char *arg1)
static void debug_disable_tracepoint(struct target_ops *self, struct bp_location *arg1)
static int delegate_stopped_data_address(struct target_ops *self, CORE_ADDR *arg1)
static ptid_t debug_wait(struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
static void debug_get_tracepoint_status(struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
static int debug_watchpoint_addr_within_range(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
void(* to_trace_stop)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:976
static void tdefault_trace_init(struct target_ops *self)
static int tdefault_supports_evaluation_of_breakpoint_conditions(struct target_ops *self)
static int default_follow_fork(struct target_ops *self, int follow_child, int detach_fork)
Definition: target.c:2274
int(* to_supports_string_tracing)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:824
static void debug_flash_erase(struct target_ops *self, ULONGEST arg1, LONGEST arg2)
static int delegate_get_min_fast_tracepoint_insn_len(struct target_ops *self)
static char * default_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: target.c:3216
btrace_format
Definition: btrace-common.h:54
static gdb_byte * tdefault_get_bookmark(struct target_ops *self, const char *arg1, int arg2)
void(* to_set_trace_buffer_size)(struct target_ops *, LONGEST val) TARGET_DEFAULT_IGNORE()
Definition: target.h:1025
static void delegate_stop_recording(struct target_ops *self)
static int tdefault_can_run_breakpoint_commands(struct target_ops *self)
static int tdefault_supports_btrace(struct target_ops *self, enum btrace_format arg1)
static void debug_stop(struct target_ops *self, ptid_t arg1)
int(* to_get_trace_state_variable_value)(struct target_ops *, int tsv, LONGEST *val) TARGET_DEFAULT_RETURN(0)
Definition: target.h:992
static int tdefault_supports_stopped_by_sw_breakpoint(struct target_ops *self)
static gdb_byte * delegate_get_bookmark(struct target_ops *self, const char *arg1, int arg2)
static void delegate_disable_btrace(struct target_ops *self, struct btrace_target_info *arg1)
struct traceframe_info *(* to_traceframe_info)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1078
Definition: ptid.h:35
static void tdefault_set_circular_trace_buffer(struct target_ops *self, int arg1)
void(* to_insn_history_range)(struct target_ops *, ULONGEST begin, ULONGEST end, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1178
int(* to_remove_exec_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:600
static void debug_enable_tracepoint(struct target_ops *self, struct bp_location *arg1)
static int debug_filesystem_is_local(struct target_ops *self)
static void tdefault_call_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
void(* to_files_info)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:479
int default_auxv_parse(struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
Definition: auxv.c:258
static void debug_insn_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
static int tdefault_masked_watch_num_registers(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
static int debug_search_memory(struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
static int debug_insert_exec_catchpoint(struct target_ops *self, int arg1)
static void tdefault_insn_history(struct target_ops *self, int arg1, int arg2)
static int delegate_supports_multi_process(struct target_ops *self)
static LONGEST tdefault_get_raw_trace_data(struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
static int tdefault_can_accel_watchpoint_condition(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
static int debug_masked_watch_num_registers(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
static void debug_update_thread_list(struct target_ops *self)
int(* to_insert_watchpoint)(struct target_ops *, CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:532
static char * debug_extra_thread_info(struct target_ops *self, struct thread_info *arg1)
static char * tdefault_thread_name(struct target_ops *self, struct thread_info *arg1)
static void target_debug_print_struct_target_waitstatus_p(struct target_waitstatus *status)
Definition: target-debug.h:157
int(* to_remove_fork_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:590
static int delegate_remove_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
void(* to_disable_tracepoint)(struct target_ops *, struct bp_location *location) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:952
static void default_terminal_info(struct target_ops *self, const char *args, int from_tty)
Definition: target.c:576
static int debug_core_of_thread(struct target_ops *self, ptid_t arg1)
static void debug_terminal_init(struct target_ops *self)
static int delegate_can_run(struct target_ops *self)
static int debug_remove_fork_catchpoint(struct target_ops *self, int arg1)
static void debug_resume(struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
static int debug_can_download_tracepoint(struct target_ops *self)
static int debug_insert_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
static char * debug_thread_name(struct target_ops *self, struct thread_info *arg1)
static void tdefault_set_disconnected_tracing(struct target_ops *self, int arg1)
#define target_debug_print_VEC_static_tracepoint_marker_p__p(X)
Definition: target-debug.h:119
static void tdefault_kill(struct target_ops *self)
void(* to_prepare_to_generate_core)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1217
static void debug_teardown_btrace(struct target_ops *self, struct btrace_target_info *arg1)
#define target_debug_print_struct_uploaded_tsv_pp(X)
Definition: target-debug.h:135
static void delegate_goto_record_begin(struct target_ops *self)
static int debug_static_tracepoint_marker_at(struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
static const struct frame_unwind * debug_get_tailcall_unwinder(struct target_ops *self)
static void debug_async(struct target_ops *self, int arg1)
static int debug_supports_non_stop(struct target_ops *self)
void(* to_call_history_range)(struct target_ops *, ULONGEST begin, ULONGEST end, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1198
char *(* to_thread_name)(struct target_ops *, struct thread_info *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:635
static void debug_prepare_to_store(struct target_ops *self, struct regcache *arg1)
static int debug_save_trace_data(struct target_ops *self, const char *arg1)
static void delegate_pass_signals(struct target_ops *self, int arg1, unsigned char *arg2)
#define target_debug_print_step(X)
Definition: target-debug.h:169
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:984
static int default_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR addr, int len)
Definition: target.c:3111
static int tdefault_insert_vfork_catchpoint(struct target_ops *self, int arg1)
static void delegate_detach(struct target_ops *self, const char *arg1, int arg2)
static void delegate_rcmd(struct target_ops *self, const char *arg1, struct ui_file *arg2)
static void delegate_flash_done(struct target_ops *self)
static void delegate_kill(struct target_ops *self)
static void debug_set_disconnected_tracing(struct target_ops *self, int arg1)
#define target_debug_print_struct_static_tracepoint_marker_p(X)
Definition: target-debug.h:137
#define target_debug_print_struct_traceframe_info_p(X)
Definition: target-debug.h:139
static void debug_kill(struct target_ops *self)
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:548
LONGEST(* to_get_raw_trace_data)(struct target_ops *, gdb_byte *buf, ULONGEST offset, LONGEST len) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1007
static void tdefault_enable_tracepoint(struct target_ops *self, struct bp_location *arg1)
static int tdefault_supports_string_tracing(struct target_ops *self)
static void delegate_trace_start(struct target_ops *self)
static void tdefault_call_history_from(struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
static void delegate_files_info(struct target_ops *self)
#define target_debug_print_const_struct_frame_unwind_p(X)
Definition: target-debug.h:145
static int delegate_insert_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
static struct target_section_table * delegate_get_section_table(struct target_ops *self)
static void generic_tls_error(void)
Definition: target.c:49
static int debug_is_async_p(struct target_ops *self)
static struct target_section_table * tdefault_get_section_table(struct target_ops *self)
int(* to_remove_vfork_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:594
static int delegate_record_is_replaying(struct target_ops *self)
int(* to_remove_watchpoint)(struct target_ops *, CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:529
static int tdefault_set_syscall_catchpoint(struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
static struct btrace_target_info * debug_enable_btrace(struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
int(* to_supports_stopped_by_sw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:500
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:464
#define target_debug_print_struct_btrace_target_info_p(X)
Definition: target-debug.h:141
static int tdefault_save_trace_data(struct target_ops *self, const char *arg1)
static int delegate_watchpoint_addr_within_range(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
static void delegate_post_attach(struct target_ops *self, int arg1)
int(* to_get_min_fast_tracepoint_insn_len)(struct target_ops *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:1015
static struct btrace_target_info * delegate_enable_btrace(struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
struct target_section_table *(* to_get_section_table)(struct target_ops *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:648
static struct gdbarch * default_thread_architecture(struct target_ops *ops, ptid_t ptid)
Definition: target.c:3126
static int tdefault_remove_vfork_catchpoint(struct target_ops *self, int arg1)
static int debug_remove_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
trace_find_type
Definition: target.h:246
int(* to_can_run)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:612
static void delegate_trace_init(struct target_ops *self)
static int default_watchpoint_addr_within_range(struct target_ops *target, CORE_ADDR addr, CORE_ADDR start, int length)
Definition: target.c:3118
static int delegate_insert_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
btrace_read_type
static void debug_download_tracepoint(struct target_ops *self, struct bp_location *arg1)
static int delegate_remove_exec_catchpoint(struct target_ops *self, int arg1)
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:689
static char * delegate_pid_to_str(struct target_ops *self, ptid_t arg1)
static int tdefault_remove_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
static void debug_call_history(struct target_ops *self, int arg1, int arg2)
int(* to_insert_exec_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:598
static int delegate_can_use_hw_breakpoint(struct target_ops *self, int arg1, int arg2, int arg3)
static int tdefault_stopped_data_address(struct target_ops *self, CORE_ADDR *arg1)
static char * delegate_thread_name(struct target_ops *self, struct thread_info *arg1)
#define target_debug_print_enum_target_object(X)
Definition: target-debug.h:49
static void debug_goto_record_begin(struct target_ops *self)
static void delegate_update_thread_list(struct target_ops *self)
void(* to_set_permissions)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1060
target_xfer_status
Definition: target.h:219
#define target_debug_print_bfd_p(X)
Definition: target-debug.h:115
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:1097
int(* to_masked_watch_num_registers)(struct target_ops *, CORE_ADDR, CORE_ADDR) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:562
static int delegate_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2)
static void tdefault_trace_set_readonly_regions(struct target_ops *self)
static int tdefault_can_download_tracepoint(struct target_ops *self)
static void tdefault_prepare_to_generate_core(struct target_ops *self)
static void tdefault_update_thread_list(struct target_ops *self)
static void delegate_terminal_ours(struct target_ops *self)
void(* to_trace_set_readonly_regions)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:959
static struct address_space * default_thread_address_space(struct target_ops *self, ptid_t ptid)
Definition: target.c:2667
#define target_debug_print_find_memory_region_ftype(X)
Definition: target-debug.h:113
static void tdefault_teardown_btrace(struct target_ops *self, struct btrace_target_info *arg1)
static int tdefault_ranged_break_num_registers(struct target_ops *self)
static int debug_can_accel_watchpoint_condition(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
static ptid_t delegate_wait(struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
static void debug_trace_init(struct target_ops *self)
#define target_debug_print_struct_target_ops_p(X)
Definition: target-debug.h:47
static int tdefault_can_async_p(struct target_ops *self)
static void delegate_set_circular_trace_buffer(struct target_ops *self, int arg1)
static int delegate_thread_alive(struct target_ops *self, ptid_t arg1)
static int delegate_remove_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
exec_direction_kind
Definition: infrun.h:65
void(* to_get_tracepoint_status)(struct target_ops *, struct breakpoint *tp, struct uploaded_tp *utp) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:970
#define target_debug_print_CORE_ADDR_p(X)
Definition: target-debug.h:97
static void tdefault_stop_recording(struct target_ops *self)
#define target_debug_print_struct_trace_status_p(X)
Definition: target-debug.h:127
int(* to_upload_trace_state_variables)(struct target_ops *, struct uploaded_tsv **utsvp) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1003
#define target_debug_print_struct_regcache_p(X)
Definition: target-debug.h:101
static int debug_insert_vfork_catchpoint(struct target_ops *self, int arg1)
#define target_debug_print_enum_btrace_format(X)
Definition: target-debug.h:149
static int debug_get_trace_status(struct target_ops *self, struct trace_status *arg1)
static int delegate_can_execute_reverse(struct target_ops *self)
static void debug_mourn_inferior(struct target_ops *self)
int(* to_augmented_libraries_svr4_read)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1204
static int debug_use_agent(struct target_ops *self, int arg1)
static void tdefault_terminal_ours_for_output(struct target_ops *self)
int(* to_insert_fork_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:588
static int debug_augmented_libraries_svr4_read(struct target_ops *self)
static void delegate_check_pending_interrupt(struct target_ops *self)
static int tdefault_augmented_libraries_svr4_read(struct target_ops *self)
static int debug_supports_multi_process(struct target_ops *self)
static int tdefault_can_execute_reverse(struct target_ops *self)
static int tdefault_use_agent(struct target_ops *self, int arg1)
#define target_debug_print_VEC_mem_region_s__p(X)
Definition: target-debug.h:117
const struct btrace_config *(* to_btrace_conf)(struct target_ops *self, const struct btrace_target_info *) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:1124
btrace_error
static void debug_insn_history(struct target_ops *self, int arg1, int arg2)
static int debug_record_is_replaying(struct target_ops *self)
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:724
static int delegate_verify_memory(struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
static void tdefault_save_record(struct target_ops *self, const char *arg1)
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:794
static void debug_terminal_ours_for_output(struct target_ops *self)
static void delegate_set_disconnected_tracing(struct target_ops *self, int arg1)
static int tdefault_supports_multi_process(struct target_ops *self)
static char * debug_pid_to_exec_file(struct target_ops *self, int arg1)
int(* to_get_tib_address)(struct target_ops *, ptid_t ptid, CORE_ADDR *addr) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1055
static int delegate_core_of_thread(struct target_ops *self, ptid_t arg1)
static void tdefault_fetch_registers(struct target_ops *self, struct regcache *arg1, int arg2)
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:460
static void delegate_disconnect(struct target_ops *self, const char *arg1, int arg2)
static int delegate_insert_fork_catchpoint(struct target_ops *self, int arg1)
static int delegate_stopped_by_hw_breakpoint(struct target_ops *self)
static void delegate_mourn_inferior(struct target_ops *self)
void(* to_async)(struct target_ops *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:664
static void debug_fetch_registers(struct target_ops *self, struct regcache *arg1, int arg2)
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)
static void debug_terminal_info(struct target_ops *self, const char *arg1, int arg2)
static void delegate_terminal_inferior(struct target_ops *self)
static enum exec_direction_kind default_execution_direction(struct target_ops *self)
Definition: target.c:594
static int debug_set_syscall_catchpoint(struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
#define target_debug_print_const_struct_target_desc_p(X)
Definition: target-debug.h:121
char *(* to_make_corefile_notes)(struct target_ops *, bfd *, int *) TARGET_DEFAULT_FUNC(dummy_make_corefile_notes)
Definition: target.h:675
static void tdefault_insn_history_from(struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
struct ui_file * gdb_stdlog
Definition: main.c:73
static char * delegate_pid_to_exec_file(struct target_ops *self, int arg1)
static void tdefault_download_trace_state_variable(struct target_ops *self, struct trace_state_variable *arg1)
target_object
Definition: target.h:136
int(* to_insert_hw_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:520
static int debug_can_run(struct target_ops *self)
static void delegate_trace_stop(struct target_ops *self)
char *(* to_pid_to_exec_file)(struct target_ops *, int pid) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:644
static void delegate_delete_record(struct target_ops *self)
int(* to_can_run_breakpoint_commands)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:834
static void install_delegators(struct target_ops *ops)
static void tdefault_async(struct target_ops *self, int arg1)
static int delegate_supports_stopped_by_sw_breakpoint(struct target_ops *self)
static void delegate_store_registers(struct target_ops *self, struct regcache *arg1, int arg2)
static int debug_insert_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
int(* to_remove_mask_watchpoint)(struct target_ops *, CORE_ADDR, CORE_ADDR, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:539
static int dummy_find_memory_regions(struct target_ops *self, find_memory_region_ftype ignore1, void *ignore2)
Definition: target.c:3223
static const struct frame_unwind * tdefault_get_unwinder(struct target_ops *self)
static void target_debug_print_signals(unsigned char *sigs)
Definition: target-debug.h:182
static const struct frame_unwind * delegate_get_unwinder(struct target_ops *self)
void(* to_disconnect)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:462
static int debug_get_tib_address(struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
int(* to_can_download_tracepoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:938
static void tdefault_log_command(struct target_ops *self, const char *arg1)
static void debug_trace_start(struct target_ops *self)
void(* to_log_command)(struct target_ops *, const char *) TARGET_DEFAULT_IGNORE()
Definition: target.h:646
#define target_debug_print_long(X)
Definition: target-debug.h:59
static void delegate_call_history_range(struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
static int delegate_augmented_libraries_svr4_read(struct target_ops *self)
#define target_debug_print_enum_btrace_read_type(X)
Definition: target-debug.h:67
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:1117
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:784
static int delegate_set_trace_notes(struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
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:1049
static CORE_ADDR delegate_get_thread_local_address(struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
static void delegate_save_record(struct target_ops *self, const char *arg1)
static int delegate_supports_evaluation_of_breakpoint_conditions(struct target_ops *self)
static void tdefault_terminal_init(struct target_ops *self)
void(* to_download_tracepoint)(struct target_ops *, struct bp_location *location) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:932
static int delegate_use_agent(struct target_ops *self, int arg1)
#define target_debug_print_LONGEST_p(X)
Definition: target-debug.h:89
static const struct target_desc * delegate_read_description(struct target_ops *self)
static struct traceframe_info * debug_traceframe_info(struct target_ops *self)
static void default_mourn_inferior(struct target_ops *self)
Definition: target.c:2293
int(* to_remove_hw_breakpoint)(struct target_ops *, struct gdbarch *, struct bp_target_info *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:523
bfd_byte gdb_byte
Definition: common-types.h:38
static void tdefault_call_history(struct target_ops *self, int arg1, int arg2)
enum exec_direction_kind(* to_execution_direction)(struct target_ops *) TARGET_DEFAULT_FUNC(default_execution_direction)
Definition: target.h:807
static int tdefault_upload_trace_state_variables(struct target_ops *self, struct uploaded_tsv **arg1)
#define target_debug_print_const_char_p(X)
Definition: target-debug.h:53
static int delegate_remove_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
#define target_debug_print_struct_ui_file_p(X)
Definition: target-debug.h:105
static const struct target_desc * debug_read_description(struct target_ops *self)
static void debug_rcmd(struct target_ops *self, const char *arg1, struct ui_file *arg2)
static void delegate_info_record(struct target_ops *self)
static void tdefault_check_pending_interrupt(struct target_ops *self)
static int debug_stopped_by_hw_breakpoint(struct target_ops *self)
static int delegate_auxv_parse(struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
static gdb_byte * debug_get_bookmark(struct target_ops *self, const char *arg1, int arg2)
static int debug_can_use_agent(struct target_ops *self)
#define target_debug_print_ULONGEST_p(X)
Definition: target-debug.h:85
#define target_debug_print_struct_uploaded_tp_pp(X)
Definition: target-debug.h:133
#define target_debug_print_struct_target_section_table_p(X)
Definition: target-debug.h:107
void(* to_flash_erase)(struct target_ops *, ULONGEST address, LONGEST length) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:754
static int delegate_trace_find(struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
static void debug_store_registers(struct target_ops *self, struct regcache *arg1, int arg2)
static void delegate_get_tracepoint_status(struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
void(* to_fetch_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:472
void(* to_mourn_inferior)(struct target_ops *) TARGET_DEFAULT_FUNC(default_mourn_inferior)
Definition: target.h:607
const struct frame_unwind *(* to_get_unwinder)(struct target_ops *self) TARGET_DEFAULT_RETURN(NULL)
Definition: target.h:1210
static int tdefault_can_use_agent(struct target_ops *self)
static int delegate_insert_mask_watchpoint(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
static int debug_remove_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
#define target_debug_print_int_p(X)
Definition: target-debug.h:99
static int tdefault_set_trace_notes(struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
int(* to_set_trace_notes)(struct target_ops *, const char *user, const char *notes, const char *stopnotes) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1030
int(* to_can_use_hw_breakpoint)(struct target_ops *, int, int, int) TARGET_DEFAULT_RETURN(0)
Definition: target.h:516
static int delegate_upload_tracepoints(struct target_ops *self, struct uploaded_tp **arg1)
static void tdefault_goto_bookmark(struct target_ops *self, const gdb_byte *arg1, int arg2)
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:2429
static int debug_can_use_hw_breakpoint(struct target_ops *self, int arg1, int arg2, int arg3)
void(* to_pass_signals)(struct target_ops *, int, unsigned char *TARGET_DEBUG_PRINTER(target_debug_print_signals)) TARGET_DEFAULT_IGNORE()
Definition: target.h:617
void(* to_stop)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:637
#define target_debug_print_const_struct_btrace_config_p(X)
Definition: target-debug.h:151
void(* to_teardown_btrace)(struct target_ops *, struct btrace_target_info *tinfo) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1111
static int delegate_supports_stopped_by_hw_breakpoint(struct target_ops *self)
int(* to_save_trace_data)(struct target_ops *, const char *filename) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:996
void(* to_download_trace_state_variable)(struct target_ops *, struct trace_state_variable *tsv) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:942
#define target_debug_print_const_gdb_byte_p(X)
Definition: target-debug.h:75
static void delegate_resume(struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
static void debug_flash_done(struct target_ops *self)
#define target_debug_print_LONGEST(X)
Definition: target-debug.h:87
static int debug_remove_exec_catchpoint(struct target_ops *self, int arg1)
void(* to_kill)(struct target_ops *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:575
gdb_byte *(* to_get_bookmark)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:678
static void debug_disconnect(struct target_ops *self, const char *arg1, int arg2)
static int delegate_upload_trace_state_variables(struct target_ops *self, struct uploaded_tsv **arg1)
int(* to_can_accel_watchpoint_condition)(struct target_ops *, CORE_ADDR, int, int, struct expression *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:558
static int debug_can_run_breakpoint_commands(struct target_ops *self)
static void debug_set_permissions(struct target_ops *self)
#define target_debug_print_void_p(X)
Definition: target-debug.h:111
static void delegate_insn_history(struct target_ops *self, int arg1, int arg2)
int(* to_stopped_by_sw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:497
static int debug_insert_fork_catchpoint(struct target_ops *self, int arg1)
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)
void(* to_goto_record_end)(struct target_ops *) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1154
void(* to_set_circular_trace_buffer)(struct target_ops *, int val) TARGET_DEFAULT_IGNORE()
Definition: target.h:1022
static char * dummy_make_corefile_notes(struct target_ops *self, bfd *ignore1, int *ignore2)
Definition: target.c:3232
static struct address_space * debug_thread_address_space(struct target_ops *self, ptid_t arg1)
static int tdefault_supports_non_stop(struct target_ops *self)
#define target_debug_print_ULONGEST(X)
Definition: target-debug.h:83
static void debug_terminal_inferior(struct target_ops *self)
static int debug_remove_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
int(* to_ranged_break_num_registers)(struct target_ops *) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:518
static CORE_ADDR debug_get_thread_local_address(struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
void(* to_call_history_from)(struct target_ops *, ULONGEST begin, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1192
void(* to_post_attach)(struct target_ops *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:458
static void delegate_call_history(struct target_ops *self, int arg1, int arg2)
static void debug_goto_record(struct target_ops *self, ULONGEST arg1)
int(* to_can_async_p)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:660
static void delegate_terminal_ours_for_output(struct target_ops *self)
static int delegate_remove_fork_catchpoint(struct target_ops *self, int arg1)
int(* to_static_tracepoint_marker_at)(struct target_ops *, CORE_ADDR, struct static_tracepoint_marker *marker) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1065
static int tdefault_supports_enable_disable_tracepoint(struct target_ops *self)
static void delegate_goto_record(struct target_ops *self, ULONGEST arg1)
static int tdefault_is_async_p(struct target_ops *self)
struct gdbarch *(* to_thread_architecture)(struct target_ops *, ptid_t) TARGET_DEFAULT_FUNC(default_thread_architecture)
Definition: target.h:847
static int debug_supports_stopped_by_hw_breakpoint(struct target_ops *self)
int(* to_stopped_by_watchpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:542
int(* to_get_trace_status)(struct target_ops *, struct trace_status *ts) TARGET_DEFAULT_RETURN(-1)
Definition: target.h:967
static enum exec_direction_kind delegate_execution_direction(struct target_ops *self)
static int delegate_supports_non_stop(struct target_ops *self)
static void delegate_set_trace_buffer_size(struct target_ops *self, LONGEST arg1)
static void tdefault_terminal_ours(struct target_ops *self)
static int debug_supports_stopped_by_sw_breakpoint(struct target_ops *self)
static int delegate_stopped_by_sw_breakpoint(struct target_ops *self)
static void tdefault_store_registers(struct target_ops *self, struct regcache *arg1, int arg2)
static void delegate_prepare_to_store(struct target_ops *self, struct regcache *arg1)
static void delegate_goto_record_end(struct target_ops *self)
static int delegate_can_download_tracepoint(struct target_ops *self)
void(* to_terminal_ours)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:571
int(* to_stopped_by_hw_breakpoint)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:510
void(* to_enable_tracepoint)(struct target_ops *, struct bp_location *location) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:947
static int default_verify_memory(struct target_ops *self, const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
Definition: target.c:3478
static void tdefault_trace_stop(struct target_ops *self)
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)
void(* to_terminal_inferior)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:567
static void default_rcmd(struct target_ops *self, const char *command, struct ui_file *output)
Definition: target.c:3748
static int debug_set_trace_notes(struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
static ptid_t debug_get_ada_task_ptid(struct target_ops *self, long arg1, long arg2)
static int delegate_insert_exec_catchpoint(struct target_ops *self, int arg1)
static char * tdefault_pid_to_exec_file(struct target_ops *self, int arg1)
unsigned long long ULONGEST
Definition: common-types.h:53
static int delegate_supports_btrace(struct target_ops *self, enum btrace_format arg1)
static void tdefault_disable_tracepoint(struct target_ops *self, struct bp_location *arg1)
static int debug_insert_hw_breakpoint(struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
static int delegate_get_tib_address(struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
static void delegate_goto_bookmark(struct target_ops *self, const gdb_byte *arg1, int arg2)
static int delegate_set_syscall_catchpoint(struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
static void delegate_load(struct target_ops *self, const char *arg1, int arg2)
static int delegate_find_memory_regions(struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
static struct gdbarch * delegate_thread_architecture(struct target_ops *self, ptid_t arg1)
static void debug_check_pending_interrupt(struct target_ops *self)
void(* to_insn_history)(struct target_ops *, int size, int flags) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1165
int(* to_record_is_replaying)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1146
static VEC(mem_region_s)
int(* to_supports_non_stop)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:668
int memory_insert_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: mem-break.c:88
static const struct btrace_config * debug_btrace_conf(struct target_ops *self, const struct btrace_target_info *arg1)
static struct traceframe_info * delegate_traceframe_info(struct target_ops *self)
static void tdefault_download_tracepoint(struct target_ops *self, struct bp_location *arg1)
int memory_remove_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: mem-break.c:95
void(* to_done_generating_core)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:1221
static int delegate_search_memory(struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
static void tdefault_files_info(struct target_ops *self)
static struct traceframe_info * tdefault_traceframe_info(struct target_ops *self)
#define target_debug_print_enum_exec_direction_kind(X)
Definition: target-debug.h:63
static int tdefault_insert_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
static void debug_trace_stop(struct target_ops *self)
#define target_debug_print_enum_trace_find_type(X)
Definition: target-debug.h:65
static const struct target_desc * tdefault_read_description(struct target_ops *self)
#define target_debug_print_struct_gdbarch_p(X)
Definition: target-debug.h:73
static int delegate_static_tracepoint_marker_at(struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
static int delegate_filesystem_is_local(struct target_ops *self)
static int debug_stopped_by_sw_breakpoint(struct target_ops *self)
static void tdefault_done_generating_core(struct target_ops *self)
static int tdefault_can_run(struct target_ops *self)
int(* to_insert_vfork_catchpoint)(struct target_ops *, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:592
int(* to_thread_alive)(struct target_ops *, ptid_t ptid) TARGET_DEFAULT_RETURN(0)
Definition: target.h:627
static const struct frame_unwind * debug_get_unwinder(struct target_ops *self)
#define target_debug_print_const_struct_btrace_target_info_p(X)
Definition: target-debug.h:153
static int delegate_masked_watch_num_registers(struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
static CORE_ADDR tdefault_get_thread_local_address(struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
static int debug_stopped_by_watchpoint(struct target_ops *self)
static void delegate_teardown_btrace(struct target_ops *self, struct btrace_target_info *arg1)
static void init_debug_target(struct target_ops *ops)
int(* to_use_agent)(struct target_ops *, int use) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1083
static int delegate_ranged_break_num_registers(struct target_ops *self)
static void debug_set_trace_buffer_size(struct target_ops *self, LONGEST arg1)
int(* to_supports_btrace)(struct target_ops *, enum btrace_format) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1091
static void tdefault_terminal_inferior(struct target_ops *self)
int(* to_stopped_data_address)(struct target_ops *, CORE_ADDR *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:546
static int debug_insert_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
int(* to_set_syscall_catchpoint)(struct target_ops *, int, int, int, int, int *) TARGET_DEFAULT_RETURN(1)
Definition: target.h:602
static int debug_trace_find(struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
static void debug_save_record(struct target_ops *self, const char *arg1)
static void debug_download_trace_state_variable(struct target_ops *self, struct trace_state_variable *arg1)
void(* to_update_thread_list)(struct target_ops *) TARGET_DEFAULT_IGNORE()
Definition: target.h:629
static int debug_auxv_parse(struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
static void debug_info_record(struct target_ops *self)
void(* to_prepare_to_store)(struct target_ops *, struct regcache *) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:476
void(* to_store_registers)(struct target_ops *, struct regcache *, int) TARGET_DEFAULT_NORETURN(noprocess())
Definition: target.h:474
int(* find_memory_region_ftype)(CORE_ADDR addr, unsigned long size, int read, int write, int exec, int modified, void *data)
Definition: defs.h:343
static void delegate_terminal_init(struct target_ops *self)
static void tdefault_post_attach(struct target_ops *self, int arg1)
void noprocess(void)
Definition: target.c:570
static int delegate_can_use_agent(struct target_ops *self)
static int debug_thread_alive(struct target_ops *self, ptid_t arg1)
static const struct btrace_config * tdefault_btrace_conf(struct target_ops *self, const struct btrace_target_info *arg1)
static int debug_region_ok_for_hw_watchpoint(struct target_ops *self, CORE_ADDR arg1, int arg2)
static void target_debug_print_options(int options)
Definition: target-debug.h:173
static int tdefault_supports_stopped_by_hw_breakpoint(struct target_ops *self)
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:776
static void tdefault_set_trace_buffer_size(struct target_ops *self, LONGEST arg1)
static int debug_stopped_data_address(struct target_ops *self, CORE_ADDR *arg1)
static void tdefault_delete_record(struct target_ops *self)
static int delegate_is_async_p(struct target_ops *self)
static void tcomplain(void)
Definition: target.c:563
static void debug_call_history_from(struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
static void tdefault_goto_record_end(struct target_ops *self)
int(* to_insert_mask_watchpoint)(struct target_ops *, CORE_ADDR, CORE_ADDR, int) TARGET_DEFAULT_RETURN(1)
Definition: target.h:536
void(* to_disable_btrace)(struct target_ops *, struct btrace_target_info *tinfo) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1103
static void delegate_enable_tracepoint(struct target_ops *self, struct bp_location *arg1)
static int tdefault_stopped_by_hw_breakpoint(struct target_ops *self)
static void tdefault_set_permissions(struct target_ops *self)
static void debug_goto_bookmark(struct target_ops *self, const gdb_byte *arg1, int arg2)
static int tdefault_core_of_thread(struct target_ops *self, ptid_t arg1)
#define target_debug_print_gdb_byte_p(X)
Definition: target-debug.h:77
static const struct frame_unwind * tdefault_get_tailcall_unwinder(struct target_ops *self)
static void delegate_trace_set_readonly_regions(struct target_ops *self)
#define target_debug_print_struct_uploaded_tp_p(X)
Definition: target-debug.h:131
static int tdefault_stopped_by_watchpoint(struct target_ops *self)
static char * delegate_make_corefile_notes(struct target_ops *self, bfd *arg1, int *arg2)
static int tdefault_trace_find(struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
static void debug_files_info(struct target_ops *self)
long long LONGEST
Definition: common-types.h:52
static void tdefault_disable_btrace(struct target_ops *self, struct btrace_target_info *arg1)
int(* to_can_execute_reverse)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:801
void(* to_load)(struct target_ops *, const char *, int) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:577
static void tdefault_flash_done(struct target_ops *self)
void(* to_terminal_info)(struct target_ops *, const char *, int) TARGET_DEFAULT_FUNC(default_terminal_info)
Definition: target.h:573
#define target_debug_print_enum_btrace_error(X)
Definition: target-debug.h:69
static int delegate_can_async_p(struct target_ops *self)
int(* to_filesystem_is_local)(struct target_ops *) TARGET_DEFAULT_RETURN(1)
Definition: target.h:862
int(* to_supports_multi_process)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:812
static int debug_get_min_fast_tracepoint_insn_len(struct target_ops *self)
static void debug_set_circular_trace_buffer(struct target_ops *self, int arg1)
#define target_debug_print_struct_thread_info_p(X)
Definition: target-debug.h:103
void(* to_post_startup_inferior)(struct target_ops *, ptid_t) TARGET_DEFAULT_IGNORE()
Definition: target.h:586
int(* to_can_use_agent)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:1087
static int delegate_follow_fork(struct target_ops *self, int arg1, int arg2)
static void delegate_post_startup_inferior(struct target_ops *self, ptid_t arg1)
static void debug_detach(struct target_ops *self, const char *arg1, int arg2)
void(* to_goto_record)(struct target_ops *, ULONGEST insn) TARGET_DEFAULT_NORETURN(tcomplain())
Definition: target.h:1158
static int debug_supports_btrace(struct target_ops *self, enum btrace_format arg1)
static struct btrace_target_info * tdefault_enable_btrace(struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
static int delegate_get_trace_state_variable_value(struct target_ops *self, int arg1, LONGEST *arg2)
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)
static void tdefault_info_record(struct target_ops *self)
static void tdefault_pass_signals(struct target_ops *self, int arg1, unsigned char *arg2)
static void delegate_async(struct target_ops *self, int arg1)