gdb/target-delegates.c

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