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