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