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