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