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