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 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 char *
1541 tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
1542 {
1543   return NULL;
1544 }
1545
1546 static char *
1547 debug_thread_name (struct target_ops *self, struct thread_info *arg1)
1548 {
1549   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_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 int
1813 delegate_supports_non_stop (struct target_ops *self)
1814 {
1815   self = self->beneath;
1816   return self->to_supports_non_stop (self);
1817 }
1818
1819 static int
1820 tdefault_supports_non_stop (struct target_ops *self)
1821 {
1822   return 0;
1823 }
1824
1825 static int
1826 debug_supports_non_stop (struct target_ops *self)
1827 {
1828   int result;
1829   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", debug_target.to_shortname);
1830   result = debug_target.to_supports_non_stop (&debug_target);
1831   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", debug_target.to_shortname);
1832   target_debug_print_struct_target_ops_p (&debug_target);
1833   fputs_unfiltered (") = ", gdb_stdlog);
1834   target_debug_print_int (result);
1835   fputs_unfiltered ("\n", gdb_stdlog);
1836   return result;
1837 }
1838
1839 static int
1840 delegate_always_non_stop_p (struct target_ops *self)
1841 {
1842   self = self->beneath;
1843   return self->to_always_non_stop_p (self);
1844 }
1845
1846 static int
1847 tdefault_always_non_stop_p (struct target_ops *self)
1848 {
1849   return 0;
1850 }
1851
1852 static int
1853 debug_always_non_stop_p (struct target_ops *self)
1854 {
1855   int result;
1856   fprintf_unfiltered (gdb_stdlog, "-> %s->to_always_non_stop_p (...)\n", debug_target.to_shortname);
1857   result = debug_target.to_always_non_stop_p (&debug_target);
1858   fprintf_unfiltered (gdb_stdlog, "<- %s->to_always_non_stop_p (", debug_target.to_shortname);
1859   target_debug_print_struct_target_ops_p (&debug_target);
1860   fputs_unfiltered (") = ", gdb_stdlog);
1861   target_debug_print_int (result);
1862   fputs_unfiltered ("\n", gdb_stdlog);
1863   return result;
1864 }
1865
1866 static int
1867 delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
1868 {
1869   self = self->beneath;
1870   return self->to_find_memory_regions (self, arg1, arg2);
1871 }
1872
1873 static int
1874 debug_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
1875 {
1876   int result;
1877   fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", debug_target.to_shortname);
1878   result = debug_target.to_find_memory_regions (&debug_target, arg1, arg2);
1879   fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", debug_target.to_shortname);
1880   target_debug_print_struct_target_ops_p (&debug_target);
1881   fputs_unfiltered (", ", gdb_stdlog);
1882   target_debug_print_find_memory_region_ftype (arg1);
1883   fputs_unfiltered (", ", gdb_stdlog);
1884   target_debug_print_void_p (arg2);
1885   fputs_unfiltered (") = ", gdb_stdlog);
1886   target_debug_print_int (result);
1887   fputs_unfiltered ("\n", gdb_stdlog);
1888   return result;
1889 }
1890
1891 static char *
1892 delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
1893 {
1894   self = self->beneath;
1895   return self->to_make_corefile_notes (self, arg1, arg2);
1896 }
1897
1898 static char *
1899 debug_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
1900 {
1901   char * result;
1902   fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", debug_target.to_shortname);
1903   result = debug_target.to_make_corefile_notes (&debug_target, arg1, arg2);
1904   fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", debug_target.to_shortname);
1905   target_debug_print_struct_target_ops_p (&debug_target);
1906   fputs_unfiltered (", ", gdb_stdlog);
1907   target_debug_print_bfd_p (arg1);
1908   fputs_unfiltered (", ", gdb_stdlog);
1909   target_debug_print_int_p (arg2);
1910   fputs_unfiltered (") = ", gdb_stdlog);
1911   target_debug_print_char_p (result);
1912   fputs_unfiltered ("\n", gdb_stdlog);
1913   return result;
1914 }
1915
1916 static gdb_byte *
1917 delegate_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
1918 {
1919   self = self->beneath;
1920   return self->to_get_bookmark (self, arg1, arg2);
1921 }
1922
1923 static gdb_byte *
1924 tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
1925 {
1926   tcomplain ();
1927 }
1928
1929 static gdb_byte *
1930 debug_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
1931 {
1932   gdb_byte * result;
1933   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", debug_target.to_shortname);
1934   result = debug_target.to_get_bookmark (&debug_target, arg1, arg2);
1935   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", debug_target.to_shortname);
1936   target_debug_print_struct_target_ops_p (&debug_target);
1937   fputs_unfiltered (", ", gdb_stdlog);
1938   target_debug_print_const_char_p (arg1);
1939   fputs_unfiltered (", ", gdb_stdlog);
1940   target_debug_print_int (arg2);
1941   fputs_unfiltered (") = ", gdb_stdlog);
1942   target_debug_print_gdb_byte_p (result);
1943   fputs_unfiltered ("\n", gdb_stdlog);
1944   return result;
1945 }
1946
1947 static void
1948 delegate_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
1949 {
1950   self = self->beneath;
1951   self->to_goto_bookmark (self, arg1, arg2);
1952 }
1953
1954 static void
1955 tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
1956 {
1957   tcomplain ();
1958 }
1959
1960 static void
1961 debug_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
1962 {
1963   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", debug_target.to_shortname);
1964   debug_target.to_goto_bookmark (&debug_target, arg1, arg2);
1965   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", debug_target.to_shortname);
1966   target_debug_print_struct_target_ops_p (&debug_target);
1967   fputs_unfiltered (", ", gdb_stdlog);
1968   target_debug_print_const_gdb_byte_p (arg1);
1969   fputs_unfiltered (", ", gdb_stdlog);
1970   target_debug_print_int (arg2);
1971   fputs_unfiltered (")\n", gdb_stdlog);
1972 }
1973
1974 static CORE_ADDR
1975 delegate_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
1976 {
1977   self = self->beneath;
1978   return self->to_get_thread_local_address (self, arg1, arg2, arg3);
1979 }
1980
1981 static CORE_ADDR
1982 tdefault_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
1983 {
1984   generic_tls_error ();
1985 }
1986
1987 static CORE_ADDR
1988 debug_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3)
1989 {
1990   CORE_ADDR result;
1991   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_thread_local_address (...)\n", debug_target.to_shortname);
1992   result = debug_target.to_get_thread_local_address (&debug_target, arg1, arg2, arg3);
1993   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_thread_local_address (", debug_target.to_shortname);
1994   target_debug_print_struct_target_ops_p (&debug_target);
1995   fputs_unfiltered (", ", gdb_stdlog);
1996   target_debug_print_ptid_t (arg1);
1997   fputs_unfiltered (", ", gdb_stdlog);
1998   target_debug_print_CORE_ADDR (arg2);
1999   fputs_unfiltered (", ", gdb_stdlog);
2000   target_debug_print_CORE_ADDR (arg3);
2001   fputs_unfiltered (") = ", gdb_stdlog);
2002   target_debug_print_CORE_ADDR (result);
2003   fputs_unfiltered ("\n", gdb_stdlog);
2004   return result;
2005 }
2006
2007 static enum target_xfer_status
2008 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)
2009 {
2010   self = self->beneath;
2011   return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2012 }
2013
2014 static enum target_xfer_status
2015 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)
2016 {
2017   return TARGET_XFER_E_IO;
2018 }
2019
2020 static enum target_xfer_status
2021 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)
2022 {
2023   enum target_xfer_status result;
2024   fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", debug_target.to_shortname);
2025   result = debug_target.to_xfer_partial (&debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2026   fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", debug_target.to_shortname);
2027   target_debug_print_struct_target_ops_p (&debug_target);
2028   fputs_unfiltered (", ", gdb_stdlog);
2029   target_debug_print_enum_target_object (arg1);
2030   fputs_unfiltered (", ", gdb_stdlog);
2031   target_debug_print_const_char_p (arg2);
2032   fputs_unfiltered (", ", gdb_stdlog);
2033   target_debug_print_gdb_byte_p (arg3);
2034   fputs_unfiltered (", ", gdb_stdlog);
2035   target_debug_print_const_gdb_byte_p (arg4);
2036   fputs_unfiltered (", ", gdb_stdlog);
2037   target_debug_print_ULONGEST (arg5);
2038   fputs_unfiltered (", ", gdb_stdlog);
2039   target_debug_print_ULONGEST (arg6);
2040   fputs_unfiltered (", ", gdb_stdlog);
2041   target_debug_print_ULONGEST_p (arg7);
2042   fputs_unfiltered (") = ", gdb_stdlog);
2043   target_debug_print_enum_target_xfer_status (result);
2044   fputs_unfiltered ("\n", gdb_stdlog);
2045   return result;
2046 }
2047
2048 static VEC(mem_region_s) *
2049 delegate_memory_map (struct target_ops *self)
2050 {
2051   self = self->beneath;
2052   return self->to_memory_map (self);
2053 }
2054
2055 static VEC(mem_region_s) *
2056 tdefault_memory_map (struct target_ops *self)
2057 {
2058   return NULL;
2059 }
2060
2061 static VEC(mem_region_s) *
2062 debug_memory_map (struct target_ops *self)
2063 {
2064   VEC(mem_region_s) * result;
2065   fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", debug_target.to_shortname);
2066   result = debug_target.to_memory_map (&debug_target);
2067   fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", debug_target.to_shortname);
2068   target_debug_print_struct_target_ops_p (&debug_target);
2069   fputs_unfiltered (") = ", gdb_stdlog);
2070   target_debug_print_VEC_mem_region_s__p (result);
2071   fputs_unfiltered ("\n", gdb_stdlog);
2072   return result;
2073 }
2074
2075 static void
2076 delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
2077 {
2078   self = self->beneath;
2079   self->to_flash_erase (self, arg1, arg2);
2080 }
2081
2082 static void
2083 tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
2084 {
2085   tcomplain ();
2086 }
2087
2088 static void
2089 debug_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
2090 {
2091   fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", debug_target.to_shortname);
2092   debug_target.to_flash_erase (&debug_target, arg1, arg2);
2093   fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", debug_target.to_shortname);
2094   target_debug_print_struct_target_ops_p (&debug_target);
2095   fputs_unfiltered (", ", gdb_stdlog);
2096   target_debug_print_ULONGEST (arg1);
2097   fputs_unfiltered (", ", gdb_stdlog);
2098   target_debug_print_LONGEST (arg2);
2099   fputs_unfiltered (")\n", gdb_stdlog);
2100 }
2101
2102 static void
2103 delegate_flash_done (struct target_ops *self)
2104 {
2105   self = self->beneath;
2106   self->to_flash_done (self);
2107 }
2108
2109 static void
2110 tdefault_flash_done (struct target_ops *self)
2111 {
2112   tcomplain ();
2113 }
2114
2115 static void
2116 debug_flash_done (struct target_ops *self)
2117 {
2118   fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", debug_target.to_shortname);
2119   debug_target.to_flash_done (&debug_target);
2120   fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", debug_target.to_shortname);
2121   target_debug_print_struct_target_ops_p (&debug_target);
2122   fputs_unfiltered (")\n", gdb_stdlog);
2123 }
2124
2125 static const struct target_desc *
2126 delegate_read_description (struct target_ops *self)
2127 {
2128   self = self->beneath;
2129   return self->to_read_description (self);
2130 }
2131
2132 static const struct target_desc *
2133 tdefault_read_description (struct target_ops *self)
2134 {
2135   return NULL;
2136 }
2137
2138 static const struct target_desc *
2139 debug_read_description (struct target_ops *self)
2140 {
2141   const struct target_desc * result;
2142   fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", debug_target.to_shortname);
2143   result = debug_target.to_read_description (&debug_target);
2144   fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", debug_target.to_shortname);
2145   target_debug_print_struct_target_ops_p (&debug_target);
2146   fputs_unfiltered (") = ", gdb_stdlog);
2147   target_debug_print_const_struct_target_desc_p (result);
2148   fputs_unfiltered ("\n", gdb_stdlog);
2149   return result;
2150 }
2151
2152 static ptid_t
2153 delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
2154 {
2155   self = self->beneath;
2156   return self->to_get_ada_task_ptid (self, arg1, arg2);
2157 }
2158
2159 static ptid_t
2160 debug_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
2161 {
2162   ptid_t result;
2163   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", debug_target.to_shortname);
2164   result = debug_target.to_get_ada_task_ptid (&debug_target, arg1, arg2);
2165   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", debug_target.to_shortname);
2166   target_debug_print_struct_target_ops_p (&debug_target);
2167   fputs_unfiltered (", ", gdb_stdlog);
2168   target_debug_print_long (arg1);
2169   fputs_unfiltered (", ", gdb_stdlog);
2170   target_debug_print_long (arg2);
2171   fputs_unfiltered (") = ", gdb_stdlog);
2172   target_debug_print_ptid_t (result);
2173   fputs_unfiltered ("\n", gdb_stdlog);
2174   return result;
2175 }
2176
2177 static int
2178 delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
2179 {
2180   self = self->beneath;
2181   return self->to_auxv_parse (self, arg1, arg2, arg3, arg4);
2182 }
2183
2184 static int
2185 debug_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
2186 {
2187   int result;
2188   fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", debug_target.to_shortname);
2189   result = debug_target.to_auxv_parse (&debug_target, arg1, arg2, arg3, arg4);
2190   fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", debug_target.to_shortname);
2191   target_debug_print_struct_target_ops_p (&debug_target);
2192   fputs_unfiltered (", ", gdb_stdlog);
2193   target_debug_print_gdb_byte_pp (arg1);
2194   fputs_unfiltered (", ", gdb_stdlog);
2195   target_debug_print_gdb_byte_p (arg2);
2196   fputs_unfiltered (", ", gdb_stdlog);
2197   target_debug_print_CORE_ADDR_p (arg3);
2198   fputs_unfiltered (", ", gdb_stdlog);
2199   target_debug_print_CORE_ADDR_p (arg4);
2200   fputs_unfiltered (") = ", gdb_stdlog);
2201   target_debug_print_int (result);
2202   fputs_unfiltered ("\n", gdb_stdlog);
2203   return result;
2204 }
2205
2206 static int
2207 delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
2208 {
2209   self = self->beneath;
2210   return self->to_search_memory (self, arg1, arg2, arg3, arg4, arg5);
2211 }
2212
2213 static int
2214 debug_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
2215 {
2216   int result;
2217   fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", debug_target.to_shortname);
2218   result = debug_target.to_search_memory (&debug_target, arg1, arg2, arg3, arg4, arg5);
2219   fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", debug_target.to_shortname);
2220   target_debug_print_struct_target_ops_p (&debug_target);
2221   fputs_unfiltered (", ", gdb_stdlog);
2222   target_debug_print_CORE_ADDR (arg1);
2223   fputs_unfiltered (", ", gdb_stdlog);
2224   target_debug_print_ULONGEST (arg2);
2225   fputs_unfiltered (", ", gdb_stdlog);
2226   target_debug_print_const_gdb_byte_p (arg3);
2227   fputs_unfiltered (", ", gdb_stdlog);
2228   target_debug_print_ULONGEST (arg4);
2229   fputs_unfiltered (", ", gdb_stdlog);
2230   target_debug_print_CORE_ADDR_p (arg5);
2231   fputs_unfiltered (") = ", gdb_stdlog);
2232   target_debug_print_int (result);
2233   fputs_unfiltered ("\n", gdb_stdlog);
2234   return result;
2235 }
2236
2237 static int
2238 delegate_can_execute_reverse (struct target_ops *self)
2239 {
2240   self = self->beneath;
2241   return self->to_can_execute_reverse (self);
2242 }
2243
2244 static int
2245 tdefault_can_execute_reverse (struct target_ops *self)
2246 {
2247   return 0;
2248 }
2249
2250 static int
2251 debug_can_execute_reverse (struct target_ops *self)
2252 {
2253   int result;
2254   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", debug_target.to_shortname);
2255   result = debug_target.to_can_execute_reverse (&debug_target);
2256   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", debug_target.to_shortname);
2257   target_debug_print_struct_target_ops_p (&debug_target);
2258   fputs_unfiltered (") = ", gdb_stdlog);
2259   target_debug_print_int (result);
2260   fputs_unfiltered ("\n", gdb_stdlog);
2261   return result;
2262 }
2263
2264 static enum exec_direction_kind
2265 delegate_execution_direction (struct target_ops *self)
2266 {
2267   self = self->beneath;
2268   return self->to_execution_direction (self);
2269 }
2270
2271 static enum exec_direction_kind
2272 debug_execution_direction (struct target_ops *self)
2273 {
2274   enum exec_direction_kind result;
2275   fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", debug_target.to_shortname);
2276   result = debug_target.to_execution_direction (&debug_target);
2277   fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", debug_target.to_shortname);
2278   target_debug_print_struct_target_ops_p (&debug_target);
2279   fputs_unfiltered (") = ", gdb_stdlog);
2280   target_debug_print_enum_exec_direction_kind (result);
2281   fputs_unfiltered ("\n", gdb_stdlog);
2282   return result;
2283 }
2284
2285 static int
2286 delegate_supports_multi_process (struct target_ops *self)
2287 {
2288   self = self->beneath;
2289   return self->to_supports_multi_process (self);
2290 }
2291
2292 static int
2293 tdefault_supports_multi_process (struct target_ops *self)
2294 {
2295   return 0;
2296 }
2297
2298 static int
2299 debug_supports_multi_process (struct target_ops *self)
2300 {
2301   int result;
2302   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", debug_target.to_shortname);
2303   result = debug_target.to_supports_multi_process (&debug_target);
2304   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", debug_target.to_shortname);
2305   target_debug_print_struct_target_ops_p (&debug_target);
2306   fputs_unfiltered (") = ", gdb_stdlog);
2307   target_debug_print_int (result);
2308   fputs_unfiltered ("\n", gdb_stdlog);
2309   return result;
2310 }
2311
2312 static int
2313 delegate_supports_enable_disable_tracepoint (struct target_ops *self)
2314 {
2315   self = self->beneath;
2316   return self->to_supports_enable_disable_tracepoint (self);
2317 }
2318
2319 static int
2320 tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
2321 {
2322   return 0;
2323 }
2324
2325 static int
2326 debug_supports_enable_disable_tracepoint (struct target_ops *self)
2327 {
2328   int result;
2329   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", debug_target.to_shortname);
2330   result = debug_target.to_supports_enable_disable_tracepoint (&debug_target);
2331   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", debug_target.to_shortname);
2332   target_debug_print_struct_target_ops_p (&debug_target);
2333   fputs_unfiltered (") = ", gdb_stdlog);
2334   target_debug_print_int (result);
2335   fputs_unfiltered ("\n", gdb_stdlog);
2336   return result;
2337 }
2338
2339 static int
2340 delegate_supports_string_tracing (struct target_ops *self)
2341 {
2342   self = self->beneath;
2343   return self->to_supports_string_tracing (self);
2344 }
2345
2346 static int
2347 tdefault_supports_string_tracing (struct target_ops *self)
2348 {
2349   return 0;
2350 }
2351
2352 static int
2353 debug_supports_string_tracing (struct target_ops *self)
2354 {
2355   int result;
2356   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", debug_target.to_shortname);
2357   result = debug_target.to_supports_string_tracing (&debug_target);
2358   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", debug_target.to_shortname);
2359   target_debug_print_struct_target_ops_p (&debug_target);
2360   fputs_unfiltered (") = ", gdb_stdlog);
2361   target_debug_print_int (result);
2362   fputs_unfiltered ("\n", gdb_stdlog);
2363   return result;
2364 }
2365
2366 static int
2367 delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
2368 {
2369   self = self->beneath;
2370   return self->to_supports_evaluation_of_breakpoint_conditions (self);
2371 }
2372
2373 static int
2374 tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
2375 {
2376   return 0;
2377 }
2378
2379 static int
2380 debug_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
2381 {
2382   int result;
2383   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", debug_target.to_shortname);
2384   result = debug_target.to_supports_evaluation_of_breakpoint_conditions (&debug_target);
2385   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", debug_target.to_shortname);
2386   target_debug_print_struct_target_ops_p (&debug_target);
2387   fputs_unfiltered (") = ", gdb_stdlog);
2388   target_debug_print_int (result);
2389   fputs_unfiltered ("\n", gdb_stdlog);
2390   return result;
2391 }
2392
2393 static int
2394 delegate_can_run_breakpoint_commands (struct target_ops *self)
2395 {
2396   self = self->beneath;
2397   return self->to_can_run_breakpoint_commands (self);
2398 }
2399
2400 static int
2401 tdefault_can_run_breakpoint_commands (struct target_ops *self)
2402 {
2403   return 0;
2404 }
2405
2406 static int
2407 debug_can_run_breakpoint_commands (struct target_ops *self)
2408 {
2409   int result;
2410   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", debug_target.to_shortname);
2411   result = debug_target.to_can_run_breakpoint_commands (&debug_target);
2412   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", debug_target.to_shortname);
2413   target_debug_print_struct_target_ops_p (&debug_target);
2414   fputs_unfiltered (") = ", gdb_stdlog);
2415   target_debug_print_int (result);
2416   fputs_unfiltered ("\n", gdb_stdlog);
2417   return result;
2418 }
2419
2420 static struct gdbarch *
2421 delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
2422 {
2423   self = self->beneath;
2424   return self->to_thread_architecture (self, arg1);
2425 }
2426
2427 static struct gdbarch *
2428 debug_thread_architecture (struct target_ops *self, ptid_t arg1)
2429 {
2430   struct gdbarch * result;
2431   fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", debug_target.to_shortname);
2432   result = debug_target.to_thread_architecture (&debug_target, arg1);
2433   fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", debug_target.to_shortname);
2434   target_debug_print_struct_target_ops_p (&debug_target);
2435   fputs_unfiltered (", ", gdb_stdlog);
2436   target_debug_print_ptid_t (arg1);
2437   fputs_unfiltered (") = ", gdb_stdlog);
2438   target_debug_print_struct_gdbarch_p (result);
2439   fputs_unfiltered ("\n", gdb_stdlog);
2440   return result;
2441 }
2442
2443 static struct address_space *
2444 delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
2445 {
2446   self = self->beneath;
2447   return self->to_thread_address_space (self, arg1);
2448 }
2449
2450 static struct address_space *
2451 debug_thread_address_space (struct target_ops *self, ptid_t arg1)
2452 {
2453   struct address_space * result;
2454   fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", debug_target.to_shortname);
2455   result = debug_target.to_thread_address_space (&debug_target, arg1);
2456   fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", debug_target.to_shortname);
2457   target_debug_print_struct_target_ops_p (&debug_target);
2458   fputs_unfiltered (", ", gdb_stdlog);
2459   target_debug_print_ptid_t (arg1);
2460   fputs_unfiltered (") = ", gdb_stdlog);
2461   target_debug_print_struct_address_space_p (result);
2462   fputs_unfiltered ("\n", gdb_stdlog);
2463   return result;
2464 }
2465
2466 static int
2467 delegate_filesystem_is_local (struct target_ops *self)
2468 {
2469   self = self->beneath;
2470   return self->to_filesystem_is_local (self);
2471 }
2472
2473 static int
2474 tdefault_filesystem_is_local (struct target_ops *self)
2475 {
2476   return 1;
2477 }
2478
2479 static int
2480 debug_filesystem_is_local (struct target_ops *self)
2481 {
2482   int result;
2483   fprintf_unfiltered (gdb_stdlog, "-> %s->to_filesystem_is_local (...)\n", debug_target.to_shortname);
2484   result = debug_target.to_filesystem_is_local (&debug_target);
2485   fprintf_unfiltered (gdb_stdlog, "<- %s->to_filesystem_is_local (", debug_target.to_shortname);
2486   target_debug_print_struct_target_ops_p (&debug_target);
2487   fputs_unfiltered (") = ", gdb_stdlog);
2488   target_debug_print_int (result);
2489   fputs_unfiltered ("\n", gdb_stdlog);
2490   return result;
2491 }
2492
2493 static void
2494 delegate_trace_init (struct target_ops *self)
2495 {
2496   self = self->beneath;
2497   self->to_trace_init (self);
2498 }
2499
2500 static void
2501 tdefault_trace_init (struct target_ops *self)
2502 {
2503   tcomplain ();
2504 }
2505
2506 static void
2507 debug_trace_init (struct target_ops *self)
2508 {
2509   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", debug_target.to_shortname);
2510   debug_target.to_trace_init (&debug_target);
2511   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", debug_target.to_shortname);
2512   target_debug_print_struct_target_ops_p (&debug_target);
2513   fputs_unfiltered (")\n", gdb_stdlog);
2514 }
2515
2516 static void
2517 delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
2518 {
2519   self = self->beneath;
2520   self->to_download_tracepoint (self, arg1);
2521 }
2522
2523 static void
2524 tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
2525 {
2526   tcomplain ();
2527 }
2528
2529 static void
2530 debug_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
2531 {
2532   fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", debug_target.to_shortname);
2533   debug_target.to_download_tracepoint (&debug_target, arg1);
2534   fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", debug_target.to_shortname);
2535   target_debug_print_struct_target_ops_p (&debug_target);
2536   fputs_unfiltered (", ", gdb_stdlog);
2537   target_debug_print_struct_bp_location_p (arg1);
2538   fputs_unfiltered (")\n", gdb_stdlog);
2539 }
2540
2541 static int
2542 delegate_can_download_tracepoint (struct target_ops *self)
2543 {
2544   self = self->beneath;
2545   return self->to_can_download_tracepoint (self);
2546 }
2547
2548 static int
2549 tdefault_can_download_tracepoint (struct target_ops *self)
2550 {
2551   return 0;
2552 }
2553
2554 static int
2555 debug_can_download_tracepoint (struct target_ops *self)
2556 {
2557   int result;
2558   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", debug_target.to_shortname);
2559   result = debug_target.to_can_download_tracepoint (&debug_target);
2560   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", debug_target.to_shortname);
2561   target_debug_print_struct_target_ops_p (&debug_target);
2562   fputs_unfiltered (") = ", gdb_stdlog);
2563   target_debug_print_int (result);
2564   fputs_unfiltered ("\n", gdb_stdlog);
2565   return result;
2566 }
2567
2568 static void
2569 delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
2570 {
2571   self = self->beneath;
2572   self->to_download_trace_state_variable (self, arg1);
2573 }
2574
2575 static void
2576 tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
2577 {
2578   tcomplain ();
2579 }
2580
2581 static void
2582 debug_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
2583 {
2584   fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", debug_target.to_shortname);
2585   debug_target.to_download_trace_state_variable (&debug_target, arg1);
2586   fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", debug_target.to_shortname);
2587   target_debug_print_struct_target_ops_p (&debug_target);
2588   fputs_unfiltered (", ", gdb_stdlog);
2589   target_debug_print_struct_trace_state_variable_p (arg1);
2590   fputs_unfiltered (")\n", gdb_stdlog);
2591 }
2592
2593 static void
2594 delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2595 {
2596   self = self->beneath;
2597   self->to_enable_tracepoint (self, arg1);
2598 }
2599
2600 static void
2601 tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2602 {
2603   tcomplain ();
2604 }
2605
2606 static void
2607 debug_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2608 {
2609   fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", debug_target.to_shortname);
2610   debug_target.to_enable_tracepoint (&debug_target, arg1);
2611   fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", debug_target.to_shortname);
2612   target_debug_print_struct_target_ops_p (&debug_target);
2613   fputs_unfiltered (", ", gdb_stdlog);
2614   target_debug_print_struct_bp_location_p (arg1);
2615   fputs_unfiltered (")\n", gdb_stdlog);
2616 }
2617
2618 static void
2619 delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2620 {
2621   self = self->beneath;
2622   self->to_disable_tracepoint (self, arg1);
2623 }
2624
2625 static void
2626 tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2627 {
2628   tcomplain ();
2629 }
2630
2631 static void
2632 debug_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
2633 {
2634   fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", debug_target.to_shortname);
2635   debug_target.to_disable_tracepoint (&debug_target, arg1);
2636   fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", debug_target.to_shortname);
2637   target_debug_print_struct_target_ops_p (&debug_target);
2638   fputs_unfiltered (", ", gdb_stdlog);
2639   target_debug_print_struct_bp_location_p (arg1);
2640   fputs_unfiltered (")\n", gdb_stdlog);
2641 }
2642
2643 static void
2644 delegate_trace_set_readonly_regions (struct target_ops *self)
2645 {
2646   self = self->beneath;
2647   self->to_trace_set_readonly_regions (self);
2648 }
2649
2650 static void
2651 tdefault_trace_set_readonly_regions (struct target_ops *self)
2652 {
2653   tcomplain ();
2654 }
2655
2656 static void
2657 debug_trace_set_readonly_regions (struct target_ops *self)
2658 {
2659   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", debug_target.to_shortname);
2660   debug_target.to_trace_set_readonly_regions (&debug_target);
2661   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", debug_target.to_shortname);
2662   target_debug_print_struct_target_ops_p (&debug_target);
2663   fputs_unfiltered (")\n", gdb_stdlog);
2664 }
2665
2666 static void
2667 delegate_trace_start (struct target_ops *self)
2668 {
2669   self = self->beneath;
2670   self->to_trace_start (self);
2671 }
2672
2673 static void
2674 tdefault_trace_start (struct target_ops *self)
2675 {
2676   tcomplain ();
2677 }
2678
2679 static void
2680 debug_trace_start (struct target_ops *self)
2681 {
2682   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", debug_target.to_shortname);
2683   debug_target.to_trace_start (&debug_target);
2684   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", debug_target.to_shortname);
2685   target_debug_print_struct_target_ops_p (&debug_target);
2686   fputs_unfiltered (")\n", gdb_stdlog);
2687 }
2688
2689 static int
2690 delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
2691 {
2692   self = self->beneath;
2693   return self->to_get_trace_status (self, arg1);
2694 }
2695
2696 static int
2697 tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
2698 {
2699   return -1;
2700 }
2701
2702 static int
2703 debug_get_trace_status (struct target_ops *self, struct trace_status *arg1)
2704 {
2705   int result;
2706   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", debug_target.to_shortname);
2707   result = debug_target.to_get_trace_status (&debug_target, arg1);
2708   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", debug_target.to_shortname);
2709   target_debug_print_struct_target_ops_p (&debug_target);
2710   fputs_unfiltered (", ", gdb_stdlog);
2711   target_debug_print_struct_trace_status_p (arg1);
2712   fputs_unfiltered (") = ", gdb_stdlog);
2713   target_debug_print_int (result);
2714   fputs_unfiltered ("\n", gdb_stdlog);
2715   return result;
2716 }
2717
2718 static void
2719 delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2720 {
2721   self = self->beneath;
2722   self->to_get_tracepoint_status (self, arg1, arg2);
2723 }
2724
2725 static void
2726 tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2727 {
2728   tcomplain ();
2729 }
2730
2731 static void
2732 debug_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
2733 {
2734   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", debug_target.to_shortname);
2735   debug_target.to_get_tracepoint_status (&debug_target, arg1, arg2);
2736   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", debug_target.to_shortname);
2737   target_debug_print_struct_target_ops_p (&debug_target);
2738   fputs_unfiltered (", ", gdb_stdlog);
2739   target_debug_print_struct_breakpoint_p (arg1);
2740   fputs_unfiltered (", ", gdb_stdlog);
2741   target_debug_print_struct_uploaded_tp_p (arg2);
2742   fputs_unfiltered (")\n", gdb_stdlog);
2743 }
2744
2745 static void
2746 delegate_trace_stop (struct target_ops *self)
2747 {
2748   self = self->beneath;
2749   self->to_trace_stop (self);
2750 }
2751
2752 static void
2753 tdefault_trace_stop (struct target_ops *self)
2754 {
2755   tcomplain ();
2756 }
2757
2758 static void
2759 debug_trace_stop (struct target_ops *self)
2760 {
2761   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", debug_target.to_shortname);
2762   debug_target.to_trace_stop (&debug_target);
2763   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", debug_target.to_shortname);
2764   target_debug_print_struct_target_ops_p (&debug_target);
2765   fputs_unfiltered (")\n", gdb_stdlog);
2766 }
2767
2768 static int
2769 delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
2770 {
2771   self = self->beneath;
2772   return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5);
2773 }
2774
2775 static int
2776 tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
2777 {
2778   return -1;
2779 }
2780
2781 static int
2782 debug_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
2783 {
2784   int result;
2785   fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", debug_target.to_shortname);
2786   result = debug_target.to_trace_find (&debug_target, arg1, arg2, arg3, arg4, arg5);
2787   fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", debug_target.to_shortname);
2788   target_debug_print_struct_target_ops_p (&debug_target);
2789   fputs_unfiltered (", ", gdb_stdlog);
2790   target_debug_print_enum_trace_find_type (arg1);
2791   fputs_unfiltered (", ", gdb_stdlog);
2792   target_debug_print_int (arg2);
2793   fputs_unfiltered (", ", gdb_stdlog);
2794   target_debug_print_CORE_ADDR (arg3);
2795   fputs_unfiltered (", ", gdb_stdlog);
2796   target_debug_print_CORE_ADDR (arg4);
2797   fputs_unfiltered (", ", gdb_stdlog);
2798   target_debug_print_int_p (arg5);
2799   fputs_unfiltered (") = ", gdb_stdlog);
2800   target_debug_print_int (result);
2801   fputs_unfiltered ("\n", gdb_stdlog);
2802   return result;
2803 }
2804
2805 static int
2806 delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
2807 {
2808   self = self->beneath;
2809   return self->to_get_trace_state_variable_value (self, arg1, arg2);
2810 }
2811
2812 static int
2813 tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
2814 {
2815   return 0;
2816 }
2817
2818 static int
2819 debug_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
2820 {
2821   int result;
2822   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", debug_target.to_shortname);
2823   result = debug_target.to_get_trace_state_variable_value (&debug_target, arg1, arg2);
2824   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", debug_target.to_shortname);
2825   target_debug_print_struct_target_ops_p (&debug_target);
2826   fputs_unfiltered (", ", gdb_stdlog);
2827   target_debug_print_int (arg1);
2828   fputs_unfiltered (", ", gdb_stdlog);
2829   target_debug_print_LONGEST_p (arg2);
2830   fputs_unfiltered (") = ", gdb_stdlog);
2831   target_debug_print_int (result);
2832   fputs_unfiltered ("\n", gdb_stdlog);
2833   return result;
2834 }
2835
2836 static int
2837 delegate_save_trace_data (struct target_ops *self, const char *arg1)
2838 {
2839   self = self->beneath;
2840   return self->to_save_trace_data (self, arg1);
2841 }
2842
2843 static int
2844 tdefault_save_trace_data (struct target_ops *self, const char *arg1)
2845 {
2846   tcomplain ();
2847 }
2848
2849 static int
2850 debug_save_trace_data (struct target_ops *self, const char *arg1)
2851 {
2852   int result;
2853   fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", debug_target.to_shortname);
2854   result = debug_target.to_save_trace_data (&debug_target, arg1);
2855   fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", debug_target.to_shortname);
2856   target_debug_print_struct_target_ops_p (&debug_target);
2857   fputs_unfiltered (", ", gdb_stdlog);
2858   target_debug_print_const_char_p (arg1);
2859   fputs_unfiltered (") = ", gdb_stdlog);
2860   target_debug_print_int (result);
2861   fputs_unfiltered ("\n", gdb_stdlog);
2862   return result;
2863 }
2864
2865 static int
2866 delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
2867 {
2868   self = self->beneath;
2869   return self->to_upload_tracepoints (self, arg1);
2870 }
2871
2872 static int
2873 tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
2874 {
2875   return 0;
2876 }
2877
2878 static int
2879 debug_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
2880 {
2881   int result;
2882   fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", debug_target.to_shortname);
2883   result = debug_target.to_upload_tracepoints (&debug_target, arg1);
2884   fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", debug_target.to_shortname);
2885   target_debug_print_struct_target_ops_p (&debug_target);
2886   fputs_unfiltered (", ", gdb_stdlog);
2887   target_debug_print_struct_uploaded_tp_pp (arg1);
2888   fputs_unfiltered (") = ", gdb_stdlog);
2889   target_debug_print_int (result);
2890   fputs_unfiltered ("\n", gdb_stdlog);
2891   return result;
2892 }
2893
2894 static int
2895 delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
2896 {
2897   self = self->beneath;
2898   return self->to_upload_trace_state_variables (self, arg1);
2899 }
2900
2901 static int
2902 tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
2903 {
2904   return 0;
2905 }
2906
2907 static int
2908 debug_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
2909 {
2910   int result;
2911   fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", debug_target.to_shortname);
2912   result = debug_target.to_upload_trace_state_variables (&debug_target, arg1);
2913   fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", debug_target.to_shortname);
2914   target_debug_print_struct_target_ops_p (&debug_target);
2915   fputs_unfiltered (", ", gdb_stdlog);
2916   target_debug_print_struct_uploaded_tsv_pp (arg1);
2917   fputs_unfiltered (") = ", gdb_stdlog);
2918   target_debug_print_int (result);
2919   fputs_unfiltered ("\n", gdb_stdlog);
2920   return result;
2921 }
2922
2923 static LONGEST
2924 delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
2925 {
2926   self = self->beneath;
2927   return self->to_get_raw_trace_data (self, arg1, arg2, arg3);
2928 }
2929
2930 static LONGEST
2931 tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
2932 {
2933   tcomplain ();
2934 }
2935
2936 static LONGEST
2937 debug_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
2938 {
2939   LONGEST result;
2940   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", debug_target.to_shortname);
2941   result = debug_target.to_get_raw_trace_data (&debug_target, arg1, arg2, arg3);
2942   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", debug_target.to_shortname);
2943   target_debug_print_struct_target_ops_p (&debug_target);
2944   fputs_unfiltered (", ", gdb_stdlog);
2945   target_debug_print_gdb_byte_p (arg1);
2946   fputs_unfiltered (", ", gdb_stdlog);
2947   target_debug_print_ULONGEST (arg2);
2948   fputs_unfiltered (", ", gdb_stdlog);
2949   target_debug_print_LONGEST (arg3);
2950   fputs_unfiltered (") = ", gdb_stdlog);
2951   target_debug_print_LONGEST (result);
2952   fputs_unfiltered ("\n", gdb_stdlog);
2953   return result;
2954 }
2955
2956 static int
2957 delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
2958 {
2959   self = self->beneath;
2960   return self->to_get_min_fast_tracepoint_insn_len (self);
2961 }
2962
2963 static int
2964 tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
2965 {
2966   return -1;
2967 }
2968
2969 static int
2970 debug_get_min_fast_tracepoint_insn_len (struct target_ops *self)
2971 {
2972   int result;
2973   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", debug_target.to_shortname);
2974   result = debug_target.to_get_min_fast_tracepoint_insn_len (&debug_target);
2975   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", debug_target.to_shortname);
2976   target_debug_print_struct_target_ops_p (&debug_target);
2977   fputs_unfiltered (") = ", gdb_stdlog);
2978   target_debug_print_int (result);
2979   fputs_unfiltered ("\n", gdb_stdlog);
2980   return result;
2981 }
2982
2983 static void
2984 delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
2985 {
2986   self = self->beneath;
2987   self->to_set_disconnected_tracing (self, arg1);
2988 }
2989
2990 static void
2991 tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
2992 {
2993 }
2994
2995 static void
2996 debug_set_disconnected_tracing (struct target_ops *self, int arg1)
2997 {
2998   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", debug_target.to_shortname);
2999   debug_target.to_set_disconnected_tracing (&debug_target, arg1);
3000   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", debug_target.to_shortname);
3001   target_debug_print_struct_target_ops_p (&debug_target);
3002   fputs_unfiltered (", ", gdb_stdlog);
3003   target_debug_print_int (arg1);
3004   fputs_unfiltered (")\n", gdb_stdlog);
3005 }
3006
3007 static void
3008 delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
3009 {
3010   self = self->beneath;
3011   self->to_set_circular_trace_buffer (self, arg1);
3012 }
3013
3014 static void
3015 tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
3016 {
3017 }
3018
3019 static void
3020 debug_set_circular_trace_buffer (struct target_ops *self, int arg1)
3021 {
3022   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", debug_target.to_shortname);
3023   debug_target.to_set_circular_trace_buffer (&debug_target, arg1);
3024   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", 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_trace_buffer_size (struct target_ops *self, LONGEST arg1)
3033 {
3034   self = self->beneath;
3035   self->to_set_trace_buffer_size (self, arg1);
3036 }
3037
3038 static void
3039 tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
3040 {
3041 }
3042
3043 static void
3044 debug_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
3045 {
3046   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", debug_target.to_shortname);
3047   debug_target.to_set_trace_buffer_size (&debug_target, arg1);
3048   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", debug_target.to_shortname);
3049   target_debug_print_struct_target_ops_p (&debug_target);
3050   fputs_unfiltered (", ", gdb_stdlog);
3051   target_debug_print_LONGEST (arg1);
3052   fputs_unfiltered (")\n", gdb_stdlog);
3053 }
3054
3055 static int
3056 delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
3057 {
3058   self = self->beneath;
3059   return self->to_set_trace_notes (self, arg1, arg2, arg3);
3060 }
3061
3062 static int
3063 tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
3064 {
3065   return 0;
3066 }
3067
3068 static int
3069 debug_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
3070 {
3071   int result;
3072   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", debug_target.to_shortname);
3073   result = debug_target.to_set_trace_notes (&debug_target, arg1, arg2, arg3);
3074   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", debug_target.to_shortname);
3075   target_debug_print_struct_target_ops_p (&debug_target);
3076   fputs_unfiltered (", ", gdb_stdlog);
3077   target_debug_print_const_char_p (arg1);
3078   fputs_unfiltered (", ", gdb_stdlog);
3079   target_debug_print_const_char_p (arg2);
3080   fputs_unfiltered (", ", gdb_stdlog);
3081   target_debug_print_const_char_p (arg3);
3082   fputs_unfiltered (") = ", gdb_stdlog);
3083   target_debug_print_int (result);
3084   fputs_unfiltered ("\n", gdb_stdlog);
3085   return result;
3086 }
3087
3088 static int
3089 delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
3090 {
3091   self = self->beneath;
3092   return self->to_core_of_thread (self, arg1);
3093 }
3094
3095 static int
3096 tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
3097 {
3098   return -1;
3099 }
3100
3101 static int
3102 debug_core_of_thread (struct target_ops *self, ptid_t arg1)
3103 {
3104   int result;
3105   fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", debug_target.to_shortname);
3106   result = debug_target.to_core_of_thread (&debug_target, arg1);
3107   fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", debug_target.to_shortname);
3108   target_debug_print_struct_target_ops_p (&debug_target);
3109   fputs_unfiltered (", ", gdb_stdlog);
3110   target_debug_print_ptid_t (arg1);
3111   fputs_unfiltered (") = ", gdb_stdlog);
3112   target_debug_print_int (result);
3113   fputs_unfiltered ("\n", gdb_stdlog);
3114   return result;
3115 }
3116
3117 static int
3118 delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
3119 {
3120   self = self->beneath;
3121   return self->to_verify_memory (self, arg1, arg2, arg3);
3122 }
3123
3124 static int
3125 debug_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
3126 {
3127   int result;
3128   fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", debug_target.to_shortname);
3129   result = debug_target.to_verify_memory (&debug_target, arg1, arg2, arg3);
3130   fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", debug_target.to_shortname);
3131   target_debug_print_struct_target_ops_p (&debug_target);
3132   fputs_unfiltered (", ", gdb_stdlog);
3133   target_debug_print_const_gdb_byte_p (arg1);
3134   fputs_unfiltered (", ", gdb_stdlog);
3135   target_debug_print_CORE_ADDR (arg2);
3136   fputs_unfiltered (", ", gdb_stdlog);
3137   target_debug_print_ULONGEST (arg3);
3138   fputs_unfiltered (") = ", gdb_stdlog);
3139   target_debug_print_int (result);
3140   fputs_unfiltered ("\n", gdb_stdlog);
3141   return result;
3142 }
3143
3144 static int
3145 delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
3146 {
3147   self = self->beneath;
3148   return self->to_get_tib_address (self, arg1, arg2);
3149 }
3150
3151 static int
3152 tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
3153 {
3154   tcomplain ();
3155 }
3156
3157 static int
3158 debug_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
3159 {
3160   int result;
3161   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", debug_target.to_shortname);
3162   result = debug_target.to_get_tib_address (&debug_target, arg1, arg2);
3163   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_address (", debug_target.to_shortname);
3164   target_debug_print_struct_target_ops_p (&debug_target);
3165   fputs_unfiltered (", ", gdb_stdlog);
3166   target_debug_print_ptid_t (arg1);
3167   fputs_unfiltered (", ", gdb_stdlog);
3168   target_debug_print_CORE_ADDR_p (arg2);
3169   fputs_unfiltered (") = ", gdb_stdlog);
3170   target_debug_print_int (result);
3171   fputs_unfiltered ("\n", gdb_stdlog);
3172   return result;
3173 }
3174
3175 static void
3176 delegate_set_permissions (struct target_ops *self)
3177 {
3178   self = self->beneath;
3179   self->to_set_permissions (self);
3180 }
3181
3182 static void
3183 tdefault_set_permissions (struct target_ops *self)
3184 {
3185 }
3186
3187 static void
3188 debug_set_permissions (struct target_ops *self)
3189 {
3190   fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", debug_target.to_shortname);
3191   debug_target.to_set_permissions (&debug_target);
3192   fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", debug_target.to_shortname);
3193   target_debug_print_struct_target_ops_p (&debug_target);
3194   fputs_unfiltered (")\n", gdb_stdlog);
3195 }
3196
3197 static int
3198 delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
3199 {
3200   self = self->beneath;
3201   return self->to_static_tracepoint_marker_at (self, arg1, arg2);
3202 }
3203
3204 static int
3205 tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
3206 {
3207   return 0;
3208 }
3209
3210 static int
3211 debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
3212 {
3213   int result;
3214   fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", debug_target.to_shortname);
3215   result = debug_target.to_static_tracepoint_marker_at (&debug_target, arg1, arg2);
3216   fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", debug_target.to_shortname);
3217   target_debug_print_struct_target_ops_p (&debug_target);
3218   fputs_unfiltered (", ", gdb_stdlog);
3219   target_debug_print_CORE_ADDR (arg1);
3220   fputs_unfiltered (", ", gdb_stdlog);
3221   target_debug_print_struct_static_tracepoint_marker_p (arg2);
3222   fputs_unfiltered (") = ", gdb_stdlog);
3223   target_debug_print_int (result);
3224   fputs_unfiltered ("\n", gdb_stdlog);
3225   return result;
3226 }
3227
3228 static VEC(static_tracepoint_marker_p) *
3229 delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
3230 {
3231   self = self->beneath;
3232   return self->to_static_tracepoint_markers_by_strid (self, arg1);
3233 }
3234
3235 static VEC(static_tracepoint_marker_p) *
3236 tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
3237 {
3238   tcomplain ();
3239 }
3240
3241 static VEC(static_tracepoint_marker_p) *
3242 debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
3243 {
3244   VEC(static_tracepoint_marker_p) * result;
3245   fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", debug_target.to_shortname);
3246   result = debug_target.to_static_tracepoint_markers_by_strid (&debug_target, arg1);
3247   fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", debug_target.to_shortname);
3248   target_debug_print_struct_target_ops_p (&debug_target);
3249   fputs_unfiltered (", ", gdb_stdlog);
3250   target_debug_print_const_char_p (arg1);
3251   fputs_unfiltered (") = ", gdb_stdlog);
3252   target_debug_print_VEC_static_tracepoint_marker_p__p (result);
3253   fputs_unfiltered ("\n", gdb_stdlog);
3254   return result;
3255 }
3256
3257 static struct traceframe_info *
3258 delegate_traceframe_info (struct target_ops *self)
3259 {
3260   self = self->beneath;
3261   return self->to_traceframe_info (self);
3262 }
3263
3264 static struct traceframe_info *
3265 tdefault_traceframe_info (struct target_ops *self)
3266 {
3267   tcomplain ();
3268 }
3269
3270 static struct traceframe_info *
3271 debug_traceframe_info (struct target_ops *self)
3272 {
3273   struct traceframe_info * result;
3274   fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", debug_target.to_shortname);
3275   result = debug_target.to_traceframe_info (&debug_target);
3276   fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", debug_target.to_shortname);
3277   target_debug_print_struct_target_ops_p (&debug_target);
3278   fputs_unfiltered (") = ", gdb_stdlog);
3279   target_debug_print_struct_traceframe_info_p (result);
3280   fputs_unfiltered ("\n", gdb_stdlog);
3281   return result;
3282 }
3283
3284 static int
3285 delegate_use_agent (struct target_ops *self, int arg1)
3286 {
3287   self = self->beneath;
3288   return self->to_use_agent (self, arg1);
3289 }
3290
3291 static int
3292 tdefault_use_agent (struct target_ops *self, int arg1)
3293 {
3294   tcomplain ();
3295 }
3296
3297 static int
3298 debug_use_agent (struct target_ops *self, int arg1)
3299 {
3300   int result;
3301   fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", debug_target.to_shortname);
3302   result = debug_target.to_use_agent (&debug_target, arg1);
3303   fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", debug_target.to_shortname);
3304   target_debug_print_struct_target_ops_p (&debug_target);
3305   fputs_unfiltered (", ", gdb_stdlog);
3306   target_debug_print_int (arg1);
3307   fputs_unfiltered (") = ", gdb_stdlog);
3308   target_debug_print_int (result);
3309   fputs_unfiltered ("\n", gdb_stdlog);
3310   return result;
3311 }
3312
3313 static int
3314 delegate_can_use_agent (struct target_ops *self)
3315 {
3316   self = self->beneath;
3317   return self->to_can_use_agent (self);
3318 }
3319
3320 static int
3321 tdefault_can_use_agent (struct target_ops *self)
3322 {
3323   return 0;
3324 }
3325
3326 static int
3327 debug_can_use_agent (struct target_ops *self)
3328 {
3329   int result;
3330   fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", debug_target.to_shortname);
3331   result = debug_target.to_can_use_agent (&debug_target);
3332   fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", debug_target.to_shortname);
3333   target_debug_print_struct_target_ops_p (&debug_target);
3334   fputs_unfiltered (") = ", gdb_stdlog);
3335   target_debug_print_int (result);
3336   fputs_unfiltered ("\n", gdb_stdlog);
3337   return result;
3338 }
3339
3340 static int
3341 delegate_supports_btrace (struct target_ops *self, enum btrace_format arg1)
3342 {
3343   self = self->beneath;
3344   return self->to_supports_btrace (self, arg1);
3345 }
3346
3347 static int
3348 tdefault_supports_btrace (struct target_ops *self, enum btrace_format arg1)
3349 {
3350   return 0;
3351 }
3352
3353 static int
3354 debug_supports_btrace (struct target_ops *self, enum btrace_format arg1)
3355 {
3356   int result;
3357   fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname);
3358   result = debug_target.to_supports_btrace (&debug_target, arg1);
3359   fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname);
3360   target_debug_print_struct_target_ops_p (&debug_target);
3361   fputs_unfiltered (", ", gdb_stdlog);
3362   target_debug_print_enum_btrace_format (arg1);
3363   fputs_unfiltered (") = ", gdb_stdlog);
3364   target_debug_print_int (result);
3365   fputs_unfiltered ("\n", gdb_stdlog);
3366   return result;
3367 }
3368
3369 static struct btrace_target_info *
3370 delegate_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3371 {
3372   self = self->beneath;
3373   return self->to_enable_btrace (self, arg1, arg2);
3374 }
3375
3376 static struct btrace_target_info *
3377 tdefault_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3378 {
3379   tcomplain ();
3380 }
3381
3382 static struct btrace_target_info *
3383 debug_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2)
3384 {
3385   struct btrace_target_info * result;
3386   fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname);
3387   result = debug_target.to_enable_btrace (&debug_target, arg1, arg2);
3388   fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname);
3389   target_debug_print_struct_target_ops_p (&debug_target);
3390   fputs_unfiltered (", ", gdb_stdlog);
3391   target_debug_print_ptid_t (arg1);
3392   fputs_unfiltered (", ", gdb_stdlog);
3393   target_debug_print_const_struct_btrace_config_p (arg2);
3394   fputs_unfiltered (") = ", gdb_stdlog);
3395   target_debug_print_struct_btrace_target_info_p (result);
3396   fputs_unfiltered ("\n", gdb_stdlog);
3397   return result;
3398 }
3399
3400 static void
3401 delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3402 {
3403   self = self->beneath;
3404   self->to_disable_btrace (self, arg1);
3405 }
3406
3407 static void
3408 tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3409 {
3410   tcomplain ();
3411 }
3412
3413 static void
3414 debug_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3415 {
3416   fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname);
3417   debug_target.to_disable_btrace (&debug_target, arg1);
3418   fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname);
3419   target_debug_print_struct_target_ops_p (&debug_target);
3420   fputs_unfiltered (", ", gdb_stdlog);
3421   target_debug_print_struct_btrace_target_info_p (arg1);
3422   fputs_unfiltered (")\n", gdb_stdlog);
3423 }
3424
3425 static void
3426 delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3427 {
3428   self = self->beneath;
3429   self->to_teardown_btrace (self, arg1);
3430 }
3431
3432 static void
3433 tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3434 {
3435   tcomplain ();
3436 }
3437
3438 static void
3439 debug_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
3440 {
3441   fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname);
3442   debug_target.to_teardown_btrace (&debug_target, arg1);
3443   fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname);
3444   target_debug_print_struct_target_ops_p (&debug_target);
3445   fputs_unfiltered (", ", gdb_stdlog);
3446   target_debug_print_struct_btrace_target_info_p (arg1);
3447   fputs_unfiltered (")\n", gdb_stdlog);
3448 }
3449
3450 static enum btrace_error
3451 delegate_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3452 {
3453   self = self->beneath;
3454   return self->to_read_btrace (self, arg1, arg2, arg3);
3455 }
3456
3457 static enum btrace_error
3458 tdefault_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3459 {
3460   tcomplain ();
3461 }
3462
3463 static enum btrace_error
3464 debug_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3)
3465 {
3466   enum btrace_error result;
3467   fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname);
3468   result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3);
3469   fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname);
3470   target_debug_print_struct_target_ops_p (&debug_target);
3471   fputs_unfiltered (", ", gdb_stdlog);
3472   target_debug_print_struct_btrace_data_p (arg1);
3473   fputs_unfiltered (", ", gdb_stdlog);
3474   target_debug_print_struct_btrace_target_info_p (arg2);
3475   fputs_unfiltered (", ", gdb_stdlog);
3476   target_debug_print_enum_btrace_read_type (arg3);
3477   fputs_unfiltered (") = ", gdb_stdlog);
3478   target_debug_print_enum_btrace_error (result);
3479   fputs_unfiltered ("\n", gdb_stdlog);
3480   return result;
3481 }
3482
3483 static const struct btrace_config *
3484 delegate_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3485 {
3486   self = self->beneath;
3487   return self->to_btrace_conf (self, arg1);
3488 }
3489
3490 static const struct btrace_config *
3491 tdefault_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3492 {
3493   return NULL;
3494 }
3495
3496 static const struct btrace_config *
3497 debug_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1)
3498 {
3499   const struct btrace_config * result;
3500   fprintf_unfiltered (gdb_stdlog, "-> %s->to_btrace_conf (...)\n", debug_target.to_shortname);
3501   result = debug_target.to_btrace_conf (&debug_target, arg1);
3502   fprintf_unfiltered (gdb_stdlog, "<- %s->to_btrace_conf (", debug_target.to_shortname);
3503   target_debug_print_struct_target_ops_p (&debug_target);
3504   fputs_unfiltered (", ", gdb_stdlog);
3505   target_debug_print_const_struct_btrace_target_info_p (arg1);
3506   fputs_unfiltered (") = ", gdb_stdlog);
3507   target_debug_print_const_struct_btrace_config_p (result);
3508   fputs_unfiltered ("\n", gdb_stdlog);
3509   return result;
3510 }
3511
3512 static void
3513 delegate_stop_recording (struct target_ops *self)
3514 {
3515   self = self->beneath;
3516   self->to_stop_recording (self);
3517 }
3518
3519 static void
3520 tdefault_stop_recording (struct target_ops *self)
3521 {
3522 }
3523
3524 static void
3525 debug_stop_recording (struct target_ops *self)
3526 {
3527   fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname);
3528   debug_target.to_stop_recording (&debug_target);
3529   fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname);
3530   target_debug_print_struct_target_ops_p (&debug_target);
3531   fputs_unfiltered (")\n", gdb_stdlog);
3532 }
3533
3534 static void
3535 delegate_info_record (struct target_ops *self)
3536 {
3537   self = self->beneath;
3538   self->to_info_record (self);
3539 }
3540
3541 static void
3542 tdefault_info_record (struct target_ops *self)
3543 {
3544 }
3545
3546 static void
3547 debug_info_record (struct target_ops *self)
3548 {
3549   fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", debug_target.to_shortname);
3550   debug_target.to_info_record (&debug_target);
3551   fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", debug_target.to_shortname);
3552   target_debug_print_struct_target_ops_p (&debug_target);
3553   fputs_unfiltered (")\n", gdb_stdlog);
3554 }
3555
3556 static void
3557 delegate_save_record (struct target_ops *self, const char *arg1)
3558 {
3559   self = self->beneath;
3560   self->to_save_record (self, arg1);
3561 }
3562
3563 static void
3564 tdefault_save_record (struct target_ops *self, const char *arg1)
3565 {
3566   tcomplain ();
3567 }
3568
3569 static void
3570 debug_save_record (struct target_ops *self, const char *arg1)
3571 {
3572   fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname);
3573   debug_target.to_save_record (&debug_target, arg1);
3574   fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", debug_target.to_shortname);
3575   target_debug_print_struct_target_ops_p (&debug_target);
3576   fputs_unfiltered (", ", gdb_stdlog);
3577   target_debug_print_const_char_p (arg1);
3578   fputs_unfiltered (")\n", gdb_stdlog);
3579 }
3580
3581 static void
3582 delegate_delete_record (struct target_ops *self)
3583 {
3584   self = self->beneath;
3585   self->to_delete_record (self);
3586 }
3587
3588 static void
3589 tdefault_delete_record (struct target_ops *self)
3590 {
3591   tcomplain ();
3592 }
3593
3594 static void
3595 debug_delete_record (struct target_ops *self)
3596 {
3597   fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname);
3598   debug_target.to_delete_record (&debug_target);
3599   fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname);
3600   target_debug_print_struct_target_ops_p (&debug_target);
3601   fputs_unfiltered (")\n", gdb_stdlog);
3602 }
3603
3604 static int
3605 delegate_record_is_replaying (struct target_ops *self, ptid_t arg1)
3606 {
3607   self = self->beneath;
3608   return self->to_record_is_replaying (self, arg1);
3609 }
3610
3611 static int
3612 tdefault_record_is_replaying (struct target_ops *self, ptid_t arg1)
3613 {
3614   return 0;
3615 }
3616
3617 static int
3618 debug_record_is_replaying (struct target_ops *self, ptid_t arg1)
3619 {
3620   int result;
3621   fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname);
3622   result = debug_target.to_record_is_replaying (&debug_target, arg1);
3623   fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname);
3624   target_debug_print_struct_target_ops_p (&debug_target);
3625   fputs_unfiltered (", ", gdb_stdlog);
3626   target_debug_print_ptid_t (arg1);
3627   fputs_unfiltered (") = ", gdb_stdlog);
3628   target_debug_print_int (result);
3629   fputs_unfiltered ("\n", gdb_stdlog);
3630   return result;
3631 }
3632
3633 static int
3634 delegate_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
3635 {
3636   self = self->beneath;
3637   return self->to_record_will_replay (self, arg1, arg2);
3638 }
3639
3640 static int
3641 tdefault_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
3642 {
3643   return 0;
3644 }
3645
3646 static int
3647 debug_record_will_replay (struct target_ops *self, ptid_t arg1, int arg2)
3648 {
3649   int result;
3650   fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_will_replay (...)\n", debug_target.to_shortname);
3651   result = debug_target.to_record_will_replay (&debug_target, arg1, arg2);
3652   fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_will_replay (", debug_target.to_shortname);
3653   target_debug_print_struct_target_ops_p (&debug_target);
3654   fputs_unfiltered (", ", gdb_stdlog);
3655   target_debug_print_ptid_t (arg1);
3656   fputs_unfiltered (", ", gdb_stdlog);
3657   target_debug_print_int (arg2);
3658   fputs_unfiltered (") = ", gdb_stdlog);
3659   target_debug_print_int (result);
3660   fputs_unfiltered ("\n", gdb_stdlog);
3661   return result;
3662 }
3663
3664 static void
3665 delegate_record_stop_replaying (struct target_ops *self)
3666 {
3667   self = self->beneath;
3668   self->to_record_stop_replaying (self);
3669 }
3670
3671 static void
3672 tdefault_record_stop_replaying (struct target_ops *self)
3673 {
3674 }
3675
3676 static void
3677 debug_record_stop_replaying (struct target_ops *self)
3678 {
3679   fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_stop_replaying (...)\n", debug_target.to_shortname);
3680   debug_target.to_record_stop_replaying (&debug_target);
3681   fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_stop_replaying (", debug_target.to_shortname);
3682   target_debug_print_struct_target_ops_p (&debug_target);
3683   fputs_unfiltered (")\n", gdb_stdlog);
3684 }
3685
3686 static void
3687 delegate_goto_record_begin (struct target_ops *self)
3688 {
3689   self = self->beneath;
3690   self->to_goto_record_begin (self);
3691 }
3692
3693 static void
3694 tdefault_goto_record_begin (struct target_ops *self)
3695 {
3696   tcomplain ();
3697 }
3698
3699 static void
3700 debug_goto_record_begin (struct target_ops *self)
3701 {
3702   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname);
3703   debug_target.to_goto_record_begin (&debug_target);
3704   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname);
3705   target_debug_print_struct_target_ops_p (&debug_target);
3706   fputs_unfiltered (")\n", gdb_stdlog);
3707 }
3708
3709 static void
3710 delegate_goto_record_end (struct target_ops *self)
3711 {
3712   self = self->beneath;
3713   self->to_goto_record_end (self);
3714 }
3715
3716 static void
3717 tdefault_goto_record_end (struct target_ops *self)
3718 {
3719   tcomplain ();
3720 }
3721
3722 static void
3723 debug_goto_record_end (struct target_ops *self)
3724 {
3725   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname);
3726   debug_target.to_goto_record_end (&debug_target);
3727   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname);
3728   target_debug_print_struct_target_ops_p (&debug_target);
3729   fputs_unfiltered (")\n", gdb_stdlog);
3730 }
3731
3732 static void
3733 delegate_goto_record (struct target_ops *self, ULONGEST arg1)
3734 {
3735   self = self->beneath;
3736   self->to_goto_record (self, arg1);
3737 }
3738
3739 static void
3740 tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
3741 {
3742   tcomplain ();
3743 }
3744
3745 static void
3746 debug_goto_record (struct target_ops *self, ULONGEST arg1)
3747 {
3748   fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname);
3749   debug_target.to_goto_record (&debug_target, arg1);
3750   fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname);
3751   target_debug_print_struct_target_ops_p (&debug_target);
3752   fputs_unfiltered (", ", gdb_stdlog);
3753   target_debug_print_ULONGEST (arg1);
3754   fputs_unfiltered (")\n", gdb_stdlog);
3755 }
3756
3757 static void
3758 delegate_insn_history (struct target_ops *self, int arg1, int arg2)
3759 {
3760   self = self->beneath;
3761   self->to_insn_history (self, arg1, arg2);
3762 }
3763
3764 static void
3765 tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
3766 {
3767   tcomplain ();
3768 }
3769
3770 static void
3771 debug_insn_history (struct target_ops *self, int arg1, int arg2)
3772 {
3773   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname);
3774   debug_target.to_insn_history (&debug_target, arg1, arg2);
3775   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", debug_target.to_shortname);
3776   target_debug_print_struct_target_ops_p (&debug_target);
3777   fputs_unfiltered (", ", gdb_stdlog);
3778   target_debug_print_int (arg1);
3779   fputs_unfiltered (", ", gdb_stdlog);
3780   target_debug_print_int (arg2);
3781   fputs_unfiltered (")\n", gdb_stdlog);
3782 }
3783
3784 static void
3785 delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3786 {
3787   self = self->beneath;
3788   self->to_insn_history_from (self, arg1, arg2, arg3);
3789 }
3790
3791 static void
3792 tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3793 {
3794   tcomplain ();
3795 }
3796
3797 static void
3798 debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3799 {
3800   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname);
3801   debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3);
3802   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", debug_target.to_shortname);
3803   target_debug_print_struct_target_ops_p (&debug_target);
3804   fputs_unfiltered (", ", gdb_stdlog);
3805   target_debug_print_ULONGEST (arg1);
3806   fputs_unfiltered (", ", gdb_stdlog);
3807   target_debug_print_int (arg2);
3808   fputs_unfiltered (", ", gdb_stdlog);
3809   target_debug_print_int (arg3);
3810   fputs_unfiltered (")\n", gdb_stdlog);
3811 }
3812
3813 static void
3814 delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3815 {
3816   self = self->beneath;
3817   self->to_insn_history_range (self, arg1, arg2, arg3);
3818 }
3819
3820 static void
3821 tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3822 {
3823   tcomplain ();
3824 }
3825
3826 static void
3827 debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3828 {
3829   fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname);
3830   debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3);
3831   fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", debug_target.to_shortname);
3832   target_debug_print_struct_target_ops_p (&debug_target);
3833   fputs_unfiltered (", ", gdb_stdlog);
3834   target_debug_print_ULONGEST (arg1);
3835   fputs_unfiltered (", ", gdb_stdlog);
3836   target_debug_print_ULONGEST (arg2);
3837   fputs_unfiltered (", ", gdb_stdlog);
3838   target_debug_print_int (arg3);
3839   fputs_unfiltered (")\n", gdb_stdlog);
3840 }
3841
3842 static void
3843 delegate_call_history (struct target_ops *self, int arg1, int arg2)
3844 {
3845   self = self->beneath;
3846   self->to_call_history (self, arg1, arg2);
3847 }
3848
3849 static void
3850 tdefault_call_history (struct target_ops *self, int arg1, int arg2)
3851 {
3852   tcomplain ();
3853 }
3854
3855 static void
3856 debug_call_history (struct target_ops *self, int arg1, int arg2)
3857 {
3858   fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname);
3859   debug_target.to_call_history (&debug_target, arg1, arg2);
3860   fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", debug_target.to_shortname);
3861   target_debug_print_struct_target_ops_p (&debug_target);
3862   fputs_unfiltered (", ", gdb_stdlog);
3863   target_debug_print_int (arg1);
3864   fputs_unfiltered (", ", gdb_stdlog);
3865   target_debug_print_int (arg2);
3866   fputs_unfiltered (")\n", gdb_stdlog);
3867 }
3868
3869 static void
3870 delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3871 {
3872   self = self->beneath;
3873   self->to_call_history_from (self, arg1, arg2, arg3);
3874 }
3875
3876 static void
3877 tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3878 {
3879   tcomplain ();
3880 }
3881
3882 static void
3883 debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
3884 {
3885   fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname);
3886   debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3);
3887   fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", debug_target.to_shortname);
3888   target_debug_print_struct_target_ops_p (&debug_target);
3889   fputs_unfiltered (", ", gdb_stdlog);
3890   target_debug_print_ULONGEST (arg1);
3891   fputs_unfiltered (", ", gdb_stdlog);
3892   target_debug_print_int (arg2);
3893   fputs_unfiltered (", ", gdb_stdlog);
3894   target_debug_print_int (arg3);
3895   fputs_unfiltered (")\n", gdb_stdlog);
3896 }
3897
3898 static void
3899 delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3900 {
3901   self = self->beneath;
3902   self->to_call_history_range (self, arg1, arg2, arg3);
3903 }
3904
3905 static void
3906 tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3907 {
3908   tcomplain ();
3909 }
3910
3911 static void
3912 debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
3913 {
3914   fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname);
3915   debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3);
3916   fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", debug_target.to_shortname);
3917   target_debug_print_struct_target_ops_p (&debug_target);
3918   fputs_unfiltered (", ", gdb_stdlog);
3919   target_debug_print_ULONGEST (arg1);
3920   fputs_unfiltered (", ", gdb_stdlog);
3921   target_debug_print_ULONGEST (arg2);
3922   fputs_unfiltered (", ", gdb_stdlog);
3923   target_debug_print_int (arg3);
3924   fputs_unfiltered (")\n", gdb_stdlog);
3925 }
3926
3927 static int
3928 delegate_augmented_libraries_svr4_read (struct target_ops *self)
3929 {
3930   self = self->beneath;
3931   return self->to_augmented_libraries_svr4_read (self);
3932 }
3933
3934 static int
3935 tdefault_augmented_libraries_svr4_read (struct target_ops *self)
3936 {
3937   return 0;
3938 }
3939
3940 static int
3941 debug_augmented_libraries_svr4_read (struct target_ops *self)
3942 {
3943   int result;
3944   fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname);
3945   result = debug_target.to_augmented_libraries_svr4_read (&debug_target);
3946   fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", debug_target.to_shortname);
3947   target_debug_print_struct_target_ops_p (&debug_target);
3948   fputs_unfiltered (") = ", gdb_stdlog);
3949   target_debug_print_int (result);
3950   fputs_unfiltered ("\n", gdb_stdlog);
3951   return result;
3952 }
3953
3954 static const struct frame_unwind *
3955 delegate_get_unwinder (struct target_ops *self)
3956 {
3957   self = self->beneath;
3958   return self->to_get_unwinder (self);
3959 }
3960
3961 static const struct frame_unwind *
3962 tdefault_get_unwinder (struct target_ops *self)
3963 {
3964   return NULL;
3965 }
3966
3967 static const struct frame_unwind *
3968 debug_get_unwinder (struct target_ops *self)
3969 {
3970   const struct frame_unwind * result;
3971   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname);
3972   result = debug_target.to_get_unwinder (&debug_target);
3973   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname);
3974   target_debug_print_struct_target_ops_p (&debug_target);
3975   fputs_unfiltered (") = ", gdb_stdlog);
3976   target_debug_print_const_struct_frame_unwind_p (result);
3977   fputs_unfiltered ("\n", gdb_stdlog);
3978   return result;
3979 }
3980
3981 static const struct frame_unwind *
3982 delegate_get_tailcall_unwinder (struct target_ops *self)
3983 {
3984   self = self->beneath;
3985   return self->to_get_tailcall_unwinder (self);
3986 }
3987
3988 static const struct frame_unwind *
3989 tdefault_get_tailcall_unwinder (struct target_ops *self)
3990 {
3991   return NULL;
3992 }
3993
3994 static const struct frame_unwind *
3995 debug_get_tailcall_unwinder (struct target_ops *self)
3996 {
3997   const struct frame_unwind * result;
3998   fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname);
3999   result = debug_target.to_get_tailcall_unwinder (&debug_target);
4000   fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname);
4001   target_debug_print_struct_target_ops_p (&debug_target);
4002   fputs_unfiltered (") = ", gdb_stdlog);
4003   target_debug_print_const_struct_frame_unwind_p (result);
4004   fputs_unfiltered ("\n", gdb_stdlog);
4005   return result;
4006 }
4007
4008 static void
4009 delegate_prepare_to_generate_core (struct target_ops *self)
4010 {
4011   self = self->beneath;
4012   self->to_prepare_to_generate_core (self);
4013 }
4014
4015 static void
4016 tdefault_prepare_to_generate_core (struct target_ops *self)
4017 {
4018 }
4019
4020 static void
4021 debug_prepare_to_generate_core (struct target_ops *self)
4022 {
4023   fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", debug_target.to_shortname);
4024   debug_target.to_prepare_to_generate_core (&debug_target);
4025   fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", debug_target.to_shortname);
4026   target_debug_print_struct_target_ops_p (&debug_target);
4027   fputs_unfiltered (")\n", gdb_stdlog);
4028 }
4029
4030 static void
4031 delegate_done_generating_core (struct target_ops *self)
4032 {
4033   self = self->beneath;
4034   self->to_done_generating_core (self);
4035 }
4036
4037 static void
4038 tdefault_done_generating_core (struct target_ops *self)
4039 {
4040 }
4041
4042 static void
4043 debug_done_generating_core (struct target_ops *self)
4044 {
4045   fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", debug_target.to_shortname);
4046   debug_target.to_done_generating_core (&debug_target);
4047   fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", debug_target.to_shortname);
4048   target_debug_print_struct_target_ops_p (&debug_target);
4049   fputs_unfiltered (")\n", gdb_stdlog);
4050 }
4051
4052 static void
4053 install_delegators (struct target_ops *ops)
4054 {
4055   if (ops->to_post_attach == NULL)
4056     ops->to_post_attach = delegate_post_attach;
4057   if (ops->to_detach == NULL)
4058     ops->to_detach = delegate_detach;
4059   if (ops->to_disconnect == NULL)
4060     ops->to_disconnect = delegate_disconnect;
4061   if (ops->to_resume == NULL)
4062     ops->to_resume = delegate_resume;
4063   if (ops->to_wait == NULL)
4064     ops->to_wait = delegate_wait;
4065   if (ops->to_fetch_registers == NULL)
4066     ops->to_fetch_registers = delegate_fetch_registers;
4067   if (ops->to_store_registers == NULL)
4068     ops->to_store_registers = delegate_store_registers;
4069   if (ops->to_prepare_to_store == NULL)
4070     ops->to_prepare_to_store = delegate_prepare_to_store;
4071   if (ops->to_files_info == NULL)
4072     ops->to_files_info = delegate_files_info;
4073   if (ops->to_insert_breakpoint == NULL)
4074     ops->to_insert_breakpoint = delegate_insert_breakpoint;
4075   if (ops->to_remove_breakpoint == NULL)
4076     ops->to_remove_breakpoint = delegate_remove_breakpoint;
4077   if (ops->to_stopped_by_sw_breakpoint == NULL)
4078     ops->to_stopped_by_sw_breakpoint = delegate_stopped_by_sw_breakpoint;
4079   if (ops->to_supports_stopped_by_sw_breakpoint == NULL)
4080     ops->to_supports_stopped_by_sw_breakpoint = delegate_supports_stopped_by_sw_breakpoint;
4081   if (ops->to_stopped_by_hw_breakpoint == NULL)
4082     ops->to_stopped_by_hw_breakpoint = delegate_stopped_by_hw_breakpoint;
4083   if (ops->to_supports_stopped_by_hw_breakpoint == NULL)
4084     ops->to_supports_stopped_by_hw_breakpoint = delegate_supports_stopped_by_hw_breakpoint;
4085   if (ops->to_can_use_hw_breakpoint == NULL)
4086     ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint;
4087   if (ops->to_ranged_break_num_registers == NULL)
4088     ops->to_ranged_break_num_registers = delegate_ranged_break_num_registers;
4089   if (ops->to_insert_hw_breakpoint == NULL)
4090     ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint;
4091   if (ops->to_remove_hw_breakpoint == NULL)
4092     ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint;
4093   if (ops->to_remove_watchpoint == NULL)
4094     ops->to_remove_watchpoint = delegate_remove_watchpoint;
4095   if (ops->to_insert_watchpoint == NULL)
4096     ops->to_insert_watchpoint = delegate_insert_watchpoint;
4097   if (ops->to_insert_mask_watchpoint == NULL)
4098     ops->to_insert_mask_watchpoint = delegate_insert_mask_watchpoint;
4099   if (ops->to_remove_mask_watchpoint == NULL)
4100     ops->to_remove_mask_watchpoint = delegate_remove_mask_watchpoint;
4101   if (ops->to_stopped_by_watchpoint == NULL)
4102     ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint;
4103   if (ops->to_stopped_data_address == NULL)
4104     ops->to_stopped_data_address = delegate_stopped_data_address;
4105   if (ops->to_watchpoint_addr_within_range == NULL)
4106     ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range;
4107   if (ops->to_region_ok_for_hw_watchpoint == NULL)
4108     ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint;
4109   if (ops->to_can_accel_watchpoint_condition == NULL)
4110     ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
4111   if (ops->to_masked_watch_num_registers == NULL)
4112     ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers;
4113   if (ops->to_can_do_single_step == NULL)
4114     ops->to_can_do_single_step = delegate_can_do_single_step;
4115   if (ops->to_terminal_init == NULL)
4116     ops->to_terminal_init = delegate_terminal_init;
4117   if (ops->to_terminal_inferior == NULL)
4118     ops->to_terminal_inferior = delegate_terminal_inferior;
4119   if (ops->to_terminal_ours_for_output == NULL)
4120     ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
4121   if (ops->to_terminal_ours == NULL)
4122     ops->to_terminal_ours = delegate_terminal_ours;
4123   if (ops->to_terminal_info == NULL)
4124     ops->to_terminal_info = delegate_terminal_info;
4125   if (ops->to_kill == NULL)
4126     ops->to_kill = delegate_kill;
4127   if (ops->to_load == NULL)
4128     ops->to_load = delegate_load;
4129   if (ops->to_post_startup_inferior == NULL)
4130     ops->to_post_startup_inferior = delegate_post_startup_inferior;
4131   if (ops->to_insert_fork_catchpoint == NULL)
4132     ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint;
4133   if (ops->to_remove_fork_catchpoint == NULL)
4134     ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint;
4135   if (ops->to_insert_vfork_catchpoint == NULL)
4136     ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint;
4137   if (ops->to_remove_vfork_catchpoint == NULL)
4138     ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint;
4139   if (ops->to_follow_fork == NULL)
4140     ops->to_follow_fork = delegate_follow_fork;
4141   if (ops->to_insert_exec_catchpoint == NULL)
4142     ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
4143   if (ops->to_remove_exec_catchpoint == NULL)
4144     ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
4145   if (ops->to_follow_exec == NULL)
4146     ops->to_follow_exec = delegate_follow_exec;
4147   if (ops->to_set_syscall_catchpoint == NULL)
4148     ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
4149   if (ops->to_has_exited == NULL)
4150     ops->to_has_exited = delegate_has_exited;
4151   if (ops->to_mourn_inferior == NULL)
4152     ops->to_mourn_inferior = delegate_mourn_inferior;
4153   if (ops->to_can_run == NULL)
4154     ops->to_can_run = delegate_can_run;
4155   if (ops->to_pass_signals == NULL)
4156     ops->to_pass_signals = delegate_pass_signals;
4157   if (ops->to_program_signals == NULL)
4158     ops->to_program_signals = delegate_program_signals;
4159   if (ops->to_thread_alive == NULL)
4160     ops->to_thread_alive = delegate_thread_alive;
4161   if (ops->to_update_thread_list == NULL)
4162     ops->to_update_thread_list = delegate_update_thread_list;
4163   if (ops->to_pid_to_str == NULL)
4164     ops->to_pid_to_str = delegate_pid_to_str;
4165   if (ops->to_extra_thread_info == NULL)
4166     ops->to_extra_thread_info = delegate_extra_thread_info;
4167   if (ops->to_thread_name == NULL)
4168     ops->to_thread_name = delegate_thread_name;
4169   if (ops->to_stop == NULL)
4170     ops->to_stop = delegate_stop;
4171   if (ops->to_interrupt == NULL)
4172     ops->to_interrupt = delegate_interrupt;
4173   if (ops->to_check_pending_interrupt == NULL)
4174     ops->to_check_pending_interrupt = delegate_check_pending_interrupt;
4175   if (ops->to_rcmd == NULL)
4176     ops->to_rcmd = delegate_rcmd;
4177   if (ops->to_pid_to_exec_file == NULL)
4178     ops->to_pid_to_exec_file = delegate_pid_to_exec_file;
4179   if (ops->to_log_command == NULL)
4180     ops->to_log_command = delegate_log_command;
4181   if (ops->to_get_section_table == NULL)
4182     ops->to_get_section_table = delegate_get_section_table;
4183   if (ops->to_can_async_p == NULL)
4184     ops->to_can_async_p = delegate_can_async_p;
4185   if (ops->to_is_async_p == NULL)
4186     ops->to_is_async_p = delegate_is_async_p;
4187   if (ops->to_async == NULL)
4188     ops->to_async = delegate_async;
4189   if (ops->to_supports_non_stop == NULL)
4190     ops->to_supports_non_stop = delegate_supports_non_stop;
4191   if (ops->to_always_non_stop_p == NULL)
4192     ops->to_always_non_stop_p = delegate_always_non_stop_p;
4193   if (ops->to_find_memory_regions == NULL)
4194     ops->to_find_memory_regions = delegate_find_memory_regions;
4195   if (ops->to_make_corefile_notes == NULL)
4196     ops->to_make_corefile_notes = delegate_make_corefile_notes;
4197   if (ops->to_get_bookmark == NULL)
4198     ops->to_get_bookmark = delegate_get_bookmark;
4199   if (ops->to_goto_bookmark == NULL)
4200     ops->to_goto_bookmark = delegate_goto_bookmark;
4201   if (ops->to_get_thread_local_address == NULL)
4202     ops->to_get_thread_local_address = delegate_get_thread_local_address;
4203   if (ops->to_xfer_partial == NULL)
4204     ops->to_xfer_partial = delegate_xfer_partial;
4205   if (ops->to_memory_map == NULL)
4206     ops->to_memory_map = delegate_memory_map;
4207   if (ops->to_flash_erase == NULL)
4208     ops->to_flash_erase = delegate_flash_erase;
4209   if (ops->to_flash_done == NULL)
4210     ops->to_flash_done = delegate_flash_done;
4211   if (ops->to_read_description == NULL)
4212     ops->to_read_description = delegate_read_description;
4213   if (ops->to_get_ada_task_ptid == NULL)
4214     ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid;
4215   if (ops->to_auxv_parse == NULL)
4216     ops->to_auxv_parse = delegate_auxv_parse;
4217   if (ops->to_search_memory == NULL)
4218     ops->to_search_memory = delegate_search_memory;
4219   if (ops->to_can_execute_reverse == NULL)
4220     ops->to_can_execute_reverse = delegate_can_execute_reverse;
4221   if (ops->to_execution_direction == NULL)
4222     ops->to_execution_direction = delegate_execution_direction;
4223   if (ops->to_supports_multi_process == NULL)
4224     ops->to_supports_multi_process = delegate_supports_multi_process;
4225   if (ops->to_supports_enable_disable_tracepoint == NULL)
4226     ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint;
4227   if (ops->to_supports_string_tracing == NULL)
4228     ops->to_supports_string_tracing = delegate_supports_string_tracing;
4229   if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL)
4230     ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions;
4231   if (ops->to_can_run_breakpoint_commands == NULL)
4232     ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands;
4233   if (ops->to_thread_architecture == NULL)
4234     ops->to_thread_architecture = delegate_thread_architecture;
4235   if (ops->to_thread_address_space == NULL)
4236     ops->to_thread_address_space = delegate_thread_address_space;
4237   if (ops->to_filesystem_is_local == NULL)
4238     ops->to_filesystem_is_local = delegate_filesystem_is_local;
4239   if (ops->to_trace_init == NULL)
4240     ops->to_trace_init = delegate_trace_init;
4241   if (ops->to_download_tracepoint == NULL)
4242     ops->to_download_tracepoint = delegate_download_tracepoint;
4243   if (ops->to_can_download_tracepoint == NULL)
4244     ops->to_can_download_tracepoint = delegate_can_download_tracepoint;
4245   if (ops->to_download_trace_state_variable == NULL)
4246     ops->to_download_trace_state_variable = delegate_download_trace_state_variable;
4247   if (ops->to_enable_tracepoint == NULL)
4248     ops->to_enable_tracepoint = delegate_enable_tracepoint;
4249   if (ops->to_disable_tracepoint == NULL)
4250     ops->to_disable_tracepoint = delegate_disable_tracepoint;
4251   if (ops->to_trace_set_readonly_regions == NULL)
4252     ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions;
4253   if (ops->to_trace_start == NULL)
4254     ops->to_trace_start = delegate_trace_start;
4255   if (ops->to_get_trace_status == NULL)
4256     ops->to_get_trace_status = delegate_get_trace_status;
4257   if (ops->to_get_tracepoint_status == NULL)
4258     ops->to_get_tracepoint_status = delegate_get_tracepoint_status;
4259   if (ops->to_trace_stop == NULL)
4260     ops->to_trace_stop = delegate_trace_stop;
4261   if (ops->to_trace_find == NULL)
4262     ops->to_trace_find = delegate_trace_find;
4263   if (ops->to_get_trace_state_variable_value == NULL)
4264     ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value;
4265   if (ops->to_save_trace_data == NULL)
4266     ops->to_save_trace_data = delegate_save_trace_data;
4267   if (ops->to_upload_tracepoints == NULL)
4268     ops->to_upload_tracepoints = delegate_upload_tracepoints;
4269   if (ops->to_upload_trace_state_variables == NULL)
4270     ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables;
4271   if (ops->to_get_raw_trace_data == NULL)
4272     ops->to_get_raw_trace_data = delegate_get_raw_trace_data;
4273   if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
4274     ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len;
4275   if (ops->to_set_disconnected_tracing == NULL)
4276     ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing;
4277   if (ops->to_set_circular_trace_buffer == NULL)
4278     ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer;
4279   if (ops->to_set_trace_buffer_size == NULL)
4280     ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size;
4281   if (ops->to_set_trace_notes == NULL)
4282     ops->to_set_trace_notes = delegate_set_trace_notes;
4283   if (ops->to_core_of_thread == NULL)
4284     ops->to_core_of_thread = delegate_core_of_thread;
4285   if (ops->to_verify_memory == NULL)
4286     ops->to_verify_memory = delegate_verify_memory;
4287   if (ops->to_get_tib_address == NULL)
4288     ops->to_get_tib_address = delegate_get_tib_address;
4289   if (ops->to_set_permissions == NULL)
4290     ops->to_set_permissions = delegate_set_permissions;
4291   if (ops->to_static_tracepoint_marker_at == NULL)
4292     ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at;
4293   if (ops->to_static_tracepoint_markers_by_strid == NULL)
4294     ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
4295   if (ops->to_traceframe_info == NULL)
4296     ops->to_traceframe_info = delegate_traceframe_info;
4297   if (ops->to_use_agent == NULL)
4298     ops->to_use_agent = delegate_use_agent;
4299   if (ops->to_can_use_agent == NULL)
4300     ops->to_can_use_agent = delegate_can_use_agent;
4301   if (ops->to_supports_btrace == NULL)
4302     ops->to_supports_btrace = delegate_supports_btrace;
4303   if (ops->to_enable_btrace == NULL)
4304     ops->to_enable_btrace = delegate_enable_btrace;
4305   if (ops->to_disable_btrace == NULL)
4306     ops->to_disable_btrace = delegate_disable_btrace;
4307   if (ops->to_teardown_btrace == NULL)
4308     ops->to_teardown_btrace = delegate_teardown_btrace;
4309   if (ops->to_read_btrace == NULL)
4310     ops->to_read_btrace = delegate_read_btrace;
4311   if (ops->to_btrace_conf == NULL)
4312     ops->to_btrace_conf = delegate_btrace_conf;
4313   if (ops->to_stop_recording == NULL)
4314     ops->to_stop_recording = delegate_stop_recording;
4315   if (ops->to_info_record == NULL)
4316     ops->to_info_record = delegate_info_record;
4317   if (ops->to_save_record == NULL)
4318     ops->to_save_record = delegate_save_record;
4319   if (ops->to_delete_record == NULL)
4320     ops->to_delete_record = delegate_delete_record;
4321   if (ops->to_record_is_replaying == NULL)
4322     ops->to_record_is_replaying = delegate_record_is_replaying;
4323   if (ops->to_record_will_replay == NULL)
4324     ops->to_record_will_replay = delegate_record_will_replay;
4325   if (ops->to_record_stop_replaying == NULL)
4326     ops->to_record_stop_replaying = delegate_record_stop_replaying;
4327   if (ops->to_goto_record_begin == NULL)
4328     ops->to_goto_record_begin = delegate_goto_record_begin;
4329   if (ops->to_goto_record_end == NULL)
4330     ops->to_goto_record_end = delegate_goto_record_end;
4331   if (ops->to_goto_record == NULL)
4332     ops->to_goto_record = delegate_goto_record;
4333   if (ops->to_insn_history == NULL)
4334     ops->to_insn_history = delegate_insn_history;
4335   if (ops->to_insn_history_from == NULL)
4336     ops->to_insn_history_from = delegate_insn_history_from;
4337   if (ops->to_insn_history_range == NULL)
4338     ops->to_insn_history_range = delegate_insn_history_range;
4339   if (ops->to_call_history == NULL)
4340     ops->to_call_history = delegate_call_history;
4341   if (ops->to_call_history_from == NULL)
4342     ops->to_call_history_from = delegate_call_history_from;
4343   if (ops->to_call_history_range == NULL)
4344     ops->to_call_history_range = delegate_call_history_range;
4345   if (ops->to_augmented_libraries_svr4_read == NULL)
4346     ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read;
4347   if (ops->to_get_unwinder == NULL)
4348     ops->to_get_unwinder = delegate_get_unwinder;
4349   if (ops->to_get_tailcall_unwinder == NULL)
4350     ops->to_get_tailcall_unwinder = delegate_get_tailcall_unwinder;
4351   if (ops->to_prepare_to_generate_core == NULL)
4352     ops->to_prepare_to_generate_core = delegate_prepare_to_generate_core;
4353   if (ops->to_done_generating_core == NULL)
4354     ops->to_done_generating_core = delegate_done_generating_core;
4355 }
4356
4357 static void
4358 install_dummy_methods (struct target_ops *ops)
4359 {
4360   ops->to_post_attach = tdefault_post_attach;
4361   ops->to_detach = tdefault_detach;
4362   ops->to_disconnect = tdefault_disconnect;
4363   ops->to_resume = tdefault_resume;
4364   ops->to_wait = default_target_wait;
4365   ops->to_fetch_registers = tdefault_fetch_registers;
4366   ops->to_store_registers = tdefault_store_registers;
4367   ops->to_prepare_to_store = tdefault_prepare_to_store;
4368   ops->to_files_info = tdefault_files_info;
4369   ops->to_insert_breakpoint = memory_insert_breakpoint;
4370   ops->to_remove_breakpoint = memory_remove_breakpoint;
4371   ops->to_stopped_by_sw_breakpoint = tdefault_stopped_by_sw_breakpoint;
4372   ops->to_supports_stopped_by_sw_breakpoint = tdefault_supports_stopped_by_sw_breakpoint;
4373   ops->to_stopped_by_hw_breakpoint = tdefault_stopped_by_hw_breakpoint;
4374   ops->to_supports_stopped_by_hw_breakpoint = tdefault_supports_stopped_by_hw_breakpoint;
4375   ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint;
4376   ops->to_ranged_break_num_registers = tdefault_ranged_break_num_registers;
4377   ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint;
4378   ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint;
4379   ops->to_remove_watchpoint = tdefault_remove_watchpoint;
4380   ops->to_insert_watchpoint = tdefault_insert_watchpoint;
4381   ops->to_insert_mask_watchpoint = tdefault_insert_mask_watchpoint;
4382   ops->to_remove_mask_watchpoint = tdefault_remove_mask_watchpoint;
4383   ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint;
4384   ops->to_stopped_data_address = tdefault_stopped_data_address;
4385   ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range;
4386   ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
4387   ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
4388   ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers;
4389   ops->to_can_do_single_step = tdefault_can_do_single_step;
4390   ops->to_terminal_init = tdefault_terminal_init;
4391   ops->to_terminal_inferior = tdefault_terminal_inferior;
4392   ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
4393   ops->to_terminal_ours = tdefault_terminal_ours;
4394   ops->to_terminal_info = default_terminal_info;
4395   ops->to_kill = tdefault_kill;
4396   ops->to_load = tdefault_load;
4397   ops->to_post_startup_inferior = tdefault_post_startup_inferior;
4398   ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint;
4399   ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint;
4400   ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint;
4401   ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint;
4402   ops->to_follow_fork = default_follow_fork;
4403   ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
4404   ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
4405   ops->to_follow_exec = tdefault_follow_exec;
4406   ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
4407   ops->to_has_exited = tdefault_has_exited;
4408   ops->to_mourn_inferior = default_mourn_inferior;
4409   ops->to_can_run = tdefault_can_run;
4410   ops->to_pass_signals = tdefault_pass_signals;
4411   ops->to_program_signals = tdefault_program_signals;
4412   ops->to_thread_alive = tdefault_thread_alive;
4413   ops->to_update_thread_list = tdefault_update_thread_list;
4414   ops->to_pid_to_str = default_pid_to_str;
4415   ops->to_extra_thread_info = tdefault_extra_thread_info;
4416   ops->to_thread_name = tdefault_thread_name;
4417   ops->to_stop = tdefault_stop;
4418   ops->to_interrupt = tdefault_interrupt;
4419   ops->to_check_pending_interrupt = tdefault_check_pending_interrupt;
4420   ops->to_rcmd = default_rcmd;
4421   ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
4422   ops->to_log_command = tdefault_log_command;
4423   ops->to_get_section_table = tdefault_get_section_table;
4424   ops->to_can_async_p = tdefault_can_async_p;
4425   ops->to_is_async_p = tdefault_is_async_p;
4426   ops->to_async = tdefault_async;
4427   ops->to_supports_non_stop = tdefault_supports_non_stop;
4428   ops->to_always_non_stop_p = tdefault_always_non_stop_p;
4429   ops->to_find_memory_regions = dummy_find_memory_regions;
4430   ops->to_make_corefile_notes = dummy_make_corefile_notes;
4431   ops->to_get_bookmark = tdefault_get_bookmark;
4432   ops->to_goto_bookmark = tdefault_goto_bookmark;
4433   ops->to_get_thread_local_address = tdefault_get_thread_local_address;
4434   ops->to_xfer_partial = tdefault_xfer_partial;
4435   ops->to_memory_map = tdefault_memory_map;
4436   ops->to_flash_erase = tdefault_flash_erase;
4437   ops->to_flash_done = tdefault_flash_done;
4438   ops->to_read_description = tdefault_read_description;
4439   ops->to_get_ada_task_ptid = default_get_ada_task_ptid;
4440   ops->to_auxv_parse = default_auxv_parse;
4441   ops->to_search_memory = default_search_memory;
4442   ops->to_can_execute_reverse = tdefault_can_execute_reverse;
4443   ops->to_execution_direction = default_execution_direction;
4444   ops->to_supports_multi_process = tdefault_supports_multi_process;
4445   ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint;
4446   ops->to_supports_string_tracing = tdefault_supports_string_tracing;
4447   ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions;
4448   ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands;
4449   ops->to_thread_architecture = default_thread_architecture;
4450   ops->to_thread_address_space = default_thread_address_space;
4451   ops->to_filesystem_is_local = tdefault_filesystem_is_local;
4452   ops->to_trace_init = tdefault_trace_init;
4453   ops->to_download_tracepoint = tdefault_download_tracepoint;
4454   ops->to_can_download_tracepoint = tdefault_can_download_tracepoint;
4455   ops->to_download_trace_state_variable = tdefault_download_trace_state_variable;
4456   ops->to_enable_tracepoint = tdefault_enable_tracepoint;
4457   ops->to_disable_tracepoint = tdefault_disable_tracepoint;
4458   ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions;
4459   ops->to_trace_start = tdefault_trace_start;
4460   ops->to_get_trace_status = tdefault_get_trace_status;
4461   ops->to_get_tracepoint_status = tdefault_get_tracepoint_status;
4462   ops->to_trace_stop = tdefault_trace_stop;
4463   ops->to_trace_find = tdefault_trace_find;
4464   ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value;
4465   ops->to_save_trace_data = tdefault_save_trace_data;
4466   ops->to_upload_tracepoints = tdefault_upload_tracepoints;
4467   ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables;
4468   ops->to_get_raw_trace_data = tdefault_get_raw_trace_data;
4469   ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len;
4470   ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing;
4471   ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer;
4472   ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size;
4473   ops->to_set_trace_notes = tdefault_set_trace_notes;
4474   ops->to_core_of_thread = tdefault_core_of_thread;
4475   ops->to_verify_memory = default_verify_memory;
4476   ops->to_get_tib_address = tdefault_get_tib_address;
4477   ops->to_set_permissions = tdefault_set_permissions;
4478   ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at;
4479   ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
4480   ops->to_traceframe_info = tdefault_traceframe_info;
4481   ops->to_use_agent = tdefault_use_agent;
4482   ops->to_can_use_agent = tdefault_can_use_agent;
4483   ops->to_supports_btrace = tdefault_supports_btrace;
4484   ops->to_enable_btrace = tdefault_enable_btrace;
4485   ops->to_disable_btrace = tdefault_disable_btrace;
4486   ops->to_teardown_btrace = tdefault_teardown_btrace;
4487   ops->to_read_btrace = tdefault_read_btrace;
4488   ops->to_btrace_conf = tdefault_btrace_conf;
4489   ops->to_stop_recording = tdefault_stop_recording;
4490   ops->to_info_record = tdefault_info_record;
4491   ops->to_save_record = tdefault_save_record;
4492   ops->to_delete_record = tdefault_delete_record;
4493   ops->to_record_is_replaying = tdefault_record_is_replaying;
4494   ops->to_record_will_replay = tdefault_record_will_replay;
4495   ops->to_record_stop_replaying = tdefault_record_stop_replaying;
4496   ops->to_goto_record_begin = tdefault_goto_record_begin;
4497   ops->to_goto_record_end = tdefault_goto_record_end;
4498   ops->to_goto_record = tdefault_goto_record;
4499   ops->to_insn_history = tdefault_insn_history;
4500   ops->to_insn_history_from = tdefault_insn_history_from;
4501   ops->to_insn_history_range = tdefault_insn_history_range;
4502   ops->to_call_history = tdefault_call_history;
4503   ops->to_call_history_from = tdefault_call_history_from;
4504   ops->to_call_history_range = tdefault_call_history_range;
4505   ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read;
4506   ops->to_get_unwinder = tdefault_get_unwinder;
4507   ops->to_get_tailcall_unwinder = tdefault_get_tailcall_unwinder;
4508   ops->to_prepare_to_generate_core = tdefault_prepare_to_generate_core;
4509   ops->to_done_generating_core = tdefault_done_generating_core;
4510 }
4511
4512 static void
4513 init_debug_target (struct target_ops *ops)
4514 {
4515   ops->to_post_attach = debug_post_attach;
4516   ops->to_detach = debug_detach;
4517   ops->to_disconnect = debug_disconnect;
4518   ops->to_resume = debug_resume;
4519   ops->to_wait = debug_wait;
4520   ops->to_fetch_registers = debug_fetch_registers;
4521   ops->to_store_registers = debug_store_registers;
4522   ops->to_prepare_to_store = debug_prepare_to_store;
4523   ops->to_files_info = debug_files_info;
4524   ops->to_insert_breakpoint = debug_insert_breakpoint;
4525   ops->to_remove_breakpoint = debug_remove_breakpoint;
4526   ops->to_stopped_by_sw_breakpoint = debug_stopped_by_sw_breakpoint;
4527   ops->to_supports_stopped_by_sw_breakpoint = debug_supports_stopped_by_sw_breakpoint;
4528   ops->to_stopped_by_hw_breakpoint = debug_stopped_by_hw_breakpoint;
4529   ops->to_supports_stopped_by_hw_breakpoint = debug_supports_stopped_by_hw_breakpoint;
4530   ops->to_can_use_hw_breakpoint = debug_can_use_hw_breakpoint;
4531   ops->to_ranged_break_num_registers = debug_ranged_break_num_registers;
4532   ops->to_insert_hw_breakpoint = debug_insert_hw_breakpoint;
4533   ops->to_remove_hw_breakpoint = debug_remove_hw_breakpoint;
4534   ops->to_remove_watchpoint = debug_remove_watchpoint;
4535   ops->to_insert_watchpoint = debug_insert_watchpoint;
4536   ops->to_insert_mask_watchpoint = debug_insert_mask_watchpoint;
4537   ops->to_remove_mask_watchpoint = debug_remove_mask_watchpoint;
4538   ops->to_stopped_by_watchpoint = debug_stopped_by_watchpoint;
4539   ops->to_stopped_data_address = debug_stopped_data_address;
4540   ops->to_watchpoint_addr_within_range = debug_watchpoint_addr_within_range;
4541   ops->to_region_ok_for_hw_watchpoint = debug_region_ok_for_hw_watchpoint;
4542   ops->to_can_accel_watchpoint_condition = debug_can_accel_watchpoint_condition;
4543   ops->to_masked_watch_num_registers = debug_masked_watch_num_registers;
4544   ops->to_can_do_single_step = debug_can_do_single_step;
4545   ops->to_terminal_init = debug_terminal_init;
4546   ops->to_terminal_inferior = debug_terminal_inferior;
4547   ops->to_terminal_ours_for_output = debug_terminal_ours_for_output;
4548   ops->to_terminal_ours = debug_terminal_ours;
4549   ops->to_terminal_info = debug_terminal_info;
4550   ops->to_kill = debug_kill;
4551   ops->to_load = debug_load;
4552   ops->to_post_startup_inferior = debug_post_startup_inferior;
4553   ops->to_insert_fork_catchpoint = debug_insert_fork_catchpoint;
4554   ops->to_remove_fork_catchpoint = debug_remove_fork_catchpoint;
4555   ops->to_insert_vfork_catchpoint = debug_insert_vfork_catchpoint;
4556   ops->to_remove_vfork_catchpoint = debug_remove_vfork_catchpoint;
4557   ops->to_follow_fork = debug_follow_fork;
4558   ops->to_insert_exec_catchpoint = debug_insert_exec_catchpoint;
4559   ops->to_remove_exec_catchpoint = debug_remove_exec_catchpoint;
4560   ops->to_follow_exec = debug_follow_exec;
4561   ops->to_set_syscall_catchpoint = debug_set_syscall_catchpoint;
4562   ops->to_has_exited = debug_has_exited;
4563   ops->to_mourn_inferior = debug_mourn_inferior;
4564   ops->to_can_run = debug_can_run;
4565   ops->to_pass_signals = debug_pass_signals;
4566   ops->to_program_signals = debug_program_signals;
4567   ops->to_thread_alive = debug_thread_alive;
4568   ops->to_update_thread_list = debug_update_thread_list;
4569   ops->to_pid_to_str = debug_pid_to_str;
4570   ops->to_extra_thread_info = debug_extra_thread_info;
4571   ops->to_thread_name = debug_thread_name;
4572   ops->to_stop = debug_stop;
4573   ops->to_interrupt = debug_interrupt;
4574   ops->to_check_pending_interrupt = debug_check_pending_interrupt;
4575   ops->to_rcmd = debug_rcmd;
4576   ops->to_pid_to_exec_file = debug_pid_to_exec_file;
4577   ops->to_log_command = debug_log_command;
4578   ops->to_get_section_table = debug_get_section_table;
4579   ops->to_can_async_p = debug_can_async_p;
4580   ops->to_is_async_p = debug_is_async_p;
4581   ops->to_async = debug_async;
4582   ops->to_supports_non_stop = debug_supports_non_stop;
4583   ops->to_always_non_stop_p = debug_always_non_stop_p;
4584   ops->to_find_memory_regions = debug_find_memory_regions;
4585   ops->to_make_corefile_notes = debug_make_corefile_notes;
4586   ops->to_get_bookmark = debug_get_bookmark;
4587   ops->to_goto_bookmark = debug_goto_bookmark;
4588   ops->to_get_thread_local_address = debug_get_thread_local_address;
4589   ops->to_xfer_partial = debug_xfer_partial;
4590   ops->to_memory_map = debug_memory_map;
4591   ops->to_flash_erase = debug_flash_erase;
4592   ops->to_flash_done = debug_flash_done;
4593   ops->to_read_description = debug_read_description;
4594   ops->to_get_ada_task_ptid = debug_get_ada_task_ptid;
4595   ops->to_auxv_parse = debug_auxv_parse;
4596   ops->to_search_memory = debug_search_memory;
4597   ops->to_can_execute_reverse = debug_can_execute_reverse;
4598   ops->to_execution_direction = debug_execution_direction;
4599   ops->to_supports_multi_process = debug_supports_multi_process;
4600   ops->to_supports_enable_disable_tracepoint = debug_supports_enable_disable_tracepoint;
4601   ops->to_supports_string_tracing = debug_supports_string_tracing;
4602   ops->to_supports_evaluation_of_breakpoint_conditions = debug_supports_evaluation_of_breakpoint_conditions;
4603   ops->to_can_run_breakpoint_commands = debug_can_run_breakpoint_commands;
4604   ops->to_thread_architecture = debug_thread_architecture;
4605   ops->to_thread_address_space = debug_thread_address_space;
4606   ops->to_filesystem_is_local = debug_filesystem_is_local;
4607   ops->to_trace_init = debug_trace_init;
4608   ops->to_download_tracepoint = debug_download_tracepoint;
4609   ops->to_can_download_tracepoint = debug_can_download_tracepoint;
4610   ops->to_download_trace_state_variable = debug_download_trace_state_variable;
4611   ops->to_enable_tracepoint = debug_enable_tracepoint;
4612   ops->to_disable_tracepoint = debug_disable_tracepoint;
4613   ops->to_trace_set_readonly_regions = debug_trace_set_readonly_regions;
4614   ops->to_trace_start = debug_trace_start;
4615   ops->to_get_trace_status = debug_get_trace_status;
4616   ops->to_get_tracepoint_status = debug_get_tracepoint_status;
4617   ops->to_trace_stop = debug_trace_stop;
4618   ops->to_trace_find = debug_trace_find;
4619   ops->to_get_trace_state_variable_value = debug_get_trace_state_variable_value;
4620   ops->to_save_trace_data = debug_save_trace_data;
4621   ops->to_upload_tracepoints = debug_upload_tracepoints;
4622   ops->to_upload_trace_state_variables = debug_upload_trace_state_variables;
4623   ops->to_get_raw_trace_data = debug_get_raw_trace_data;
4624   ops->to_get_min_fast_tracepoint_insn_len = debug_get_min_fast_tracepoint_insn_len;
4625   ops->to_set_disconnected_tracing = debug_set_disconnected_tracing;
4626   ops->to_set_circular_trace_buffer = debug_set_circular_trace_buffer;
4627   ops->to_set_trace_buffer_size = debug_set_trace_buffer_size;
4628   ops->to_set_trace_notes = debug_set_trace_notes;
4629   ops->to_core_of_thread = debug_core_of_thread;
4630   ops->to_verify_memory = debug_verify_memory;
4631   ops->to_get_tib_address = debug_get_tib_address;
4632   ops->to_set_permissions = debug_set_permissions;
4633   ops->to_static_tracepoint_marker_at = debug_static_tracepoint_marker_at;
4634   ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid;
4635   ops->to_traceframe_info = debug_traceframe_info;
4636   ops->to_use_agent = debug_use_agent;
4637   ops->to_can_use_agent = debug_can_use_agent;
4638   ops->to_supports_btrace = debug_supports_btrace;
4639   ops->to_enable_btrace = debug_enable_btrace;
4640   ops->to_disable_btrace = debug_disable_btrace;
4641   ops->to_teardown_btrace = debug_teardown_btrace;
4642   ops->to_read_btrace = debug_read_btrace;
4643   ops->to_btrace_conf = debug_btrace_conf;
4644   ops->to_stop_recording = debug_stop_recording;
4645   ops->to_info_record = debug_info_record;
4646   ops->to_save_record = debug_save_record;
4647   ops->to_delete_record = debug_delete_record;
4648   ops->to_record_is_replaying = debug_record_is_replaying;
4649   ops->to_record_will_replay = debug_record_will_replay;
4650   ops->to_record_stop_replaying = debug_record_stop_replaying;
4651   ops->to_goto_record_begin = debug_goto_record_begin;
4652   ops->to_goto_record_end = debug_goto_record_end;
4653   ops->to_goto_record = debug_goto_record;
4654   ops->to_insn_history = debug_insn_history;
4655   ops->to_insn_history_from = debug_insn_history_from;
4656   ops->to_insn_history_range = debug_insn_history_range;
4657   ops->to_call_history = debug_call_history;
4658   ops->to_call_history_from = debug_call_history_from;
4659   ops->to_call_history_range = debug_call_history_range;
4660   ops->to_augmented_libraries_svr4_read = debug_augmented_libraries_svr4_read;
4661   ops->to_get_unwinder = debug_get_unwinder;
4662   ops->to_get_tailcall_unwinder = debug_get_tailcall_unwinder;
4663   ops->to_prepare_to_generate_core = debug_prepare_to_generate_core;
4664   ops->to_done_generating_core = debug_done_generating_core;
4665 }