gdb/target-delegates.c

   1 /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */
   2 /* vi:set ro: */
   3
   4 /* To regenerate this file, run:*/
   5 /*      make-target-delegates target.h > target-delegates.c */
   6 static void
   7 delegate_post_attach (struct target_ops *self, int arg1)
   8 {
   9   self = self->beneath;
  10   self->to_post_attach (self, arg1);
  11 }
  12
  13 static void
  14 tdefault_post_attach (struct target_ops *self, int arg1)
  15 {
  16 }
  17
  18 static void
  19 debug_post_attach (struct target_ops *self, int arg1)
  20 {
  21   fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", debug_target.to_shortname);
  22   debug_target.to_post_attach (&debug_target, arg1);
  23   fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", debug_target.to_shortname);
  24   target_debug_print_struct_target_ops_p (&debug_target);
  25   fputs_unfiltered (", ", gdb_stdlog);
  26   target_debug_print_int (arg1);
  27   fputs_unfiltered (")\n", gdb_stdlog);
  28 }
  29
  30 static void
  31 delegate_detach (struct target_ops *self, const char *arg1, int arg2)
  32 {
  33   self = self->beneath;
  34   self->to_detach (self, arg1, arg2);
  35 }
  36
  37 static void
  38 tdefault_detach (struct target_ops *self, const char *arg1, int arg2)
  39 {
  40 }
  41
  42 static void
  43 debug_detach (struct target_ops *self, const char *arg1, int arg2)
  44 {
  45   fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", debug_target.to_shortname);
  46   debug_target.to_detach (&debug_target, arg1, arg2);
  47   fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", debug_target.to_shortname);
  48   target_debug_print_struct_target_ops_p (&debug_target);
  49   fputs_unfiltered (", ", gdb_stdlog);
  50   target_debug_print_const_char_p (arg1);
  51   fputs_unfiltered (", ", gdb_stdlog);
  52   target_debug_print_int (arg2);
  53   fputs_unfiltered (")\n", gdb_stdlog);
  54 }
  55
  56 static void
  57 delegate_disconnect (struct target_ops *self, const char *arg1, int arg2)
  58 {
  59   self = self->beneath;
  60   self->to_disconnect (self, arg1, arg2);
  61 }
  62
  63 static void
  64 tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
  65 {
  66   tcomplain ();
  67 }
  68
  69 static void
  70 debug_disconnect (struct target_ops *self, const char *arg1, int arg2)
  71 {
  72   fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", debug_target.to_shortname);
  73   debug_target.to_disconnect (&debug_target, arg1, arg2);
  74   fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", debug_target.to_shortname);
  75   target_debug_print_struct_target_ops_p (&debug_target);
  76   fputs_unfiltered (", ", gdb_stdlog);
  77   target_debug_print_const_char_p (arg1);
  78   fputs_unfiltered (", ", gdb_stdlog);
  79   target_debug_print_int (arg2);
  80   fputs_unfiltered (")\n", gdb_stdlog);
  81 }
  82
  83 static void
  84 delegate_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
  85 {
  86   self = self->beneath;
  87   self->to_resume (self, arg1, arg2, arg3);
  88 }
  89
  90 static void
  91 tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
  92 {
  93   noprocess ();
  94 }
  95
  96 static void
  97 debug_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
  98 {
  99   fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", debug_target.to_shortname);
 100   debug_target.to_resume (&debug_target, arg1, arg2, arg3);
 101   fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", debug_target.to_shortname);
 102   target_debug_print_struct_target_ops_p (&debug_target);
 103   fputs_unfiltered (", ", gdb_stdlog);
 104   target_debug_print_ptid_t (arg1);
 105   fputs_unfiltered (", ", gdb_stdlog);
 106   target_debug_print_step (arg2);
 107   fputs_unfiltered (", ", gdb_stdlog);
 108   target_debug_print_enum_gdb_signal (arg3);
 109   fputs_unfiltered (")\n", gdb_stdlog);
 110 }
 111
 112 static ptid_t
 113 delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
 114 {
 115   self = self->beneath;
 116   return self->to_wait (self, arg1, arg2, arg3);
 117 }
 118
 119 static ptid_t
 120 tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
 121 {
 122   noprocess ();
 123 }
 124
 125 static ptid_t
 126 debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
 127 {
 128   ptid_t result;
 129   fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", debug_target.to_shortname);
 130   result = debug_target.to_wait (&debug_target, arg1, arg2, arg3);
 131   fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", debug_target.to_shortname);
 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 }
 144
 145 static void
 146 delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
 147 {
 148   self = self->beneath;
 149   self->to_fetch_registers (self, arg1, arg2);
 150 }
 151
 152 static void
 153 tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
 154 {
 155 }
 156
 157 static void
 158 debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
 159 {
 160   fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname);
 161   debug_target.to_fetch_registers (&debug_target, arg1, arg2);
 162   fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname);
 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 }
 170
 171 static void
 172 delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
 173 {
 174   self = self->beneath;
 175   self->to_store_registers (self, arg1, arg2);
 176 }
 177
 178 static void
 179 tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
 180 {
 181   noprocess ();
 182 }
 183
 184 static void
 185 debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
 186 {
 187   fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname);
 188   debug_target.to_store_registers (&debug_target, arg1, arg2);
 189   fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname);
 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 }
 197
 198 static void
 199 delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
 200 {
 201   self = self->beneath;
 202   self->to_prepare_to_store (self, arg1);
 203 }
 204
 205 static void
 206 tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
 207 {
 208   noprocess ();
 209 }
 210
 211 static void
 212 debug_prepare_to_store (struct target_ops *self, struct regcache *arg1)
 213 {
 214   fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", debug_target.to_shortname);
 215   debug_target.to_prepare_to_store (&debug_target, arg1);
 216   fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", debug_target.to_shortname);
 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 }
 222
 223 static void
 224 delegate_files_info (struct target_ops *self)
 225 {
 226   self = self->beneath;
 227   self->to_files_info (self);
 228 }
 229
 230 static void
 231 tdefault_files_info (struct target_ops *self)
 232 {
 233 }
 234
 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 }
 244
 245 static int
 246 delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 247 {
 248   self = self->beneath;
 249   return self->to_insert_breakpoint (self, arg1, arg2);
 250 }
 251
 252 static int
 253 debug_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 254 {
 255   int result;
 256   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_breakpoint (...)\n", debug_target.to_shortname);
 257   result = debug_target.to_insert_breakpoint (&debug_target, arg1, arg2);
 258   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_breakpoint (", debug_target.to_shortname);
 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 }
 269
 270 static int
 271 delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 272 {
 273   self = self->beneath;
 274   return self->to_remove_breakpoint (self, arg1, arg2);
 275 }
 276
 277 static int
 278 debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 279 {
 280   int result;
 281   fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", debug_target.to_shortname);
 282   result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2);
 283   fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", debug_target.to_shortname);
 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 }
 294
 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 }
 301
 302 static int
 303 tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
 304 {
 305   return 0;
 306 }
 307
 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 }
 327
 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 }
 334
 335 static int
 336 tdefault_ranged_break_num_registers (struct target_ops *self)
 337 {
 338   return -1;
 339 }
 340
 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 }
 354
 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 }
 361
 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 }
 367
 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 }
 385
 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 }
 392
 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 }
 398
 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 }
 416
 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 }
 423
 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 }
 429
 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 }
 451
 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 }
 458
 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 }
 464
 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 }
 486
 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 }
 493
 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 }
 499
 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 }
 519
 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 }
 526
 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 }
 532
 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 }
 552
 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 }
 559
 560 static int
 561 tdefault_stopped_by_watchpoint (struct target_ops *self)
 562 {
 563   return 0;
 564 }
 565
 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 }
 579
 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 }
 586
 587 static int
 588 tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
 589 {
 590   return 0;
 591 }
 592
 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 }
 608
 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 }
 615
 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 }
 635
 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 }
 642
 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 }
 660
 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 }
 667
 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 }
 673
 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 }
 695
 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 }
 702
 703 static int
 704 tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
 705 {
 706   return -1;
 707 }
 708
 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 }
 726
 727 static void
 728 delegate_terminal_init (struct target_ops *self)
 729 {
 730   self = self->beneath;
 731   self->to_terminal_init (self);
 732 }
 733
 734 static void
 735 tdefault_terminal_init (struct target_ops *self)
 736 {
 737 }
 738
 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 }
 748
 749 static void
 750 delegate_terminal_inferior (struct target_ops *self)
 751 {
 752   self = self->beneath;
 753   self->to_terminal_inferior (self);
 754 }
 755
 756 static void
 757 tdefault_terminal_inferior (struct target_ops *self)
 758 {
 759 }
 760
 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 }
 770
 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 }
 777
 778 static void
 779 tdefault_terminal_ours_for_output (struct target_ops *self)
 780 {
 781 }
 782
 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 }
 792
 793 static void
 794 delegate_terminal_ours (struct target_ops *self)
 795 {
 796   self = self->beneath;
 797   self->to_terminal_ours (self);
 798 }
 799
 800 static void
 801 tdefault_terminal_ours (struct target_ops *self)
 802 {
 803 }
 804
 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 }
 814
 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 }
 821
 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 }
 835
 836 static void
 837 delegate_kill (struct target_ops *self)
 838 {
 839   self = self->beneath;
 840   self->to_kill (self);
 841 }
 842
 843 static void
 844 tdefault_kill (struct target_ops *self)
 845 {
 846   noprocess ();
 847 }
 848
 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 }
 858
 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 }
 865
 866 static void
 867 tdefault_load (struct target_ops *self, const char *arg1, int arg2)
 868 {
 869   tcomplain ();
 870 }
 871
 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 }
 885
 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 }
 892
 893 static void
 894 tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
 895 {
 896 }
 897
 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 }
 909
 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 }
 916
 917 static int
 918 tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
 919 {
 920   return 1;
 921 }
 922
 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 }
 938
 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 }
 945
 946 static int
 947 tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
 948 {
 949   return 1;
 950 }
 951
 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 }
 967
 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 }
 974
 975 static int
 976 tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
 977 {
 978   return 1;
 979 }
 980
 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 }
 996
 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 }
1003
1004 static int
1005 tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
1006 {
1007   return 1;
1008 }
1009
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 }
1025
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 }
1032
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 }
1050
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 }
1057
1058 static int
1059 tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
1060 {
1061   return 1;
1062 }
1063
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 }
1079
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 }
1086
1087 static int
1088 tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
1089 {
1090   return 1;
1091 }
1092
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 }
1108
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 }
1115
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 }
1121
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 }
1145
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 }
1152
1153 static int
1154 tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
1155 {
1156   return 0;
1157 }
1158
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 }
1178
1179 static void
1180 delegate_mourn_inferior (struct target_ops *self)
1181 {
1182   self = self->beneath;
1183   self->to_mourn_inferior (self);
1184 }
1185
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 }
1195
1196 static int
1197 delegate_can_run (struct target_ops *self)
1198 {
1199   self = self->beneath;
1200   return self->to_can_run (self);
1201 }
1202
1203 static int
1204 tdefault_can_run (struct target_ops *self)
1205 {
1206   return 0;
1207 }
1208
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 }
1222
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 }
1229
1230 static void
1231 tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1232 {
1233 }
1234
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 }
1248
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 }
1255
1256 static void
1257 tdefault_program_signals (struct target_ops *self, int arg1, unsigned char * arg2)
1258 {
1259 }
1260
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 }
1274
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 }
1281
1282 static int
1283 tdefault_thread_alive (struct target_ops *self, ptid_t arg1)
1284 {
1285   return 0;
1286 }
1287
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 }
1303
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 }
1310
1311 static void
1312 tdefault_update_thread_list (struct target_ops *self)
1313 {
1314 }
1315
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 }
1325
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 }
1332
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 }
1348
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 }
1355
1356 static char *
1357 tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
1358 {
1359   return NULL;
1360 }
1361
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 }
1377
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 }
1384
1385 static char *
1386 tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
1387 {
1388   return NULL;
1389 }
1390
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 }
1406
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 }
1413
1414 static void
1415 tdefault_stop (struct target_ops *self, ptid_t arg1)
1416 {
1417 }
1418
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 }
1430
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 }
1437
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 }
1451
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 }
1458
1459 static char *
1460 tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
1461 {
1462   return NULL;
1463 }
1464
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 }
1480
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 }
1487
1488 static void
1489 tdefault_log_command (struct target_ops *self, const char *arg1)
1490 {
1491 }
1492
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 }
1504
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 }
1511
1512 static struct target_section_table *
1513 tdefault_get_section_table (struct target_ops *self)
1514 {
1515   return NULL;
1516 }
1517
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 }
1531
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 }
1538
1539 static int
1540 tdefault_can_async_p (struct target_ops *self)
1541 {
1542   return 0;
1543 }
1544
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 }
1558
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 }
1565
1566 static int
1567 tdefault_is_async_p (struct target_ops *self)
1568 {
1569   return 0;
1570 }
1571
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 }
1585
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 }
1592
1593 static void
1594 tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
1595 {
1596   tcomplain ();
1597 }
1598
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 }
1612
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 }
1619
1620 static int
1621 tdefault_supports_non_stop (struct target_ops *self)
1622 {
1623   return 0;
1624 }
1625
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 }
1639
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 }
1646
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 }
1664
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 }
1671
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 }
1689
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 }
1696
1697 static gdb_byte *
1698 tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
1699 {
1700   tcomplain ();
1701 }
1702
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 }
1720
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 }
1727
1728 static void
1729 tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
1730 {
1731   tcomplain ();
1732 }
1733
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 }
1747
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 }
1754
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 }
1760
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 }
1780
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 }
1787
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 }
1793
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 }
1821
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 }
1828
1829 static VEC(mem_region_s) *
1830 tdefault_memory_map (struct target_ops *self)
1831 {
1832   return NULL;
1833 }
1834
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 }
1848
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 }
1855
1856 static void
1857 tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
1858 {
1859   tcomplain ();
1860 }
1861
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 }
1875
1876 static void
1877 delegate_flash_done (struct target_ops *self)
1878 {
1879   self = self->beneath;
1880   self->to_flash_done (self);
1881 }
1882
1883 static void
1884 tdefault_flash_done (struct target_ops *self)
1885 {
1886   tcomplain ();
1887 }
1888
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 }
1898
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 }
1905
1906 static const struct target_desc *
1907 tdefault_read_description (struct target_ops *self)
1908 {
1909   return NULL;
1910 }
1911
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 }
1925
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 }
1932
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 }
1950
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 }
1957
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 }
1979
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 }
1986
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 }
2010
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 }
2017
2018 static int
2019 tdefault_can_execute_reverse (struct target_ops *self)
2020 {
2021   return 0;
2022 }
2023
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 }
2037
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 }
2044
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 }
2058
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 }
2065
2066 static int
2067 tdefault_supports_multi_process (struct target_ops *self)
2068 {
2069   return 0;
2070 }
2071
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 }
2085
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 }
2092
2093 static int
2094 tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
2095 {
2096   return 0;
2097 }
2098
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 }
2112
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 }
2119
2120 static int
2121 tdefault_supports_string_tracing (struct target_ops *self)
2122 {
2123   return 0;
2124 }
2125
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 }
2139
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 }
2146
2147 static int
2148 tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
2149 {
2150   return 0;
2151 }
2152
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 }
2166
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 }
2173
2174 static int
2175 tdefault_can_run_breakpoint_commands (struct target_ops *self)
2176 {
2177   return 0;
2178 }
2179
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 }
2193
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 }
2200
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 }
2216
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 }
2223
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 }
2239
2240 static void
2241 delegate_trace_init (struct target_ops *self)
2242 {
2243   self = self->beneath;
2244   self->to_trace_init (self);
2245 }
2246
2247 static void
2248 tdefault_trace_init (struct target_ops *self)
2249 {
2250   tcomplain ();
2251 }
2252
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 }
2262
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 }
2269
2270 static void
2271 tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
2272 {
2273   tcomplain ();
2274 }
2275
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 }
2287
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 }
2294
2295 static int
2296 tdefault_can_download_tracepoint (struct target_ops *self)
2297 {
2298   return 0;
2299 }
2300
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 }
2314
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 }
2321
2322 static void
2323 tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
2324 {
2325   tcomplain ();
2326 }
2327
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 }
2339
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 }
2346
2347 static void
2348 tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2349 {
2350   tcomplain ();
2351 }
2352
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 }
2364
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 }
2371
2372 static void
2373 tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2374 {
2375   tcomplain ();
2376 }
2377
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 }
2389
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 }
2396
2397 static void
2398 tdefault_trace_set_readonly_regions (struct target_ops *self)
2399 {
2400   tcomplain ();
2401 }
2402
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 }
2412
2413 static void
2414 delegate_trace_start (struct target_ops *self)
2415 {
2416   self = self->beneath;
2417   self->to_trace_start (self);
2418 }
2419
2420 static void
2421 tdefault_trace_start (struct target_ops *self)
2422 {
2423   tcomplain ();
2424 }
2425
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 }
2435
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 }
2442
2443 static int
2444 tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
2445 {
2446   return -1;
2447 }
2448
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 }
2464
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 }
2471
2472 static void
2473 tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2474 {
2475   tcomplain ();
2476 }
2477
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 }
2491
2492 static void
2493 delegate_trace_stop (struct target_ops *self)
2494 {
2495   self = self->beneath;
2496   self->to_trace_stop (self);
2497 }
2498
2499 static void
2500 tdefault_trace_stop (struct target_ops *self)
2501 {
2502   tcomplain ();
2503 }
2504
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 }
2514
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 }
2521
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 }
2527
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 }
2551
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 }
2558
2559 static int
2560 tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
2561 {
2562   return 0;
2563 }
2564
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 }
2582
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 }
2589
2590 static int
2591 tdefault_save_trace_data (struct target_ops *self, const char *arg1)
2592 {
2593   tcomplain ();
2594 }
2595
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 }
2611
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 }
2618
2619 static int
2620 tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
2621 {
2622   return 0;
2623 }
2624
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 }
2640
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 }
2647
2648 static int
2649 tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
2650 {
2651   return 0;
2652 }
2653
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 }
2669
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 }
2676
2677 static LONGEST
2678 tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
2679 {
2680   tcomplain ();
2681 }
2682
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 }
2702
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 }
2709
2710 static int
2711 tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
2712 {
2713   return -1;
2714 }
2715
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 }
2729
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 }
2736
2737 static void
2738 tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
2739 {
2740 }
2741
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 }
2753
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 }
2760
2761 static void
2762 tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
2763 {
2764 }
2765
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 }
2777
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 }
2784
2785 static void
2786 tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
2787 {
2788 }
2789
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 }
2801
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 }
2808
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 }
2814
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 }
2834
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 }
2841
2842 static int
2843 tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
2844 {
2845   return -1;
2846 }
2847
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 }
2863
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 }
2870
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 }
2890
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 }
2897
2898 static int
2899 tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
2900 {
2901   tcomplain ();
2902 }
2903
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 }
2921
2922 static void
2923 delegate_set_permissions (struct target_ops *self)
2924 {
2925   self = self->beneath;
2926   self->to_set_permissions (self);
2927 }
2928
2929 static void
2930 tdefault_set_permissions (struct target_ops *self)
2931 {
2932 }
2933
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 }
2943
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 }
2950
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 }
2956
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 }
2974
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 }
2981
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 }
2987
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 }
3003
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 }
3010
3011 static struct traceframe_info *
3012 tdefault_traceframe_info (struct target_ops *self)
3013 {
3014   tcomplain ();
3015 }
3016
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 }
3030
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 }
3037
3038 static int
3039 tdefault_use_agent (struct target_ops *self, int arg1)
3040 {
3041   tcomplain ();
3042 }
3043
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 }
3059
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 }
3066
3067 static int
3068 tdefault_can_use_agent (struct target_ops *self)
3069 {
3070   return 0;
3071 }
3072
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 }
3086
3087 static int
3088 delegate_supports_btrace (struct target_ops *self, enum btrace_format arg1)
3089 {
3090   self = self->beneath;
3091   return self->to_supports_btrace (self, arg1);
3092 }
3093
3094 static int
3095 tdefault_supports_btrace (struct target_ops *self, enum btrace_format arg1)
3096 {
3097   return 0;
3098 }
3099
3100 static int
3101 debug_supports_btrace (struct target_ops *self, enum btrace_format arg1)
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, arg1);
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_enum_btrace_format (arg1);
3110   fputs_unfiltered (") = ", gdb_stdlog);
3111   target_debug_print_int (result);
3112   fputs_unfiltered ("\n", gdb_stdlog);
3113   return result;
3114 }
3115
3116 static struct btrace_target_info *
3117 delegate_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3118 {
3119   self = self->beneath;
3120   return self->to_enable_btrace (self, arg1, arg2);
3121 }
3122
3123 static struct btrace_target_info *
3124 tdefault_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3125 {
3126   tcomplain ();
3127 }
3128
3129 static struct btrace_target_info *
3130 debug_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3131 {
3132   struct btrace_target_info * result;
3133   fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname);
3134   result = debug_target.to_enable_btrace (&debug_target, arg1, arg2);
3135   fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname);
3136   target_debug_print_struct_target_ops_p (&debug_target);
3137   fputs_unfiltered (", ", gdb_stdlog);
3138   target_debug_print_ptid_t (arg1);
3139   fputs_unfiltered (", ", gdb_stdlog);
3140   target_debug_print_const_struct_btrace_config_p (arg2);
3141   fputs_unfiltered (") = ", gdb_stdlog);
3142   target_debug_print_struct_btrace_target_info_p (result);
3143   fputs_unfiltered ("\n", gdb_stdlog);
3144   return result;
3145 }
3146
3147 static void
3148 delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3149 {
3150   self = self->beneath;
3151   self->to_disable_btrace (self, arg1);
3152 }
3153
3154 static void
3155 tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3156 {
3157   tcomplain ();
3158 }
3159
3160 static void
3161 debug_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3162 {
3163   fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname);
3164   debug_target.to_disable_btrace (&debug_target, arg1);
3165   fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname);
3166   target_debug_print_struct_target_ops_p (&debug_target);
3167   fputs_unfiltered (", ", gdb_stdlog);
3168   target_debug_print_struct_btrace_target_info_p (arg1);
3169   fputs_unfiltered (")\n", gdb_stdlog);
3170 }
3171
3172 static void
3173 delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3174 {
3175   self = self->beneath;
3176   self->to_teardown_btrace (self, arg1);
3177 }
3178
3179 static void
3180 tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3181 {
3182   tcomplain ();
3183 }
3184
3185 static void
3186 debug_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3187 {
3188   fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname);
3189   debug_target.to_teardown_btrace (&debug_target, arg1);
3190   fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname);
3191   target_debug_print_struct_target_ops_p (&debug_target);
3192   fputs_unfiltered (", ", gdb_stdlog);
3193   target_debug_print_struct_btrace_target_info_p (arg1);
3194   fputs_unfiltered (")\n", gdb_stdlog);
3195 }
3196
3197 static enum btrace_error
3198 delegate_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3199 {
3200   self = self->beneath;
3201   return self->to_read_btrace (self, arg1, arg2, arg3);
3202 }
3203
3204 static enum btrace_error
3205 tdefault_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3206 {
3207   tcomplain ();
3208 }
3209
3210 static enum btrace_error
3211 debug_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3212 {
3213   enum btrace_error result;
3214   fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname);
3215   result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3);
3216   fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname);
3217   target_debug_print_struct_target_ops_p (&debug_target);
3218   fputs_unfiltered (", ", gdb_stdlog);
3219   target_debug_print_struct_btrace_data_p (arg1);
3220   fputs_unfiltered (", ", gdb_stdlog);
3221   target_debug_print_struct_btrace_target_info_p (arg2);
3222   fputs_unfiltered (", ", gdb_stdlog);
3223   target_debug_print_enum_btrace_read_type (arg3);
3224   fputs_unfiltered (") = ", gdb_stdlog);
3225   target_debug_print_enum_btrace_error (result);
3226   fputs_unfiltered ("\n", gdb_stdlog);
3227   return result;
3228 }
3229
3230 static const struct btrace_config *
3231 delegate_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3232 {
3233   self = self->beneath;
3234   return self->to_btrace_conf (self, arg1);
3235 }
3236
3237 static const struct btrace_config *
3238 tdefault_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3239 {
3240   return NULL;
3241 }
3242
3243 static const struct btrace_config *
3244 debug_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3245 {
3246   const struct btrace_config * result;
3247   fprintf_unfiltered (gdb_stdlog, "-> %s->to_btrace_conf (...)\n", debug_target.to_shortname);
3248   result = debug_target.to_btrace_conf (&debug_target, arg1);
3249   fprintf_unfiltered (gdb_stdlog, "<- %s->to_btrace_conf (", debug_target.to_shortname);
3250   target_debug_print_struct_target_ops_p (&debug_target);
3251   fputs_unfiltered (", ", gdb_stdlog);
3252   target_debug_print_const_struct_btrace_target_info_p (arg1);
3253   fputs_unfiltered (") = ", gdb_stdlog);
3254   target_debug_print_const_struct_btrace_config_p (result);
3255   fputs_unfiltered ("\n", gdb_stdlog);
3256   return result;
3257 }
3258
3259 static void
3260 delegate_stop_recording (struct target_ops *self)
3261 {
3262   self = self->beneath;
3263   self->to_stop_recording (self);
3264 }
3265
3266 static void
3267 tdefault_stop_recording (struct target_ops *self)
3268 {
3269 }
3270
3271 static void
3272 debug_stop_recording (struct target_ops *self)
3273 {
3274   fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname);
3275   debug_target.to_stop_recording (&debug_target);
3276   fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname);
3277   target_debug_print_struct_target_ops_p (&debug_target);
3278   fputs_unfiltered (")\n", gdb_stdlog);
3279 }
3280
3281 static void
3282 delegate_info_record (struct target_ops *self)
3283 {
3284   self = self->beneath;
3285   self->to_info_record (self);
3286 }
3287
3288 static void
3289 tdefault_info_record (struct target_ops *self)
3290 {
3291 }
3292
3293 static void
3294 debug_info_record (struct target_ops *self)
3295 {
3296   fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", debug_target.to_shortname);
3297   debug_target.to_info_record (&debug_target);
3298   fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", debug_target.to_shortname);
3299   target_debug_print_struct_target_ops_p (&debug_target);
3300   fputs_unfiltered (")\n", gdb_stdlog);
3301 }
3302
3303 static void
3304 delegate_save_record (struct target_ops *self, const char *arg1)
3305 {
3306   self = self->beneath;
3307   self->to_save_record (self, arg1);
3308 }
3309
3310 static void
3311 tdefault_save_record (struct target_ops *self, const char *arg1)
3312 {
3313   tcomplain ();
3314 }
3315
3316 static void
3317 debug_save_record (struct target_ops *self, const char *arg1)
3318 {
3319   fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname);
3320   debug_target.to_save_record (&debug_target, arg1);
3321   fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", debug_target.to_shortname);
3322   target_debug_print_struct_target_ops_p (&debug_target);
3323   fputs_unfiltered (", ", gdb_stdlog);
3324   target_debug_print_const_char_p (arg1);
3325   fputs_unfiltered (")\n", gdb_stdlog);
3326 }
3327
3328 static void
3329 delegate_delete_record (struct target_ops *self)
3330 {
3331   self = self->beneath;
3332   self->to_delete_record (self);
3333 }
3334
3335 static void
3336 tdefault_delete_record (struct target_ops *self)
3337 {
3338   tcomplain ();
3339 }
3340
3341 static void
3342 debug_delete_record (struct target_ops *self)
3343 {
3344   fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname);
3345   debug_target.to_delete_record (&debug_target);
3346   fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname);
3347   target_debug_print_struct_target_ops_p (&debug_target);
3348   fputs_unfiltered (")\n", gdb_stdlog);
3349 }
3350
3351 static int
3352 delegate_record_is_replaying (struct target_ops *self)
3353 {
3354   self = self->beneath;
3355   return self->to_record_is_replaying (self);
3356 }
3357
3358 static int
3359 tdefault_record_is_replaying (struct target_ops *self)
3360 {
3361   return 0;
3362 }
3363
3364 static int
3365 debug_record_is_replaying (struct target_ops *self)
3366 {
3367   int result;
3368   fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
3369   result = debug_target.to_record_is_replaying (&debug_target);
3370   fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
3371   target_debug_print_struct_target_ops_p (&debug_target);
3372   fputs_unfiltered (") = ", gdb_stdlog);
3373   target_debug_print_int (result);
3374   fputs_unfiltered ("\n", gdb_stdlog);
3375   return result;
3376 }
3377
3378 static void
3379 delegate_goto_record_begin (struct target_ops *self)
3380 {
3381   self = self->beneath;
3382   self->to_goto_record_begin (self);
3383 }
3384
3385 static void
3386 tdefault_goto_record_begin (struct target_ops *self)
3387 {
3388   tcomplain ();
3389 }
3390
3391 static void
3392 debug_goto_record_begin (struct target_ops *self)
3393 {
3394   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname);
3395   debug_target.to_goto_record_begin (&debug_target);
3396   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname);
3397   target_debug_print_struct_target_ops_p (&debug_target);
3398   fputs_unfiltered (")\n", gdb_stdlog);
3399 }
3400
3401 static void
3402 delegate_goto_record_end (struct target_ops *self)
3403 {
3404   self = self->beneath;
3405   self->to_goto_record_end (self);
3406 }
3407
3408 static void
3409 tdefault_goto_record_end (struct target_ops *self)
3410 {
3411   tcomplain ();
3412 }
3413
3414 static void
3415 debug_goto_record_end (struct target_ops *self)
3416 {
3417   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname);
3418   debug_target.to_goto_record_end (&debug_target);
3419   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname);
3420   target_debug_print_struct_target_ops_p (&debug_target);
3421   fputs_unfiltered (")\n", gdb_stdlog);
3422 }
3423
3424 static void
3425 delegate_goto_record (struct target_ops *self, ULONGEST arg1)
3426 {
3427   self = self->beneath;
3428   self->to_goto_record (self, arg1);
3429 }
3430
3431 static void
3432 tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
3433 {
3434   tcomplain ();
3435 }
3436
3437 static void
3438 debug_goto_record (struct target_ops *self, ULONGEST arg1)
3439 {
3440   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname);
3441   debug_target.to_goto_record (&debug_target, arg1);
3442   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname);
3443   target_debug_print_struct_target_ops_p (&debug_target);
3444   fputs_unfiltered (", ", gdb_stdlog);
3445   target_debug_print_ULONGEST (arg1);
3446   fputs_unfiltered (")\n", gdb_stdlog);
3447 }
3448
3449 static void
3450 delegate_insn_history (struct target_ops *self, int arg1, int arg2)
3451 {
3452   self = self->beneath;
3453   self->to_insn_history (self, arg1, arg2);
3454 }
3455
3456 static void
3457 tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
3458 {
3459   tcomplain ();
3460 }
3461
3462 static void
3463 debug_insn_history (struct target_ops *self, int arg1, int arg2)
3464 {
3465   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
3466   debug_target.to_insn_history (&debug_target, arg1, arg2);
3467   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", debug_target.to_shortname);
3468   target_debug_print_struct_target_ops_p (&debug_target);
3469   fputs_unfiltered (", ", gdb_stdlog);
3470   target_debug_print_int (arg1);
3471   fputs_unfiltered (", ", gdb_stdlog);
3472   target_debug_print_int (arg2);
3473   fputs_unfiltered (")\n", gdb_stdlog);
3474 }
3475
3476 static void
3477 delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3478 {
3479   self = self->beneath;
3480   self->to_insn_history_from (self, arg1, arg2, arg3);
3481 }
3482
3483 static void
3484 tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3485 {
3486   tcomplain ();
3487 }
3488
3489 static void
3490 debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3491 {
3492   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname);
3493   debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3);
3494   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", debug_target.to_shortname);
3495   target_debug_print_struct_target_ops_p (&debug_target);
3496   fputs_unfiltered (", ", gdb_stdlog);
3497   target_debug_print_ULONGEST (arg1);
3498   fputs_unfiltered (", ", gdb_stdlog);
3499   target_debug_print_int (arg2);
3500   fputs_unfiltered (", ", gdb_stdlog);
3501   target_debug_print_int (arg3);
3502   fputs_unfiltered (")\n", gdb_stdlog);
3503 }
3504
3505 static void
3506 delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3507 {
3508   self = self->beneath;
3509   self->to_insn_history_range (self, arg1, arg2, arg3);
3510 }
3511
3512 static void
3513 tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3514 {
3515   tcomplain ();
3516 }
3517
3518 static void
3519 debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3520 {
3521   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname);
3522   debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3);
3523   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", debug_target.to_shortname);
3524   target_debug_print_struct_target_ops_p (&debug_target);
3525   fputs_unfiltered (", ", gdb_stdlog);
3526   target_debug_print_ULONGEST (arg1);
3527   fputs_unfiltered (", ", gdb_stdlog);
3528   target_debug_print_ULONGEST (arg2);
3529   fputs_unfiltered (", ", gdb_stdlog);
3530   target_debug_print_int (arg3);
3531   fputs_unfiltered (")\n", gdb_stdlog);
3532 }
3533
3534 static void
3535 delegate_call_history (struct target_ops *self, int arg1, int arg2)
3536 {
3537   self = self->beneath;
3538   self->to_call_history (self, arg1, arg2);
3539 }
3540
3541 static void
3542 tdefault_call_history (struct target_ops *self, int arg1, int arg2)
3543 {
3544   tcomplain ();
3545 }
3546
3547 static void
3548 debug_call_history (struct target_ops *self, int arg1, int arg2)
3549 {
3550   fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
3551   debug_target.to_call_history (&debug_target, arg1, arg2);
3552   fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", debug_target.to_shortname);
3553   target_debug_print_struct_target_ops_p (&debug_target);
3554   fputs_unfiltered (", ", gdb_stdlog);
3555   target_debug_print_int (arg1);
3556   fputs_unfiltered (", ", gdb_stdlog);
3557   target_debug_print_int (arg2);
3558   fputs_unfiltered (")\n", gdb_stdlog);
3559 }
3560
3561 static void
3562 delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3563 {
3564   self = self->beneath;
3565   self->to_call_history_from (self, arg1, arg2, arg3);
3566 }
3567
3568 static void
3569 tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3570 {
3571   tcomplain ();
3572 }
3573
3574 static void
3575 debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3576 {
3577   fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname);
3578   debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3);
3579   fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", debug_target.to_shortname);
3580   target_debug_print_struct_target_ops_p (&debug_target);
3581   fputs_unfiltered (", ", gdb_stdlog);
3582   target_debug_print_ULONGEST (arg1);
3583   fputs_unfiltered (", ", gdb_stdlog);
3584   target_debug_print_int (arg2);
3585   fputs_unfiltered (", ", gdb_stdlog);
3586   target_debug_print_int (arg3);
3587   fputs_unfiltered (")\n", gdb_stdlog);
3588 }
3589
3590 static void
3591 delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3592 {
3593   self = self->beneath;
3594   self->to_call_history_range (self, arg1, arg2, arg3);
3595 }
3596
3597 static void
3598 tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3599 {
3600   tcomplain ();
3601 }
3602
3603 static void
3604 debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3605 {
3606   fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname);
3607   debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3);
3608   fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", debug_target.to_shortname);
3609   target_debug_print_struct_target_ops_p (&debug_target);
3610   fputs_unfiltered (", ", gdb_stdlog);
3611   target_debug_print_ULONGEST (arg1);
3612   fputs_unfiltered (", ", gdb_stdlog);
3613   target_debug_print_ULONGEST (arg2);
3614   fputs_unfiltered (", ", gdb_stdlog);
3615   target_debug_print_int (arg3);
3616   fputs_unfiltered (")\n", gdb_stdlog);
3617 }
3618
3619 static int
3620 delegate_augmented_libraries_svr4_read (struct target_ops *self)
3621 {
3622   self = self->beneath;
3623   return self->to_augmented_libraries_svr4_read (self);
3624 }
3625
3626 static int
3627 tdefault_augmented_libraries_svr4_read (struct target_ops *self)
3628 {
3629   return 0;
3630 }
3631
3632 static int
3633 debug_augmented_libraries_svr4_read (struct target_ops *self)
3634 {
3635   int result;
3636   fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname);
3637   result = debug_target.to_augmented_libraries_svr4_read (&debug_target);
3638   fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", debug_target.to_shortname);
3639   target_debug_print_struct_target_ops_p (&debug_target);
3640   fputs_unfiltered (") = ", gdb_stdlog);
3641   target_debug_print_int (result);
3642   fputs_unfiltered ("\n", gdb_stdlog);
3643   return result;
3644 }
3645
3646 static const struct frame_unwind *
3647 delegate_get_unwinder (struct target_ops *self)
3648 {
3649   self = self->beneath;
3650   return self->to_get_unwinder (self);
3651 }
3652
3653 static const struct frame_unwind *
3654 tdefault_get_unwinder (struct target_ops *self)
3655 {
3656   return NULL;
3657 }
3658
3659 static const struct frame_unwind *
3660 debug_get_unwinder (struct target_ops *self)
3661 {
3662   const struct frame_unwind * result;
3663   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname);
3664   result = debug_target.to_get_unwinder (&debug_target);
3665   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname);
3666   target_debug_print_struct_target_ops_p (&debug_target);
3667   fputs_unfiltered (") = ", gdb_stdlog);
3668   target_debug_print_const_struct_frame_unwind_p (result);
3669   fputs_unfiltered ("\n", gdb_stdlog);
3670   return result;
3671 }
3672
3673 static const struct frame_unwind *
3674 delegate_get_tailcall_unwinder (struct target_ops *self)
3675 {
3676   self = self->beneath;
3677   return self->to_get_tailcall_unwinder (self);
3678 }
3679
3680 static const struct frame_unwind *
3681 tdefault_get_tailcall_unwinder (struct target_ops *self)
3682 {
3683   return NULL;
3684 }
3685
3686 static const struct frame_unwind *
3687 debug_get_tailcall_unwinder (struct target_ops *self)
3688 {
3689   const struct frame_unwind * result;
3690   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname);
3691   result = debug_target.to_get_tailcall_unwinder (&debug_target);
3692   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname);
3693   target_debug_print_struct_target_ops_p (&debug_target);
3694   fputs_unfiltered (") = ", gdb_stdlog);
3695   target_debug_print_const_struct_frame_unwind_p (result);
3696   fputs_unfiltered ("\n", gdb_stdlog);
3697   return result;
3698 }
3699
3700 static CORE_ADDR
3701 delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
3702 {
3703   self = self->beneath;
3704   return self->to_decr_pc_after_break (self, arg1);
3705 }
3706
3707 static CORE_ADDR
3708 debug_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
3709 {
3710   CORE_ADDR result;
3711   fprintf_unfiltered (gdb_stdlog, "-> %s->to_decr_pc_after_break (...)\n", debug_target.to_shortname);
3712   result = debug_target.to_decr_pc_after_break (&debug_target, arg1);
3713   fprintf_unfiltered (gdb_stdlog, "<- %s->to_decr_pc_after_break (", debug_target.to_shortname);
3714   target_debug_print_struct_target_ops_p (&debug_target);
3715   fputs_unfiltered (", ", gdb_stdlog);
3716   target_debug_print_struct_gdbarch_p (arg1);
3717   fputs_unfiltered (") = ", gdb_stdlog);
3718   target_debug_print_CORE_ADDR (result);
3719   fputs_unfiltered ("\n", gdb_stdlog);
3720   return result;
3721 }
3722
3723 static void
3724 delegate_prepare_to_generate_core (struct target_ops *self)
3725 {
3726   self = self->beneath;
3727   self->to_prepare_to_generate_core (self);
3728 }
3729
3730 static void
3731 tdefault_prepare_to_generate_core (struct target_ops *self)
3732 {
3733 }
3734
3735 static void
3736 debug_prepare_to_generate_core (struct target_ops *self)
3737 {
3738   fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", debug_target.to_shortname);
3739   debug_target.to_prepare_to_generate_core (&debug_target);
3740   fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", debug_target.to_shortname);
3741   target_debug_print_struct_target_ops_p (&debug_target);
3742   fputs_unfiltered (")\n", gdb_stdlog);
3743 }
3744
3745 static void
3746 delegate_done_generating_core (struct target_ops *self)
3747 {
3748   self = self->beneath;
3749   self->to_done_generating_core (self);
3750 }
3751
3752 static void
3753 tdefault_done_generating_core (struct target_ops *self)
3754 {
3755 }
3756
3757 static void
3758 debug_done_generating_core (struct target_ops *self)
3759 {
3760   fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", debug_target.to_shortname);
3761   debug_target.to_done_generating_core (&debug_target);
3762   fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", debug_target.to_shortname);
3763   target_debug_print_struct_target_ops_p (&debug_target);
3764   fputs_unfiltered (")\n", gdb_stdlog);
3765 }
3766
3767 static void
3768 install_delegators (struct target_ops *ops)
3769 {
3770   if (ops->to_post_attach == NULL)
3771     ops->to_post_attach = delegate_post_attach;
3772   if (ops->to_detach == NULL)
3773     ops->to_detach = delegate_detach;
3774   if (ops->to_disconnect == NULL)
3775     ops->to_disconnect = delegate_disconnect;
3776   if (ops->to_resume == NULL)
3777     ops->to_resume = delegate_resume;
3778   if (ops->to_wait == NULL)
3779     ops->to_wait = delegate_wait;
3780   if (ops->to_fetch_registers == NULL)
3781     ops->to_fetch_registers = delegate_fetch_registers;
3782   if (ops->to_store_registers == NULL)
3783     ops->to_store_registers = delegate_store_registers;
3784   if (ops->to_prepare_to_store == NULL)
3785     ops->to_prepare_to_store = delegate_prepare_to_store;
3786   if (ops->to_files_info == NULL)
3787     ops->to_files_info = delegate_files_info;
3788   if (ops->to_insert_breakpoint == NULL)
3789     ops->to_insert_breakpoint = delegate_insert_breakpoint;
3790   if (ops->to_remove_breakpoint == NULL)
3791     ops->to_remove_breakpoint = delegate_remove_breakpoint;
3792   if (ops->to_can_use_hw_breakpoint == NULL)
3793     ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint;
3794   if (ops->to_ranged_break_num_registers == NULL)
3795     ops->to_ranged_break_num_registers = delegate_ranged_break_num_registers;
3796   if (ops->to_insert_hw_breakpoint == NULL)
3797     ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint;
3798   if (ops->to_remove_hw_breakpoint == NULL)
3799     ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint;
3800   if (ops->to_remove_watchpoint == NULL)
3801     ops->to_remove_watchpoint = delegate_remove_watchpoint;
3802   if (ops->to_insert_watchpoint == NULL)
3803     ops->to_insert_watchpoint = delegate_insert_watchpoint;
3804   if (ops->to_insert_mask_watchpoint == NULL)
3805     ops->to_insert_mask_watchpoint = delegate_insert_mask_watchpoint;
3806   if (ops->to_remove_mask_watchpoint == NULL)
3807     ops->to_remove_mask_watchpoint = delegate_remove_mask_watchpoint;
3808   if (ops->to_stopped_by_watchpoint == NULL)
3809     ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint;
3810   if (ops->to_stopped_data_address == NULL)
3811     ops->to_stopped_data_address = delegate_stopped_data_address;
3812   if (ops->to_watchpoint_addr_within_range == NULL)
3813     ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range;
3814   if (ops->to_region_ok_for_hw_watchpoint == NULL)
3815     ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint;
3816   if (ops->to_can_accel_watchpoint_condition == NULL)
3817     ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
3818   if (ops->to_masked_watch_num_registers == NULL)
3819     ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers;
3820   if (ops->to_terminal_init == NULL)
3821     ops->to_terminal_init = delegate_terminal_init;
3822   if (ops->to_terminal_inferior == NULL)
3823     ops->to_terminal_inferior = delegate_terminal_inferior;
3824   if (ops->to_terminal_ours_for_output == NULL)
3825     ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
3826   if (ops->to_terminal_ours == NULL)
3827     ops->to_terminal_ours = delegate_terminal_ours;
3828   if (ops->to_terminal_info == NULL)
3829     ops->to_terminal_info = delegate_terminal_info;
3830   if (ops->to_kill == NULL)
3831     ops->to_kill = delegate_kill;
3832   if (ops->to_load == NULL)
3833     ops->to_load = delegate_load;
3834   if (ops->to_post_startup_inferior == NULL)
3835     ops->to_post_startup_inferior = delegate_post_startup_inferior;
3836   if (ops->to_insert_fork_catchpoint == NULL)
3837     ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint;
3838   if (ops->to_remove_fork_catchpoint == NULL)
3839     ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint;
3840   if (ops->to_insert_vfork_catchpoint == NULL)
3841     ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint;
3842   if (ops->to_remove_vfork_catchpoint == NULL)
3843     ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint;
3844   if (ops->to_follow_fork == NULL)
3845     ops->to_follow_fork = delegate_follow_fork;
3846   if (ops->to_insert_exec_catchpoint == NULL)
3847     ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
3848   if (ops->to_remove_exec_catchpoint == NULL)
3849     ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
3850   if (ops->to_set_syscall_catchpoint == NULL)
3851     ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
3852   if (ops->to_has_exited == NULL)
3853     ops->to_has_exited = delegate_has_exited;
3854   if (ops->to_mourn_inferior == NULL)
3855     ops->to_mourn_inferior = delegate_mourn_inferior;
3856   if (ops->to_can_run == NULL)
3857     ops->to_can_run = delegate_can_run;
3858   if (ops->to_pass_signals == NULL)
3859     ops->to_pass_signals = delegate_pass_signals;
3860   if (ops->to_program_signals == NULL)
3861     ops->to_program_signals = delegate_program_signals;
3862   if (ops->to_thread_alive == NULL)
3863     ops->to_thread_alive = delegate_thread_alive;
3864   if (ops->to_update_thread_list == NULL)
3865     ops->to_update_thread_list = delegate_update_thread_list;
3866   if (ops->to_pid_to_str == NULL)
3867     ops->to_pid_to_str = delegate_pid_to_str;
3868   if (ops->to_extra_thread_info == NULL)
3869     ops->to_extra_thread_info = delegate_extra_thread_info;
3870   if (ops->to_thread_name == NULL)
3871     ops->to_thread_name = delegate_thread_name;
3872   if (ops->to_stop == NULL)
3873     ops->to_stop = delegate_stop;
3874   if (ops->to_rcmd == NULL)
3875     ops->to_rcmd = delegate_rcmd;
3876   if (ops->to_pid_to_exec_file == NULL)
3877     ops->to_pid_to_exec_file = delegate_pid_to_exec_file;
3878   if (ops->to_log_command == NULL)
3879     ops->to_log_command = delegate_log_command;
3880   if (ops->to_get_section_table == NULL)
3881     ops->to_get_section_table = delegate_get_section_table;
3882   if (ops->to_can_async_p == NULL)
3883     ops->to_can_async_p = delegate_can_async_p;
3884   if (ops->to_is_async_p == NULL)
3885     ops->to_is_async_p = delegate_is_async_p;
3886   if (ops->to_async == NULL)
3887     ops->to_async = delegate_async;
3888   if (ops->to_supports_non_stop == NULL)
3889     ops->to_supports_non_stop = delegate_supports_non_stop;
3890   if (ops->to_find_memory_regions == NULL)
3891     ops->to_find_memory_regions = delegate_find_memory_regions;
3892   if (ops->to_make_corefile_notes == NULL)
3893     ops->to_make_corefile_notes = delegate_make_corefile_notes;
3894   if (ops->to_get_bookmark == NULL)
3895     ops->to_get_bookmark = delegate_get_bookmark;
3896   if (ops->to_goto_bookmark == NULL)
3897     ops->to_goto_bookmark = delegate_goto_bookmark;
3898   if (ops->to_get_thread_local_address == NULL)
3899     ops->to_get_thread_local_address = delegate_get_thread_local_address;
3900   if (ops->to_xfer_partial == NULL)
3901     ops->to_xfer_partial = delegate_xfer_partial;
3902   if (ops->to_memory_map == NULL)
3903     ops->to_memory_map = delegate_memory_map;
3904   if (ops->to_flash_erase == NULL)
3905     ops->to_flash_erase = delegate_flash_erase;
3906   if (ops->to_flash_done == NULL)
3907     ops->to_flash_done = delegate_flash_done;
3908   if (ops->to_read_description == NULL)
3909     ops->to_read_description = delegate_read_description;
3910   if (ops->to_get_ada_task_ptid == NULL)
3911     ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid;
3912   if (ops->to_auxv_parse == NULL)
3913     ops->to_auxv_parse = delegate_auxv_parse;
3914   if (ops->to_search_memory == NULL)
3915     ops->to_search_memory = delegate_search_memory;
3916   if (ops->to_can_execute_reverse == NULL)
3917     ops->to_can_execute_reverse = delegate_can_execute_reverse;
3918   if (ops->to_execution_direction == NULL)
3919     ops->to_execution_direction = delegate_execution_direction;
3920   if (ops->to_supports_multi_process == NULL)
3921     ops->to_supports_multi_process = delegate_supports_multi_process;
3922   if (ops->to_supports_enable_disable_tracepoint == NULL)
3923     ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint;
3924   if (ops->to_supports_string_tracing == NULL)
3925     ops->to_supports_string_tracing = delegate_supports_string_tracing;
3926   if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL)
3927     ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions;
3928   if (ops->to_can_run_breakpoint_commands == NULL)
3929     ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands;
3930   if (ops->to_thread_architecture == NULL)
3931     ops->to_thread_architecture = delegate_thread_architecture;
3932   if (ops->to_thread_address_space == NULL)
3933     ops->to_thread_address_space = delegate_thread_address_space;
3934   if (ops->to_trace_init == NULL)
3935     ops->to_trace_init = delegate_trace_init;
3936   if (ops->to_download_tracepoint == NULL)
3937     ops->to_download_tracepoint = delegate_download_tracepoint;
3938   if (ops->to_can_download_tracepoint == NULL)
3939     ops->to_can_download_tracepoint = delegate_can_download_tracepoint;
3940   if (ops->to_download_trace_state_variable == NULL)
3941     ops->to_download_trace_state_variable = delegate_download_trace_state_variable;
3942   if (ops->to_enable_tracepoint == NULL)
3943     ops->to_enable_tracepoint = delegate_enable_tracepoint;
3944   if (ops->to_disable_tracepoint == NULL)
3945     ops->to_disable_tracepoint = delegate_disable_tracepoint;
3946   if (ops->to_trace_set_readonly_regions == NULL)
3947     ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions;
3948   if (ops->to_trace_start == NULL)
3949     ops->to_trace_start = delegate_trace_start;
3950   if (ops->to_get_trace_status == NULL)
3951     ops->to_get_trace_status = delegate_get_trace_status;
3952   if (ops->to_get_tracepoint_status == NULL)
3953     ops->to_get_tracepoint_status = delegate_get_tracepoint_status;
3954   if (ops->to_trace_stop == NULL)
3955     ops->to_trace_stop = delegate_trace_stop;
3956   if (ops->to_trace_find == NULL)
3957     ops->to_trace_find = delegate_trace_find;
3958   if (ops->to_get_trace_state_variable_value == NULL)
3959     ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value;
3960   if (ops->to_save_trace_data == NULL)
3961     ops->to_save_trace_data = delegate_save_trace_data;
3962   if (ops->to_upload_tracepoints == NULL)
3963     ops->to_upload_tracepoints = delegate_upload_tracepoints;
3964   if (ops->to_upload_trace_state_variables == NULL)
3965     ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables;
3966   if (ops->to_get_raw_trace_data == NULL)
3967     ops->to_get_raw_trace_data = delegate_get_raw_trace_data;
3968   if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
3969     ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len;
3970   if (ops->to_set_disconnected_tracing == NULL)
3971     ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing;
3972   if (ops->to_set_circular_trace_buffer == NULL)
3973     ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer;
3974   if (ops->to_set_trace_buffer_size == NULL)
3975     ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size;
3976   if (ops->to_set_trace_notes == NULL)
3977     ops->to_set_trace_notes = delegate_set_trace_notes;
3978   if (ops->to_core_of_thread == NULL)
3979     ops->to_core_of_thread = delegate_core_of_thread;
3980   if (ops->to_verify_memory == NULL)
3981     ops->to_verify_memory = delegate_verify_memory;
3982   if (ops->to_get_tib_address == NULL)
3983     ops->to_get_tib_address = delegate_get_tib_address;
3984   if (ops->to_set_permissions == NULL)
3985     ops->to_set_permissions = delegate_set_permissions;
3986   if (ops->to_static_tracepoint_marker_at == NULL)
3987     ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at;
3988   if (ops->to_static_tracepoint_markers_by_strid == NULL)
3989     ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
3990   if (ops->to_traceframe_info == NULL)
3991     ops->to_traceframe_info = delegate_traceframe_info;
3992   if (ops->to_use_agent == NULL)
3993     ops->to_use_agent = delegate_use_agent;
3994   if (ops->to_can_use_agent == NULL)
3995     ops->to_can_use_agent = delegate_can_use_agent;
3996   if (ops->to_supports_btrace == NULL)
3997     ops->to_supports_btrace = delegate_supports_btrace;
3998   if (ops->to_enable_btrace == NULL)
3999     ops->to_enable_btrace = delegate_enable_btrace;
4000   if (ops->to_disable_btrace == NULL)
4001     ops->to_disable_btrace = delegate_disable_btrace;
4002   if (ops->to_teardown_btrace == NULL)
4003     ops->to_teardown_btrace = delegate_teardown_btrace;
4004   if (ops->to_read_btrace == NULL)
4005     ops->to_read_btrace = delegate_read_btrace;
4006   if (ops->to_btrace_conf == NULL)
4007     ops->to_btrace_conf = delegate_btrace_conf;
4008   if (ops->to_stop_recording == NULL)
4009     ops->to_stop_recording = delegate_stop_recording;
4010   if (ops->to_info_record == NULL)
4011     ops->to_info_record = delegate_info_record;
4012   if (ops->to_save_record == NULL)
4013     ops->to_save_record = delegate_save_record;
4014   if (ops->to_delete_record == NULL)
4015     ops->to_delete_record = delegate_delete_record;
4016   if (ops->to_record_is_replaying == NULL)
4017     ops->to_record_is_replaying = delegate_record_is_replaying;
4018   if (ops->to_goto_record_begin == NULL)
4019     ops->to_goto_record_begin = delegate_goto_record_begin;
4020   if (ops->to_goto_record_end == NULL)
4021     ops->to_goto_record_end = delegate_goto_record_end;
4022   if (ops->to_goto_record == NULL)
4023     ops->to_goto_record = delegate_goto_record;
4024   if (ops->to_insn_history == NULL)
4025     ops->to_insn_history = delegate_insn_history;
4026   if (ops->to_insn_history_from == NULL)
4027     ops->to_insn_history_from = delegate_insn_history_from;
4028   if (ops->to_insn_history_range == NULL)
4029     ops->to_insn_history_range = delegate_insn_history_range;
4030   if (ops->to_call_history == NULL)
4031     ops->to_call_history = delegate_call_history;
4032   if (ops->to_call_history_from == NULL)
4033     ops->to_call_history_from = delegate_call_history_from;
4034   if (ops->to_call_history_range == NULL)
4035     ops->to_call_history_range = delegate_call_history_range;
4036   if (ops->to_augmented_libraries_svr4_read == NULL)
4037     ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read;
4038   if (ops->to_get_unwinder == NULL)
4039     ops->to_get_unwinder = delegate_get_unwinder;
4040   if (ops->to_get_tailcall_unwinder == NULL)
4041     ops->to_get_tailcall_unwinder = delegate_get_tailcall_unwinder;
4042   if (ops->to_decr_pc_after_break == NULL)
4043     ops->to_decr_pc_after_break = delegate_decr_pc_after_break;
4044   if (ops->to_prepare_to_generate_core == NULL)
4045     ops->to_prepare_to_generate_core = delegate_prepare_to_generate_core;
4046   if (ops->to_done_generating_core == NULL)
4047     ops->to_done_generating_core = delegate_done_generating_core;
4048 }
4049
4050 static void
4051 install_dummy_methods (struct target_ops *ops)
4052 {
4053   ops->to_post_attach = tdefault_post_attach;
4054   ops->to_detach = tdefault_detach;
4055   ops->to_disconnect = tdefault_disconnect;
4056   ops->to_resume = tdefault_resume;
4057   ops->to_wait = tdefault_wait;
4058   ops->to_fetch_registers = tdefault_fetch_registers;
4059   ops->to_store_registers = tdefault_store_registers;
4060   ops->to_prepare_to_store = tdefault_prepare_to_store;
4061   ops->to_files_info = tdefault_files_info;
4062   ops->to_insert_breakpoint = memory_insert_breakpoint;
4063   ops->to_remove_breakpoint = memory_remove_breakpoint;
4064   ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint;
4065   ops->to_ranged_break_num_registers = tdefault_ranged_break_num_registers;
4066   ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint;
4067   ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint;
4068   ops->to_remove_watchpoint = tdefault_remove_watchpoint;
4069   ops->to_insert_watchpoint = tdefault_insert_watchpoint;
4070   ops->to_insert_mask_watchpoint = tdefault_insert_mask_watchpoint;
4071   ops->to_remove_mask_watchpoint = tdefault_remove_mask_watchpoint;
4072   ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint;
4073   ops->to_stopped_data_address = tdefault_stopped_data_address;
4074   ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range;
4075   ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
4076   ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
4077   ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers;
4078   ops->to_terminal_init = tdefault_terminal_init;
4079   ops->to_terminal_inferior = tdefault_terminal_inferior;
4080   ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
4081   ops->to_terminal_ours = tdefault_terminal_ours;
4082   ops->to_terminal_info = default_terminal_info;
4083   ops->to_kill = tdefault_kill;
4084   ops->to_load = tdefault_load;
4085   ops->to_post_startup_inferior = tdefault_post_startup_inferior;
4086   ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint;
4087   ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint;
4088   ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint;
4089   ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint;
4090   ops->to_follow_fork = default_follow_fork;
4091   ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
4092   ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
4093   ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
4094   ops->to_has_exited = tdefault_has_exited;
4095   ops->to_mourn_inferior = default_mourn_inferior;
4096   ops->to_can_run = tdefault_can_run;
4097   ops->to_pass_signals = tdefault_pass_signals;
4098   ops->to_program_signals = tdefault_program_signals;
4099   ops->to_thread_alive = tdefault_thread_alive;
4100   ops->to_update_thread_list = tdefault_update_thread_list;
4101   ops->to_pid_to_str = default_pid_to_str;
4102   ops->to_extra_thread_info = tdefault_extra_thread_info;
4103   ops->to_thread_name = tdefault_thread_name;
4104   ops->to_stop = tdefault_stop;
4105   ops->to_rcmd = default_rcmd;
4106   ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
4107   ops->to_log_command = tdefault_log_command;
4108   ops->to_get_section_table = tdefault_get_section_table;
4109   ops->to_can_async_p = tdefault_can_async_p;
4110   ops->to_is_async_p = tdefault_is_async_p;
4111   ops->to_async = tdefault_async;
4112   ops->to_supports_non_stop = tdefault_supports_non_stop;
4113   ops->to_find_memory_regions = dummy_find_memory_regions;
4114   ops->to_make_corefile_notes = dummy_make_corefile_notes;
4115   ops->to_get_bookmark = tdefault_get_bookmark;
4116   ops->to_goto_bookmark = tdefault_goto_bookmark;
4117   ops->to_get_thread_local_address = tdefault_get_thread_local_address;
4118   ops->to_xfer_partial = tdefault_xfer_partial;
4119   ops->to_memory_map = tdefault_memory_map;
4120   ops->to_flash_erase = tdefault_flash_erase;
4121   ops->to_flash_done = tdefault_flash_done;
4122   ops->to_read_description = tdefault_read_description;
4123   ops->to_get_ada_task_ptid = default_get_ada_task_ptid;
4124   ops->to_auxv_parse = default_auxv_parse;
4125   ops->to_search_memory = default_search_memory;
4126   ops->to_can_execute_reverse = tdefault_can_execute_reverse;
4127   ops->to_execution_direction = default_execution_direction;
4128   ops->to_supports_multi_process = tdefault_supports_multi_process;
4129   ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint;
4130   ops->to_supports_string_tracing = tdefault_supports_string_tracing;
4131   ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions;
4132   ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands;
4133   ops->to_thread_architecture = default_thread_architecture;
4134   ops->to_thread_address_space = default_thread_address_space;
4135   ops->to_trace_init = tdefault_trace_init;
4136   ops->to_download_tracepoint = tdefault_download_tracepoint;
4137   ops->to_can_download_tracepoint = tdefault_can_download_tracepoint;
4138   ops->to_download_trace_state_variable = tdefault_download_trace_state_variable;
4139   ops->to_enable_tracepoint = tdefault_enable_tracepoint;
4140   ops->to_disable_tracepoint = tdefault_disable_tracepoint;
4141   ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions;
4142   ops->to_trace_start = tdefault_trace_start;
4143   ops->to_get_trace_status = tdefault_get_trace_status;
4144   ops->to_get_tracepoint_status = tdefault_get_tracepoint_status;
4145   ops->to_trace_stop = tdefault_trace_stop;
4146   ops->to_trace_find = tdefault_trace_find;
4147   ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value;
4148   ops->to_save_trace_data = tdefault_save_trace_data;
4149   ops->to_upload_tracepoints = tdefault_upload_tracepoints;
4150   ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables;
4151   ops->to_get_raw_trace_data = tdefault_get_raw_trace_data;
4152   ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len;
4153   ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing;
4154   ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer;
4155   ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size;
4156   ops->to_set_trace_notes = tdefault_set_trace_notes;
4157   ops->to_core_of_thread = tdefault_core_of_thread;
4158   ops->to_verify_memory = default_verify_memory;
4159   ops->to_get_tib_address = tdefault_get_tib_address;
4160   ops->to_set_permissions = tdefault_set_permissions;
4161   ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at;
4162   ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
4163   ops->to_traceframe_info = tdefault_traceframe_info;
4164   ops->to_use_agent = tdefault_use_agent;
4165   ops->to_can_use_agent = tdefault_can_use_agent;
4166   ops->to_supports_btrace = tdefault_supports_btrace;
4167   ops->to_enable_btrace = tdefault_enable_btrace;
4168   ops->to_disable_btrace = tdefault_disable_btrace;
4169   ops->to_teardown_btrace = tdefault_teardown_btrace;
4170   ops->to_read_btrace = tdefault_read_btrace;
4171   ops->to_btrace_conf = tdefault_btrace_conf;
4172   ops->to_stop_recording = tdefault_stop_recording;
4173   ops->to_info_record = tdefault_info_record;
4174   ops->to_save_record = tdefault_save_record;
4175   ops->to_delete_record = tdefault_delete_record;
4176   ops->to_record_is_replaying = tdefault_record_is_replaying;
4177   ops->to_goto_record_begin = tdefault_goto_record_begin;
4178   ops->to_goto_record_end = tdefault_goto_record_end;
4179   ops->to_goto_record = tdefault_goto_record;
4180   ops->to_insn_history = tdefault_insn_history;
4181   ops->to_insn_history_from = tdefault_insn_history_from;
4182   ops->to_insn_history_range = tdefault_insn_history_range;
4183   ops->to_call_history = tdefault_call_history;
4184   ops->to_call_history_from = tdefault_call_history_from;
4185   ops->to_call_history_range = tdefault_call_history_range;
4186   ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read;
4187   ops->to_get_unwinder = tdefault_get_unwinder;
4188   ops->to_get_tailcall_unwinder = tdefault_get_tailcall_unwinder;
4189   ops->to_decr_pc_after_break = default_target_decr_pc_after_break;
4190   ops->to_prepare_to_generate_core = tdefault_prepare_to_generate_core;
4191   ops->to_done_generating_core = tdefault_done_generating_core;
4192 }
4193
4194 static void
4195 init_debug_target (struct target_ops *ops)
4196 {
4197   ops->to_post_attach = debug_post_attach;
4198   ops->to_detach = debug_detach;
4199   ops->to_disconnect = debug_disconnect;
4200   ops->to_resume = debug_resume;
4201   ops->to_wait = debug_wait;
4202   ops->to_fetch_registers = debug_fetch_registers;
4203   ops->to_store_registers = debug_store_registers;
4204   ops->to_prepare_to_store = debug_prepare_to_store;
4205   ops->to_files_info = debug_files_info;
4206   ops->to_insert_breakpoint = debug_insert_breakpoint;
4207   ops->to_remove_breakpoint = debug_remove_breakpoint;
4208   ops->to_can_use_hw_breakpoint = debug_can_use_hw_breakpoint;
4209   ops->to_ranged_break_num_registers = debug_ranged_break_num_registers;
4210   ops->to_insert_hw_breakpoint = debug_insert_hw_breakpoint;
4211   ops->to_remove_hw_breakpoint = debug_remove_hw_breakpoint;
4212   ops->to_remove_watchpoint = debug_remove_watchpoint;
4213   ops->to_insert_watchpoint = debug_insert_watchpoint;
4214   ops->to_insert_mask_watchpoint = debug_insert_mask_watchpoint;
4215   ops->to_remove_mask_watchpoint = debug_remove_mask_watchpoint;
4216   ops->to_stopped_by_watchpoint = debug_stopped_by_watchpoint;
4217   ops->to_stopped_data_address = debug_stopped_data_address;
4218   ops->to_watchpoint_addr_within_range = debug_watchpoint_addr_within_range;
4219   ops->to_region_ok_for_hw_watchpoint = debug_region_ok_for_hw_watchpoint;
4220   ops->to_can_accel_watchpoint_condition = debug_can_accel_watchpoint_condition;
4221   ops->to_masked_watch_num_registers = debug_masked_watch_num_registers;
4222   ops->to_terminal_init = debug_terminal_init;
4223   ops->to_terminal_inferior = debug_terminal_inferior;
4224   ops->to_terminal_ours_for_output = debug_terminal_ours_for_output;
4225   ops->to_terminal_ours = debug_terminal_ours;
4226   ops->to_terminal_info = debug_terminal_info;
4227   ops->to_kill = debug_kill;
4228   ops->to_load = debug_load;
4229   ops->to_post_startup_inferior = debug_post_startup_inferior;
4230   ops->to_insert_fork_catchpoint = debug_insert_fork_catchpoint;
4231   ops->to_remove_fork_catchpoint = debug_remove_fork_catchpoint;
4232   ops->to_insert_vfork_catchpoint = debug_insert_vfork_catchpoint;
4233   ops->to_remove_vfork_catchpoint = debug_remove_vfork_catchpoint;
4234   ops->to_follow_fork = debug_follow_fork;
4235   ops->to_insert_exec_catchpoint = debug_insert_exec_catchpoint;
4236   ops->to_remove_exec_catchpoint = debug_remove_exec_catchpoint;
4237   ops->to_set_syscall_catchpoint = debug_set_syscall_catchpoint;
4238   ops->to_has_exited = debug_has_exited;
4239   ops->to_mourn_inferior = debug_mourn_inferior;
4240   ops->to_can_run = debug_can_run;
4241   ops->to_pass_signals = debug_pass_signals;
4242   ops->to_program_signals = debug_program_signals;
4243   ops->to_thread_alive = debug_thread_alive;
4244   ops->to_update_thread_list = debug_update_thread_list;
4245   ops->to_pid_to_str = debug_pid_to_str;
4246   ops->to_extra_thread_info = debug_extra_thread_info;
4247   ops->to_thread_name = debug_thread_name;
4248   ops->to_stop = debug_stop;
4249   ops->to_rcmd = debug_rcmd;
4250   ops->to_pid_to_exec_file = debug_pid_to_exec_file;
4251   ops->to_log_command = debug_log_command;
4252   ops->to_get_section_table = debug_get_section_table;
4253   ops->to_can_async_p = debug_can_async_p;
4254   ops->to_is_async_p = debug_is_async_p;
4255   ops->to_async = debug_async;
4256   ops->to_supports_non_stop = debug_supports_non_stop;
4257   ops->to_find_memory_regions = debug_find_memory_regions;
4258   ops->to_make_corefile_notes = debug_make_corefile_notes;
4259   ops->to_get_bookmark = debug_get_bookmark;
4260   ops->to_goto_bookmark = debug_goto_bookmark;
4261   ops->to_get_thread_local_address = debug_get_thread_local_address;
4262   ops->to_xfer_partial = debug_xfer_partial;
4263   ops->to_memory_map = debug_memory_map;
4264   ops->to_flash_erase = debug_flash_erase;
4265   ops->to_flash_done = debug_flash_done;
4266   ops->to_read_description = debug_read_description;
4267   ops->to_get_ada_task_ptid = debug_get_ada_task_ptid;
4268   ops->to_auxv_parse = debug_auxv_parse;
4269   ops->to_search_memory = debug_search_memory;
4270   ops->to_can_execute_reverse = debug_can_execute_reverse;
4271   ops->to_execution_direction = debug_execution_direction;
4272   ops->to_supports_multi_process = debug_supports_multi_process;
4273   ops->to_supports_enable_disable_tracepoint = debug_supports_enable_disable_tracepoint;
4274   ops->to_supports_string_tracing = debug_supports_string_tracing;
4275   ops->to_supports_evaluation_of_breakpoint_conditions = debug_supports_evaluation_of_breakpoint_conditions;
4276   ops->to_can_run_breakpoint_commands = debug_can_run_breakpoint_commands;
4277   ops->to_thread_architecture = debug_thread_architecture;
4278   ops->to_thread_address_space = debug_thread_address_space;
4279   ops->to_trace_init = debug_trace_init;
4280   ops->to_download_tracepoint = debug_download_tracepoint;
4281   ops->to_can_download_tracepoint = debug_can_download_tracepoint;
4282   ops->to_download_trace_state_variable = debug_download_trace_state_variable;
4283   ops->to_enable_tracepoint = debug_enable_tracepoint;
4284   ops->to_disable_tracepoint = debug_disable_tracepoint;
4285   ops->to_trace_set_readonly_regions = debug_trace_set_readonly_regions;
4286   ops->to_trace_start = debug_trace_start;
4287   ops->to_get_trace_status = debug_get_trace_status;
4288   ops->to_get_tracepoint_status = debug_get_tracepoint_status;
4289   ops->to_trace_stop = debug_trace_stop;
4290   ops->to_trace_find = debug_trace_find;
4291   ops->to_get_trace_state_variable_value = debug_get_trace_state_variable_value;
4292   ops->to_save_trace_data = debug_save_trace_data;
4293   ops->to_upload_tracepoints = debug_upload_tracepoints;
4294   ops->to_upload_trace_state_variables = debug_upload_trace_state_variables;
4295   ops->to_get_raw_trace_data = debug_get_raw_trace_data;
4296   ops->to_get_min_fast_tracepoint_insn_len = debug_get_min_fast_tracepoint_insn_len;
4297   ops->to_set_disconnected_tracing = debug_set_disconnected_tracing;
4298   ops->to_set_circular_trace_buffer = debug_set_circular_trace_buffer;
4299   ops->to_set_trace_buffer_size = debug_set_trace_buffer_size;
4300   ops->to_set_trace_notes = debug_set_trace_notes;
4301   ops->to_core_of_thread = debug_core_of_thread;
4302   ops->to_verify_memory = debug_verify_memory;
4303   ops->to_get_tib_address = debug_get_tib_address;
4304   ops->to_set_permissions = debug_set_permissions;
4305   ops->to_static_tracepoint_marker_at = debug_static_tracepoint_marker_at;
4306   ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid;
4307   ops->to_traceframe_info = debug_traceframe_info;
4308   ops->to_use_agent = debug_use_agent;
4309   ops->to_can_use_agent = debug_can_use_agent;
4310   ops->to_supports_btrace = debug_supports_btrace;
4311   ops->to_enable_btrace = debug_enable_btrace;
4312   ops->to_disable_btrace = debug_disable_btrace;
4313   ops->to_teardown_btrace = debug_teardown_btrace;
4314   ops->to_read_btrace = debug_read_btrace;
4315   ops->to_btrace_conf = debug_btrace_conf;
4316   ops->to_stop_recording = debug_stop_recording;
4317   ops->to_info_record = debug_info_record;
4318   ops->to_save_record = debug_save_record;
4319   ops->to_delete_record = debug_delete_record;
4320   ops->to_record_is_replaying = debug_record_is_replaying;
4321   ops->to_goto_record_begin = debug_goto_record_begin;
4322   ops->to_goto_record_end = debug_goto_record_end;
4323   ops->to_goto_record = debug_goto_record;
4324   ops->to_insn_history = debug_insn_history;
4325   ops->to_insn_history_from = debug_insn_history_from;
4326   ops->to_insn_history_range = debug_insn_history_range;
4327   ops->to_call_history = debug_call_history;
4328   ops->to_call_history_from = debug_call_history_from;
4329   ops->to_call_history_range = debug_call_history_range;
4330   ops->to_augmented_libraries_svr4_read = debug_augmented_libraries_svr4_read;
4331   ops->to_get_unwinder = debug_get_unwinder;
4332   ops->to_get_tailcall_unwinder = debug_get_tailcall_unwinder;
4333   ops->to_decr_pc_after_break = debug_decr_pc_after_break;
4334   ops->to_prepare_to_generate_core = debug_prepare_to_generate_core;
4335   ops->to_done_generating_core = debug_done_generating_core;
4336 }