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