gdb/target-delegates.c

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