gdb/target-delegates.c

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