gdb/target-delegates.c - gdb

Functions defined

Source code

  1. /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
  2. /* vi:set ro: */

  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. }

  13. static void
  14. ‌tdefault_post_attach (struct target_ops *self, int arg1)
  15. {
  16. }

  18. static void
  19. ‌debug_post_attach (struct target_ops *self, int arg1)
  20. {
  21.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", debug_target.to_shortname);
  22.   debug_target.to_post_attach (&debug_target, arg1);
  23.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", debug_target.to_shortname);
  24.   target_debug_print_struct_target_ops_p (&debug_target);
  25.   fputs_unfiltered (", ", gdb_stdlog);
  26.   target_debug_print_int (arg1);
  27.   fputs_unfiltered (")\n", gdb_stdlog);
  28. }

  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. }

  37. static void
  38. ‌tdefault_detach (struct target_ops *self, const char *arg1, int arg2)
  39. {
  40. }

  42. static void
  43. ‌debug_detach (struct target_ops *self, const char *arg1, int arg2)
  44. {
  45.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", debug_target.to_shortname);
  46.   debug_target.to_detach (&debug_target, arg1, arg2);
  47.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", debug_target.to_shortname);
  48.   target_debug_print_struct_target_ops_p (&debug_target);
  49.   fputs_unfiltered (", ", gdb_stdlog);
  50.   target_debug_print_const_char_p (arg1);
  51.   fputs_unfiltered (", ", gdb_stdlog);
  52.   target_debug_print_int (arg2);
  53.   fputs_unfiltered (")\n", gdb_stdlog);
  54. }

  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. }

  63. static void
  64. ‌tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
  65. {
  66.   tcomplain ();
  67. }

  69. static void
  70. ‌debug_disconnect (struct target_ops *self, const char *arg1, int arg2)
  71. {
  72.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", debug_target.to_shortname);
  73.   debug_target.to_disconnect (&debug_target, arg1, arg2);
  74.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", debug_target.to_shortname);
  75.   target_debug_print_struct_target_ops_p (&debug_target);
  76.   fputs_unfiltered (", ", gdb_stdlog);
  77.   target_debug_print_const_char_p (arg1);
  78.   fputs_unfiltered (", ", gdb_stdlog);
  79.   target_debug_print_int (arg2);
  80.   fputs_unfiltered (")\n", gdb_stdlog);
  81. }

  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. }

  90. static void
  91. ‌tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
  92. {
  93.   noprocess ();
  94. }

  96. static void
  97. ‌debug_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
  98. {
  99.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", debug_target.to_shortname);
  100.   debug_target.to_resume (&debug_target, arg1, arg2, arg3);
  101.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", debug_target.to_shortname);
  102.   target_debug_print_struct_target_ops_p (&debug_target);
  103.   fputs_unfiltered (", ", gdb_stdlog);
  104.   target_debug_print_ptid_t (arg1);
  105.   fputs_unfiltered (", ", gdb_stdlog);
  106.   target_debug_print_step (arg2);
  107.   fputs_unfiltered (", ", gdb_stdlog);
  108.   target_debug_print_enum_gdb_signal (arg3);
  109.   fputs_unfiltered (")\n", gdb_stdlog);
  110. }

  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. }

  119. static ptid_t
  120. ‌tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
  121. {
  122.   noprocess ();
  123. }

  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);
  132.   target_debug_print_struct_target_ops_p (&debug_target);
  133.   fputs_unfiltered (", ", gdb_stdlog);
  134.   target_debug_print_ptid_t (arg1);
  135.   fputs_unfiltered (", ", gdb_stdlog);
  136.   target_debug_print_struct_target_waitstatus_p (arg2);
  137.   fputs_unfiltered (", ", gdb_stdlog);
  138.   target_debug_print_options (arg3);
  139.   fputs_unfiltered (") = ", gdb_stdlog);
  140.   target_debug_print_ptid_t (result);
  141.   fputs_unfiltered ("\n", gdb_stdlog);
  142.   return result;
  143. }

  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. }

  152. static void
  153. ‌tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
  154. {
  155. }

  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);
  163.   target_debug_print_struct_target_ops_p (&debug_target);
  164.   fputs_unfiltered (", ", gdb_stdlog);
  165.   target_debug_print_struct_regcache_p (arg1);
  166.   fputs_unfiltered (", ", gdb_stdlog);
  167.   target_debug_print_int (arg2);
  168.   fputs_unfiltered (")\n", gdb_stdlog);
  169. }

  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. }

  178. static void
  179. ‌tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
  180. {
  181.   noprocess ();
  182. }

  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);
  190.   target_debug_print_struct_target_ops_p (&debug_target);
  191.   fputs_unfiltered (", ", gdb_stdlog);
  192.   target_debug_print_struct_regcache_p (arg1);
  193.   fputs_unfiltered (", ", gdb_stdlog);
  194.   target_debug_print_int (arg2);
  195.   fputs_unfiltered (")\n", gdb_stdlog);
  196. }

  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. }

  205. static void
  206. ‌tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
  207. {
  208.   noprocess ();
  209. }

  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);
  217.   target_debug_print_struct_target_ops_p (&debug_target);
  218.   fputs_unfiltered (", ", gdb_stdlog);
  219.   target_debug_print_struct_regcache_p (arg1);
  220.   fputs_unfiltered (")\n", gdb_stdlog);
  221. }

  223. static void
  224. ‌delegate_files_info (struct target_ops *self)
  225. {
  226.   self = self->beneath;
  227.   self->to_files_info (self);
  228. }

  230. static void
  231. ‌tdefault_files_info (struct target_ops *self)
  232. {
  233. }

  235. static void
  236. ‌debug_files_info (struct target_ops *self)
  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);
  241.   target_debug_print_struct_target_ops_p (&debug_target);
  242.   fputs_unfiltered (")\n", gdb_stdlog);
  243. }

  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. }

  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);
  259.   target_debug_print_struct_target_ops_p (&debug_target);
  260.   fputs_unfiltered (", ", gdb_stdlog);
  261.   target_debug_print_struct_gdbarch_p (arg1);
  262.   fputs_unfiltered (", ", gdb_stdlog);
  263.   target_debug_print_struct_bp_target_info_p (arg2);
  264.   fputs_unfiltered (") = ", gdb_stdlog);
  265.   target_debug_print_int (result);
  266.   fputs_unfiltered ("\n", gdb_stdlog);
  267.   return result;
  268. }

  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. }

  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);
  284.   target_debug_print_struct_target_ops_p (&debug_target);
  285.   fputs_unfiltered (", ", gdb_stdlog);
  286.   target_debug_print_struct_gdbarch_p (arg1);
  287.   fputs_unfiltered (", ", gdb_stdlog);
  288.   target_debug_print_struct_bp_target_info_p (arg2);
  289.   fputs_unfiltered (") = ", gdb_stdlog);
  290.   target_debug_print_int (result);
  291.   fputs_unfiltered ("\n", gdb_stdlog);
  292.   return result;
  293. }

  295. static int
  296. ‌delegate_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
  297. {
  298.   self = self->beneath;
  299.   return self->to_can_use_hw_breakpoint (self, arg1, arg2, arg3);
  300. }

  302. static int
  303. ‌tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
  304. {
  305.   return 0;
  306. }

  308. static int
  309. ‌debug_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
  310. {
  311.   int result;
  312.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", debug_target.to_shortname);
  313.   result = debug_target.to_can_use_hw_breakpoint (&debug_target, arg1, arg2, arg3);
  314.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", debug_target.to_shortname);
  315.   target_debug_print_struct_target_ops_p (&debug_target);
  316.   fputs_unfiltered (", ", gdb_stdlog);
  317.   target_debug_print_int (arg1);
  318.   fputs_unfiltered (", ", gdb_stdlog);
  319.   target_debug_print_int (arg2);
  320.   fputs_unfiltered (", ", gdb_stdlog);
  321.   target_debug_print_int (arg3);
  322.   fputs_unfiltered (") = ", gdb_stdlog);
  323.   target_debug_print_int (result);
  324.   fputs_unfiltered ("\n", gdb_stdlog);
  325.   return result;
  326. }

  328. static int
  329. ‌delegate_ranged_break_num_registers (struct target_ops *self)
  330. {
  331.   self = self->beneath;
  332.   return self->to_ranged_break_num_registers (self);
  333. }

  335. static int
  336. ‌tdefault_ranged_break_num_registers (struct target_ops *self)
  337. {
  338.   return -1;
  339. }

  341. static int
  342. ‌debug_ranged_break_num_registers (struct target_ops *self)
  343. {
  344.   int result;
  345.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_ranged_break_num_registers (...)\n", debug_target.to_shortname);
  346.   result = debug_target.to_ranged_break_num_registers (&debug_target);
  347.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_ranged_break_num_registers (", debug_target.to_shortname);
  348.   target_debug_print_struct_target_ops_p (&debug_target);
  349.   fputs_unfiltered (") = ", gdb_stdlog);
  350.   target_debug_print_int (result);
  351.   fputs_unfiltered ("\n", gdb_stdlog);
  352.   return result;
  353. }

  355. static int
  356. ‌delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
  357. {
  358.   self = self->beneath;
  359.   return self->to_insert_hw_breakpoint (self, arg1, arg2);
  360. }

  362. static int
  363. ‌tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
  364. {
  365.   return -1;
  366. }

  368. static int
  369. ‌debug_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
  370. {
  371.   int result;
  372.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_hw_breakpoint (...)\n", debug_target.to_shortname);
  373.   result = debug_target.to_insert_hw_breakpoint (&debug_target, arg1, arg2);
  374.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_hw_breakpoint (", debug_target.to_shortname);
  375.   target_debug_print_struct_target_ops_p (&debug_target);
  376.   fputs_unfiltered (", ", gdb_stdlog);
  377.   target_debug_print_struct_gdbarch_p (arg1);
  378.   fputs_unfiltered (", ", gdb_stdlog);
  379.   target_debug_print_struct_bp_target_info_p (arg2);
  380.   fputs_unfiltered (") = ", gdb_stdlog);
  381.   target_debug_print_int (result);
  382.   fputs_unfiltered ("\n", gdb_stdlog);
  383.   return result;
  384. }

  386. static int
  387. ‌delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
  388. {
  389.   self = self->beneath;
  390.   return self->to_remove_hw_breakpoint (self, arg1, arg2);
  391. }

  393. static int
  394. ‌tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
  395. {
  396.   return -1;
  397. }

  399. static int
  400. ‌debug_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
  401. {
  402.   int result;
  403.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_hw_breakpoint (...)\n", debug_target.to_shortname);
  404.   result = debug_target.to_remove_hw_breakpoint (&debug_target, arg1, arg2);
  405.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_hw_breakpoint (", debug_target.to_shortname);
  406.   target_debug_print_struct_target_ops_p (&debug_target);
  407.   fputs_unfiltered (", ", gdb_stdlog);
  408.   target_debug_print_struct_gdbarch_p (arg1);
  409.   fputs_unfiltered (", ", gdb_stdlog);
  410.   target_debug_print_struct_bp_target_info_p (arg2);
  411.   fputs_unfiltered (") = ", gdb_stdlog);
  412.   target_debug_print_int (result);
  413.   fputs_unfiltered ("\n", gdb_stdlog);
  414.   return result;
  415. }

  417. static int
  418. ‌delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
  419. {
  420.   self = self->beneath;
  421.   return self->to_remove_watchpoint (self, arg1, arg2, arg3, arg4);
  422. }

  424. static int
  425. ‌tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
  426. {
  427.   return -1;
  428. }

  430. static int
  431. ‌debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
  432. {
  433.   int result;
  434.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", debug_target.to_shortname);
  435.   result = debug_target.to_remove_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
  436.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", debug_target.to_shortname);
  437.   target_debug_print_struct_target_ops_p (&debug_target);
  438.   fputs_unfiltered (", ", gdb_stdlog);
  439.   target_debug_print_CORE_ADDR (arg1);
  440.   fputs_unfiltered (", ", gdb_stdlog);
  441.   target_debug_print_int (arg2);
  442.   fputs_unfiltered (", ", gdb_stdlog);
  443.   target_debug_print_int (arg3);
  444.   fputs_unfiltered (", ", gdb_stdlog);
  445.   target_debug_print_struct_expression_p (arg4);
  446.   fputs_unfiltered (") = ", gdb_stdlog);
  447.   target_debug_print_int (result);
  448.   fputs_unfiltered ("\n", gdb_stdlog);
  449.   return result;
  450. }

  452. static int
  453. ‌delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
  454. {
  455.   self = self->beneath;
  456.   return self->to_insert_watchpoint (self, arg1, arg2, arg3, arg4);
  457. }

  459. static int
  460. ‌tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
  461. {
  462.   return -1;
  463. }

  465. static int
  466. ‌debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
  467. {
  468.   int result;
  469.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", debug_target.to_shortname);
  470.   result = debug_target.to_insert_watchpoint (&debug_target, arg1, arg2, arg3, arg4);
  471.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", debug_target.to_shortname);
  472.   target_debug_print_struct_target_ops_p (&debug_target);
  473.   fputs_unfiltered (", ", gdb_stdlog);
  474.   target_debug_print_CORE_ADDR (arg1);
  475.   fputs_unfiltered (", ", gdb_stdlog);
  476.   target_debug_print_int (arg2);
  477.   fputs_unfiltered (", ", gdb_stdlog);
  478.   target_debug_print_int (arg3);
  479.   fputs_unfiltered (", ", gdb_stdlog);
  480.   target_debug_print_struct_expression_p (arg4);
  481.   fputs_unfiltered (") = ", gdb_stdlog);
  482.   target_debug_print_int (result);
  483.   fputs_unfiltered ("\n", gdb_stdlog);
  484.   return result;
  485. }

  487. static int
  488. ‌delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
  489. {
  490.   self = self->beneath;
  491.   return self->to_insert_mask_watchpoint (self, arg1, arg2, arg3);
  492. }

  494. static int
  495. ‌tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
  496. {
  497.   return 1;
  498. }

  500. static int
  501. ‌debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
  502. {
  503.   int result;
  504.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_mask_watchpoint (...)\n", debug_target.to_shortname);
  505.   result = debug_target.to_insert_mask_watchpoint (&debug_target, arg1, arg2, arg3);
  506.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_mask_watchpoint (", debug_target.to_shortname);
  507.   target_debug_print_struct_target_ops_p (&debug_target);
  508.   fputs_unfiltered (", ", gdb_stdlog);
  509.   target_debug_print_CORE_ADDR (arg1);
  510.   fputs_unfiltered (", ", gdb_stdlog);
  511.   target_debug_print_CORE_ADDR (arg2);
  512.   fputs_unfiltered (", ", gdb_stdlog);
  513.   target_debug_print_int (arg3);
  514.   fputs_unfiltered (") = ", gdb_stdlog);
  515.   target_debug_print_int (result);
  516.   fputs_unfiltered ("\n", gdb_stdlog);
  517.   return result;
  518. }

  520. static int
  521. ‌delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
  522. {
  523.   self = self->beneath;
  524.   return self->to_remove_mask_watchpoint (self, arg1, arg2, arg3);
  525. }

  527. static int
  528. ‌tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
  529. {
  530.   return 1;
  531. }

  533. static int
  534. ‌debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
  535. {
  536.   int result;
  537.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_mask_watchpoint (...)\n", debug_target.to_shortname);
  538.   result = debug_target.to_remove_mask_watchpoint (&debug_target, arg1, arg2, arg3);
  539.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_mask_watchpoint (", debug_target.to_shortname);
  540.   target_debug_print_struct_target_ops_p (&debug_target);
  541.   fputs_unfiltered (", ", gdb_stdlog);
  542.   target_debug_print_CORE_ADDR (arg1);
  543.   fputs_unfiltered (", ", gdb_stdlog);
  544.   target_debug_print_CORE_ADDR (arg2);
  545.   fputs_unfiltered (", ", gdb_stdlog);
  546.   target_debug_print_int (arg3);
  547.   fputs_unfiltered (") = ", gdb_stdlog);
  548.   target_debug_print_int (result);
  549.   fputs_unfiltered ("\n", gdb_stdlog);
  550.   return result;
  551. }

  553. static int
  554. ‌delegate_stopped_by_watchpoint (struct target_ops *self)
  555. {
  556.   self = self->beneath;
  557.   return self->to_stopped_by_watchpoint (self);
  558. }

  560. static int
  561. ‌tdefault_stopped_by_watchpoint (struct target_ops *self)
  562. {
  563.   return 0;
  564. }

  566. static int
  567. ‌debug_stopped_by_watchpoint (struct target_ops *self)
  568. {
  569.   int result;
  570.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_watchpoint (...)\n", debug_target.to_shortname);
  571.   result = debug_target.to_stopped_by_watchpoint (&debug_target);
  572.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_watchpoint (", debug_target.to_shortname);
  573.   target_debug_print_struct_target_ops_p (&debug_target);
  574.   fputs_unfiltered (") = ", gdb_stdlog);
  575.   target_debug_print_int (result);
  576.   fputs_unfiltered ("\n", gdb_stdlog);
  577.   return result;
  578. }

  580. static int
  581. ‌delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
  582. {
  583.   self = self->beneath;
  584.   return self->to_stopped_data_address (self, arg1);
  585. }

  587. static int
  588. ‌tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
  589. {
  590.   return 0;
  591. }

  593. static int
  594. ‌debug_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
  595. {
  596.   int result;
  597.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_data_address (...)\n", debug_target.to_shortname);
  598.   result = debug_target.to_stopped_data_address (&debug_target, arg1);
  599.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_data_address (", debug_target.to_shortname);
  600.   target_debug_print_struct_target_ops_p (&debug_target);
  601.   fputs_unfiltered (", ", gdb_stdlog);
  602.   target_debug_print_CORE_ADDR_p (arg1);
  603.   fputs_unfiltered (") = ", gdb_stdlog);
  604.   target_debug_print_int (result);
  605.   fputs_unfiltered ("\n", gdb_stdlog);
  606.   return result;
  607. }

  609. static int
  610. ‌delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
  611. {
  612.   self = self->beneath;
  613.   return self->to_watchpoint_addr_within_range (self, arg1, arg2, arg3);
  614. }

  616. static int
  617. ‌debug_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
  618. {
  619.   int result;
  620.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_watchpoint_addr_within_range (...)\n", debug_target.to_shortname);
  621.   result = debug_target.to_watchpoint_addr_within_range (&debug_target, arg1, arg2, arg3);
  622.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_watchpoint_addr_within_range (", debug_target.to_shortname);
  623.   target_debug_print_struct_target_ops_p (&debug_target);
  624.   fputs_unfiltered (", ", gdb_stdlog);
  625.   target_debug_print_CORE_ADDR (arg1);
  626.   fputs_unfiltered (", ", gdb_stdlog);
  627.   target_debug_print_CORE_ADDR (arg2);
  628.   fputs_unfiltered (", ", gdb_stdlog);
  629.   target_debug_print_int (arg3);
  630.   fputs_unfiltered (") = ", gdb_stdlog);
  631.   target_debug_print_int (result);
  632.   fputs_unfiltered ("\n", gdb_stdlog);
  633.   return result;
  634. }

  636. static int
  637. ‌delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
  638. {
  639.   self = self->beneath;
  640.   return self->to_region_ok_for_hw_watchpoint (self, arg1, arg2);
  641. }

  643. static int
  644. ‌debug_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
  645. {
  646.   int result;
  647.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", debug_target.to_shortname);
  648.   result = debug_target.to_region_ok_for_hw_watchpoint (&debug_target, arg1, arg2);
  649.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_region_ok_for_hw_watchpoint (", debug_target.to_shortname);
  650.   target_debug_print_struct_target_ops_p (&debug_target);
  651.   fputs_unfiltered (", ", gdb_stdlog);
  652.   target_debug_print_CORE_ADDR (arg1);
  653.   fputs_unfiltered (", ", gdb_stdlog);
  654.   target_debug_print_int (arg2);
  655.   fputs_unfiltered (") = ", gdb_stdlog);
  656.   target_debug_print_int (result);
  657.   fputs_unfiltered ("\n", gdb_stdlog);
  658.   return result;
  659. }

  661. static int
  662. ‌delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
  663. {
  664.   self = self->beneath;
  665.   return self->to_can_accel_watchpoint_condition (self, arg1, arg2, arg3, arg4);
  666. }

  668. static int
  669. ‌tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
  670. {
  671.   return 0;
  672. }

  674. static int
  675. ‌debug_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
  676. {
  677.   int result;
  678.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_accel_watchpoint_condition (...)\n", debug_target.to_shortname);
  679.   result = debug_target.to_can_accel_watchpoint_condition (&debug_target, arg1, arg2, arg3, arg4);
  680.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_accel_watchpoint_condition (", debug_target.to_shortname);
  681.   target_debug_print_struct_target_ops_p (&debug_target);
  682.   fputs_unfiltered (", ", gdb_stdlog);
  683.   target_debug_print_CORE_ADDR (arg1);
  684.   fputs_unfiltered (", ", gdb_stdlog);
  685.   target_debug_print_int (arg2);
  686.   fputs_unfiltered (", ", gdb_stdlog);
  687.   target_debug_print_int (arg3);
  688.   fputs_unfiltered (", ", gdb_stdlog);
  689.   target_debug_print_struct_expression_p (arg4);
  690.   fputs_unfiltered (") = ", gdb_stdlog);
  691.   target_debug_print_int (result);
  692.   fputs_unfiltered ("\n", gdb_stdlog);
  693.   return result;
  694. }

  696. static int
  697. ‌delegate_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
  698. {
  699.   self = self->beneath;
  700.   return self->to_masked_watch_num_registers (self, arg1, arg2);
  701. }

  703. static int
  704. ‌tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
  705. {
  706.   return -1;
  707. }

  709. static int
  710. ‌debug_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
  711. {
  712.   int result;
  713.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_masked_watch_num_registers (...)\n", debug_target.to_shortname);
  714.   result = debug_target.to_masked_watch_num_registers (&debug_target, arg1, arg2);
  715.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_masked_watch_num_registers (", debug_target.to_shortname);
  716.   target_debug_print_struct_target_ops_p (&debug_target);
  717.   fputs_unfiltered (", ", gdb_stdlog);
  718.   target_debug_print_CORE_ADDR (arg1);
  719.   fputs_unfiltered (", ", gdb_stdlog);
  720.   target_debug_print_CORE_ADDR (arg2);
  721.   fputs_unfiltered (") = ", gdb_stdlog);
  722.   target_debug_print_int (result);
  723.   fputs_unfiltered ("\n", gdb_stdlog);
  724.   return result;
  725. }

  727. static void
  728. ‌delegate_terminal_init (struct target_ops *self)
  729. {
  730.   self = self->beneath;
  731.   self->to_terminal_init (self);
  732. }

  734. static void
  735. ‌tdefault_terminal_init (struct target_ops *self)
  736. {
  737. }

  739. static void
  740. ‌debug_terminal_init (struct target_ops *self)
  741. {
  742.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_init (...)\n", debug_target.to_shortname);
  743.   debug_target.to_terminal_init (&debug_target);
  744.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_init (", debug_target.to_shortname);
  745.   target_debug_print_struct_target_ops_p (&debug_target);
  746.   fputs_unfiltered (")\n", gdb_stdlog);
  747. }

  749. static void
  750. ‌delegate_terminal_inferior (struct target_ops *self)
  751. {
  752.   self = self->beneath;
  753.   self->to_terminal_inferior (self);
  754. }

  756. static void
  757. ‌tdefault_terminal_inferior (struct target_ops *self)
  758. {
  759. }

  761. static void
  762. ‌debug_terminal_inferior (struct target_ops *self)
  763. {
  764.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_inferior (...)\n", debug_target.to_shortname);
  765.   debug_target.to_terminal_inferior (&debug_target);
  766.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_inferior (", debug_target.to_shortname);
  767.   target_debug_print_struct_target_ops_p (&debug_target);
  768.   fputs_unfiltered (")\n", gdb_stdlog);
  769. }

  771. static void
  772. ‌delegate_terminal_ours_for_output (struct target_ops *self)
  773. {
  774.   self = self->beneath;
  775.   self->to_terminal_ours_for_output (self);
  776. }

  778. static void
  779. ‌tdefault_terminal_ours_for_output (struct target_ops *self)
  780. {
  781. }

  783. static void
  784. ‌debug_terminal_ours_for_output (struct target_ops *self)
  785. {
  786.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours_for_output (...)\n", debug_target.to_shortname);
  787.   debug_target.to_terminal_ours_for_output (&debug_target);
  788.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours_for_output (", debug_target.to_shortname);
  789.   target_debug_print_struct_target_ops_p (&debug_target);
  790.   fputs_unfiltered (")\n", gdb_stdlog);
  791. }

  793. static void
  794. ‌delegate_terminal_ours (struct target_ops *self)
  795. {
  796.   self = self->beneath;
  797.   self->to_terminal_ours (self);
  798. }

  800. static void
  801. ‌tdefault_terminal_ours (struct target_ops *self)
  802. {
  803. }

  805. static void
  806. ‌debug_terminal_ours (struct target_ops *self)
  807. {
  808.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours (...)\n", debug_target.to_shortname);
  809.   debug_target.to_terminal_ours (&debug_target);
  810.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours (", debug_target.to_shortname);
  811.   target_debug_print_struct_target_ops_p (&debug_target);
  812.   fputs_unfiltered (")\n", gdb_stdlog);
  813. }

  815. static void
  816. ‌delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
  817. {
  818.   self = self->beneath;
  819.   self->to_terminal_info (self, arg1, arg2);
  820. }

  822. static void
  823. ‌debug_terminal_info (struct target_ops *self, const char *arg1, int arg2)
  824. {
  825.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_info (...)\n", debug_target.to_shortname);
  826.   debug_target.to_terminal_info (&debug_target, arg1, arg2);
  827.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_info (", debug_target.to_shortname);
  828.   target_debug_print_struct_target_ops_p (&debug_target);
  829.   fputs_unfiltered (", ", gdb_stdlog);
  830.   target_debug_print_const_char_p (arg1);
  831.   fputs_unfiltered (", ", gdb_stdlog);
  832.   target_debug_print_int (arg2);
  833.   fputs_unfiltered (")\n", gdb_stdlog);
  834. }

  836. static void
  837. ‌delegate_kill (struct target_ops *self)
  838. {
  839.   self = self->beneath;
  840.   self->to_kill (self);
  841. }

  843. static void
  844. ‌tdefault_kill (struct target_ops *self)
  845. {
  846.   noprocess ();
  847. }

  849. static void
  850. ‌debug_kill (struct target_ops *self)
  851. {
  852.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_kill (...)\n", debug_target.to_shortname);
  853.   debug_target.to_kill (&debug_target);
  854.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_kill (", debug_target.to_shortname);
  855.   target_debug_print_struct_target_ops_p (&debug_target);
  856.   fputs_unfiltered (")\n", gdb_stdlog);
  857. }

  859. static void
  860. ‌delegate_load (struct target_ops *self, const char *arg1, int arg2)
  861. {
  862.   self = self->beneath;
  863.   self->to_load (self, arg1, arg2);
  864. }

  866. static void
  867. ‌tdefault_load (struct target_ops *self, const char *arg1, int arg2)
  868. {
  869.   tcomplain ();
  870. }

  872. static void
  873. ‌debug_load (struct target_ops *self, const char *arg1, int arg2)
  874. {
  875.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_load (...)\n", debug_target.to_shortname);
  876.   debug_target.to_load (&debug_target, arg1, arg2);
  877.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_load (", debug_target.to_shortname);
  878.   target_debug_print_struct_target_ops_p (&debug_target);
  879.   fputs_unfiltered (", ", gdb_stdlog);
  880.   target_debug_print_const_char_p (arg1);
  881.   fputs_unfiltered (", ", gdb_stdlog);
  882.   target_debug_print_int (arg2);
  883.   fputs_unfiltered (")\n", gdb_stdlog);
  884. }

  886. static void
  887. ‌delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1)
  888. {
  889.   self = self->beneath;
  890.   self->to_post_startup_inferior (self, arg1);
  891. }

  893. static void
  894. ‌tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
  895. {
  896. }

  898. static void
  899. ‌debug_post_startup_inferior (struct target_ops *self, ptid_t arg1)
  900. {
  901.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_startup_inferior (...)\n", debug_target.to_shortname);
  902.   debug_target.to_post_startup_inferior (&debug_target, arg1);
  903.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_startup_inferior (", debug_target.to_shortname);
  904.   target_debug_print_struct_target_ops_p (&debug_target);
  905.   fputs_unfiltered (", ", gdb_stdlog);
  906.   target_debug_print_ptid_t (arg1);
  907.   fputs_unfiltered (")\n", gdb_stdlog);
  908. }

  910. static int
  911. ‌delegate_insert_fork_catchpoint (struct target_ops *self, int arg1)
  912. {
  913.   self = self->beneath;
  914.   return self->to_insert_fork_catchpoint (self, arg1);
  915. }

  917. static int
  918. ‌tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
  919. {
  920.   return 1;
  921. }

  923. static int
  924. ‌debug_insert_fork_catchpoint (struct target_ops *self, int arg1)
  925. {
  926.   int result;
  927.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_fork_catchpoint (...)\n", debug_target.to_shortname);
  928.   result = debug_target.to_insert_fork_catchpoint (&debug_target, arg1);
  929.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_fork_catchpoint (", debug_target.to_shortname);
  930.   target_debug_print_struct_target_ops_p (&debug_target);
  931.   fputs_unfiltered (", ", gdb_stdlog);
  932.   target_debug_print_int (arg1);
  933.   fputs_unfiltered (") = ", gdb_stdlog);
  934.   target_debug_print_int (result);
  935.   fputs_unfiltered ("\n", gdb_stdlog);
  936.   return result;
  937. }

  939. static int
  940. ‌delegate_remove_fork_catchpoint (struct target_ops *self, int arg1)
  941. {
  942.   self = self->beneath;
  943.   return self->to_remove_fork_catchpoint (self, arg1);
  944. }

  946. static int
  947. ‌tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
  948. {
  949.   return 1;
  950. }

  952. static int
  953. ‌debug_remove_fork_catchpoint (struct target_ops *self, int arg1)
  954. {
  955.   int result;
  956.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_fork_catchpoint (...)\n", debug_target.to_shortname);
  957.   result = debug_target.to_remove_fork_catchpoint (&debug_target, arg1);
  958.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_fork_catchpoint (", debug_target.to_shortname);
  959.   target_debug_print_struct_target_ops_p (&debug_target);
  960.   fputs_unfiltered (", ", gdb_stdlog);
  961.   target_debug_print_int (arg1);
  962.   fputs_unfiltered (") = ", gdb_stdlog);
  963.   target_debug_print_int (result);
  964.   fputs_unfiltered ("\n", gdb_stdlog);
  965.   return result;
  966. }

  968. static int
  969. ‌delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1)
  970. {
  971.   self = self->beneath;
  972.   return self->to_insert_vfork_catchpoint (self, arg1);
  973. }

  975. static int
  976. ‌tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
  977. {
  978.   return 1;
  979. }

  981. static int
  982. ‌debug_insert_vfork_catchpoint (struct target_ops *self, int arg1)
  983. {
  984.   int result;
  985.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_vfork_catchpoint (...)\n", debug_target.to_shortname);
  986.   result = debug_target.to_insert_vfork_catchpoint (&debug_target, arg1);
  987.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_vfork_catchpoint (", debug_target.to_shortname);
  988.   target_debug_print_struct_target_ops_p (&debug_target);
  989.   fputs_unfiltered (", ", gdb_stdlog);
  990.   target_debug_print_int (arg1);
  991.   fputs_unfiltered (") = ", gdb_stdlog);
  992.   target_debug_print_int (result);
  993.   fputs_unfiltered ("\n", gdb_stdlog);
  994.   return result;
  995. }

  997. static int
  998. ‌delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1)
  999. {
  1000.   self = self->beneath;
  1001.   return self->to_remove_vfork_catchpoint (self, arg1);
  1002. }

  1004. static int
  1005. ‌tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
  1006. {
  1007.   return 1;
  1008. }

  1010. static int
  1011. ‌debug_remove_vfork_catchpoint (struct target_ops *self, int arg1)
  1012. {
  1013.   int result;
  1014.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_vfork_catchpoint (...)\n", debug_target.to_shortname);
  1015.   result = debug_target.to_remove_vfork_catchpoint (&debug_target, arg1);
  1016.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_vfork_catchpoint (", debug_target.to_shortname);
  1017.   target_debug_print_struct_target_ops_p (&debug_target);
  1018.   fputs_unfiltered (", ", gdb_stdlog);
  1019.   target_debug_print_int (arg1);
  1020.   fputs_unfiltered (") = ", gdb_stdlog);
  1021.   target_debug_print_int (result);
  1022.   fputs_unfiltered ("\n", gdb_stdlog);
  1023.   return result;
  1024. }

  1026. static int
  1027. ‌delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
  1028. {
  1029.   self = self->beneath;
  1030.   return self->to_follow_fork (self, arg1, arg2);
  1031. }

  1033. static int
  1034. ‌debug_follow_fork (struct target_ops *self, int arg1, int arg2)
  1035. {
  1036.   int result;
  1037.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_fork (...)\n", debug_target.to_shortname);
  1038.   result = debug_target.to_follow_fork (&debug_target, arg1, arg2);
  1039.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_fork (", debug_target.to_shortname);
  1040.   target_debug_print_struct_target_ops_p (&debug_target);
  1041.   fputs_unfiltered (", ", gdb_stdlog);
  1042.   target_debug_print_int (arg1);
  1043.   fputs_unfiltered (", ", gdb_stdlog);
  1044.   target_debug_print_int (arg2);
  1045.   fputs_unfiltered (") = ", gdb_stdlog);
  1046.   target_debug_print_int (result);
  1047.   fputs_unfiltered ("\n", gdb_stdlog);
  1048.   return result;
  1049. }

  1051. static int
  1052. ‌delegate_insert_exec_catchpoint (struct target_ops *self, int arg1)
  1053. {
  1054.   self = self->beneath;
  1055.   return self->to_insert_exec_catchpoint (self, arg1);
  1056. }

  1058. static int
  1059. ‌tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
  1060. {
  1061.   return 1;
  1062. }

  1064. static int
  1065. ‌debug_insert_exec_catchpoint (struct target_ops *self, int arg1)
  1066. {
  1067.   int result;
  1068.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_exec_catchpoint (...)\n", debug_target.to_shortname);
  1069.   result = debug_target.to_insert_exec_catchpoint (&debug_target, arg1);
  1070.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_exec_catchpoint (", debug_target.to_shortname);
  1071.   target_debug_print_struct_target_ops_p (&debug_target);
  1072.   fputs_unfiltered (", ", gdb_stdlog);
  1073.   target_debug_print_int (arg1);
  1074.   fputs_unfiltered (") = ", gdb_stdlog);
  1075.   target_debug_print_int (result);
  1076.   fputs_unfiltered ("\n", gdb_stdlog);
  1077.   return result;
  1078. }

  1080. static int
  1081. ‌delegate_remove_exec_catchpoint (struct target_ops *self, int arg1)
  1082. {
  1083.   self = self->beneath;
  1084.   return self->to_remove_exec_catchpoint (self, arg1);
  1085. }

  1087. static int
  1088. ‌tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
  1089. {
  1090.   return 1;
  1091. }

  1093. static int
  1094. ‌debug_remove_exec_catchpoint (struct target_ops *self, int arg1)
  1095. {
  1096.   int result;
  1097.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_exec_catchpoint (...)\n", debug_target.to_shortname);
  1098.   result = debug_target.to_remove_exec_catchpoint (&debug_target, arg1);
  1099.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_exec_catchpoint (", debug_target.to_shortname);
  1100.   target_debug_print_struct_target_ops_p (&debug_target);
  1101.   fputs_unfiltered (", ", gdb_stdlog);
  1102.   target_debug_print_int (arg1);
  1103.   fputs_unfiltered (") = ", gdb_stdlog);
  1104.   target_debug_print_int (result);
  1105.   fputs_unfiltered ("\n", gdb_stdlog);
  1106.   return result;
  1107. }

  1109. static int
  1110. ‌delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
  1111. {
  1112.   self = self->beneath;
  1113.   return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4, arg5);
  1114. }

  1116. static int
  1117. ‌tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
  1118. {
  1119.   return 1;
  1120. }

  1122. static int
  1123. ‌debug_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
  1124. {
  1125.   int result;
  1126.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname);
  1127.   result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4, arg5);
  1128.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname);
  1129.   target_debug_print_struct_target_ops_p (&debug_target);
  1130.   fputs_unfiltered (", ", gdb_stdlog);
  1131.   target_debug_print_int (arg1);
  1132.   fputs_unfiltered (", ", gdb_stdlog);
  1133.   target_debug_print_int (arg2);
  1134.   fputs_unfiltered (", ", gdb_stdlog);
  1135.   target_debug_print_int (arg3);
  1136.   fputs_unfiltered (", ", gdb_stdlog);
  1137.   target_debug_print_int (arg4);
  1138.   fputs_unfiltered (", ", gdb_stdlog);
  1139.   target_debug_print_int_p (arg5);
  1140.   fputs_unfiltered (") = ", gdb_stdlog);
  1141.   target_debug_print_int (result);
  1142.   fputs_unfiltered ("\n", gdb_stdlog);
  1143.   return result;
  1144. }

  1146. static int
  1147. ‌delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
  1148. {
  1149.   self = self->beneath;
  1150.   return self->to_has_exited (self, arg1, arg2, arg3);
  1151. }

  1153. static int
  1154. ‌tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
  1155. {
  1156.   return 0;
  1157. }

  1159. static int
  1160. ‌debug_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
  1161. {
  1162.   int result;
  1163.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_has_exited (...)\n", debug_target.to_shortname);
  1164.   result = debug_target.to_has_exited (&debug_target, arg1, arg2, arg3);
  1165.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_has_exited (", debug_target.to_shortname);
  1166.   target_debug_print_struct_target_ops_p (&debug_target);
  1167.   fputs_unfiltered (", ", gdb_stdlog);
  1168.   target_debug_print_int (arg1);
  1169.   fputs_unfiltered (", ", gdb_stdlog);
  1170.   target_debug_print_int (arg2);
  1171.   fputs_unfiltered (", ", gdb_stdlog);
  1172.   target_debug_print_int_p (arg3);
  1173.   fputs_unfiltered (") = ", gdb_stdlog);
  1174.   target_debug_print_int (result);
  1175.   fputs_unfiltered ("\n", gdb_stdlog);
  1176.   return result;
  1177. }

  1179. static void
  1180. ‌delegate_mourn_inferior (struct target_ops *self)
  1181. {
  1182.   self = self->beneath;
  1183.   self->to_mourn_inferior (self);
  1184. }

  1186. static void
  1187. ‌debug_mourn_inferior (struct target_ops *self)
  1188. {
  1189.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_mourn_inferior (...)\n", debug_target.to_shortname);
  1190.   debug_target.to_mourn_inferior (&debug_target);
  1191.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_mourn_inferior (", debug_target.to_shortname);
  1192.   target_debug_print_struct_target_ops_p (&debug_target);
  1193.   fputs_unfiltered (")\n", gdb_stdlog);
  1194. }

  1196. static int
  1197. ‌delegate_can_run (struct target_ops *self)
  1198. {
  1199.   self = self->beneath;
  1200.   return self->to_can_run (self);
  1201. }

  1203. static int
  1204. ‌tdefault_can_run (struct target_ops *self)
  1205. {
  1206.   return 0;
  1207. }

  1209. static int
  1210. ‌debug_can_run (struct target_ops *self)
  1211. {
  1212.   int result;
  1213.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run (...)\n", debug_target.to_shortname);
  1214.   result = debug_target.to_can_run (&debug_target);
  1215.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run (", debug_target.to_shortname);
  1216.   target_debug_print_struct_target_ops_p (&debug_target);
  1217.   fputs_unfiltered (") = ", gdb_stdlog);
  1218.   target_debug_print_int (result);
  1219.   fputs_unfiltered ("\n", gdb_stdlog);
  1220.   return result;
  1221. }

  1223. static void
  1224. ‌delegate_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
  1225. {
  1226.   self = self->beneath;
  1227.   self->to_pass_signals (self, arg1, arg2);
  1228. }

  1230. static void
  1231. ‌tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
  1232. {
  1233. }

  1235. static void
  1236. ‌debug_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
  1237. {
  1238.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", debug_target.to_shortname);
  1239.   debug_target.to_pass_signals (&debug_target, arg1, arg2);
  1240.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", debug_target.to_shortname);
  1241.   target_debug_print_struct_target_ops_p (&debug_target);
  1242.   fputs_unfiltered (", ", gdb_stdlog);
  1243.   target_debug_print_int (arg1);
  1244.   fputs_unfiltered (", ", gdb_stdlog);
  1245.   target_debug_print_signals (arg2);
  1246.   fputs_unfiltered (")\n", gdb_stdlog);
  1247. }

  1249. static void
  1250. ‌delegate_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
  1251. {
  1252.   self = self->beneath;
  1253.   self->to_program_signals (self, arg1, arg2);
  1254. }

  1256. static void
  1257. ‌tdefault_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
  1258. {
  1259. }

  1261. static void
  1262. ‌debug_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
  1263. {
  1264.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", debug_target.to_shortname);
  1265.   debug_target.to_program_signals (&debug_target, arg1, arg2);
  1266.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", debug_target.to_shortname);
  1267.   target_debug_print_struct_target_ops_p (&debug_target);
  1268.   fputs_unfiltered (", ", gdb_stdlog);
  1269.   target_debug_print_int (arg1);
  1270.   fputs_unfiltered (", ", gdb_stdlog);
  1271.   target_debug_print_signals (arg2);
  1272.   fputs_unfiltered (")\n", gdb_stdlog);
  1273. }

  1275. static int
  1276. ‌delegate_thread_alive (struct target_ops *self, ptid_t arg1)
  1277. {
  1278.   self = self->beneath;
  1279.   return self->to_thread_alive (self, arg1);
  1280. }

  1282. static int
  1283. ‌tdefault_thread_alive (struct target_ops *self, ptid_t arg1)
  1284. {
  1285.   return 0;
  1286. }

  1288. static int
  1289. ‌debug_thread_alive (struct target_ops *self, ptid_t arg1)
  1290. {
  1291.   int result;
  1292.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_alive (...)\n", debug_target.to_shortname);
  1293.   result = debug_target.to_thread_alive (&debug_target, arg1);
  1294.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_alive (", debug_target.to_shortname);
  1295.   target_debug_print_struct_target_ops_p (&debug_target);
  1296.   fputs_unfiltered (", ", gdb_stdlog);
  1297.   target_debug_print_ptid_t (arg1);
  1298.   fputs_unfiltered (") = ", gdb_stdlog);
  1299.   target_debug_print_int (result);
  1300.   fputs_unfiltered ("\n", gdb_stdlog);
  1301.   return result;
  1302. }

  1304. static void
  1305. ‌delegate_update_thread_list (struct target_ops *self)
  1306. {
  1307.   self = self->beneath;
  1308.   self->to_update_thread_list (self);
  1309. }

  1311. static void
  1312. ‌tdefault_update_thread_list (struct target_ops *self)
  1313. {
  1314. }

  1316. static void
  1317. ‌debug_update_thread_list (struct target_ops *self)
  1318. {
  1319.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_update_thread_list (...)\n", debug_target.to_shortname);
  1320.   debug_target.to_update_thread_list (&debug_target);
  1321.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_update_thread_list (", debug_target.to_shortname);
  1322.   target_debug_print_struct_target_ops_p (&debug_target);
  1323.   fputs_unfiltered (")\n", gdb_stdlog);
  1324. }

  1326. static char *
  1327. ‌delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
  1328. {
  1329.   self = self->beneath;
  1330.   return self->to_pid_to_str (self, arg1);
  1331. }

  1333. static char *
  1334. ‌debug_pid_to_str (struct target_ops *self, ptid_t arg1)
  1335. {
  1336.   char * result;
  1337.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_str (...)\n", debug_target.to_shortname);
  1338.   result = debug_target.to_pid_to_str (&debug_target, arg1);
  1339.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_str (", debug_target.to_shortname);
  1340.   target_debug_print_struct_target_ops_p (&debug_target);
  1341.   fputs_unfiltered (", ", gdb_stdlog);
  1342.   target_debug_print_ptid_t (arg1);
  1343.   fputs_unfiltered (") = ", gdb_stdlog);
  1344.   target_debug_print_char_p (result);
  1345.   fputs_unfiltered ("\n", gdb_stdlog);
  1346.   return result;
  1347. }

  1349. static char *
  1350. ‌delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
  1351. {
  1352.   self = self->beneath;
  1353.   return self->to_extra_thread_info (self, arg1);
  1354. }

  1356. static char *
  1357. ‌tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
  1358. {
  1359.   return NULL;
  1360. }

  1362. static char *
  1363. ‌debug_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
  1364. {
  1365.   char * result;
  1366.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_extra_thread_info (...)\n", debug_target.to_shortname);
  1367.   result = debug_target.to_extra_thread_info (&debug_target, arg1);
  1368.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_extra_thread_info (", debug_target.to_shortname);
  1369.   target_debug_print_struct_target_ops_p (&debug_target);
  1370.   fputs_unfiltered (", ", gdb_stdlog);
  1371.   target_debug_print_struct_thread_info_p (arg1);
  1372.   fputs_unfiltered (") = ", gdb_stdlog);
  1373.   target_debug_print_char_p (result);
  1374.   fputs_unfiltered ("\n", gdb_stdlog);
  1375.   return result;
  1376. }

  1378. static char *
  1379. ‌delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
  1380. {
  1381.   self = self->beneath;
  1382.   return self->to_thread_name (self, arg1);
  1383. }

  1385. static char *
  1386. ‌tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
  1387. {
  1388.   return NULL;
  1389. }

  1391. static char *
  1392. ‌debug_thread_name (struct target_ops *self, struct thread_info *arg1)
  1393. {
  1394.   char * result;
  1395.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_name (...)\n", debug_target.to_shortname);
  1396.   result = debug_target.to_thread_name (&debug_target, arg1);
  1397.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_name (", debug_target.to_shortname);
  1398.   target_debug_print_struct_target_ops_p (&debug_target);
  1399.   fputs_unfiltered (", ", gdb_stdlog);
  1400.   target_debug_print_struct_thread_info_p (arg1);
  1401.   fputs_unfiltered (") = ", gdb_stdlog);
  1402.   target_debug_print_char_p (result);
  1403.   fputs_unfiltered ("\n", gdb_stdlog);
  1404.   return result;
  1405. }

  1407. static void
  1408. ‌delegate_stop (struct target_ops *self, ptid_t arg1)
  1409. {
  1410.   self = self->beneath;
  1411.   self->to_stop (self, arg1);
  1412. }

  1414. static void
  1415. ‌tdefault_stop (struct target_ops *self, ptid_t arg1)
  1416. {
  1417. }

  1419. static void
  1420. ‌debug_stop (struct target_ops *self, ptid_t arg1)
  1421. {
  1422.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop (...)\n", debug_target.to_shortname);
  1423.   debug_target.to_stop (&debug_target, arg1);
  1424.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop (", debug_target.to_shortname);
  1425.   target_debug_print_struct_target_ops_p (&debug_target);
  1426.   fputs_unfiltered (", ", gdb_stdlog);
  1427.   target_debug_print_ptid_t (arg1);
  1428.   fputs_unfiltered (")\n", gdb_stdlog);
  1429. }

  1431. static void
  1432. ‌delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
  1433. {
  1434.   self = self->beneath;
  1435.   self->to_rcmd (self, arg1, arg2);
  1436. }

  1438. static void
  1439. ‌debug_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
  1440. {
  1441.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_rcmd (...)\n", debug_target.to_shortname);
  1442.   debug_target.to_rcmd (&debug_target, arg1, arg2);
  1443.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_rcmd (", debug_target.to_shortname);
  1444.   target_debug_print_struct_target_ops_p (&debug_target);
  1445.   fputs_unfiltered (", ", gdb_stdlog);
  1446.   target_debug_print_const_char_p (arg1);
  1447.   fputs_unfiltered (", ", gdb_stdlog);
  1448.   target_debug_print_struct_ui_file_p (arg2);
  1449.   fputs_unfiltered (")\n", gdb_stdlog);
  1450. }

  1452. static char *
  1453. ‌delegate_pid_to_exec_file (struct target_ops *self, int arg1)
  1454. {
  1455.   self = self->beneath;
  1456.   return self->to_pid_to_exec_file (self, arg1);
  1457. }

  1459. static char *
  1460. ‌tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
  1461. {
  1462.   return NULL;
  1463. }

  1465. static char *
  1466. ‌debug_pid_to_exec_file (struct target_ops *self, int arg1)
  1467. {
  1468.   char * result;
  1469.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_exec_file (...)\n", debug_target.to_shortname);
  1470.   result = debug_target.to_pid_to_exec_file (&debug_target, arg1);
  1471.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_exec_file (", debug_target.to_shortname);
  1472.   target_debug_print_struct_target_ops_p (&debug_target);
  1473.   fputs_unfiltered (", ", gdb_stdlog);
  1474.   target_debug_print_int (arg1);
  1475.   fputs_unfiltered (") = ", gdb_stdlog);
  1476.   target_debug_print_char_p (result);
  1477.   fputs_unfiltered ("\n", gdb_stdlog);
  1478.   return result;
  1479. }

  1481. static void
  1482. ‌delegate_log_command (struct target_ops *self, const char *arg1)
  1483. {
  1484.   self = self->beneath;
  1485.   self->to_log_command (self, arg1);
  1486. }

  1488. static void
  1489. ‌tdefault_log_command (struct target_ops *self, const char *arg1)
  1490. {
  1491. }

  1493. static void
  1494. ‌debug_log_command (struct target_ops *self, const char *arg1)
  1495. {
  1496.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_log_command (...)\n", debug_target.to_shortname);
  1497.   debug_target.to_log_command (&debug_target, arg1);
  1498.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_log_command (", debug_target.to_shortname);
  1499.   target_debug_print_struct_target_ops_p (&debug_target);
  1500.   fputs_unfiltered (", ", gdb_stdlog);
  1501.   target_debug_print_const_char_p (arg1);
  1502.   fputs_unfiltered (")\n", gdb_stdlog);
  1503. }

  1505. static struct target_section_table *
  1506. ‌delegate_get_section_table (struct target_ops *self)
  1507. {
  1508.   self = self->beneath;
  1509.   return self->to_get_section_table (self);
  1510. }

  1512. static struct target_section_table *
  1513. ‌tdefault_get_section_table (struct target_ops *self)
  1514. {
  1515.   return NULL;
  1516. }

  1518. static struct target_section_table *
  1519. ‌debug_get_section_table (struct target_ops *self)
  1520. {
  1521.   struct target_section_table * result;
  1522.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_section_table (...)\n", debug_target.to_shortname);
  1523.   result = debug_target.to_get_section_table (&debug_target);
  1524.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_section_table (", debug_target.to_shortname);
  1525.   target_debug_print_struct_target_ops_p (&debug_target);
  1526.   fputs_unfiltered (") = ", gdb_stdlog);
  1527.   target_debug_print_struct_target_section_table_p (result);
  1528.   fputs_unfiltered ("\n", gdb_stdlog);
  1529.   return result;
  1530. }

  1532. static int
  1533. ‌delegate_can_async_p (struct target_ops *self)
  1534. {
  1535.   self = self->beneath;
  1536.   return self->to_can_async_p (self);
  1537. }

  1539. static int
  1540. ‌tdefault_can_async_p (struct target_ops *self)
  1541. {
  1542.   return 0;
  1543. }

  1545. static int
  1546. ‌debug_can_async_p (struct target_ops *self)
  1547. {
  1548.   int result;
  1549.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_async_p (...)\n", debug_target.to_shortname);
  1550.   result = debug_target.to_can_async_p (&debug_target);
  1551.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_async_p (", debug_target.to_shortname);
  1552.   target_debug_print_struct_target_ops_p (&debug_target);
  1553.   fputs_unfiltered (") = ", gdb_stdlog);
  1554.   target_debug_print_int (result);
  1555.   fputs_unfiltered ("\n", gdb_stdlog);
  1556.   return result;
  1557. }

  1559. static int
  1560. ‌delegate_is_async_p (struct target_ops *self)
  1561. {
  1562.   self = self->beneath;
  1563.   return self->to_is_async_p (self);
  1564. }

  1566. static int
  1567. ‌tdefault_is_async_p (struct target_ops *self)
  1568. {
  1569.   return 0;
  1570. }

  1572. static int
  1573. ‌debug_is_async_p (struct target_ops *self)
  1574. {
  1575.   int result;
  1576.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_is_async_p (...)\n", debug_target.to_shortname);
  1577.   result = debug_target.to_is_async_p (&debug_target);
  1578.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_is_async_p (", debug_target.to_shortname);
  1579.   target_debug_print_struct_target_ops_p (&debug_target);
  1580.   fputs_unfiltered (") = ", gdb_stdlog);
  1581.   target_debug_print_int (result);
  1582.   fputs_unfiltered ("\n", gdb_stdlog);
  1583.   return result;
  1584. }

  1586. static void
  1587. ‌delegate_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
  1588. {
  1589.   self = self->beneath;
  1590.   self->to_async (self, arg1, arg2);
  1591. }

  1593. static void
  1594. ‌tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
  1595. {
  1596.   tcomplain ();
  1597. }

  1599. static void
  1600. ‌debug_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
  1601. {
  1602.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname);
  1603.   debug_target.to_async (&debug_target, arg1, arg2);
  1604.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", debug_target.to_shortname);
  1605.   target_debug_print_struct_target_ops_p (&debug_target);
  1606.   fputs_unfiltered (", ", gdb_stdlog);
  1607.   target_debug_print_async_callback_ftype_p (arg1);
  1608.   fputs_unfiltered (", ", gdb_stdlog);
  1609.   target_debug_print_void_p (arg2);
  1610.   fputs_unfiltered (")\n", gdb_stdlog);
  1611. }

  1613. static int
  1614. ‌delegate_supports_non_stop (struct target_ops *self)
  1615. {
  1616.   self = self->beneath;
  1617.   return self->to_supports_non_stop (self);
  1618. }

  1620. static int
  1621. ‌tdefault_supports_non_stop (struct target_ops *self)
  1622. {
  1623.   return 0;
  1624. }

  1626. static int
  1627. ‌debug_supports_non_stop (struct target_ops *self)
  1628. {
  1629.   int result;
  1630.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", debug_target.to_shortname);
  1631.   result = debug_target.to_supports_non_stop (&debug_target);
  1632.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", debug_target.to_shortname);
  1633.   target_debug_print_struct_target_ops_p (&debug_target);
  1634.   fputs_unfiltered (") = ", gdb_stdlog);
  1635.   target_debug_print_int (result);
  1636.   fputs_unfiltered ("\n", gdb_stdlog);
  1637.   return result;
  1638. }

  1640. static int
  1641. ‌delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
  1642. {
  1643.   self = self->beneath;
  1644.   return self->to_find_memory_regions (self, arg1, arg2);
  1645. }

  1647. static int
  1648. ‌debug_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
  1649. {
  1650.   int result;
  1651.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", debug_target.to_shortname);
  1652.   result = debug_target.to_find_memory_regions (&debug_target, arg1, arg2);
  1653.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", debug_target.to_shortname);
  1654.   target_debug_print_struct_target_ops_p (&debug_target);
  1655.   fputs_unfiltered (", ", gdb_stdlog);
  1656.   target_debug_print_find_memory_region_ftype (arg1);
  1657.   fputs_unfiltered (", ", gdb_stdlog);
  1658.   target_debug_print_void_p (arg2);
  1659.   fputs_unfiltered (") = ", gdb_stdlog);
  1660.   target_debug_print_int (result);
  1661.   fputs_unfiltered ("\n", gdb_stdlog);
  1662.   return result;
  1663. }

  1665. static char *
  1666. ‌delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
  1667. {
  1668.   self = self->beneath;
  1669.   return self->to_make_corefile_notes (self, arg1, arg2);
  1670. }

  1672. static char *
  1673. ‌debug_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
  1674. {
  1675.   char * result;
  1676.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", debug_target.to_shortname);
  1677.   result = debug_target.to_make_corefile_notes (&debug_target, arg1, arg2);
  1678.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", debug_target.to_shortname);
  1679.   target_debug_print_struct_target_ops_p (&debug_target);
  1680.   fputs_unfiltered (", ", gdb_stdlog);
  1681.   target_debug_print_bfd_p (arg1);
  1682.   fputs_unfiltered (", ", gdb_stdlog);
  1683.   target_debug_print_int_p (arg2);
  1684.   fputs_unfiltered (") = ", gdb_stdlog);
  1685.   target_debug_print_char_p (result);
  1686.   fputs_unfiltered ("\n", gdb_stdlog);
  1687.   return result;
  1688. }

  1690. static gdb_byte *
  1691. ‌delegate_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
  1692. {
  1693.   self = self->beneath;
  1694.   return self->to_get_bookmark (self, arg1, arg2);
  1695. }

  1697. static gdb_byte *
  1698. ‌tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
  1699. {
  1700.   tcomplain ();
  1701. }

  1703. static gdb_byte *
  1704. ‌debug_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
  1705. {
  1706.   gdb_byte * result;
  1707.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", debug_target.to_shortname);
  1708.   result = debug_target.to_get_bookmark (&debug_target, arg1, arg2);
  1709.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", debug_target.to_shortname);
  1710.   target_debug_print_struct_target_ops_p (&debug_target);
  1711.   fputs_unfiltered (", ", gdb_stdlog);
  1712.   target_debug_print_const_char_p (arg1);
  1713.   fputs_unfiltered (", ", gdb_stdlog);
  1714.   target_debug_print_int (arg2);
  1715.   fputs_unfiltered (") = ", gdb_stdlog);
  1716.   target_debug_print_gdb_byte_p (result);
  1717.   fputs_unfiltered ("\n", gdb_stdlog);
  1718.   return result;
  1719. }

  1721. static void
  1722. ‌delegate_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
  1723. {
  1724.   self = self->beneath;
  1725.   self->to_goto_bookmark (self, arg1, arg2);
  1726. }

  1728. static void
  1729. ‌tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
  1730. {
  1731.   tcomplain ();
  1732. }

  1734. static void
  1735. ‌debug_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
  1736. {
  1737.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", debug_target.to_shortname);
  1738.   debug_target.to_goto_bookmark (&debug_target, arg1, arg2);
  1739.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", debug_target.to_shortname);
  1740.   target_debug_print_struct_target_ops_p (&debug_target);
  1741.   fputs_unfiltered (", ", gdb_stdlog);
  1742.   target_debug_print_const_gdb_byte_p (arg1);
  1743.   fputs_unfiltered (", ", gdb_stdlog);
  1744.   target_debug_print_int (arg2);
  1745.   fputs_unfiltered (")\n", gdb_stdlog);
  1746. }

  1748. static CORE_ADDR
  1749. ‌delegate_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
  1750. {
  1751.   self = self->beneath;
  1752.   return self->to_get_thread_local_address (self, arg1, arg2, arg3);
  1753. }

  1755. static CORE_ADDR
  1756. ‌tdefault_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
  1757. {
  1758.   generic_tls_error ();
  1759. }

  1761. static CORE_ADDR
  1762. ‌debug_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
  1763. {
  1764.   CORE_ADDR result;
  1765.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_thread_local_address (...)\n", debug_target.to_shortname);
  1766.   result = debug_target.to_get_thread_local_address (&debug_target, arg1, arg2, arg3);
  1767.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_thread_local_address (", debug_target.to_shortname);
  1768.   target_debug_print_struct_target_ops_p (&debug_target);
  1769.   fputs_unfiltered (", ", gdb_stdlog);
  1770.   target_debug_print_ptid_t (arg1);
  1771.   fputs_unfiltered (", ", gdb_stdlog);
  1772.   target_debug_print_CORE_ADDR (arg2);
  1773.   fputs_unfiltered (", ", gdb_stdlog);
  1774.   target_debug_print_CORE_ADDR (arg3);
  1775.   fputs_unfiltered (") = ", gdb_stdlog);
  1776.   target_debug_print_CORE_ADDR (result);
  1777.   fputs_unfiltered ("\n", gdb_stdlog);
  1778.   return result;
  1779. }

  1781. static enum target_xfer_status
  1782. ‌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)
  1783. {
  1784.   self = self->beneath;
  1785.   return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  1786. }

  1788. static enum target_xfer_status
  1789. ‌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)
  1790. {
  1791.   return TARGET_XFER_E_IO;
  1792. }

  1794. static enum target_xfer_status
  1795. ‌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)
  1796. {
  1797.   enum target_xfer_status result;
  1798.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", debug_target.to_shortname);
  1799.   result = debug_target.to_xfer_partial (&debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  1800.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", debug_target.to_shortname);
  1801.   target_debug_print_struct_target_ops_p (&debug_target);
  1802.   fputs_unfiltered (", ", gdb_stdlog);
  1803.   target_debug_print_enum_target_object (arg1);
  1804.   fputs_unfiltered (", ", gdb_stdlog);
  1805.   target_debug_print_const_char_p (arg2);
  1806.   fputs_unfiltered (", ", gdb_stdlog);
  1807.   target_debug_print_gdb_byte_p (arg3);
  1808.   fputs_unfiltered (", ", gdb_stdlog);
  1809.   target_debug_print_const_gdb_byte_p (arg4);
  1810.   fputs_unfiltered (", ", gdb_stdlog);
  1811.   target_debug_print_ULONGEST (arg5);
  1812.   fputs_unfiltered (", ", gdb_stdlog);
  1813.   target_debug_print_ULONGEST (arg6);
  1814.   fputs_unfiltered (", ", gdb_stdlog);
  1815.   target_debug_print_ULONGEST_p (arg7);
  1816.   fputs_unfiltered (") = ", gdb_stdlog);
  1817.   target_debug_print_enum_target_xfer_status (result);
  1818.   fputs_unfiltered ("\n", gdb_stdlog);
  1819.   return result;
  1820. }

  1822. ‌static VEC(mem_region_s) *
  1823. delegate_memory_map (struct target_ops *self)
  1824. {
  1825.   self = self->beneath;
  1826.   return self->to_memory_map (self);
  1827. }

  1829. ‌static VEC(mem_region_s) *
  1830. tdefault_memory_map (struct target_ops *self)
  1831. {
  1832.   return NULL;
  1833. }

  1835. ‌static VEC(mem_region_s) *
  1836. debug_memory_map (struct target_ops *self)
  1837. {
  1838.   VEC(mem_region_s) * result;
  1839.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", debug_target.to_shortname);
  1840.   result = debug_target.to_memory_map (&debug_target);
  1841.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", debug_target.to_shortname);
  1842.   target_debug_print_struct_target_ops_p (&debug_target);
  1843.   fputs_unfiltered (") = ", gdb_stdlog);
  1844.   target_debug_print_VEC_mem_region_s__p (result);
  1845.   fputs_unfiltered ("\n", gdb_stdlog);
  1846.   return result;
  1847. }

  1849. static void
  1850. ‌delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
  1851. {
  1852.   self = self->beneath;
  1853.   self->to_flash_erase (self, arg1, arg2);
  1854. }

  1856. static void
  1857. ‌tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
  1858. {
  1859.   tcomplain ();
  1860. }

  1862. static void
  1863. ‌debug_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
  1864. {
  1865.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", debug_target.to_shortname);
  1866.   debug_target.to_flash_erase (&debug_target, arg1, arg2);
  1867.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", debug_target.to_shortname);
  1868.   target_debug_print_struct_target_ops_p (&debug_target);
  1869.   fputs_unfiltered (", ", gdb_stdlog);
  1870.   target_debug_print_ULONGEST (arg1);
  1871.   fputs_unfiltered (", ", gdb_stdlog);
  1872.   target_debug_print_LONGEST (arg2);
  1873.   fputs_unfiltered (")\n", gdb_stdlog);
  1874. }

  1876. static void
  1877. ‌delegate_flash_done (struct target_ops *self)
  1878. {
  1879.   self = self->beneath;
  1880.   self->to_flash_done (self);
  1881. }

  1883. static void
  1884. ‌tdefault_flash_done (struct target_ops *self)
  1885. {
  1886.   tcomplain ();
  1887. }

  1889. static void
  1890. ‌debug_flash_done (struct target_ops *self)
  1891. {
  1892.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", debug_target.to_shortname);
  1893.   debug_target.to_flash_done (&debug_target);
  1894.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", debug_target.to_shortname);
  1895.   target_debug_print_struct_target_ops_p (&debug_target);
  1896.   fputs_unfiltered (")\n", gdb_stdlog);
  1897. }

  1899. static const struct target_desc *
  1900. ‌delegate_read_description (struct target_ops *self)
  1901. {
  1902.   self = self->beneath;
  1903.   return self->to_read_description (self);
  1904. }

  1906. static const struct target_desc *
  1907. ‌tdefault_read_description (struct target_ops *self)
  1908. {
  1909.   return NULL;
  1910. }

  1912. static const struct target_desc *
  1913. ‌debug_read_description (struct target_ops *self)
  1914. {
  1915.   const struct target_desc * result;
  1916.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", debug_target.to_shortname);
  1917.   result = debug_target.to_read_description (&debug_target);
  1918.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", debug_target.to_shortname);
  1919.   target_debug_print_struct_target_ops_p (&debug_target);
  1920.   fputs_unfiltered (") = ", gdb_stdlog);
  1921.   target_debug_print_const_struct_target_desc_p (result);
  1922.   fputs_unfiltered ("\n", gdb_stdlog);
  1923.   return result;
  1924. }

  1926. static ptid_t
  1927. ‌delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
  1928. {
  1929.   self = self->beneath;
  1930.   return self->to_get_ada_task_ptid (self, arg1, arg2);
  1931. }

  1933. static ptid_t
  1934. ‌debug_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
  1935. {
  1936.   ptid_t result;
  1937.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", debug_target.to_shortname);
  1938.   result = debug_target.to_get_ada_task_ptid (&debug_target, arg1, arg2);
  1939.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", debug_target.to_shortname);
  1940.   target_debug_print_struct_target_ops_p (&debug_target);
  1941.   fputs_unfiltered (", ", gdb_stdlog);
  1942.   target_debug_print_long (arg1);
  1943.   fputs_unfiltered (", ", gdb_stdlog);
  1944.   target_debug_print_long (arg2);
  1945.   fputs_unfiltered (") = ", gdb_stdlog);
  1946.   target_debug_print_ptid_t (result);
  1947.   fputs_unfiltered ("\n", gdb_stdlog);
  1948.   return result;
  1949. }

  1951. static int
  1952. ‌delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
  1953. {
  1954.   self = self->beneath;
  1955.   return self->to_auxv_parse (self, arg1, arg2, arg3, arg4);
  1956. }

  1958. static int
  1959. ‌debug_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
  1960. {
  1961.   int result;
  1962.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", debug_target.to_shortname);
  1963.   result = debug_target.to_auxv_parse (&debug_target, arg1, arg2, arg3, arg4);
  1964.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", debug_target.to_shortname);
  1965.   target_debug_print_struct_target_ops_p (&debug_target);
  1966.   fputs_unfiltered (", ", gdb_stdlog);
  1967.   target_debug_print_gdb_byte_pp (arg1);
  1968.   fputs_unfiltered (", ", gdb_stdlog);
  1969.   target_debug_print_gdb_byte_p (arg2);
  1970.   fputs_unfiltered (", ", gdb_stdlog);
  1971.   target_debug_print_CORE_ADDR_p (arg3);
  1972.   fputs_unfiltered (", ", gdb_stdlog);
  1973.   target_debug_print_CORE_ADDR_p (arg4);
  1974.   fputs_unfiltered (") = ", gdb_stdlog);
  1975.   target_debug_print_int (result);
  1976.   fputs_unfiltered ("\n", gdb_stdlog);
  1977.   return result;
  1978. }

  1980. static int
  1981. ‌delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
  1982. {
  1983.   self = self->beneath;
  1984.   return self->to_search_memory (self, arg1, arg2, arg3, arg4, arg5);
  1985. }

  1987. static int
  1988. ‌debug_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
  1989. {
  1990.   int result;
  1991.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", debug_target.to_shortname);
  1992.   result = debug_target.to_search_memory (&debug_target, arg1, arg2, arg3, arg4, arg5);
  1993.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", debug_target.to_shortname);
  1994.   target_debug_print_struct_target_ops_p (&debug_target);
  1995.   fputs_unfiltered (", ", gdb_stdlog);
  1996.   target_debug_print_CORE_ADDR (arg1);
  1997.   fputs_unfiltered (", ", gdb_stdlog);
  1998.   target_debug_print_ULONGEST (arg2);
  1999.   fputs_unfiltered (", ", gdb_stdlog);
  2000.   target_debug_print_const_gdb_byte_p (arg3);
  2001.   fputs_unfiltered (", ", gdb_stdlog);
  2002.   target_debug_print_ULONGEST (arg4);
  2003.   fputs_unfiltered (", ", gdb_stdlog);
  2004.   target_debug_print_CORE_ADDR_p (arg5);
  2005.   fputs_unfiltered (") = ", gdb_stdlog);
  2006.   target_debug_print_int (result);
  2007.   fputs_unfiltered ("\n", gdb_stdlog);
  2008.   return result;
  2009. }

  2011. static int
  2012. ‌delegate_can_execute_reverse (struct target_ops *self)
  2013. {
  2014.   self = self->beneath;
  2015.   return self->to_can_execute_reverse (self);
  2016. }

  2018. static int
  2019. ‌tdefault_can_execute_reverse (struct target_ops *self)
  2020. {
  2021.   return 0;
  2022. }

  2024. static int
  2025. ‌debug_can_execute_reverse (struct target_ops *self)
  2026. {
  2027.   int result;
  2028.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", debug_target.to_shortname);
  2029.   result = debug_target.to_can_execute_reverse (&debug_target);
  2030.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", debug_target.to_shortname);
  2031.   target_debug_print_struct_target_ops_p (&debug_target);
  2032.   fputs_unfiltered (") = ", gdb_stdlog);
  2033.   target_debug_print_int (result);
  2034.   fputs_unfiltered ("\n", gdb_stdlog);
  2035.   return result;
  2036. }

  2038. static enum exec_direction_kind
  2039. ‌delegate_execution_direction (struct target_ops *self)
  2040. {
  2041.   self = self->beneath;
  2042.   return self->to_execution_direction (self);
  2043. }

  2045. static enum exec_direction_kind
  2046. ‌debug_execution_direction (struct target_ops *self)
  2047. {
  2048.   enum exec_direction_kind result;
  2049.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", debug_target.to_shortname);
  2050.   result = debug_target.to_execution_direction (&debug_target);
  2051.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", debug_target.to_shortname);
  2052.   target_debug_print_struct_target_ops_p (&debug_target);
  2053.   fputs_unfiltered (") = ", gdb_stdlog);
  2054.   target_debug_print_enum_exec_direction_kind (result);
  2055.   fputs_unfiltered ("\n", gdb_stdlog);
  2056.   return result;
  2057. }

  2059. static int
  2060. ‌delegate_supports_multi_process (struct target_ops *self)
  2061. {
  2062.   self = self->beneath;
  2063.   return self->to_supports_multi_process (self);
  2064. }

  2066. static int
  2067. ‌tdefault_supports_multi_process (struct target_ops *self)
  2068. {
  2069.   return 0;
  2070. }

  2072. static int
  2073. ‌debug_supports_multi_process (struct target_ops *self)
  2074. {
  2075.   int result;
  2076.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", debug_target.to_shortname);
  2077.   result = debug_target.to_supports_multi_process (&debug_target);
  2078.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", debug_target.to_shortname);
  2079.   target_debug_print_struct_target_ops_p (&debug_target);
  2080.   fputs_unfiltered (") = ", gdb_stdlog);
  2081.   target_debug_print_int (result);
  2082.   fputs_unfiltered ("\n", gdb_stdlog);
  2083.   return result;
  2084. }

  2086. static int
  2087. ‌delegate_supports_enable_disable_tracepoint (struct target_ops *self)
  2088. {
  2089.   self = self->beneath;
  2090.   return self->to_supports_enable_disable_tracepoint (self);
  2091. }

  2093. static int
  2094. ‌tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
  2095. {
  2096.   return 0;
  2097. }

  2099. static int
  2100. ‌debug_supports_enable_disable_tracepoint (struct target_ops *self)
  2101. {
  2102.   int result;
  2103.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", debug_target.to_shortname);
  2104.   result = debug_target.to_supports_enable_disable_tracepoint (&debug_target);
  2105.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", debug_target.to_shortname);
  2106.   target_debug_print_struct_target_ops_p (&debug_target);
  2107.   fputs_unfiltered (") = ", gdb_stdlog);
  2108.   target_debug_print_int (result);
  2109.   fputs_unfiltered ("\n", gdb_stdlog);
  2110.   return result;
  2111. }

  2113. static int
  2114. ‌delegate_supports_string_tracing (struct target_ops *self)
  2115. {
  2116.   self = self->beneath;
  2117.   return self->to_supports_string_tracing (self);
  2118. }

  2120. static int
  2121. ‌tdefault_supports_string_tracing (struct target_ops *self)
  2122. {
  2123.   return 0;
  2124. }

  2126. static int
  2127. ‌debug_supports_string_tracing (struct target_ops *self)
  2128. {
  2129.   int result;
  2130.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", debug_target.to_shortname);
  2131.   result = debug_target.to_supports_string_tracing (&debug_target);
  2132.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", debug_target.to_shortname);
  2133.   target_debug_print_struct_target_ops_p (&debug_target);
  2134.   fputs_unfiltered (") = ", gdb_stdlog);
  2135.   target_debug_print_int (result);
  2136.   fputs_unfiltered ("\n", gdb_stdlog);
  2137.   return result;
  2138. }

  2140. static int
  2141. ‌delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
  2142. {
  2143.   self = self->beneath;
  2144.   return self->to_supports_evaluation_of_breakpoint_conditions (self);
  2145. }

  2147. static int
  2148. ‌tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
  2149. {
  2150.   return 0;
  2151. }

  2153. static int
  2154. ‌debug_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
  2155. {
  2156.   int result;
  2157.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", debug_target.to_shortname);
  2158.   result = debug_target.to_supports_evaluation_of_breakpoint_conditions (&debug_target);
  2159.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", debug_target.to_shortname);
  2160.   target_debug_print_struct_target_ops_p (&debug_target);
  2161.   fputs_unfiltered (") = ", gdb_stdlog);
  2162.   target_debug_print_int (result);
  2163.   fputs_unfiltered ("\n", gdb_stdlog);
  2164.   return result;
  2165. }

  2167. static int
  2168. ‌delegate_can_run_breakpoint_commands (struct target_ops *self)
  2169. {
  2170.   self = self->beneath;
  2171.   return self->to_can_run_breakpoint_commands (self);
  2172. }

  2174. static int
  2175. ‌tdefault_can_run_breakpoint_commands (struct target_ops *self)
  2176. {
  2177.   return 0;
  2178. }

  2180. static int
  2181. ‌debug_can_run_breakpoint_commands (struct target_ops *self)
  2182. {
  2183.   int result;
  2184.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", debug_target.to_shortname);
  2185.   result = debug_target.to_can_run_breakpoint_commands (&debug_target);
  2186.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", debug_target.to_shortname);
  2187.   target_debug_print_struct_target_ops_p (&debug_target);
  2188.   fputs_unfiltered (") = ", gdb_stdlog);
  2189.   target_debug_print_int (result);
  2190.   fputs_unfiltered ("\n", gdb_stdlog);
  2191.   return result;
  2192. }

  2194. static struct gdbarch *
  2195. ‌delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
  2196. {
  2197.   self = self->beneath;
  2198.   return self->to_thread_architecture (self, arg1);
  2199. }

  2201. static struct gdbarch *
  2202. ‌debug_thread_architecture (struct target_ops *self, ptid_t arg1)
  2203. {
  2204.   struct gdbarch * result;
  2205.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", debug_target.to_shortname);
  2206.   result = debug_target.to_thread_architecture (&debug_target, arg1);
  2207.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", debug_target.to_shortname);
  2208.   target_debug_print_struct_target_ops_p (&debug_target);
  2209.   fputs_unfiltered (", ", gdb_stdlog);
  2210.   target_debug_print_ptid_t (arg1);
  2211.   fputs_unfiltered (") = ", gdb_stdlog);
  2212.   target_debug_print_struct_gdbarch_p (result);
  2213.   fputs_unfiltered ("\n", gdb_stdlog);
  2214.   return result;
  2215. }

  2217. static struct address_space *
  2218. ‌delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
  2219. {
  2220.   self = self->beneath;
  2221.   return self->to_thread_address_space (self, arg1);
  2222. }

  2224. static struct address_space *
  2225. ‌debug_thread_address_space (struct target_ops *self, ptid_t arg1)
  2226. {
  2227.   struct address_space * result;
  2228.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", debug_target.to_shortname);
  2229.   result = debug_target.to_thread_address_space (&debug_target, arg1);
  2230.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", debug_target.to_shortname);
  2231.   target_debug_print_struct_target_ops_p (&debug_target);
  2232.   fputs_unfiltered (", ", gdb_stdlog);
  2233.   target_debug_print_ptid_t (arg1);
  2234.   fputs_unfiltered (") = ", gdb_stdlog);
  2235.   target_debug_print_struct_address_space_p (result);
  2236.   fputs_unfiltered ("\n", gdb_stdlog);
  2237.   return result;
  2238. }

  2240. static void
  2241. ‌delegate_trace_init (struct target_ops *self)
  2242. {
  2243.   self = self->beneath;
  2244.   self->to_trace_init (self);
  2245. }

  2247. static void
  2248. ‌tdefault_trace_init (struct target_ops *self)
  2249. {
  2250.   tcomplain ();
  2251. }

  2253. static void
  2254. ‌debug_trace_init (struct target_ops *self)
  2255. {
  2256.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", debug_target.to_shortname);
  2257.   debug_target.to_trace_init (&debug_target);
  2258.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", debug_target.to_shortname);
  2259.   target_debug_print_struct_target_ops_p (&debug_target);
  2260.   fputs_unfiltered (")\n", gdb_stdlog);
  2261. }

  2263. static void
  2264. ‌delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
  2265. {
  2266.   self = self->beneath;
  2267.   self->to_download_tracepoint (self, arg1);
  2268. }

  2270. static void
  2271. ‌tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
  2272. {
  2273.   tcomplain ();
  2274. }

  2276. static void
  2277. ‌debug_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
  2278. {
  2279.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", debug_target.to_shortname);
  2280.   debug_target.to_download_tracepoint (&debug_target, arg1);
  2281.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", debug_target.to_shortname);
  2282.   target_debug_print_struct_target_ops_p (&debug_target);
  2283.   fputs_unfiltered (", ", gdb_stdlog);
  2284.   target_debug_print_struct_bp_location_p (arg1);
  2285.   fputs_unfiltered (")\n", gdb_stdlog);
  2286. }

  2288. static int
  2289. ‌delegate_can_download_tracepoint (struct target_ops *self)
  2290. {
  2291.   self = self->beneath;
  2292.   return self->to_can_download_tracepoint (self);
  2293. }

  2295. static int
  2296. ‌tdefault_can_download_tracepoint (struct target_ops *self)
  2297. {
  2298.   return 0;
  2299. }

  2301. static int
  2302. ‌debug_can_download_tracepoint (struct target_ops *self)
  2303. {
  2304.   int result;
  2305.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", debug_target.to_shortname);
  2306.   result = debug_target.to_can_download_tracepoint (&debug_target);
  2307.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", debug_target.to_shortname);
  2308.   target_debug_print_struct_target_ops_p (&debug_target);
  2309.   fputs_unfiltered (") = ", gdb_stdlog);
  2310.   target_debug_print_int (result);
  2311.   fputs_unfiltered ("\n", gdb_stdlog);
  2312.   return result;
  2313. }

  2315. static void
  2316. ‌delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
  2317. {
  2318.   self = self->beneath;
  2319.   self->to_download_trace_state_variable (self, arg1);
  2320. }

  2322. static void
  2323. ‌tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
  2324. {
  2325.   tcomplain ();
  2326. }

  2328. static void
  2329. ‌debug_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
  2330. {
  2331.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", debug_target.to_shortname);
  2332.   debug_target.to_download_trace_state_variable (&debug_target, arg1);
  2333.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", debug_target.to_shortname);
  2334.   target_debug_print_struct_target_ops_p (&debug_target);
  2335.   fputs_unfiltered (", ", gdb_stdlog);
  2336.   target_debug_print_struct_trace_state_variable_p (arg1);
  2337.   fputs_unfiltered (")\n", gdb_stdlog);
  2338. }

  2340. static void
  2341. ‌delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
  2342. {
  2343.   self = self->beneath;
  2344.   self->to_enable_tracepoint (self, arg1);
  2345. }

  2347. static void
  2348. ‌tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
  2349. {
  2350.   tcomplain ();
  2351. }

  2353. static void
  2354. ‌debug_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
  2355. {
  2356.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", debug_target.to_shortname);
  2357.   debug_target.to_enable_tracepoint (&debug_target, arg1);
  2358.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", debug_target.to_shortname);
  2359.   target_debug_print_struct_target_ops_p (&debug_target);
  2360.   fputs_unfiltered (", ", gdb_stdlog);
  2361.   target_debug_print_struct_bp_location_p (arg1);
  2362.   fputs_unfiltered (")\n", gdb_stdlog);
  2363. }

  2365. static void
  2366. ‌delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
  2367. {
  2368.   self = self->beneath;
  2369.   self->to_disable_tracepoint (self, arg1);
  2370. }

  2372. static void
  2373. ‌tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
  2374. {
  2375.   tcomplain ();
  2376. }

  2378. static void
  2379. ‌debug_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
  2380. {
  2381.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", debug_target.to_shortname);
  2382.   debug_target.to_disable_tracepoint (&debug_target, arg1);
  2383.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", debug_target.to_shortname);
  2384.   target_debug_print_struct_target_ops_p (&debug_target);
  2385.   fputs_unfiltered (", ", gdb_stdlog);
  2386.   target_debug_print_struct_bp_location_p (arg1);
  2387.   fputs_unfiltered (")\n", gdb_stdlog);
  2388. }

  2390. static void
  2391. ‌delegate_trace_set_readonly_regions (struct target_ops *self)
  2392. {
  2393.   self = self->beneath;
  2394.   self->to_trace_set_readonly_regions (self);
  2395. }

  2397. static void
  2398. ‌tdefault_trace_set_readonly_regions (struct target_ops *self)
  2399. {
  2400.   tcomplain ();
  2401. }

  2403. static void
  2404. ‌debug_trace_set_readonly_regions (struct target_ops *self)
  2405. {
  2406.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", debug_target.to_shortname);
  2407.   debug_target.to_trace_set_readonly_regions (&debug_target);
  2408.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", debug_target.to_shortname);
  2409.   target_debug_print_struct_target_ops_p (&debug_target);
  2410.   fputs_unfiltered (")\n", gdb_stdlog);
  2411. }

  2413. static void
  2414. ‌delegate_trace_start (struct target_ops *self)
  2415. {
  2416.   self = self->beneath;
  2417.   self->to_trace_start (self);
  2418. }

  2420. static void
  2421. ‌tdefault_trace_start (struct target_ops *self)
  2422. {
  2423.   tcomplain ();
  2424. }

  2426. static void
  2427. ‌debug_trace_start (struct target_ops *self)
  2428. {
  2429.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", debug_target.to_shortname);
  2430.   debug_target.to_trace_start (&debug_target);
  2431.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", debug_target.to_shortname);
  2432.   target_debug_print_struct_target_ops_p (&debug_target);
  2433.   fputs_unfiltered (")\n", gdb_stdlog);
  2434. }

  2436. static int
  2437. ‌delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
  2438. {
  2439.   self = self->beneath;
  2440.   return self->to_get_trace_status (self, arg1);
  2441. }

  2443. static int
  2444. ‌tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
  2445. {
  2446.   return -1;
  2447. }

  2449. static int
  2450. ‌debug_get_trace_status (struct target_ops *self, struct trace_status *arg1)
  2451. {
  2452.   int result;
  2453.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", debug_target.to_shortname);
  2454.   result = debug_target.to_get_trace_status (&debug_target, arg1);
  2455.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", debug_target.to_shortname);
  2456.   target_debug_print_struct_target_ops_p (&debug_target);
  2457.   fputs_unfiltered (", ", gdb_stdlog);
  2458.   target_debug_print_struct_trace_status_p (arg1);
  2459.   fputs_unfiltered (") = ", gdb_stdlog);
  2460.   target_debug_print_int (result);
  2461.   fputs_unfiltered ("\n", gdb_stdlog);
  2462.   return result;
  2463. }

  2465. static void
  2466. ‌delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
  2467. {
  2468.   self = self->beneath;
  2469.   self->to_get_tracepoint_status (self, arg1, arg2);
  2470. }

  2472. static void
  2473. ‌tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
  2474. {
  2475.   tcomplain ();
  2476. }

  2478. static void
  2479. ‌debug_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
  2480. {
  2481.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", debug_target.to_shortname);
  2482.   debug_target.to_get_tracepoint_status (&debug_target, arg1, arg2);
  2483.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", debug_target.to_shortname);
  2484.   target_debug_print_struct_target_ops_p (&debug_target);
  2485.   fputs_unfiltered (", ", gdb_stdlog);
  2486.   target_debug_print_struct_breakpoint_p (arg1);
  2487.   fputs_unfiltered (", ", gdb_stdlog);
  2488.   target_debug_print_struct_uploaded_tp_p (arg2);
  2489.   fputs_unfiltered (")\n", gdb_stdlog);
  2490. }

  2492. static void
  2493. ‌delegate_trace_stop (struct target_ops *self)
  2494. {
  2495.   self = self->beneath;
  2496.   self->to_trace_stop (self);
  2497. }

  2499. static void
  2500. ‌tdefault_trace_stop (struct target_ops *self)
  2501. {
  2502.   tcomplain ();
  2503. }

  2505. static void
  2506. ‌debug_trace_stop (struct target_ops *self)
  2507. {
  2508.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", debug_target.to_shortname);
  2509.   debug_target.to_trace_stop (&debug_target);
  2510.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", debug_target.to_shortname);
  2511.   target_debug_print_struct_target_ops_p (&debug_target);
  2512.   fputs_unfiltered (")\n", gdb_stdlog);
  2513. }

  2515. static int
  2516. ‌delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
  2517. {
  2518.   self = self->beneath;
  2519.   return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5);
  2520. }

  2522. static int
  2523. ‌tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
  2524. {
  2525.   return -1;
  2526. }

  2528. static int
  2529. ‌debug_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
  2530. {
  2531.   int result;
  2532.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", debug_target.to_shortname);
  2533.   result = debug_target.to_trace_find (&debug_target, arg1, arg2, arg3, arg4, arg5);
  2534.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", debug_target.to_shortname);
  2535.   target_debug_print_struct_target_ops_p (&debug_target);
  2536.   fputs_unfiltered (", ", gdb_stdlog);
  2537.   target_debug_print_enum_trace_find_type (arg1);
  2538.   fputs_unfiltered (", ", gdb_stdlog);
  2539.   target_debug_print_int (arg2);
  2540.   fputs_unfiltered (", ", gdb_stdlog);
  2541.   target_debug_print_CORE_ADDR (arg3);
  2542.   fputs_unfiltered (", ", gdb_stdlog);
  2543.   target_debug_print_CORE_ADDR (arg4);
  2544.   fputs_unfiltered (", ", gdb_stdlog);
  2545.   target_debug_print_int_p (arg5);
  2546.   fputs_unfiltered (") = ", gdb_stdlog);
  2547.   target_debug_print_int (result);
  2548.   fputs_unfiltered ("\n", gdb_stdlog);
  2549.   return result;
  2550. }

  2552. static int
  2553. ‌delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
  2554. {
  2555.   self = self->beneath;
  2556.   return self->to_get_trace_state_variable_value (self, arg1, arg2);
  2557. }

  2559. static int
  2560. ‌tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
  2561. {
  2562.   return 0;
  2563. }

  2565. static int
  2566. ‌debug_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
  2567. {
  2568.   int result;
  2569.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", debug_target.to_shortname);
  2570.   result = debug_target.to_get_trace_state_variable_value (&debug_target, arg1, arg2);
  2571.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", debug_target.to_shortname);
  2572.   target_debug_print_struct_target_ops_p (&debug_target);
  2573.   fputs_unfiltered (", ", gdb_stdlog);
  2574.   target_debug_print_int (arg1);
  2575.   fputs_unfiltered (", ", gdb_stdlog);
  2576.   target_debug_print_LONGEST_p (arg2);
  2577.   fputs_unfiltered (") = ", gdb_stdlog);
  2578.   target_debug_print_int (result);
  2579.   fputs_unfiltered ("\n", gdb_stdlog);
  2580.   return result;
  2581. }

  2583. static int
  2584. ‌delegate_save_trace_data (struct target_ops *self, const char *arg1)
  2585. {
  2586.   self = self->beneath;
  2587.   return self->to_save_trace_data (self, arg1);
  2588. }

  2590. static int
  2591. ‌tdefault_save_trace_data (struct target_ops *self, const char *arg1)
  2592. {
  2593.   tcomplain ();
  2594. }

  2596. static int
  2597. ‌debug_save_trace_data (struct target_ops *self, const char *arg1)
  2598. {
  2599.   int result;
  2600.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", debug_target.to_shortname);
  2601.   result = debug_target.to_save_trace_data (&debug_target, arg1);
  2602.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", debug_target.to_shortname);
  2603.   target_debug_print_struct_target_ops_p (&debug_target);
  2604.   fputs_unfiltered (", ", gdb_stdlog);
  2605.   target_debug_print_const_char_p (arg1);
  2606.   fputs_unfiltered (") = ", gdb_stdlog);
  2607.   target_debug_print_int (result);
  2608.   fputs_unfiltered ("\n", gdb_stdlog);
  2609.   return result;
  2610. }

  2612. static int
  2613. ‌delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
  2614. {
  2615.   self = self->beneath;
  2616.   return self->to_upload_tracepoints (self, arg1);
  2617. }

  2619. static int
  2620. ‌tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
  2621. {
  2622.   return 0;
  2623. }

  2625. static int
  2626. ‌debug_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
  2627. {
  2628.   int result;
  2629.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", debug_target.to_shortname);
  2630.   result = debug_target.to_upload_tracepoints (&debug_target, arg1);
  2631.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", debug_target.to_shortname);
  2632.   target_debug_print_struct_target_ops_p (&debug_target);
  2633.   fputs_unfiltered (", ", gdb_stdlog);
  2634.   target_debug_print_struct_uploaded_tp_pp (arg1);
  2635.   fputs_unfiltered (") = ", gdb_stdlog);
  2636.   target_debug_print_int (result);
  2637.   fputs_unfiltered ("\n", gdb_stdlog);
  2638.   return result;
  2639. }

  2641. static int
  2642. ‌delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
  2643. {
  2644.   self = self->beneath;
  2645.   return self->to_upload_trace_state_variables (self, arg1);
  2646. }

  2648. static int
  2649. ‌tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
  2650. {
  2651.   return 0;
  2652. }

  2654. static int
  2655. ‌debug_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
  2656. {
  2657.   int result;
  2658.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", debug_target.to_shortname);
  2659.   result = debug_target.to_upload_trace_state_variables (&debug_target, arg1);
  2660.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", debug_target.to_shortname);
  2661.   target_debug_print_struct_target_ops_p (&debug_target);
  2662.   fputs_unfiltered (", ", gdb_stdlog);
  2663.   target_debug_print_struct_uploaded_tsv_pp (arg1);
  2664.   fputs_unfiltered (") = ", gdb_stdlog);
  2665.   target_debug_print_int (result);
  2666.   fputs_unfiltered ("\n", gdb_stdlog);
  2667.   return result;
  2668. }

  2670. static LONGEST
  2671. ‌delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
  2672. {
  2673.   self = self->beneath;
  2674.   return self->to_get_raw_trace_data (self, arg1, arg2, arg3);
  2675. }

  2677. static LONGEST
  2678. ‌tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
  2679. {
  2680.   tcomplain ();
  2681. }

  2683. static LONGEST
  2684. ‌debug_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
  2685. {
  2686.   LONGEST result;
  2687.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", debug_target.to_shortname);
  2688.   result = debug_target.to_get_raw_trace_data (&debug_target, arg1, arg2, arg3);
  2689.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", debug_target.to_shortname);
  2690.   target_debug_print_struct_target_ops_p (&debug_target);
  2691.   fputs_unfiltered (", ", gdb_stdlog);
  2692.   target_debug_print_gdb_byte_p (arg1);
  2693.   fputs_unfiltered (", ", gdb_stdlog);
  2694.   target_debug_print_ULONGEST (arg2);
  2695.   fputs_unfiltered (", ", gdb_stdlog);
  2696.   target_debug_print_LONGEST (arg3);
  2697.   fputs_unfiltered (") = ", gdb_stdlog);
  2698.   target_debug_print_LONGEST (result);
  2699.   fputs_unfiltered ("\n", gdb_stdlog);
  2700.   return result;
  2701. }

  2703. static int
  2704. ‌delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
  2705. {
  2706.   self = self->beneath;
  2707.   return self->to_get_min_fast_tracepoint_insn_len (self);
  2708. }

  2710. static int
  2711. ‌tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
  2712. {
  2713.   return -1;
  2714. }

  2716. static int
  2717. ‌debug_get_min_fast_tracepoint_insn_len (struct target_ops *self)
  2718. {
  2719.   int result;
  2720.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", debug_target.to_shortname);
  2721.   result = debug_target.to_get_min_fast_tracepoint_insn_len (&debug_target);
  2722.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", debug_target.to_shortname);
  2723.   target_debug_print_struct_target_ops_p (&debug_target);
  2724.   fputs_unfiltered (") = ", gdb_stdlog);
  2725.   target_debug_print_int (result);
  2726.   fputs_unfiltered ("\n", gdb_stdlog);
  2727.   return result;
  2728. }

  2730. static void
  2731. ‌delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
  2732. {
  2733.   self = self->beneath;
  2734.   self->to_set_disconnected_tracing (self, arg1);
  2735. }

  2737. static void
  2738. ‌tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
  2739. {
  2740. }

  2742. static void
  2743. ‌debug_set_disconnected_tracing (struct target_ops *self, int arg1)
  2744. {
  2745.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", debug_target.to_shortname);
  2746.   debug_target.to_set_disconnected_tracing (&debug_target, arg1);
  2747.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", debug_target.to_shortname);
  2748.   target_debug_print_struct_target_ops_p (&debug_target);
  2749.   fputs_unfiltered (", ", gdb_stdlog);
  2750.   target_debug_print_int (arg1);
  2751.   fputs_unfiltered (")\n", gdb_stdlog);
  2752. }

  2754. static void
  2755. ‌delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
  2756. {
  2757.   self = self->beneath;
  2758.   self->to_set_circular_trace_buffer (self, arg1);
  2759. }

  2761. static void
  2762. ‌tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
  2763. {
  2764. }

  2766. static void
  2767. ‌debug_set_circular_trace_buffer (struct target_ops *self, int arg1)
  2768. {
  2769.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", debug_target.to_shortname);
  2770.   debug_target.to_set_circular_trace_buffer (&debug_target, arg1);
  2771.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", debug_target.to_shortname);
  2772.   target_debug_print_struct_target_ops_p (&debug_target);
  2773.   fputs_unfiltered (", ", gdb_stdlog);
  2774.   target_debug_print_int (arg1);
  2775.   fputs_unfiltered (")\n", gdb_stdlog);
  2776. }

  2778. static void
  2779. ‌delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
  2780. {
  2781.   self = self->beneath;
  2782.   self->to_set_trace_buffer_size (self, arg1);
  2783. }

  2785. static void
  2786. ‌tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
  2787. {
  2788. }

  2790. static void
  2791. ‌debug_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
  2792. {
  2793.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", debug_target.to_shortname);
  2794.   debug_target.to_set_trace_buffer_size (&debug_target, arg1);
  2795.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", debug_target.to_shortname);
  2796.   target_debug_print_struct_target_ops_p (&debug_target);
  2797.   fputs_unfiltered (", ", gdb_stdlog);
  2798.   target_debug_print_LONGEST (arg1);
  2799.   fputs_unfiltered (")\n", gdb_stdlog);
  2800. }

  2802. static int
  2803. ‌delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
  2804. {
  2805.   self = self->beneath;
  2806.   return self->to_set_trace_notes (self, arg1, arg2, arg3);
  2807. }

  2809. static int
  2810. ‌tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
  2811. {
  2812.   return 0;
  2813. }

  2815. static int
  2816. ‌debug_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
  2817. {
  2818.   int result;
  2819.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", debug_target.to_shortname);
  2820.   result = debug_target.to_set_trace_notes (&debug_target, arg1, arg2, arg3);
  2821.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", debug_target.to_shortname);
  2822.   target_debug_print_struct_target_ops_p (&debug_target);
  2823.   fputs_unfiltered (", ", gdb_stdlog);
  2824.   target_debug_print_const_char_p (arg1);
  2825.   fputs_unfiltered (", ", gdb_stdlog);
  2826.   target_debug_print_const_char_p (arg2);
  2827.   fputs_unfiltered (", ", gdb_stdlog);
  2828.   target_debug_print_const_char_p (arg3);
  2829.   fputs_unfiltered (") = ", gdb_stdlog);
  2830.   target_debug_print_int (result);
  2831.   fputs_unfiltered ("\n", gdb_stdlog);
  2832.   return result;
  2833. }

  2835. static int
  2836. ‌delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
  2837. {
  2838.   self = self->beneath;
  2839.   return self->to_core_of_thread (self, arg1);
  2840. }

  2842. static int
  2843. ‌tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
  2844. {
  2845.   return -1;
  2846. }

  2848. static int
  2849. ‌debug_core_of_thread (struct target_ops *self, ptid_t arg1)
  2850. {
  2851.   int result;
  2852.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", debug_target.to_shortname);
  2853.   result = debug_target.to_core_of_thread (&debug_target, arg1);
  2854.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", debug_target.to_shortname);
  2855.   target_debug_print_struct_target_ops_p (&debug_target);
  2856.   fputs_unfiltered (", ", gdb_stdlog);
  2857.   target_debug_print_ptid_t (arg1);
  2858.   fputs_unfiltered (") = ", gdb_stdlog);
  2859.   target_debug_print_int (result);
  2860.   fputs_unfiltered ("\n", gdb_stdlog);
  2861.   return result;
  2862. }

  2864. static int
  2865. ‌delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
  2866. {
  2867.   self = self->beneath;
  2868.   return self->to_verify_memory (self, arg1, arg2, arg3);
  2869. }

  2871. static int
  2872. ‌debug_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
  2873. {
  2874.   int result;
  2875.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", debug_target.to_shortname);
  2876.   result = debug_target.to_verify_memory (&debug_target, arg1, arg2, arg3);
  2877.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", debug_target.to_shortname);
  2878.   target_debug_print_struct_target_ops_p (&debug_target);
  2879.   fputs_unfiltered (", ", gdb_stdlog);
  2880.   target_debug_print_const_gdb_byte_p (arg1);
  2881.   fputs_unfiltered (", ", gdb_stdlog);
  2882.   target_debug_print_CORE_ADDR (arg2);
  2883.   fputs_unfiltered (", ", gdb_stdlog);
  2884.   target_debug_print_ULONGEST (arg3);
  2885.   fputs_unfiltered (") = ", gdb_stdlog);
  2886.   target_debug_print_int (result);
  2887.   fputs_unfiltered ("\n", gdb_stdlog);
  2888.   return result;
  2889. }

  2891. static int
  2892. ‌delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
  2893. {
  2894.   self = self->beneath;
  2895.   return self->to_get_tib_address (self, arg1, arg2);
  2896. }

  2898. static int
  2899. ‌tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
  2900. {
  2901.   tcomplain ();
  2902. }

  2904. static int
  2905. ‌debug_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
  2906. {
  2907.   int result;
  2908.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", debug_target.to_shortname);
  2909.   result = debug_target.to_get_tib_address (&debug_target, arg1, arg2);
  2910.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_address (", debug_target.to_shortname);
  2911.   target_debug_print_struct_target_ops_p (&debug_target);
  2912.   fputs_unfiltered (", ", gdb_stdlog);
  2913.   target_debug_print_ptid_t (arg1);
  2914.   fputs_unfiltered (", ", gdb_stdlog);
  2915.   target_debug_print_CORE_ADDR_p (arg2);
  2916.   fputs_unfiltered (") = ", gdb_stdlog);
  2917.   target_debug_print_int (result);
  2918.   fputs_unfiltered ("\n", gdb_stdlog);
  2919.   return result;
  2920. }

  2922. static void
  2923. ‌delegate_set_permissions (struct target_ops *self)
  2924. {
  2925.   self = self->beneath;
  2926.   self->to_set_permissions (self);
  2927. }

  2929. static void
  2930. ‌tdefault_set_permissions (struct target_ops *self)
  2931. {
  2932. }

  2934. static void
  2935. ‌debug_set_permissions (struct target_ops *self)
  2936. {
  2937.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", debug_target.to_shortname);
  2938.   debug_target.to_set_permissions (&debug_target);
  2939.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", debug_target.to_shortname);
  2940.   target_debug_print_struct_target_ops_p (&debug_target);
  2941.   fputs_unfiltered (")\n", gdb_stdlog);
  2942. }

  2944. static int
  2945. ‌delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
  2946. {
  2947.   self = self->beneath;
  2948.   return self->to_static_tracepoint_marker_at (self, arg1, arg2);
  2949. }

  2951. static int
  2952. ‌tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
  2953. {
  2954.   return 0;
  2955. }

  2957. static int
  2958. ‌debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
  2959. {
  2960.   int result;
  2961.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", debug_target.to_shortname);
  2962.   result = debug_target.to_static_tracepoint_marker_at (&debug_target, arg1, arg2);
  2963.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", debug_target.to_shortname);
  2964.   target_debug_print_struct_target_ops_p (&debug_target);
  2965.   fputs_unfiltered (", ", gdb_stdlog);
  2966.   target_debug_print_CORE_ADDR (arg1);
  2967.   fputs_unfiltered (", ", gdb_stdlog);
  2968.   target_debug_print_struct_static_tracepoint_marker_p (arg2);
  2969.   fputs_unfiltered (") = ", gdb_stdlog);
  2970.   target_debug_print_int (result);
  2971.   fputs_unfiltered ("\n", gdb_stdlog);
  2972.   return result;
  2973. }

  2975. ‌static VEC(static_tracepoint_marker_p) *
  2976. delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
  2977. {
  2978.   self = self->beneath;
  2979.   return self->to_static_tracepoint_markers_by_strid (self, arg1);
  2980. }

  2982. ‌static VEC(static_tracepoint_marker_p) *
  2983. tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
  2984. {
  2985.   tcomplain ();
  2986. }

  2988. ‌static VEC(static_tracepoint_marker_p) *
  2989. debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
  2990. {
  2991.   VEC(static_tracepoint_marker_p) * result;
  2992.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", debug_target.to_shortname);
  2993.   result = debug_target.to_static_tracepoint_markers_by_strid (&debug_target, arg1);
  2994.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", debug_target.to_shortname);
  2995.   target_debug_print_struct_target_ops_p (&debug_target);
  2996.   fputs_unfiltered (", ", gdb_stdlog);
  2997.   target_debug_print_const_char_p (arg1);
  2998.   fputs_unfiltered (") = ", gdb_stdlog);
  2999.   target_debug_print_VEC_static_tracepoint_marker_p__p (result);
  3000.   fputs_unfiltered ("\n", gdb_stdlog);
  3001.   return result;
  3002. }

  3004. static struct traceframe_info *
  3005. ‌delegate_traceframe_info (struct target_ops *self)
  3006. {
  3007.   self = self->beneath;
  3008.   return self->to_traceframe_info (self);
  3009. }

  3011. static struct traceframe_info *
  3012. ‌tdefault_traceframe_info (struct target_ops *self)
  3013. {
  3014.   tcomplain ();
  3015. }

  3017. static struct traceframe_info *
  3018. ‌debug_traceframe_info (struct target_ops *self)
  3019. {
  3020.   struct traceframe_info * result;
  3021.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", debug_target.to_shortname);
  3022.   result = debug_target.to_traceframe_info (&debug_target);
  3023.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", debug_target.to_shortname);
  3024.   target_debug_print_struct_target_ops_p (&debug_target);
  3025.   fputs_unfiltered (") = ", gdb_stdlog);
  3026.   target_debug_print_struct_traceframe_info_p (result);
  3027.   fputs_unfiltered ("\n", gdb_stdlog);
  3028.   return result;
  3029. }

  3031. static int
  3032. ‌delegate_use_agent (struct target_ops *self, int arg1)
  3033. {
  3034.   self = self->beneath;
  3035.   return self->to_use_agent (self, arg1);
  3036. }

  3038. static int
  3039. ‌tdefault_use_agent (struct target_ops *self, int arg1)
  3040. {
  3041.   tcomplain ();
  3042. }

  3044. static int
  3045. ‌debug_use_agent (struct target_ops *self, int arg1)
  3046. {
  3047.   int result;
  3048.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", debug_target.to_shortname);
  3049.   result = debug_target.to_use_agent (&debug_target, arg1);
  3050.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", debug_target.to_shortname);
  3051.   target_debug_print_struct_target_ops_p (&debug_target);
  3052.   fputs_unfiltered (", ", gdb_stdlog);
  3053.   target_debug_print_int (arg1);
  3054.   fputs_unfiltered (") = ", gdb_stdlog);
  3055.   target_debug_print_int (result);
  3056.   fputs_unfiltered ("\n", gdb_stdlog);
  3057.   return result;
  3058. }

  3060. static int
  3061. ‌delegate_can_use_agent (struct target_ops *self)
  3062. {
  3063.   self = self->beneath;
  3064.   return self->to_can_use_agent (self);
  3065. }

  3067. static int
  3068. ‌tdefault_can_use_agent (struct target_ops *self)
  3069. {
  3070.   return 0;
  3071. }

  3073. static int
  3074. ‌debug_can_use_agent (struct target_ops *self)
  3075. {
  3076.   int result;
  3077.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", debug_target.to_shortname);
  3078.   result = debug_target.to_can_use_agent (&debug_target);
  3079.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", debug_target.to_shortname);
  3080.   target_debug_print_struct_target_ops_p (&debug_target);
  3081.   fputs_unfiltered (") = ", gdb_stdlog);
  3082.   target_debug_print_int (result);
  3083.   fputs_unfiltered ("\n", gdb_stdlog);
  3084.   return result;
  3085. }

  3087. static int
  3088. ‌delegate_supports_btrace (struct target_ops *self)
  3089. {
  3090.   self = self->beneath;
  3091.   return self->to_supports_btrace (self);
  3092. }

  3094. static int
  3095. ‌tdefault_supports_btrace (struct target_ops *self)
  3096. {
  3097.   return 0;
  3098. }

  3100. static int
  3101. ‌debug_supports_btrace (struct target_ops *self)
  3102. {
  3103.   int result;
  3104.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
  3105.   result = debug_target.to_supports_btrace (&debug_target);
  3106.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname);
  3107.   target_debug_print_struct_target_ops_p (&debug_target);
  3108.   fputs_unfiltered (") = ", gdb_stdlog);
  3109.   target_debug_print_int (result);
  3110.   fputs_unfiltered ("\n", gdb_stdlog);
  3111.   return result;
  3112. }

  3114. static struct btrace_target_info *
  3115. ‌delegate_enable_btrace (struct target_ops *self, ptid_t arg1)
  3116. {
  3117.   self = self->beneath;
  3118.   return self->to_enable_btrace (self, arg1);
  3119. }

  3121. static struct btrace_target_info *
  3122. ‌tdefault_enable_btrace (struct target_ops *self, ptid_t arg1)
  3123. {
  3124.   tcomplain ();
  3125. }

  3127. static struct btrace_target_info *
  3128. ‌debug_enable_btrace (struct target_ops *self, ptid_t arg1)
  3129. {
  3130.   struct btrace_target_info * result;
  3131.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname);
  3132.   result = debug_target.to_enable_btrace (&debug_target, arg1);
  3133.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname);
  3134.   target_debug_print_struct_target_ops_p (&debug_target);
  3135.   fputs_unfiltered (", ", gdb_stdlog);
  3136.   target_debug_print_ptid_t (arg1);
  3137.   fputs_unfiltered (") = ", gdb_stdlog);
  3138.   target_debug_print_struct_btrace_target_info_p (result);
  3139.   fputs_unfiltered ("\n", gdb_stdlog);
  3140.   return result;
  3141. }

  3143. static void
  3144. ‌delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
  3145. {
  3146.   self = self->beneath;
  3147.   self->to_disable_btrace (self, arg1);
  3148. }

  3150. static void
  3151. ‌tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
  3152. {
  3153.   tcomplain ();
  3154. }

  3156. static void
  3157. ‌debug_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
  3158. {
  3159.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname);
  3160.   debug_target.to_disable_btrace (&debug_target, arg1);
  3161.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname);
  3162.   target_debug_print_struct_target_ops_p (&debug_target);
  3163.   fputs_unfiltered (", ", gdb_stdlog);
  3164.   target_debug_print_struct_btrace_target_info_p (arg1);
  3165.   fputs_unfiltered (")\n", gdb_stdlog);
  3166. }

  3168. static void
  3169. ‌delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
  3170. {
  3171.   self = self->beneath;
  3172.   self->to_teardown_btrace (self, arg1);
  3173. }

  3175. static void
  3176. ‌tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
  3177. {
  3178.   tcomplain ();
  3179. }

  3181. static void
  3182. ‌debug_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
  3183. {
  3184.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname);
  3185.   debug_target.to_teardown_btrace (&debug_target, arg1);
  3186.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname);
  3187.   target_debug_print_struct_target_ops_p (&debug_target);
  3188.   fputs_unfiltered (", ", gdb_stdlog);
  3189.   target_debug_print_struct_btrace_target_info_p (arg1);
  3190.   fputs_unfiltered (")\n", gdb_stdlog);
  3191. }

  3193. static enum btrace_error
  3194. ‌delegate_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
  3195. {
  3196.   self = self->beneath;
  3197.   return self->to_read_btrace (self, arg1, arg2, arg3);
  3198. }

  3200. static enum btrace_error
  3201. ‌tdefault_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
  3202. {
  3203.   tcomplain ();
  3204. }

  3206. static enum btrace_error
  3207. ‌debug_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
  3208. {
  3209.   enum btrace_error result;
  3210.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname);
  3211.   result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3);
  3212.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname);
  3213.   target_debug_print_struct_target_ops_p (&debug_target);
  3214.   fputs_unfiltered (", ", gdb_stdlog);
  3215.   target_debug_print_VEC__btrace_block_s__pp (arg1);
  3216.   fputs_unfiltered (", ", gdb_stdlog);
  3217.   target_debug_print_struct_btrace_target_info_p (arg2);
  3218.   fputs_unfiltered (", ", gdb_stdlog);
  3219.   target_debug_print_enum_btrace_read_type (arg3);
  3220.   fputs_unfiltered (") = ", gdb_stdlog);
  3221.   target_debug_print_enum_btrace_error (result);
  3222.   fputs_unfiltered ("\n", gdb_stdlog);
  3223.   return result;
  3224. }

  3226. static void
  3227. ‌delegate_stop_recording (struct target_ops *self)
  3228. {
  3229.   self = self->beneath;
  3230.   self->to_stop_recording (self);
  3231. }

  3233. static void
  3234. ‌tdefault_stop_recording (struct target_ops *self)
  3235. {
  3236. }

  3238. static void
  3239. ‌debug_stop_recording (struct target_ops *self)
  3240. {
  3241.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname);
  3242.   debug_target.to_stop_recording (&debug_target);
  3243.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname);
  3244.   target_debug_print_struct_target_ops_p (&debug_target);
  3245.   fputs_unfiltered (")\n", gdb_stdlog);
  3246. }

  3248. static void
  3249. ‌delegate_info_record (struct target_ops *self)
  3250. {
  3251.   self = self->beneath;
  3252.   self->to_info_record (self);
  3253. }

  3255. static void
  3256. ‌tdefault_info_record (struct target_ops *self)
  3257. {
  3258. }

  3260. static void
  3261. ‌debug_info_record (struct target_ops *self)
  3262. {
  3263.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", debug_target.to_shortname);
  3264.   debug_target.to_info_record (&debug_target);
  3265.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", debug_target.to_shortname);
  3266.   target_debug_print_struct_target_ops_p (&debug_target);
  3267.   fputs_unfiltered (")\n", gdb_stdlog);
  3268. }

  3270. static void
  3271. ‌delegate_save_record (struct target_ops *self, const char *arg1)
  3272. {
  3273.   self = self->beneath;
  3274.   self->to_save_record (self, arg1);
  3275. }

  3277. static void
  3278. ‌tdefault_save_record (struct target_ops *self, const char *arg1)
  3279. {
  3280.   tcomplain ();
  3281. }

  3283. static void
  3284. ‌debug_save_record (struct target_ops *self, const char *arg1)
  3285. {
  3286.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname);
  3287.   debug_target.to_save_record (&debug_target, arg1);
  3288.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", debug_target.to_shortname);
  3289.   target_debug_print_struct_target_ops_p (&debug_target);
  3290.   fputs_unfiltered (", ", gdb_stdlog);
  3291.   target_debug_print_const_char_p (arg1);
  3292.   fputs_unfiltered (")\n", gdb_stdlog);
  3293. }

  3295. static void
  3296. ‌delegate_delete_record (struct target_ops *self)
  3297. {
  3298.   self = self->beneath;
  3299.   self->to_delete_record (self);
  3300. }

  3302. static void
  3303. ‌tdefault_delete_record (struct target_ops *self)
  3304. {
  3305.   tcomplain ();
  3306. }

  3308. static void
  3309. ‌debug_delete_record (struct target_ops *self)
  3310. {
  3311.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname);
  3312.   debug_target.to_delete_record (&debug_target);
  3313.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname);
  3314.   target_debug_print_struct_target_ops_p (&debug_target);
  3315.   fputs_unfiltered (")\n", gdb_stdlog);
  3316. }

  3318. static int
  3319. ‌delegate_record_is_replaying (struct target_ops *self)
  3320. {
  3321.   self = self->beneath;
  3322.   return self->to_record_is_replaying (self);
  3323. }

  3325. static int
  3326. ‌tdefault_record_is_replaying (struct target_ops *self)
  3327. {
  3328.   return 0;
  3329. }

  3331. static int
  3332. ‌debug_record_is_replaying (struct target_ops *self)
  3333. {
  3334.   int result;
  3335.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
  3336.   result = debug_target.to_record_is_replaying (&debug_target);
  3337.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
  3338.   target_debug_print_struct_target_ops_p (&debug_target);
  3339.   fputs_unfiltered (") = ", gdb_stdlog);
  3340.   target_debug_print_int (result);
  3341.   fputs_unfiltered ("\n", gdb_stdlog);
  3342.   return result;
  3343. }

  3345. static void
  3346. ‌delegate_goto_record_begin (struct target_ops *self)
  3347. {
  3348.   self = self->beneath;
  3349.   self->to_goto_record_begin (self);
  3350. }

  3352. static void
  3353. ‌tdefault_goto_record_begin (struct target_ops *self)
  3354. {
  3355.   tcomplain ();
  3356. }

  3358. static void
  3359. ‌debug_goto_record_begin (struct target_ops *self)
  3360. {
  3361.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname);
  3362.   debug_target.to_goto_record_begin (&debug_target);
  3363.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname);
  3364.   target_debug_print_struct_target_ops_p (&debug_target);
  3365.   fputs_unfiltered (")\n", gdb_stdlog);
  3366. }

  3368. static void
  3369. ‌delegate_goto_record_end (struct target_ops *self)
  3370. {
  3371.   self = self->beneath;
  3372.   self->to_goto_record_end (self);
  3373. }

  3375. static void
  3376. ‌tdefault_goto_record_end (struct target_ops *self)
  3377. {
  3378.   tcomplain ();
  3379. }

  3381. static void
  3382. ‌debug_goto_record_end (struct target_ops *self)
  3383. {
  3384.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname);
  3385.   debug_target.to_goto_record_end (&debug_target);
  3386.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname);
  3387.   target_debug_print_struct_target_ops_p (&debug_target);
  3388.   fputs_unfiltered (")\n", gdb_stdlog);
  3389. }

  3391. static void
  3392. ‌delegate_goto_record (struct target_ops *self, ULONGEST arg1)
  3393. {
  3394.   self = self->beneath;
  3395.   self->to_goto_record (self, arg1);
  3396. }

  3398. static void
  3399. ‌tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
  3400. {
  3401.   tcomplain ();
  3402. }

  3404. static void
  3405. ‌debug_goto_record (struct target_ops *self, ULONGEST arg1)
  3406. {
  3407.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname);
  3408.   debug_target.to_goto_record (&debug_target, arg1);
  3409.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname);
  3410.   target_debug_print_struct_target_ops_p (&debug_target);
  3411.   fputs_unfiltered (", ", gdb_stdlog);
  3412.   target_debug_print_ULONGEST (arg1);
  3413.   fputs_unfiltered (")\n", gdb_stdlog);
  3414. }

  3416. static void
  3417. ‌delegate_insn_history (struct target_ops *self, int arg1, int arg2)
  3418. {
  3419.   self = self->beneath;
  3420.   self->to_insn_history (self, arg1, arg2);
  3421. }

  3423. static void
  3424. ‌tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
  3425. {
  3426.   tcomplain ();
  3427. }

  3429. static void
  3430. ‌debug_insn_history (struct target_ops *self, int arg1, int arg2)
  3431. {
  3432.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
  3433.   debug_target.to_insn_history (&debug_target, arg1, arg2);
  3434.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", debug_target.to_shortname);
  3435.   target_debug_print_struct_target_ops_p (&debug_target);
  3436.   fputs_unfiltered (", ", gdb_stdlog);
  3437.   target_debug_print_int (arg1);
  3438.   fputs_unfiltered (", ", gdb_stdlog);
  3439.   target_debug_print_int (arg2);
  3440.   fputs_unfiltered (")\n", gdb_stdlog);
  3441. }

  3443. static void
  3444. ‌delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
  3445. {
  3446.   self = self->beneath;
  3447.   self->to_insn_history_from (self, arg1, arg2, arg3);
  3448. }

  3450. static void
  3451. ‌tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
  3452. {
  3453.   tcomplain ();
  3454. }

  3456. static void
  3457. ‌debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
  3458. {
  3459.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname);
  3460.   debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3);
  3461.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", debug_target.to_shortname);
  3462.   target_debug_print_struct_target_ops_p (&debug_target);
  3463.   fputs_unfiltered (", ", gdb_stdlog);
  3464.   target_debug_print_ULONGEST (arg1);
  3465.   fputs_unfiltered (", ", gdb_stdlog);
  3466.   target_debug_print_int (arg2);
  3467.   fputs_unfiltered (", ", gdb_stdlog);
  3468.   target_debug_print_int (arg3);
  3469.   fputs_unfiltered (")\n", gdb_stdlog);
  3470. }

  3472. static void
  3473. ‌delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
  3474. {
  3475.   self = self->beneath;
  3476.   self->to_insn_history_range (self, arg1, arg2, arg3);
  3477. }

  3479. static void
  3480. ‌tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
  3481. {
  3482.   tcomplain ();
  3483. }

  3485. static void
  3486. ‌debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
  3487. {
  3488.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname);
  3489.   debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3);
  3490.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", debug_target.to_shortname);
  3491.   target_debug_print_struct_target_ops_p (&debug_target);
  3492.   fputs_unfiltered (", ", gdb_stdlog);
  3493.   target_debug_print_ULONGEST (arg1);
  3494.   fputs_unfiltered (", ", gdb_stdlog);
  3495.   target_debug_print_ULONGEST (arg2);
  3496.   fputs_unfiltered (", ", gdb_stdlog);
  3497.   target_debug_print_int (arg3);
  3498.   fputs_unfiltered (")\n", gdb_stdlog);
  3499. }

  3501. static void
  3502. ‌delegate_call_history (struct target_ops *self, int arg1, int arg2)
  3503. {
  3504.   self = self->beneath;
  3505.   self->to_call_history (self, arg1, arg2);
  3506. }

  3508. static void
  3509. ‌tdefault_call_history (struct target_ops *self, int arg1, int arg2)
  3510. {
  3511.   tcomplain ();
  3512. }

  3514. static void
  3515. ‌debug_call_history (struct target_ops *self, int arg1, int arg2)
  3516. {
  3517.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
  3518.   debug_target.to_call_history (&debug_target, arg1, arg2);
  3519.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", debug_target.to_shortname);
  3520.   target_debug_print_struct_target_ops_p (&debug_target);
  3521.   fputs_unfiltered (", ", gdb_stdlog);
  3522.   target_debug_print_int (arg1);
  3523.   fputs_unfiltered (", ", gdb_stdlog);
  3524.   target_debug_print_int (arg2);
  3525.   fputs_unfiltered (")\n", gdb_stdlog);
  3526. }

  3528. static void
  3529. ‌delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
  3530. {
  3531.   self = self->beneath;
  3532.   self->to_call_history_from (self, arg1, arg2, arg3);
  3533. }

  3535. static void
  3536. ‌tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
  3537. {
  3538.   tcomplain ();
  3539. }

  3541. static void
  3542. ‌debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
  3543. {
  3544.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname);
  3545.   debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3);
  3546.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", debug_target.to_shortname);
  3547.   target_debug_print_struct_target_ops_p (&debug_target);
  3548.   fputs_unfiltered (", ", gdb_stdlog);
  3549.   target_debug_print_ULONGEST (arg1);
  3550.   fputs_unfiltered (", ", gdb_stdlog);
  3551.   target_debug_print_int (arg2);
  3552.   fputs_unfiltered (", ", gdb_stdlog);
  3553.   target_debug_print_int (arg3);
  3554.   fputs_unfiltered (")\n", gdb_stdlog);
  3555. }

  3557. static void
  3558. ‌delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
  3559. {
  3560.   self = self->beneath;
  3561.   self->to_call_history_range (self, arg1, arg2, arg3);
  3562. }

  3564. static void
  3565. ‌tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
  3566. {
  3567.   tcomplain ();
  3568. }

  3570. static void
  3571. ‌debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
  3572. {
  3573.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname);
  3574.   debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3);
  3575.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", debug_target.to_shortname);
  3576.   target_debug_print_struct_target_ops_p (&debug_target);
  3577.   fputs_unfiltered (", ", gdb_stdlog);
  3578.   target_debug_print_ULONGEST (arg1);
  3579.   fputs_unfiltered (", ", gdb_stdlog);
  3580.   target_debug_print_ULONGEST (arg2);
  3581.   fputs_unfiltered (", ", gdb_stdlog);
  3582.   target_debug_print_int (arg3);
  3583.   fputs_unfiltered (")\n", gdb_stdlog);
  3584. }

  3586. static int
  3587. ‌delegate_augmented_libraries_svr4_read (struct target_ops *self)
  3588. {
  3589.   self = self->beneath;
  3590.   return self->to_augmented_libraries_svr4_read (self);
  3591. }

  3593. static int
  3594. ‌tdefault_augmented_libraries_svr4_read (struct target_ops *self)
  3595. {
  3596.   return 0;
  3597. }

  3599. static int
  3600. ‌debug_augmented_libraries_svr4_read (struct target_ops *self)
  3601. {
  3602.   int result;
  3603.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname);
  3604.   result = debug_target.to_augmented_libraries_svr4_read (&debug_target);
  3605.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", debug_target.to_shortname);
  3606.   target_debug_print_struct_target_ops_p (&debug_target);
  3607.   fputs_unfiltered (") = ", gdb_stdlog);
  3608.   target_debug_print_int (result);
  3609.   fputs_unfiltered ("\n", gdb_stdlog);
  3610.   return result;
  3611. }

  3613. static const struct frame_unwind *
  3614. ‌delegate_get_unwinder (struct target_ops *self)
  3615. {
  3616.   self = self->beneath;
  3617.   return self->to_get_unwinder (self);
  3618. }

  3620. static const struct frame_unwind *
  3621. ‌tdefault_get_unwinder (struct target_ops *self)
  3622. {
  3623.   return NULL;
  3624. }

  3626. static const struct frame_unwind *
  3627. ‌debug_get_unwinder (struct target_ops *self)
  3628. {
  3629.   const struct frame_unwind * result;
  3630.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname);
  3631.   result = debug_target.to_get_unwinder (&debug_target);
  3632.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname);
  3633.   target_debug_print_struct_target_ops_p (&debug_target);
  3634.   fputs_unfiltered (") = ", gdb_stdlog);
  3635.   target_debug_print_const_struct_frame_unwind_p (result);
  3636.   fputs_unfiltered ("\n", gdb_stdlog);
  3637.   return result;
  3638. }

  3640. static const struct frame_unwind *
  3641. ‌delegate_get_tailcall_unwinder (struct target_ops *self)
  3642. {
  3643.   self = self->beneath;
  3644.   return self->to_get_tailcall_unwinder (self);
  3645. }

  3647. static const struct frame_unwind *
  3648. ‌tdefault_get_tailcall_unwinder (struct target_ops *self)
  3649. {
  3650.   return NULL;
  3651. }

  3653. static const struct frame_unwind *
  3654. ‌debug_get_tailcall_unwinder (struct target_ops *self)
  3655. {
  3656.   const struct frame_unwind * result;
  3657.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname);
  3658.   result = debug_target.to_get_tailcall_unwinder (&debug_target);
  3659.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname);
  3660.   target_debug_print_struct_target_ops_p (&debug_target);
  3661.   fputs_unfiltered (") = ", gdb_stdlog);
  3662.   target_debug_print_const_struct_frame_unwind_p (result);
  3663.   fputs_unfiltered ("\n", gdb_stdlog);
  3664.   return result;
  3665. }

  3667. static CORE_ADDR
  3668. ‌delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
  3669. {
  3670.   self = self->beneath;
  3671.   return self->to_decr_pc_after_break (self, arg1);
  3672. }

  3674. static CORE_ADDR
  3675. ‌debug_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
  3676. {
  3677.   CORE_ADDR result;
  3678.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_decr_pc_after_break (...)\n", debug_target.to_shortname);
  3679.   result = debug_target.to_decr_pc_after_break (&debug_target, arg1);
  3680.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_decr_pc_after_break (", debug_target.to_shortname);
  3681.   target_debug_print_struct_target_ops_p (&debug_target);
  3682.   fputs_unfiltered (", ", gdb_stdlog);
  3683.   target_debug_print_struct_gdbarch_p (arg1);
  3684.   fputs_unfiltered (") = ", gdb_stdlog);
  3685.   target_debug_print_CORE_ADDR (result);
  3686.   fputs_unfiltered ("\n", gdb_stdlog);
  3687.   return result;
  3688. }

  3690. static void
  3691. ‌delegate_prepare_to_generate_core (struct target_ops *self)
  3692. {
  3693.   self = self->beneath;
  3694.   self->to_prepare_to_generate_core (self);
  3695. }

  3697. static void
  3698. ‌tdefault_prepare_to_generate_core (struct target_ops *self)
  3699. {
  3700. }

  3702. static void
  3703. ‌debug_prepare_to_generate_core (struct target_ops *self)
  3704. {
  3705.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", debug_target.to_shortname);
  3706.   debug_target.to_prepare_to_generate_core (&debug_target);
  3707.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", debug_target.to_shortname);
  3708.   target_debug_print_struct_target_ops_p (&debug_target);
  3709.   fputs_unfiltered (")\n", gdb_stdlog);
  3710. }

  3712. static void
  3713. ‌delegate_done_generating_core (struct target_ops *self)
  3714. {
  3715.   self = self->beneath;
  3716.   self->to_done_generating_core (self);
  3717. }

  3719. static void
  3720. ‌tdefault_done_generating_core (struct target_ops *self)
  3721. {
  3722. }

  3724. static void
  3725. ‌debug_done_generating_core (struct target_ops *self)
  3726. {
  3727.   fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", debug_target.to_shortname);
  3728.   debug_target.to_done_generating_core (&debug_target);
  3729.   fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", debug_target.to_shortname);
  3730.   target_debug_print_struct_target_ops_p (&debug_target);
  3731.   fputs_unfiltered (")\n", gdb_stdlog);
  3732. }

  3734. static void
  3735. ‌install_delegators (struct target_ops *ops)
  3736. {
  3737.   if (ops->to_post_attach == NULL)
  3738.     ops->to_post_attach = delegate_post_attach;
  3739.   if (ops->to_detach == NULL)
  3740.     ops->to_detach = delegate_detach;
  3741.   if (ops->to_disconnect == NULL)
  3742.     ops->to_disconnect = delegate_disconnect;
  3743.   if (ops->to_resume == NULL)
  3744.     ops->to_resume = delegate_resume;
  3745.   if (ops->to_wait == NULL)
  3746.     ops->to_wait = delegate_wait;
  3747.   if (ops->to_fetch_registers == NULL)
  3748.     ops->to_fetch_registers = delegate_fetch_registers;
  3749.   if (ops->to_store_registers == NULL)
  3750.     ops->to_store_registers = delegate_store_registers;
  3751.   if (ops->to_prepare_to_store == NULL)
  3752.     ops->to_prepare_to_store = delegate_prepare_to_store;
  3753.   if (ops->to_files_info == NULL)
  3754.     ops->to_files_info = delegate_files_info;
  3755.   if (ops->to_insert_breakpoint == NULL)
  3756.     ops->to_insert_breakpoint = delegate_insert_breakpoint;
  3757.   if (ops->to_remove_breakpoint == NULL)
  3758.     ops->to_remove_breakpoint = delegate_remove_breakpoint;
  3759.   if (ops->to_can_use_hw_breakpoint == NULL)
  3760.     ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint;
  3761.   if (ops->to_ranged_break_num_registers == NULL)
  3762.     ops->to_ranged_break_num_registers = delegate_ranged_break_num_registers;
  3763.   if (ops->to_insert_hw_breakpoint == NULL)
  3764.     ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint;
  3765.   if (ops->to_remove_hw_breakpoint == NULL)
  3766.     ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint;
  3767.   if (ops->to_remove_watchpoint == NULL)
  3768.     ops->to_remove_watchpoint = delegate_remove_watchpoint;
  3769.   if (ops->to_insert_watchpoint == NULL)
  3770.     ops->to_insert_watchpoint = delegate_insert_watchpoint;
  3771.   if (ops->to_insert_mask_watchpoint == NULL)
  3772.     ops->to_insert_mask_watchpoint = delegate_insert_mask_watchpoint;
  3773.   if (ops->to_remove_mask_watchpoint == NULL)
  3774.     ops->to_remove_mask_watchpoint = delegate_remove_mask_watchpoint;
  3775.   if (ops->to_stopped_by_watchpoint == NULL)
  3776.     ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint;
  3777.   if (ops->to_stopped_data_address == NULL)
  3778.     ops->to_stopped_data_address = delegate_stopped_data_address;
  3779.   if (ops->to_watchpoint_addr_within_range == NULL)
  3780.     ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range;
  3781.   if (ops->to_region_ok_for_hw_watchpoint == NULL)
  3782.     ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint;
  3783.   if (ops->to_can_accel_watchpoint_condition == NULL)
  3784.     ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
  3785.   if (ops->to_masked_watch_num_registers == NULL)
  3786.     ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers;
  3787.   if (ops->to_terminal_init == NULL)
  3788.     ops->to_terminal_init = delegate_terminal_init;
  3789.   if (ops->to_terminal_inferior == NULL)
  3790.     ops->to_terminal_inferior = delegate_terminal_inferior;
  3791.   if (ops->to_terminal_ours_for_output == NULL)
  3792.     ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
  3793.   if (ops->to_terminal_ours == NULL)
  3794.     ops->to_terminal_ours = delegate_terminal_ours;
  3795.   if (ops->to_terminal_info == NULL)
  3796.     ops->to_terminal_info = delegate_terminal_info;
  3797.   if (ops->to_kill == NULL)
  3798.     ops->to_kill = delegate_kill;
  3799.   if (ops->to_load == NULL)
  3800.     ops->to_load = delegate_load;
  3801.   if (ops->to_post_startup_inferior == NULL)
  3802.     ops->to_post_startup_inferior = delegate_post_startup_inferior;
  3803.   if (ops->to_insert_fork_catchpoint == NULL)
  3804.     ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint;
  3805.   if (ops->to_remove_fork_catchpoint == NULL)
  3806.     ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint;
  3807.   if (ops->to_insert_vfork_catchpoint == NULL)
  3808.     ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint;
  3809.   if (ops->to_remove_vfork_catchpoint == NULL)
  3810.     ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint;
  3811.   if (ops->to_follow_fork == NULL)
  3812.     ops->to_follow_fork = delegate_follow_fork;
  3813.   if (ops->to_insert_exec_catchpoint == NULL)
  3814.     ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
  3815.   if (ops->to_remove_exec_catchpoint == NULL)
  3816.     ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
  3817.   if (ops->to_set_syscall_catchpoint == NULL)
  3818.     ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
  3819.   if (ops->to_has_exited == NULL)
  3820.     ops->to_has_exited = delegate_has_exited;
  3821.   if (ops->to_mourn_inferior == NULL)
  3822.     ops->to_mourn_inferior = delegate_mourn_inferior;
  3823.   if (ops->to_can_run == NULL)
  3824.     ops->to_can_run = delegate_can_run;
  3825.   if (ops->to_pass_signals == NULL)
  3826.     ops->to_pass_signals = delegate_pass_signals;
  3827.   if (ops->to_program_signals == NULL)
  3828.     ops->to_program_signals = delegate_program_signals;
  3829.   if (ops->to_thread_alive == NULL)
  3830.     ops->to_thread_alive = delegate_thread_alive;
  3831.   if (ops->to_update_thread_list == NULL)
  3832.     ops->to_update_thread_list = delegate_update_thread_list;
  3833.   if (ops->to_pid_to_str == NULL)
  3834.     ops->to_pid_to_str = delegate_pid_to_str;
  3835.   if (ops->to_extra_thread_info == NULL)
  3836.     ops->to_extra_thread_info = delegate_extra_thread_info;
  3837.   if (ops->to_thread_name == NULL)
  3838.     ops->to_thread_name = delegate_thread_name;
  3839.   if (ops->to_stop == NULL)
  3840.     ops->to_stop = delegate_stop;
  3841.   if (ops->to_rcmd == NULL)
  3842.     ops->to_rcmd = delegate_rcmd;
  3843.   if (ops->to_pid_to_exec_file == NULL)
  3844.     ops->to_pid_to_exec_file = delegate_pid_to_exec_file;
  3845.   if (ops->to_log_command == NULL)
  3846.     ops->to_log_command = delegate_log_command;
  3847.   if (ops->to_get_section_table == NULL)
  3848.     ops->to_get_section_table = delegate_get_section_table;
  3849.   if (ops->to_can_async_p == NULL)
  3850.     ops->to_can_async_p = delegate_can_async_p;
  3851.   if (ops->to_is_async_p == NULL)
  3852.     ops->to_is_async_p = delegate_is_async_p;
  3853.   if (ops->to_async == NULL)
  3854.     ops->to_async = delegate_async;
  3855.   if (ops->to_supports_non_stop == NULL)
  3856.     ops->to_supports_non_stop = delegate_supports_non_stop;
  3857.   if (ops->to_find_memory_regions == NULL)
  3858.     ops->to_find_memory_regions = delegate_find_memory_regions;
  3859.   if (ops->to_make_corefile_notes == NULL)
  3860.     ops->to_make_corefile_notes = delegate_make_corefile_notes;
  3861.   if (ops->to_get_bookmark == NULL)
  3862.     ops->to_get_bookmark = delegate_get_bookmark;
  3863.   if (ops->to_goto_bookmark == NULL)
  3864.     ops->to_goto_bookmark = delegate_goto_bookmark;
  3865.   if (ops->to_get_thread_local_address == NULL)
  3866.     ops->to_get_thread_local_address = delegate_get_thread_local_address;
  3867.   if (ops->to_xfer_partial == NULL)
  3868.     ops->to_xfer_partial = delegate_xfer_partial;
  3869.   if (ops->to_memory_map == NULL)
  3870.     ops->to_memory_map = delegate_memory_map;
  3871.   if (ops->to_flash_erase == NULL)
  3872.     ops->to_flash_erase = delegate_flash_erase;
  3873.   if (ops->to_flash_done == NULL)
  3874.     ops->to_flash_done = delegate_flash_done;
  3875.   if (ops->to_read_description == NULL)
  3876.     ops->to_read_description = delegate_read_description;
  3877.   if (ops->to_get_ada_task_ptid == NULL)
  3878.     ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid;
  3879.   if (ops->to_auxv_parse == NULL)
  3880.     ops->to_auxv_parse = delegate_auxv_parse;
  3881.   if (ops->to_search_memory == NULL)
  3882.     ops->to_search_memory = delegate_search_memory;
  3883.   if (ops->to_can_execute_reverse == NULL)
  3884.     ops->to_can_execute_reverse = delegate_can_execute_reverse;
  3885.   if (ops->to_execution_direction == NULL)
  3886.     ops->to_execution_direction = delegate_execution_direction;
  3887.   if (ops->to_supports_multi_process == NULL)
  3888.     ops->to_supports_multi_process = delegate_supports_multi_process;
  3889.   if (ops->to_supports_enable_disable_tracepoint == NULL)
  3890.     ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint;
  3891.   if (ops->to_supports_string_tracing == NULL)
  3892.     ops->to_supports_string_tracing = delegate_supports_string_tracing;
  3893.   if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL)
  3894.     ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions;
  3895.   if (ops->to_can_run_breakpoint_commands == NULL)
  3896.     ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands;
  3897.   if (ops->to_thread_architecture == NULL)
  3898.     ops->to_thread_architecture = delegate_thread_architecture;
  3899.   if (ops->to_thread_address_space == NULL)
  3900.     ops->to_thread_address_space = delegate_thread_address_space;
  3901.   if (ops->to_trace_init == NULL)
  3902.     ops->to_trace_init = delegate_trace_init;
  3903.   if (ops->to_download_tracepoint == NULL)
  3904.     ops->to_download_tracepoint = delegate_download_tracepoint;
  3905.   if (ops->to_can_download_tracepoint == NULL)
  3906.     ops->to_can_download_tracepoint = delegate_can_download_tracepoint;
  3907.   if (ops->to_download_trace_state_variable == NULL)
  3908.     ops->to_download_trace_state_variable = delegate_download_trace_state_variable;
  3909.   if (ops->to_enable_tracepoint == NULL)
  3910.     ops->to_enable_tracepoint = delegate_enable_tracepoint;
  3911.   if (ops->to_disable_tracepoint == NULL)
  3912.     ops->to_disable_tracepoint = delegate_disable_tracepoint;
  3913.   if (ops->to_trace_set_readonly_regions == NULL)
  3914.     ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions;
  3915.   if (ops->to_trace_start == NULL)
  3916.     ops->to_trace_start = delegate_trace_start;
  3917.   if (ops->to_get_trace_status == NULL)
  3918.     ops->to_get_trace_status = delegate_get_trace_status;
  3919.   if (ops->to_get_tracepoint_status == NULL)
  3920.     ops->to_get_tracepoint_status = delegate_get_tracepoint_status;
  3921.   if (ops->to_trace_stop == NULL)
  3922.     ops->to_trace_stop = delegate_trace_stop;
  3923.   if (ops->to_trace_find == NULL)
  3924.     ops->to_trace_find = delegate_trace_find;
  3925.   if (ops->to_get_trace_state_variable_value == NULL)
  3926.     ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value;
  3927.   if (ops->to_save_trace_data == NULL)
  3928.     ops->to_save_trace_data = delegate_save_trace_data;
  3929.   if (ops->to_upload_tracepoints == NULL)
  3930.     ops->to_upload_tracepoints = delegate_upload_tracepoints;
  3931.   if (ops->to_upload_trace_state_variables == NULL)
  3932.     ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables;
  3933.   if (ops->to_get_raw_trace_data == NULL)
  3934.     ops->to_get_raw_trace_data = delegate_get_raw_trace_data;
  3935.   if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
  3936.     ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len;
  3937.   if (ops->to_set_disconnected_tracing == NULL)
  3938.     ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing;
  3939.   if (ops->to_set_circular_trace_buffer == NULL)
  3940.     ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer;
  3941.   if (ops->to_set_trace_buffer_size == NULL)
  3942.     ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size;
  3943.   if (ops->to_set_trace_notes == NULL)
  3944.     ops->to_set_trace_notes = delegate_set_trace_notes;
  3945.   if (ops->to_core_of_thread == NULL)
  3946.     ops->to_core_of_thread = delegate_core_of_thread;
  3947.   if (ops->to_verify_memory == NULL)
  3948.     ops->to_verify_memory = delegate_verify_memory;
  3949.   if (ops->to_get_tib_address == NULL)
  3950.     ops->to_get_tib_address = delegate_get_tib_address;
  3951.   if (ops->to_set_permissions == NULL)
  3952.     ops->to_set_permissions = delegate_set_permissions;
  3953.   if (ops->to_static_tracepoint_marker_at == NULL)
  3954.     ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at;
  3955.   if (ops->to_static_tracepoint_markers_by_strid == NULL)
  3956.     ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
  3957.   if (ops->to_traceframe_info == NULL)
  3958.     ops->to_traceframe_info = delegate_traceframe_info;
  3959.   if (ops->to_use_agent == NULL)
  3960.     ops->to_use_agent = delegate_use_agent;
  3961.   if (ops->to_can_use_agent == NULL)
  3962.     ops->to_can_use_agent = delegate_can_use_agent;
  3963.   if (ops->to_supports_btrace == NULL)
  3964.     ops->to_supports_btrace = delegate_supports_btrace;
  3965.   if (ops->to_enable_btrace == NULL)
  3966.     ops->to_enable_btrace = delegate_enable_btrace;
  3967.   if (ops->to_disable_btrace == NULL)
  3968.     ops->to_disable_btrace = delegate_disable_btrace;
  3969.   if (ops->to_teardown_btrace == NULL)
  3970.     ops->to_teardown_btrace = delegate_teardown_btrace;
  3971.   if (ops->to_read_btrace == NULL)
  3972.     ops->to_read_btrace = delegate_read_btrace;
  3973.   if (ops->to_stop_recording == NULL)
  3974.     ops->to_stop_recording = delegate_stop_recording;
  3975.   if (ops->to_info_record == NULL)
  3976.     ops->to_info_record = delegate_info_record;
  3977.   if (ops->to_save_record == NULL)
  3978.     ops->to_save_record = delegate_save_record;
  3979.   if (ops->to_delete_record == NULL)
  3980.     ops->to_delete_record = delegate_delete_record;
  3981.   if (ops->to_record_is_replaying == NULL)
  3982.     ops->to_record_is_replaying = delegate_record_is_replaying;
  3983.   if (ops->to_goto_record_begin == NULL)
  3984.     ops->to_goto_record_begin = delegate_goto_record_begin;
  3985.   if (ops->to_goto_record_end == NULL)
  3986.     ops->to_goto_record_end = delegate_goto_record_end;
  3987.   if (ops->to_goto_record == NULL)
  3988.     ops->to_goto_record = delegate_goto_record;
  3989.   if (ops->to_insn_history == NULL)
  3990.     ops->to_insn_history = delegate_insn_history;
  3991.   if (ops->to_insn_history_from == NULL)
  3992.     ops->to_insn_history_from = delegate_insn_history_from;
  3993.   if (ops->to_insn_history_range == NULL)
  3994.     ops->to_insn_history_range = delegate_insn_history_range;
  3995.   if (ops->to_call_history == NULL)
  3996.     ops->to_call_history = delegate_call_history;
  3997.   if (ops->to_call_history_from == NULL)
  3998.     ops->to_call_history_from = delegate_call_history_from;
  3999.   if (ops->to_call_history_range == NULL)
  4000.     ops->to_call_history_range = delegate_call_history_range;
  4001.   if (ops->to_augmented_libraries_svr4_read == NULL)
  4002.     ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read;
  4003.   if (ops->to_get_unwinder == NULL)
  4004.     ops->to_get_unwinder = delegate_get_unwinder;
  4005.   if (ops->to_get_tailcall_unwinder == NULL)
  4006.     ops->to_get_tailcall_unwinder = delegate_get_tailcall_unwinder;
  4007.   if (ops->to_decr_pc_after_break == NULL)
  4008.     ops->to_decr_pc_after_break = delegate_decr_pc_after_break;
  4009.   if (ops->to_prepare_to_generate_core == NULL)
  4010.     ops->to_prepare_to_generate_core = delegate_prepare_to_generate_core;
  4011.   if (ops->to_done_generating_core == NULL)
  4012.     ops->to_done_generating_core = delegate_done_generating_core;
  4013. }

  4015. static void
  4016. ‌install_dummy_methods (struct target_ops *ops)
  4017. {
  4018.   ops->to_post_attach = tdefault_post_attach;
  4019.   ops->to_detach = tdefault_detach;
  4020.   ops->to_disconnect = tdefault_disconnect;
  4021.   ops->to_resume = tdefault_resume;
  4022.   ops->to_wait = tdefault_wait;
  4023.   ops->to_fetch_registers = tdefault_fetch_registers;
  4024.   ops->to_store_registers = tdefault_store_registers;
  4025.   ops->to_prepare_to_store = tdefault_prepare_to_store;
  4026.   ops->to_files_info = tdefault_files_info;
  4027.   ops->to_insert_breakpoint = memory_insert_breakpoint;
  4028.   ops->to_remove_breakpoint = memory_remove_breakpoint;
  4029.   ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint;
  4030.   ops->to_ranged_break_num_registers = tdefault_ranged_break_num_registers;
  4031.   ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint;
  4032.   ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint;
  4033.   ops->to_remove_watchpoint = tdefault_remove_watchpoint;
  4034.   ops->to_insert_watchpoint = tdefault_insert_watchpoint;
  4035.   ops->to_insert_mask_watchpoint = tdefault_insert_mask_watchpoint;
  4036.   ops->to_remove_mask_watchpoint = tdefault_remove_mask_watchpoint;
  4037.   ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint;
  4038.   ops->to_stopped_data_address = tdefault_stopped_data_address;
  4039.   ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range;
  4040.   ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
  4041.   ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
  4042.   ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers;
  4043.   ops->to_terminal_init = tdefault_terminal_init;
  4044.   ops->to_terminal_inferior = tdefault_terminal_inferior;
  4045.   ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
  4046.   ops->to_terminal_ours = tdefault_terminal_ours;
  4047.   ops->to_terminal_info = default_terminal_info;
  4048.   ops->to_kill = tdefault_kill;
  4049.   ops->to_load = tdefault_load;
  4050.   ops->to_post_startup_inferior = tdefault_post_startup_inferior;
  4051.   ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint;
  4052.   ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint;
  4053.   ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint;
  4054.   ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint;
  4055.   ops->to_follow_fork = default_follow_fork;
  4056.   ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
  4057.   ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
  4058.   ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
  4059.   ops->to_has_exited = tdefault_has_exited;
  4060.   ops->to_mourn_inferior = default_mourn_inferior;
  4061.   ops->to_can_run = tdefault_can_run;
  4062.   ops->to_pass_signals = tdefault_pass_signals;
  4063.   ops->to_program_signals = tdefault_program_signals;
  4064.   ops->to_thread_alive = tdefault_thread_alive;
  4065.   ops->to_update_thread_list = tdefault_update_thread_list;
  4066.   ops->to_pid_to_str = default_pid_to_str;
  4067.   ops->to_extra_thread_info = tdefault_extra_thread_info;
  4068.   ops->to_thread_name = tdefault_thread_name;
  4069.   ops->to_stop = tdefault_stop;
  4070.   ops->to_rcmd = default_rcmd;
  4071.   ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
  4072.   ops->to_log_command = tdefault_log_command;
  4073.   ops->to_get_section_table = tdefault_get_section_table;
  4074.   ops->to_can_async_p = tdefault_can_async_p;
  4075.   ops->to_is_async_p = tdefault_is_async_p;
  4076.   ops->to_async = tdefault_async;
  4077.   ops->to_supports_non_stop = tdefault_supports_non_stop;
  4078.   ops->to_find_memory_regions = dummy_find_memory_regions;
  4079.   ops->to_make_corefile_notes = dummy_make_corefile_notes;
  4080.   ops->to_get_bookmark = tdefault_get_bookmark;
  4081.   ops->to_goto_bookmark = tdefault_goto_bookmark;
  4082.   ops->to_get_thread_local_address = tdefault_get_thread_local_address;
  4083.   ops->to_xfer_partial = tdefault_xfer_partial;
  4084.   ops->to_memory_map = tdefault_memory_map;
  4085.   ops->to_flash_erase = tdefault_flash_erase;
  4086.   ops->to_flash_done = tdefault_flash_done;
  4087.   ops->to_read_description = tdefault_read_description;
  4088.   ops->to_get_ada_task_ptid = default_get_ada_task_ptid;
  4089.   ops->to_auxv_parse = default_auxv_parse;
  4090.   ops->to_search_memory = default_search_memory;
  4091.   ops->to_can_execute_reverse = tdefault_can_execute_reverse;
  4092.   ops->to_execution_direction = default_execution_direction;
  4093.   ops->to_supports_multi_process = tdefault_supports_multi_process;
  4094.   ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint;
  4095.   ops->to_supports_string_tracing = tdefault_supports_string_tracing;
  4096.   ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions;
  4097.   ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands;
  4098.   ops->to_thread_architecture = default_thread_architecture;
  4099.   ops->to_thread_address_space = default_thread_address_space;
  4100.   ops->to_trace_init = tdefault_trace_init;
  4101.   ops->to_download_tracepoint = tdefault_download_tracepoint;
  4102.   ops->to_can_download_tracepoint = tdefault_can_download_tracepoint;
  4103.   ops->to_download_trace_state_variable = tdefault_download_trace_state_variable;
  4104.   ops->to_enable_tracepoint = tdefault_enable_tracepoint;
  4105.   ops->to_disable_tracepoint = tdefault_disable_tracepoint;
  4106.   ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions;
  4107.   ops->to_trace_start = tdefault_trace_start;
  4108.   ops->to_get_trace_status = tdefault_get_trace_status;
  4109.   ops->to_get_tracepoint_status = tdefault_get_tracepoint_status;
  4110.   ops->to_trace_stop = tdefault_trace_stop;
  4111.   ops->to_trace_find = tdefault_trace_find;
  4112.   ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value;
  4113.   ops->to_save_trace_data = tdefault_save_trace_data;
  4114.   ops->to_upload_tracepoints = tdefault_upload_tracepoints;
  4115.   ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables;
  4116.   ops->to_get_raw_trace_data = tdefault_get_raw_trace_data;
  4117.   ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len;
  4118.   ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing;
  4119.   ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer;
  4120.   ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size;
  4121.   ops->to_set_trace_notes = tdefault_set_trace_notes;
  4122.   ops->to_core_of_thread = tdefault_core_of_thread;
  4123.   ops->to_verify_memory = default_verify_memory;
  4124.   ops->to_get_tib_address = tdefault_get_tib_address;
  4125.   ops->to_set_permissions = tdefault_set_permissions;
  4126.   ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at;
  4127.   ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
  4128.   ops->to_traceframe_info = tdefault_traceframe_info;
  4129.   ops->to_use_agent = tdefault_use_agent;
  4130.   ops->to_can_use_agent = tdefault_can_use_agent;
  4131.   ops->to_supports_btrace = tdefault_supports_btrace;
  4132.   ops->to_enable_btrace = tdefault_enable_btrace;
  4133.   ops->to_disable_btrace = tdefault_disable_btrace;
  4134.   ops->to_teardown_btrace = tdefault_teardown_btrace;
  4135.   ops->to_read_btrace = tdefault_read_btrace;
  4136.   ops->to_stop_recording = tdefault_stop_recording;
  4137.   ops->to_info_record = tdefault_info_record;
  4138.   ops->to_save_record = tdefault_save_record;
  4139.   ops->to_delete_record = tdefault_delete_record;
  4140.   ops->to_record_is_replaying = tdefault_record_is_replaying;
  4141.   ops->to_goto_record_begin = tdefault_goto_record_begin;
  4142.   ops->to_goto_record_end = tdefault_goto_record_end;
  4143.   ops->to_goto_record = tdefault_goto_record;
  4144.   ops->to_insn_history = tdefault_insn_history;
  4145.   ops->to_insn_history_from = tdefault_insn_history_from;
  4146.   ops->to_insn_history_range = tdefault_insn_history_range;
  4147.   ops->to_call_history = tdefault_call_history;
  4148.   ops->to_call_history_from = tdefault_call_history_from;
  4149.   ops->to_call_history_range = tdefault_call_history_range;
  4150.   ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read;
  4151.   ops->to_get_unwinder = tdefault_get_unwinder;
  4152.   ops->to_get_tailcall_unwinder = tdefault_get_tailcall_unwinder;
  4153.   ops->to_decr_pc_after_break = default_target_decr_pc_after_break;
  4154.   ops->to_prepare_to_generate_core = tdefault_prepare_to_generate_core;
  4155.   ops->to_done_generating_core = tdefault_done_generating_core;
  4156. }

  4158. static void
  4159. ‌init_debug_target (struct target_ops *ops)
  4160. {
  4161.   ops->to_post_attach = debug_post_attach;
  4162.   ops->to_detach = debug_detach;
  4163.   ops->to_disconnect = debug_disconnect;
  4164.   ops->to_resume = debug_resume;
  4165.   ops->to_wait = debug_wait;
  4166.   ops->to_fetch_registers = debug_fetch_registers;
  4167.   ops->to_store_registers = debug_store_registers;
  4168.   ops->to_prepare_to_store = debug_prepare_to_store;
  4169.   ops->to_files_info = debug_files_info;
  4170.   ops->to_insert_breakpoint = debug_insert_breakpoint;
  4171.   ops->to_remove_breakpoint = debug_remove_breakpoint;
  4172.   ops->to_can_use_hw_breakpoint = debug_can_use_hw_breakpoint;
  4173.   ops->to_ranged_break_num_registers = debug_ranged_break_num_registers;
  4174.   ops->to_insert_hw_breakpoint = debug_insert_hw_breakpoint;
  4175.   ops->to_remove_hw_breakpoint = debug_remove_hw_breakpoint;
  4176.   ops->to_remove_watchpoint = debug_remove_watchpoint;
  4177.   ops->to_insert_watchpoint = debug_insert_watchpoint;
  4178.   ops->to_insert_mask_watchpoint = debug_insert_mask_watchpoint;
  4179.   ops->to_remove_mask_watchpoint = debug_remove_mask_watchpoint;
  4180.   ops->to_stopped_by_watchpoint = debug_stopped_by_watchpoint;
  4181.   ops->to_stopped_data_address = debug_stopped_data_address;
  4182.   ops->to_watchpoint_addr_within_range = debug_watchpoint_addr_within_range;
  4183.   ops->to_region_ok_for_hw_watchpoint = debug_region_ok_for_hw_watchpoint;
  4184.   ops->to_can_accel_watchpoint_condition = debug_can_accel_watchpoint_condition;
  4185.   ops->to_masked_watch_num_registers = debug_masked_watch_num_registers;
  4186.   ops->to_terminal_init = debug_terminal_init;
  4187.   ops->to_terminal_inferior = debug_terminal_inferior;
  4188.   ops->to_terminal_ours_for_output = debug_terminal_ours_for_output;
  4189.   ops->to_terminal_ours = debug_terminal_ours;
  4190.   ops->to_terminal_info = debug_terminal_info;
  4191.   ops->to_kill = debug_kill;
  4192.   ops->to_load = debug_load;
  4193.   ops->to_post_startup_inferior = debug_post_startup_inferior;
  4194.   ops->to_insert_fork_catchpoint = debug_insert_fork_catchpoint;
  4195.   ops->to_remove_fork_catchpoint = debug_remove_fork_catchpoint;
  4196.   ops->to_insert_vfork_catchpoint = debug_insert_vfork_catchpoint;
  4197.   ops->to_remove_vfork_catchpoint = debug_remove_vfork_catchpoint;
  4198.   ops->to_follow_fork = debug_follow_fork;
  4199.   ops->to_insert_exec_catchpoint = debug_insert_exec_catchpoint;
  4200.   ops->to_remove_exec_catchpoint = debug_remove_exec_catchpoint;
  4201.   ops->to_set_syscall_catchpoint = debug_set_syscall_catchpoint;
  4202.   ops->to_has_exited = debug_has_exited;
  4203.   ops->to_mourn_inferior = debug_mourn_inferior;
  4204.   ops->to_can_run = debug_can_run;
  4205.   ops->to_pass_signals = debug_pass_signals;
  4206.   ops->to_program_signals = debug_program_signals;
  4207.   ops->to_thread_alive = debug_thread_alive;
  4208.   ops->to_update_thread_list = debug_update_thread_list;
  4209.   ops->to_pid_to_str = debug_pid_to_str;
  4210.   ops->to_extra_thread_info = debug_extra_thread_info;
  4211.   ops->to_thread_name = debug_thread_name;
  4212.   ops->to_stop = debug_stop;
  4213.   ops->to_rcmd = debug_rcmd;
  4214.   ops->to_pid_to_exec_file = debug_pid_to_exec_file;
  4215.   ops->to_log_command = debug_log_command;
  4216.   ops->to_get_section_table = debug_get_section_table;
  4217.   ops->to_can_async_p = debug_can_async_p;
  4218.   ops->to_is_async_p = debug_is_async_p;
  4219.   ops->to_async = debug_async;
  4220.   ops->to_supports_non_stop = debug_supports_non_stop;
  4221.   ops->to_find_memory_regions = debug_find_memory_regions;
  4222.   ops->to_make_corefile_notes = debug_make_corefile_notes;
  4223.   ops->to_get_bookmark = debug_get_bookmark;
  4224.   ops->to_goto_bookmark = debug_goto_bookmark;
  4225.   ops->to_get_thread_local_address = debug_get_thread_local_address;
  4226.   ops->to_xfer_partial = debug_xfer_partial;
  4227.   ops->to_memory_map = debug_memory_map;
  4228.   ops->to_flash_erase = debug_flash_erase;
  4229.   ops->to_flash_done = debug_flash_done;
  4230.   ops->to_read_description = debug_read_description;
  4231.   ops->to_get_ada_task_ptid = debug_get_ada_task_ptid;
  4232.   ops->to_auxv_parse = debug_auxv_parse;
  4233.   ops->to_search_memory = debug_search_memory;
  4234.   ops->to_can_execute_reverse = debug_can_execute_reverse;
  4235.   ops->to_execution_direction = debug_execution_direction;
  4236.   ops->to_supports_multi_process = debug_supports_multi_process;
  4237.   ops->to_supports_enable_disable_tracepoint = debug_supports_enable_disable_tracepoint;
  4238.   ops->to_supports_string_tracing = debug_supports_string_tracing;
  4239.   ops->to_supports_evaluation_of_breakpoint_conditions = debug_supports_evaluation_of_breakpoint_conditions;
  4240.   ops->to_can_run_breakpoint_commands = debug_can_run_breakpoint_commands;
  4241.   ops->to_thread_architecture = debug_thread_architecture;
  4242.   ops->to_thread_address_space = debug_thread_address_space;
  4243.   ops->to_trace_init = debug_trace_init;
  4244.   ops->to_download_tracepoint = debug_download_tracepoint;
  4245.   ops->to_can_download_tracepoint = debug_can_download_tracepoint;
  4246.   ops->to_download_trace_state_variable = debug_download_trace_state_variable;
  4247.   ops->to_enable_tracepoint = debug_enable_tracepoint;
  4248.   ops->to_disable_tracepoint = debug_disable_tracepoint;
  4249.   ops->to_trace_set_readonly_regions = debug_trace_set_readonly_regions;
  4250.   ops->to_trace_start = debug_trace_start;
  4251.   ops->to_get_trace_status = debug_get_trace_status;
  4252.   ops->to_get_tracepoint_status = debug_get_tracepoint_status;
  4253.   ops->to_trace_stop = debug_trace_stop;
  4254.   ops->to_trace_find = debug_trace_find;
  4255.   ops->to_get_trace_state_variable_value = debug_get_trace_state_variable_value;
  4256.   ops->to_save_trace_data = debug_save_trace_data;
  4257.   ops->to_upload_tracepoints = debug_upload_tracepoints;
  4258.   ops->to_upload_trace_state_variables = debug_upload_trace_state_variables;
  4259.   ops->to_get_raw_trace_data = debug_get_raw_trace_data;
  4260.   ops->to_get_min_fast_tracepoint_insn_len = debug_get_min_fast_tracepoint_insn_len;
  4261.   ops->to_set_disconnected_tracing = debug_set_disconnected_tracing;
  4262.   ops->to_set_circular_trace_buffer = debug_set_circular_trace_buffer;
  4263.   ops->to_set_trace_buffer_size = debug_set_trace_buffer_size;
  4264.   ops->to_set_trace_notes = debug_set_trace_notes;
  4265.   ops->to_core_of_thread = debug_core_of_thread;
  4266.   ops->to_verify_memory = debug_verify_memory;
  4267.   ops->to_get_tib_address = debug_get_tib_address;
  4268.   ops->to_set_permissions = debug_set_permissions;
  4269.   ops->to_static_tracepoint_marker_at = debug_static_tracepoint_marker_at;
  4270.   ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid;
  4271.   ops->to_traceframe_info = debug_traceframe_info;
  4272.   ops->to_use_agent = debug_use_agent;
  4273.   ops->to_can_use_agent = debug_can_use_agent;
  4274.   ops->to_supports_btrace = debug_supports_btrace;
  4275.   ops->to_enable_btrace = debug_enable_btrace;
  4276.   ops->to_disable_btrace = debug_disable_btrace;
  4277.   ops->to_teardown_btrace = debug_teardown_btrace;
  4278.   ops->to_read_btrace = debug_read_btrace;
  4279.   ops->to_stop_recording = debug_stop_recording;
  4280.   ops->to_info_record = debug_info_record;
  4281.   ops->to_save_record = debug_save_record;
  4282.   ops->to_delete_record = debug_delete_record;
  4283.   ops->to_record_is_replaying = debug_record_is_replaying;
  4284.   ops->to_goto_record_begin = debug_goto_record_begin;
  4285.   ops->to_goto_record_end = debug_goto_record_end;
  4286.   ops->to_goto_record = debug_goto_record;
  4287.   ops->to_insn_history = debug_insn_history;
  4288.   ops->to_insn_history_from = debug_insn_history_from;
  4289.   ops->to_insn_history_range = debug_insn_history_range;
  4290.   ops->to_call_history = debug_call_history;
  4291.   ops->to_call_history_from = debug_call_history_from;
  4292.   ops->to_call_history_range = debug_call_history_range;
  4293.   ops->to_augmented_libraries_svr4_read = debug_augmented_libraries_svr4_read;
  4294.   ops->to_get_unwinder = debug_get_unwinder;
  4295.   ops->to_get_tailcall_unwinder = debug_get_tailcall_unwinder;
  4296.   ops->to_decr_pc_after_break = debug_decr_pc_after_break;
  4297.   ops->to_prepare_to_generate_core = debug_prepare_to_generate_core;
  4298.   ops->to_done_generating_core = debug_done_generating_core;
  4299. }