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 delegate_detach (struct target_ops *self, const char *arg1, int arg2)
  20 {
  21   self = self->beneath;
  22   self->to_detach (self, arg1, arg2);
  23 }
  24
  25 static void
  26 tdefault_detach (struct target_ops *self, const char *arg1, int arg2)
  27 {
  28 }
  29
  30 static void
  31 delegate_disconnect (struct target_ops *self, const char *arg1, int arg2)
  32 {
  33   self = self->beneath;
  34   self->to_disconnect (self, arg1, arg2);
  35 }
  36
  37 static void
  38 tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2)
  39 {
  40   tcomplain ();
  41 }
  42
  43 static void
  44 delegate_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
  45 {
  46   self = self->beneath;
  47   self->to_resume (self, arg1, arg2, arg3);
  48 }
  49
  50 static void
  51 tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3)
  52 {
  53   noprocess ();
  54 }
  55
  56 static ptid_t
  57 delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
  58 {
  59   self = self->beneath;
  60   return self->to_wait (self, arg1, arg2, arg3);
  61 }
  62
  63 static ptid_t
  64 tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3)
  65 {
  66   noprocess ();
  67 }
  68
  69 static void
  70 delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
  71 {
  72   self = self->beneath;
  73   self->to_fetch_registers (self, arg1, arg2);
  74 }
  75
  76 static void
  77 tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2)
  78 {
  79 }
  80
  81 static void
  82 delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
  83 {
  84   self = self->beneath;
  85   self->to_store_registers (self, arg1, arg2);
  86 }
  87
  88 static void
  89 tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
  90 {
  91   noprocess ();
  92 }
  93
  94 static void
  95 delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
  96 {
  97   self = self->beneath;
  98   self->to_prepare_to_store (self, arg1);
  99 }
 100
 101 static void
 102 tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
 103 {
 104   noprocess ();
 105 }
 106
 107 static void
 108 delegate_files_info (struct target_ops *self)
 109 {
 110   self = self->beneath;
 111   self->to_files_info (self);
 112 }
 113
 114 static void
 115 tdefault_files_info (struct target_ops *self)
 116 {
 117 }
 118
 119 static int
 120 delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 121 {
 122   self = self->beneath;
 123   return self->to_insert_breakpoint (self, arg1, arg2);
 124 }
 125
 126 static int
 127 delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 128 {
 129   self = self->beneath;
 130   return self->to_remove_breakpoint (self, arg1, arg2);
 131 }
 132
 133 static int
 134 delegate_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
 135 {
 136   self = self->beneath;
 137   return self->to_can_use_hw_breakpoint (self, arg1, arg2, arg3);
 138 }
 139
 140 static int
 141 tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
 142 {
 143   return 0;
 144 }
 145
 146 static int
 147 delegate_ranged_break_num_registers (struct target_ops *self)
 148 {
 149   self = self->beneath;
 150   return self->to_ranged_break_num_registers (self);
 151 }
 152
 153 static int
 154 tdefault_ranged_break_num_registers (struct target_ops *self)
 155 {
 156   return -1;
 157 }
 158
 159 static int
 160 delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 161 {
 162   self = self->beneath;
 163   return self->to_insert_hw_breakpoint (self, arg1, arg2);
 164 }
 165
 166 static int
 167 tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 168 {
 169   return -1;
 170 }
 171
 172 static int
 173 delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 174 {
 175   self = self->beneath;
 176   return self->to_remove_hw_breakpoint (self, arg1, arg2);
 177 }
 178
 179 static int
 180 tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 181 {
 182   return -1;
 183 }
 184
 185 static int
 186 delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 187 {
 188   self = self->beneath;
 189   return self->to_remove_watchpoint (self, arg1, arg2, arg3, arg4);
 190 }
 191
 192 static int
 193 tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 194 {
 195   return -1;
 196 }
 197
 198 static int
 199 delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 200 {
 201   self = self->beneath;
 202   return self->to_insert_watchpoint (self, arg1, arg2, arg3, arg4);
 203 }
 204
 205 static int
 206 tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 207 {
 208   return -1;
 209 }
 210
 211 static int
 212 delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
 213 {
 214   self = self->beneath;
 215   return self->to_insert_mask_watchpoint (self, arg1, arg2, arg3);
 216 }
 217
 218 static int
 219 tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
 220 {
 221   return 1;
 222 }
 223
 224 static int
 225 delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
 226 {
 227   self = self->beneath;
 228   return self->to_remove_mask_watchpoint (self, arg1, arg2, arg3);
 229 }
 230
 231 static int
 232 tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
 233 {
 234   return 1;
 235 }
 236
 237 static int
 238 delegate_stopped_by_watchpoint (struct target_ops *self)
 239 {
 240   self = self->beneath;
 241   return self->to_stopped_by_watchpoint (self);
 242 }
 243
 244 static int
 245 tdefault_stopped_by_watchpoint (struct target_ops *self)
 246 {
 247   return 0;
 248 }
 249
 250 static int
 251 delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
 252 {
 253   self = self->beneath;
 254   return self->to_stopped_data_address (self, arg1);
 255 }
 256
 257 static int
 258 tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
 259 {
 260   return 0;
 261 }
 262
 263 static int
 264 delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
 265 {
 266   self = self->beneath;
 267   return self->to_watchpoint_addr_within_range (self, arg1, arg2, arg3);
 268 }
 269
 270 static int
 271 delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
 272 {
 273   self = self->beneath;
 274   return self->to_region_ok_for_hw_watchpoint (self, arg1, arg2);
 275 }
 276
 277 static int
 278 delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 279 {
 280   self = self->beneath;
 281   return self->to_can_accel_watchpoint_condition (self, arg1, arg2, arg3, arg4);
 282 }
 283
 284 static int
 285 tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 286 {
 287   return 0;
 288 }
 289
 290 static int
 291 delegate_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
 292 {
 293   self = self->beneath;
 294   return self->to_masked_watch_num_registers (self, arg1, arg2);
 295 }
 296
 297 static int
 298 tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2)
 299 {
 300   return -1;
 301 }
 302
 303 static void
 304 delegate_terminal_init (struct target_ops *self)
 305 {
 306   self = self->beneath;
 307   self->to_terminal_init (self);
 308 }
 309
 310 static void
 311 tdefault_terminal_init (struct target_ops *self)
 312 {
 313 }
 314
 315 static void
 316 delegate_terminal_inferior (struct target_ops *self)
 317 {
 318   self = self->beneath;
 319   self->to_terminal_inferior (self);
 320 }
 321
 322 static void
 323 tdefault_terminal_inferior (struct target_ops *self)
 324 {
 325 }
 326
 327 static void
 328 delegate_terminal_ours_for_output (struct target_ops *self)
 329 {
 330   self = self->beneath;
 331   self->to_terminal_ours_for_output (self);
 332 }
 333
 334 static void
 335 tdefault_terminal_ours_for_output (struct target_ops *self)
 336 {
 337 }
 338
 339 static void
 340 delegate_terminal_ours (struct target_ops *self)
 341 {
 342   self = self->beneath;
 343   self->to_terminal_ours (self);
 344 }
 345
 346 static void
 347 tdefault_terminal_ours (struct target_ops *self)
 348 {
 349 }
 350
 351 static void
 352 delegate_terminal_save_ours (struct target_ops *self)
 353 {
 354   self = self->beneath;
 355   self->to_terminal_save_ours (self);
 356 }
 357
 358 static void
 359 tdefault_terminal_save_ours (struct target_ops *self)
 360 {
 361 }
 362
 363 static void
 364 delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
 365 {
 366   self = self->beneath;
 367   self->to_terminal_info (self, arg1, arg2);
 368 }
 369
 370 static void
 371 delegate_kill (struct target_ops *self)
 372 {
 373   self = self->beneath;
 374   self->to_kill (self);
 375 }
 376
 377 static void
 378 tdefault_kill (struct target_ops *self)
 379 {
 380   noprocess ();
 381 }
 382
 383 static void
 384 delegate_load (struct target_ops *self, const char *arg1, int arg2)
 385 {
 386   self = self->beneath;
 387   self->to_load (self, arg1, arg2);
 388 }
 389
 390 static void
 391 tdefault_load (struct target_ops *self, const char *arg1, int arg2)
 392 {
 393   tcomplain ();
 394 }
 395
 396 static void
 397 delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1)
 398 {
 399   self = self->beneath;
 400   self->to_post_startup_inferior (self, arg1);
 401 }
 402
 403 static void
 404 tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
 405 {
 406 }
 407
 408 static int
 409 delegate_insert_fork_catchpoint (struct target_ops *self, int arg1)
 410 {
 411   self = self->beneath;
 412   return self->to_insert_fork_catchpoint (self, arg1);
 413 }
 414
 415 static int
 416 tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
 417 {
 418   return 1;
 419 }
 420
 421 static int
 422 delegate_remove_fork_catchpoint (struct target_ops *self, int arg1)
 423 {
 424   self = self->beneath;
 425   return self->to_remove_fork_catchpoint (self, arg1);
 426 }
 427
 428 static int
 429 tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
 430 {
 431   return 1;
 432 }
 433
 434 static int
 435 delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1)
 436 {
 437   self = self->beneath;
 438   return self->to_insert_vfork_catchpoint (self, arg1);
 439 }
 440
 441 static int
 442 tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
 443 {
 444   return 1;
 445 }
 446
 447 static int
 448 delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1)
 449 {
 450   self = self->beneath;
 451   return self->to_remove_vfork_catchpoint (self, arg1);
 452 }
 453
 454 static int
 455 tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
 456 {
 457   return 1;
 458 }
 459
 460 static int
 461 delegate_follow_fork (struct target_ops *self, int arg1, int arg2)
 462 {
 463   self = self->beneath;
 464   return self->to_follow_fork (self, arg1, arg2);
 465 }
 466
 467 static int
 468 delegate_insert_exec_catchpoint (struct target_ops *self, int arg1)
 469 {
 470   self = self->beneath;
 471   return self->to_insert_exec_catchpoint (self, arg1);
 472 }
 473
 474 static int
 475 tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
 476 {
 477   return 1;
 478 }
 479
 480 static int
 481 delegate_remove_exec_catchpoint (struct target_ops *self, int arg1)
 482 {
 483   self = self->beneath;
 484   return self->to_remove_exec_catchpoint (self, arg1);
 485 }
 486
 487 static int
 488 tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
 489 {
 490   return 1;
 491 }
 492
 493 static int
 494 delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
 495 {
 496   self = self->beneath;
 497   return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4, arg5);
 498 }
 499
 500 static int
 501 tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
 502 {
 503   return 1;
 504 }
 505
 506 static int
 507 delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
 508 {
 509   self = self->beneath;
 510   return self->to_has_exited (self, arg1, arg2, arg3);
 511 }
 512
 513 static int
 514 tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
 515 {
 516   return 0;
 517 }
 518
 519 static void
 520 delegate_mourn_inferior (struct target_ops *self)
 521 {
 522   self = self->beneath;
 523   self->to_mourn_inferior (self);
 524 }
 525
 526 static int
 527 delegate_can_run (struct target_ops *self)
 528 {
 529   self = self->beneath;
 530   return self->to_can_run (self);
 531 }
 532
 533 static int
 534 tdefault_can_run (struct target_ops *self)
 535 {
 536   return 0;
 537 }
 538
 539 static void
 540 delegate_pass_signals (struct target_ops *self, int arg1, unsigned char *arg2)
 541 {
 542   self = self->beneath;
 543   self->to_pass_signals (self, arg1, arg2);
 544 }
 545
 546 static void
 547 tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char *arg2)
 548 {
 549 }
 550
 551 static void
 552 delegate_program_signals (struct target_ops *self, int arg1, unsigned char *arg2)
 553 {
 554   self = self->beneath;
 555   self->to_program_signals (self, arg1, arg2);
 556 }
 557
 558 static void
 559 tdefault_program_signals (struct target_ops *self, int arg1, unsigned char *arg2)
 560 {
 561 }
 562
 563 static int
 564 delegate_thread_alive (struct target_ops *self, ptid_t arg1)
 565 {
 566   self = self->beneath;
 567   return self->to_thread_alive (self, arg1);
 568 }
 569
 570 static int
 571 tdefault_thread_alive (struct target_ops *self, ptid_t arg1)
 572 {
 573   return 0;
 574 }
 575
 576 static void
 577 delegate_find_new_threads (struct target_ops *self)
 578 {
 579   self = self->beneath;
 580   self->to_find_new_threads (self);
 581 }
 582
 583 static void
 584 tdefault_find_new_threads (struct target_ops *self)
 585 {
 586 }
 587
 588 static char *
 589 delegate_pid_to_str (struct target_ops *self, ptid_t arg1)
 590 {
 591   self = self->beneath;
 592   return self->to_pid_to_str (self, arg1);
 593 }
 594
 595 static char *
 596 delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
 597 {
 598   self = self->beneath;
 599   return self->to_extra_thread_info (self, arg1);
 600 }
 601
 602 static char *
 603 tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
 604 {
 605   return NULL;
 606 }
 607
 608 static char *
 609 delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
 610 {
 611   self = self->beneath;
 612   return self->to_thread_name (self, arg1);
 613 }
 614
 615 static char *
 616 tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
 617 {
 618   return NULL;
 619 }
 620
 621 static void
 622 delegate_stop (struct target_ops *self, ptid_t arg1)
 623 {
 624   self = self->beneath;
 625   self->to_stop (self, arg1);
 626 }
 627
 628 static void
 629 tdefault_stop (struct target_ops *self, ptid_t arg1)
 630 {
 631 }
 632
 633 static void
 634 delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2)
 635 {
 636   self = self->beneath;
 637   self->to_rcmd (self, arg1, arg2);
 638 }
 639
 640 static char *
 641 delegate_pid_to_exec_file (struct target_ops *self, int arg1)
 642 {
 643   self = self->beneath;
 644   return self->to_pid_to_exec_file (self, arg1);
 645 }
 646
 647 static char *
 648 tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
 649 {
 650   return NULL;
 651 }
 652
 653 static void
 654 delegate_log_command (struct target_ops *self, const char *arg1)
 655 {
 656   self = self->beneath;
 657   self->to_log_command (self, arg1);
 658 }
 659
 660 static void
 661 tdefault_log_command (struct target_ops *self, const char *arg1)
 662 {
 663 }
 664
 665 static struct target_section_table *
 666 delegate_get_section_table (struct target_ops *self)
 667 {
 668   self = self->beneath;
 669   return self->to_get_section_table (self);
 670 }
 671
 672 static struct target_section_table *
 673 tdefault_get_section_table (struct target_ops *self)
 674 {
 675   return NULL;
 676 }
 677
 678 static int
 679 delegate_can_async_p (struct target_ops *self)
 680 {
 681   self = self->beneath;
 682   return self->to_can_async_p (self);
 683 }
 684
 685 static int
 686 tdefault_can_async_p (struct target_ops *self)
 687 {
 688   return 0;
 689 }
 690
 691 static int
 692 delegate_is_async_p (struct target_ops *self)
 693 {
 694   self = self->beneath;
 695   return self->to_is_async_p (self);
 696 }
 697
 698 static int
 699 tdefault_is_async_p (struct target_ops *self)
 700 {
 701   return 0;
 702 }
 703
 704 static void
 705 delegate_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
 706 {
 707   self = self->beneath;
 708   self->to_async (self, arg1, arg2);
 709 }
 710
 711 static void
 712 tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
 713 {
 714   tcomplain ();
 715 }
 716
 717 static int
 718 delegate_supports_non_stop (struct target_ops *self)
 719 {
 720   self = self->beneath;
 721   return self->to_supports_non_stop (self);
 722 }
 723
 724 static int
 725 tdefault_supports_non_stop (struct target_ops *self)
 726 {
 727   return 0;
 728 }
 729
 730 static int
 731 delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
 732 {
 733   self = self->beneath;
 734   return self->to_find_memory_regions (self, arg1, arg2);
 735 }
 736
 737 static char *
 738 delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
 739 {
 740   self = self->beneath;
 741   return self->to_make_corefile_notes (self, arg1, arg2);
 742 }
 743
 744 static gdb_byte *
 745 delegate_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
 746 {
 747   self = self->beneath;
 748   return self->to_get_bookmark (self, arg1, arg2);
 749 }
 750
 751 static gdb_byte *
 752 tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2)
 753 {
 754   tcomplain ();
 755 }
 756
 757 static void
 758 delegate_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
 759 {
 760   self = self->beneath;
 761   self->to_goto_bookmark (self, arg1, arg2);
 762 }
 763
 764 static void
 765 tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2)
 766 {
 767   tcomplain ();
 768 }
 769
 770 static enum target_xfer_status
 771 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)
 772 {
 773   self = self->beneath;
 774   return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 775 }
 776
 777 static enum target_xfer_status
 778 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)
 779 {
 780   return TARGET_XFER_E_IO;
 781 }
 782
 783 static VEC(mem_region_s) *
 784 delegate_memory_map (struct target_ops *self)
 785 {
 786   self = self->beneath;
 787   return self->to_memory_map (self);
 788 }
 789
 790 static VEC(mem_region_s) *
 791 tdefault_memory_map (struct target_ops *self)
 792 {
 793   return NULL;
 794 }
 795
 796 static void
 797 delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
 798 {
 799   self = self->beneath;
 800   self->to_flash_erase (self, arg1, arg2);
 801 }
 802
 803 static void
 804 tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2)
 805 {
 806   tcomplain ();
 807 }
 808
 809 static void
 810 delegate_flash_done (struct target_ops *self)
 811 {
 812   self = self->beneath;
 813   self->to_flash_done (self);
 814 }
 815
 816 static void
 817 tdefault_flash_done (struct target_ops *self)
 818 {
 819   tcomplain ();
 820 }
 821
 822 static const struct target_desc *
 823 delegate_read_description (struct target_ops *self)
 824 {
 825   self = self->beneath;
 826   return self->to_read_description (self);
 827 }
 828
 829 static const struct target_desc *
 830 tdefault_read_description (struct target_ops *self)
 831 {
 832   return NULL;
 833 }
 834
 835 static ptid_t
 836 delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
 837 {
 838   self = self->beneath;
 839   return self->to_get_ada_task_ptid (self, arg1, arg2);
 840 }
 841
 842 static int
 843 delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4)
 844 {
 845   self = self->beneath;
 846   return self->to_auxv_parse (self, arg1, arg2, arg3, arg4);
 847 }
 848
 849 static int
 850 delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5)
 851 {
 852   self = self->beneath;
 853   return self->to_search_memory (self, arg1, arg2, arg3, arg4, arg5);
 854 }
 855
 856 static int
 857 delegate_can_execute_reverse (struct target_ops *self)
 858 {
 859   self = self->beneath;
 860   return self->to_can_execute_reverse (self);
 861 }
 862
 863 static int
 864 tdefault_can_execute_reverse (struct target_ops *self)
 865 {
 866   return 0;
 867 }
 868
 869 static enum exec_direction_kind
 870 delegate_execution_direction (struct target_ops *self)
 871 {
 872   self = self->beneath;
 873   return self->to_execution_direction (self);
 874 }
 875
 876 static int
 877 delegate_supports_multi_process (struct target_ops *self)
 878 {
 879   self = self->beneath;
 880   return self->to_supports_multi_process (self);
 881 }
 882
 883 static int
 884 tdefault_supports_multi_process (struct target_ops *self)
 885 {
 886   return 0;
 887 }
 888
 889 static int
 890 delegate_supports_enable_disable_tracepoint (struct target_ops *self)
 891 {
 892   self = self->beneath;
 893   return self->to_supports_enable_disable_tracepoint (self);
 894 }
 895
 896 static int
 897 tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
 898 {
 899   return 0;
 900 }
 901
 902 static int
 903 delegate_supports_string_tracing (struct target_ops *self)
 904 {
 905   self = self->beneath;
 906   return self->to_supports_string_tracing (self);
 907 }
 908
 909 static int
 910 tdefault_supports_string_tracing (struct target_ops *self)
 911 {
 912   return 0;
 913 }
 914
 915 static int
 916 delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
 917 {
 918   self = self->beneath;
 919   return self->to_supports_evaluation_of_breakpoint_conditions (self);
 920 }
 921
 922 static int
 923 tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
 924 {
 925   return 0;
 926 }
 927
 928 static int
 929 delegate_can_run_breakpoint_commands (struct target_ops *self)
 930 {
 931   self = self->beneath;
 932   return self->to_can_run_breakpoint_commands (self);
 933 }
 934
 935 static int
 936 tdefault_can_run_breakpoint_commands (struct target_ops *self)
 937 {
 938   return 0;
 939 }
 940
 941 static struct gdbarch *
 942 delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
 943 {
 944   self = self->beneath;
 945   return self->to_thread_architecture (self, arg1);
 946 }
 947
 948 static struct address_space *
 949 delegate_thread_address_space (struct target_ops *self, ptid_t arg1)
 950 {
 951   self = self->beneath;
 952   return self->to_thread_address_space (self, arg1);
 953 }
 954
 955 static void
 956 delegate_trace_init (struct target_ops *self)
 957 {
 958   self = self->beneath;
 959   self->to_trace_init (self);
 960 }
 961
 962 static void
 963 tdefault_trace_init (struct target_ops *self)
 964 {
 965   tcomplain ();
 966 }
 967
 968 static void
 969 delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
 970 {
 971   self = self->beneath;
 972   self->to_download_tracepoint (self, arg1);
 973 }
 974
 975 static void
 976 tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
 977 {
 978   tcomplain ();
 979 }
 980
 981 static int
 982 delegate_can_download_tracepoint (struct target_ops *self)
 983 {
 984   self = self->beneath;
 985   return self->to_can_download_tracepoint (self);
 986 }
 987
 988 static int
 989 tdefault_can_download_tracepoint (struct target_ops *self)
 990 {
 991   return 0;
 992 }
 993
 994 static void
 995 delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
 996 {
 997   self = self->beneath;
 998   self->to_download_trace_state_variable (self, arg1);
 999 }
1000
1001 static void
1002 tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
1003 {
1004   tcomplain ();
1005 }
1006
1007 static void
1008 delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
1009 {
1010   self = self->beneath;
1011   self->to_enable_tracepoint (self, arg1);
1012 }
1013
1014 static void
1015 tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
1016 {
1017   tcomplain ();
1018 }
1019
1020 static void
1021 delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
1022 {
1023   self = self->beneath;
1024   self->to_disable_tracepoint (self, arg1);
1025 }
1026
1027 static void
1028 tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
1029 {
1030   tcomplain ();
1031 }
1032
1033 static void
1034 delegate_trace_set_readonly_regions (struct target_ops *self)
1035 {
1036   self = self->beneath;
1037   self->to_trace_set_readonly_regions (self);
1038 }
1039
1040 static void
1041 tdefault_trace_set_readonly_regions (struct target_ops *self)
1042 {
1043   tcomplain ();
1044 }
1045
1046 static void
1047 delegate_trace_start (struct target_ops *self)
1048 {
1049   self = self->beneath;
1050   self->to_trace_start (self);
1051 }
1052
1053 static void
1054 tdefault_trace_start (struct target_ops *self)
1055 {
1056   tcomplain ();
1057 }
1058
1059 static int
1060 delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
1061 {
1062   self = self->beneath;
1063   return self->to_get_trace_status (self, arg1);
1064 }
1065
1066 static int
1067 tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
1068 {
1069   return -1;
1070 }
1071
1072 static void
1073 delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
1074 {
1075   self = self->beneath;
1076   self->to_get_tracepoint_status (self, arg1, arg2);
1077 }
1078
1079 static void
1080 tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
1081 {
1082   tcomplain ();
1083 }
1084
1085 static void
1086 delegate_trace_stop (struct target_ops *self)
1087 {
1088   self = self->beneath;
1089   self->to_trace_stop (self);
1090 }
1091
1092 static void
1093 tdefault_trace_stop (struct target_ops *self)
1094 {
1095   tcomplain ();
1096 }
1097
1098 static int
1099 delegate_trace_find (struct target_ops *self, enum trace_find_type  arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
1100 {
1101   self = self->beneath;
1102   return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5);
1103 }
1104
1105 static int
1106 tdefault_trace_find (struct target_ops *self, enum trace_find_type  arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
1107 {
1108   return -1;
1109 }
1110
1111 static int
1112 delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
1113 {
1114   self = self->beneath;
1115   return self->to_get_trace_state_variable_value (self, arg1, arg2);
1116 }
1117
1118 static int
1119 tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
1120 {
1121   return 0;
1122 }
1123
1124 static int
1125 delegate_save_trace_data (struct target_ops *self, const char *arg1)
1126 {
1127   self = self->beneath;
1128   return self->to_save_trace_data (self, arg1);
1129 }
1130
1131 static int
1132 tdefault_save_trace_data (struct target_ops *self, const char *arg1)
1133 {
1134   tcomplain ();
1135 }
1136
1137 static int
1138 delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
1139 {
1140   self = self->beneath;
1141   return self->to_upload_tracepoints (self, arg1);
1142 }
1143
1144 static int
1145 tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
1146 {
1147   return 0;
1148 }
1149
1150 static int
1151 delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
1152 {
1153   self = self->beneath;
1154   return self->to_upload_trace_state_variables (self, arg1);
1155 }
1156
1157 static int
1158 tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
1159 {
1160   return 0;
1161 }
1162
1163 static LONGEST
1164 delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
1165 {
1166   self = self->beneath;
1167   return self->to_get_raw_trace_data (self, arg1, arg2, arg3);
1168 }
1169
1170 static LONGEST
1171 tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
1172 {
1173   tcomplain ();
1174 }
1175
1176 static int
1177 delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
1178 {
1179   self = self->beneath;
1180   return self->to_get_min_fast_tracepoint_insn_len (self);
1181 }
1182
1183 static int
1184 tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
1185 {
1186   return -1;
1187 }
1188
1189 static void
1190 delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
1191 {
1192   self = self->beneath;
1193   self->to_set_disconnected_tracing (self, arg1);
1194 }
1195
1196 static void
1197 tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
1198 {
1199 }
1200
1201 static void
1202 delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
1203 {
1204   self = self->beneath;
1205   self->to_set_circular_trace_buffer (self, arg1);
1206 }
1207
1208 static void
1209 tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
1210 {
1211 }
1212
1213 static void
1214 delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
1215 {
1216   self = self->beneath;
1217   self->to_set_trace_buffer_size (self, arg1);
1218 }
1219
1220 static void
1221 tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
1222 {
1223 }
1224
1225 static int
1226 delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
1227 {
1228   self = self->beneath;
1229   return self->to_set_trace_notes (self, arg1, arg2, arg3);
1230 }
1231
1232 static int
1233 tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
1234 {
1235   return 0;
1236 }
1237
1238 static int
1239 delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
1240 {
1241   self = self->beneath;
1242   return self->to_core_of_thread (self, arg1);
1243 }
1244
1245 static int
1246 tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
1247 {
1248   return -1;
1249 }
1250
1251 static int
1252 delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
1253 {
1254   self = self->beneath;
1255   return self->to_verify_memory (self, arg1, arg2, arg3);
1256 }
1257
1258 static int
1259 delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
1260 {
1261   self = self->beneath;
1262   return self->to_get_tib_address (self, arg1, arg2);
1263 }
1264
1265 static int
1266 tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
1267 {
1268   tcomplain ();
1269 }
1270
1271 static void
1272 delegate_set_permissions (struct target_ops *self)
1273 {
1274   self = self->beneath;
1275   self->to_set_permissions (self);
1276 }
1277
1278 static void
1279 tdefault_set_permissions (struct target_ops *self)
1280 {
1281 }
1282
1283 static int
1284 delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
1285 {
1286   self = self->beneath;
1287   return self->to_static_tracepoint_marker_at (self, arg1, arg2);
1288 }
1289
1290 static int
1291 tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
1292 {
1293   return 0;
1294 }
1295
1296 static VEC(static_tracepoint_marker_p) *
1297 delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
1298 {
1299   self = self->beneath;
1300   return self->to_static_tracepoint_markers_by_strid (self, arg1);
1301 }
1302
1303 static VEC(static_tracepoint_marker_p) *
1304 tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
1305 {
1306   tcomplain ();
1307 }
1308
1309 static struct traceframe_info *
1310 delegate_traceframe_info (struct target_ops *self)
1311 {
1312   self = self->beneath;
1313   return self->to_traceframe_info (self);
1314 }
1315
1316 static struct traceframe_info *
1317 tdefault_traceframe_info (struct target_ops *self)
1318 {
1319   tcomplain ();
1320 }
1321
1322 static int
1323 delegate_use_agent (struct target_ops *self, int arg1)
1324 {
1325   self = self->beneath;
1326   return self->to_use_agent (self, arg1);
1327 }
1328
1329 static int
1330 tdefault_use_agent (struct target_ops *self, int arg1)
1331 {
1332   tcomplain ();
1333 }
1334
1335 static int
1336 delegate_can_use_agent (struct target_ops *self)
1337 {
1338   self = self->beneath;
1339   return self->to_can_use_agent (self);
1340 }
1341
1342 static int
1343 tdefault_can_use_agent (struct target_ops *self)
1344 {
1345   return 0;
1346 }
1347
1348 static int
1349 delegate_supports_btrace (struct target_ops *self)
1350 {
1351   self = self->beneath;
1352   return self->to_supports_btrace (self);
1353 }
1354
1355 static int
1356 tdefault_supports_btrace (struct target_ops *self)
1357 {
1358   return 0;
1359 }
1360
1361 static struct btrace_target_info *
1362 delegate_enable_btrace (struct target_ops *self, ptid_t arg1)
1363 {
1364   self = self->beneath;
1365   return self->to_enable_btrace (self, arg1);
1366 }
1367
1368 static struct btrace_target_info *
1369 tdefault_enable_btrace (struct target_ops *self, ptid_t arg1)
1370 {
1371   tcomplain ();
1372 }
1373
1374 static void
1375 delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
1376 {
1377   self = self->beneath;
1378   self->to_disable_btrace (self, arg1);
1379 }
1380
1381 static void
1382 tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
1383 {
1384   tcomplain ();
1385 }
1386
1387 static void
1388 delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
1389 {
1390   self = self->beneath;
1391   self->to_teardown_btrace (self, arg1);
1392 }
1393
1394 static void
1395 tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
1396 {
1397   tcomplain ();
1398 }
1399
1400 static enum btrace_error
1401 delegate_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type  arg3)
1402 {
1403   self = self->beneath;
1404   return self->to_read_btrace (self, arg1, arg2, arg3);
1405 }
1406
1407 static enum btrace_error
1408 tdefault_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type  arg3)
1409 {
1410   tcomplain ();
1411 }
1412
1413 static void
1414 delegate_stop_recording (struct target_ops *self)
1415 {
1416   self = self->beneath;
1417   self->to_stop_recording (self);
1418 }
1419
1420 static void
1421 tdefault_stop_recording (struct target_ops *self)
1422 {
1423 }
1424
1425 static void
1426 delegate_save_record (struct target_ops *self, const char *arg1)
1427 {
1428   self = self->beneath;
1429   self->to_save_record (self, arg1);
1430 }
1431
1432 static void
1433 tdefault_save_record (struct target_ops *self, const char *arg1)
1434 {
1435   tcomplain ();
1436 }
1437
1438 static void
1439 delegate_delete_record (struct target_ops *self)
1440 {
1441   self = self->beneath;
1442   self->to_delete_record (self);
1443 }
1444
1445 static void
1446 tdefault_delete_record (struct target_ops *self)
1447 {
1448   tcomplain ();
1449 }
1450
1451 static int
1452 delegate_record_is_replaying (struct target_ops *self)
1453 {
1454   self = self->beneath;
1455   return self->to_record_is_replaying (self);
1456 }
1457
1458 static int
1459 tdefault_record_is_replaying (struct target_ops *self)
1460 {
1461   return 0;
1462 }
1463
1464 static void
1465 delegate_goto_record_begin (struct target_ops *self)
1466 {
1467   self = self->beneath;
1468   self->to_goto_record_begin (self);
1469 }
1470
1471 static void
1472 tdefault_goto_record_begin (struct target_ops *self)
1473 {
1474   tcomplain ();
1475 }
1476
1477 static void
1478 delegate_goto_record_end (struct target_ops *self)
1479 {
1480   self = self->beneath;
1481   self->to_goto_record_end (self);
1482 }
1483
1484 static void
1485 tdefault_goto_record_end (struct target_ops *self)
1486 {
1487   tcomplain ();
1488 }
1489
1490 static void
1491 delegate_goto_record (struct target_ops *self, ULONGEST arg1)
1492 {
1493   self = self->beneath;
1494   self->to_goto_record (self, arg1);
1495 }
1496
1497 static void
1498 tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
1499 {
1500   tcomplain ();
1501 }
1502
1503 static void
1504 delegate_insn_history (struct target_ops *self, int arg1, int arg2)
1505 {
1506   self = self->beneath;
1507   self->to_insn_history (self, arg1, arg2);
1508 }
1509
1510 static void
1511 tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
1512 {
1513   tcomplain ();
1514 }
1515
1516 static void
1517 delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
1518 {
1519   self = self->beneath;
1520   self->to_insn_history_from (self, arg1, arg2, arg3);
1521 }
1522
1523 static void
1524 tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
1525 {
1526   tcomplain ();
1527 }
1528
1529 static void
1530 delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
1531 {
1532   self = self->beneath;
1533   self->to_insn_history_range (self, arg1, arg2, arg3);
1534 }
1535
1536 static void
1537 tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
1538 {
1539   tcomplain ();
1540 }
1541
1542 static void
1543 delegate_call_history (struct target_ops *self, int arg1, int arg2)
1544 {
1545   self = self->beneath;
1546   self->to_call_history (self, arg1, arg2);
1547 }
1548
1549 static void
1550 tdefault_call_history (struct target_ops *self, int arg1, int arg2)
1551 {
1552   tcomplain ();
1553 }
1554
1555 static void
1556 delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
1557 {
1558   self = self->beneath;
1559   self->to_call_history_from (self, arg1, arg2, arg3);
1560 }
1561
1562 static void
1563 tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
1564 {
1565   tcomplain ();
1566 }
1567
1568 static void
1569 delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
1570 {
1571   self = self->beneath;
1572   self->to_call_history_range (self, arg1, arg2, arg3);
1573 }
1574
1575 static void
1576 tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
1577 {
1578   tcomplain ();
1579 }
1580
1581 static int
1582 delegate_augmented_libraries_svr4_read (struct target_ops *self)
1583 {
1584   self = self->beneath;
1585   return self->to_augmented_libraries_svr4_read (self);
1586 }
1587
1588 static int
1589 tdefault_augmented_libraries_svr4_read (struct target_ops *self)
1590 {
1591   return 0;
1592 }
1593
1594 static const struct frame_unwind *
1595 delegate_get_unwinder (struct target_ops *self)
1596 {
1597   self = self->beneath;
1598   return self->to_get_unwinder (self);
1599 }
1600
1601 static const struct frame_unwind *
1602 tdefault_get_unwinder (struct target_ops *self)
1603 {
1604   return NULL;
1605 }
1606
1607 static const struct frame_unwind *
1608 delegate_get_tailcall_unwinder (struct target_ops *self)
1609 {
1610   self = self->beneath;
1611   return self->to_get_tailcall_unwinder (self);
1612 }
1613
1614 static const struct frame_unwind *
1615 tdefault_get_tailcall_unwinder (struct target_ops *self)
1616 {
1617   return NULL;
1618 }
1619
1620 static CORE_ADDR
1621 delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
1622 {
1623   self = self->beneath;
1624   return self->to_decr_pc_after_break (self, arg1);
1625 }
1626
1627 static void
1628 delegate_prepare_to_generate_core (struct target_ops *self)
1629 {
1630   self = self->beneath;
1631   self->to_prepare_to_generate_core (self);
1632 }
1633
1634 static void
1635 tdefault_prepare_to_generate_core (struct target_ops *self)
1636 {
1637 }
1638
1639 static void
1640 delegate_done_generating_core (struct target_ops *self)
1641 {
1642   self = self->beneath;
1643   self->to_done_generating_core (self);
1644 }
1645
1646 static void
1647 tdefault_done_generating_core (struct target_ops *self)
1648 {
1649 }
1650
1651 static void
1652 install_delegators (struct target_ops *ops)
1653 {
1654   if (ops->to_post_attach == NULL)
1655     ops->to_post_attach = delegate_post_attach;
1656   if (ops->to_detach == NULL)
1657     ops->to_detach = delegate_detach;
1658   if (ops->to_disconnect == NULL)
1659     ops->to_disconnect = delegate_disconnect;
1660   if (ops->to_resume == NULL)
1661     ops->to_resume = delegate_resume;
1662   if (ops->to_wait == NULL)
1663     ops->to_wait = delegate_wait;
1664   if (ops->to_fetch_registers == NULL)
1665     ops->to_fetch_registers = delegate_fetch_registers;
1666   if (ops->to_store_registers == NULL)
1667     ops->to_store_registers = delegate_store_registers;
1668   if (ops->to_prepare_to_store == NULL)
1669     ops->to_prepare_to_store = delegate_prepare_to_store;
1670   if (ops->to_files_info == NULL)
1671     ops->to_files_info = delegate_files_info;
1672   if (ops->to_insert_breakpoint == NULL)
1673     ops->to_insert_breakpoint = delegate_insert_breakpoint;
1674   if (ops->to_remove_breakpoint == NULL)
1675     ops->to_remove_breakpoint = delegate_remove_breakpoint;
1676   if (ops->to_can_use_hw_breakpoint == NULL)
1677     ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint;
1678   if (ops->to_ranged_break_num_registers == NULL)
1679     ops->to_ranged_break_num_registers = delegate_ranged_break_num_registers;
1680   if (ops->to_insert_hw_breakpoint == NULL)
1681     ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint;
1682   if (ops->to_remove_hw_breakpoint == NULL)
1683     ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint;
1684   if (ops->to_remove_watchpoint == NULL)
1685     ops->to_remove_watchpoint = delegate_remove_watchpoint;
1686   if (ops->to_insert_watchpoint == NULL)
1687     ops->to_insert_watchpoint = delegate_insert_watchpoint;
1688   if (ops->to_insert_mask_watchpoint == NULL)
1689     ops->to_insert_mask_watchpoint = delegate_insert_mask_watchpoint;
1690   if (ops->to_remove_mask_watchpoint == NULL)
1691     ops->to_remove_mask_watchpoint = delegate_remove_mask_watchpoint;
1692   if (ops->to_stopped_by_watchpoint == NULL)
1693     ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint;
1694   if (ops->to_stopped_data_address == NULL)
1695     ops->to_stopped_data_address = delegate_stopped_data_address;
1696   if (ops->to_watchpoint_addr_within_range == NULL)
1697     ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range;
1698   if (ops->to_region_ok_for_hw_watchpoint == NULL)
1699     ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint;
1700   if (ops->to_can_accel_watchpoint_condition == NULL)
1701     ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
1702   if (ops->to_masked_watch_num_registers == NULL)
1703     ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers;
1704   if (ops->to_terminal_init == NULL)
1705     ops->to_terminal_init = delegate_terminal_init;
1706   if (ops->to_terminal_inferior == NULL)
1707     ops->to_terminal_inferior = delegate_terminal_inferior;
1708   if (ops->to_terminal_ours_for_output == NULL)
1709     ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
1710   if (ops->to_terminal_ours == NULL)
1711     ops->to_terminal_ours = delegate_terminal_ours;
1712   if (ops->to_terminal_save_ours == NULL)
1713     ops->to_terminal_save_ours = delegate_terminal_save_ours;
1714   if (ops->to_terminal_info == NULL)
1715     ops->to_terminal_info = delegate_terminal_info;
1716   if (ops->to_kill == NULL)
1717     ops->to_kill = delegate_kill;
1718   if (ops->to_load == NULL)
1719     ops->to_load = delegate_load;
1720   if (ops->to_post_startup_inferior == NULL)
1721     ops->to_post_startup_inferior = delegate_post_startup_inferior;
1722   if (ops->to_insert_fork_catchpoint == NULL)
1723     ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint;
1724   if (ops->to_remove_fork_catchpoint == NULL)
1725     ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint;
1726   if (ops->to_insert_vfork_catchpoint == NULL)
1727     ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint;
1728   if (ops->to_remove_vfork_catchpoint == NULL)
1729     ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint;
1730   if (ops->to_follow_fork == NULL)
1731     ops->to_follow_fork = delegate_follow_fork;
1732   if (ops->to_insert_exec_catchpoint == NULL)
1733     ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
1734   if (ops->to_remove_exec_catchpoint == NULL)
1735     ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
1736   if (ops->to_set_syscall_catchpoint == NULL)
1737     ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
1738   if (ops->to_has_exited == NULL)
1739     ops->to_has_exited = delegate_has_exited;
1740   if (ops->to_mourn_inferior == NULL)
1741     ops->to_mourn_inferior = delegate_mourn_inferior;
1742   if (ops->to_can_run == NULL)
1743     ops->to_can_run = delegate_can_run;
1744   if (ops->to_pass_signals == NULL)
1745     ops->to_pass_signals = delegate_pass_signals;
1746   if (ops->to_program_signals == NULL)
1747     ops->to_program_signals = delegate_program_signals;
1748   if (ops->to_thread_alive == NULL)
1749     ops->to_thread_alive = delegate_thread_alive;
1750   if (ops->to_find_new_threads == NULL)
1751     ops->to_find_new_threads = delegate_find_new_threads;
1752   if (ops->to_pid_to_str == NULL)
1753     ops->to_pid_to_str = delegate_pid_to_str;
1754   if (ops->to_extra_thread_info == NULL)
1755     ops->to_extra_thread_info = delegate_extra_thread_info;
1756   if (ops->to_thread_name == NULL)
1757     ops->to_thread_name = delegate_thread_name;
1758   if (ops->to_stop == NULL)
1759     ops->to_stop = delegate_stop;
1760   if (ops->to_rcmd == NULL)
1761     ops->to_rcmd = delegate_rcmd;
1762   if (ops->to_pid_to_exec_file == NULL)
1763     ops->to_pid_to_exec_file = delegate_pid_to_exec_file;
1764   if (ops->to_log_command == NULL)
1765     ops->to_log_command = delegate_log_command;
1766   if (ops->to_get_section_table == NULL)
1767     ops->to_get_section_table = delegate_get_section_table;
1768   if (ops->to_can_async_p == NULL)
1769     ops->to_can_async_p = delegate_can_async_p;
1770   if (ops->to_is_async_p == NULL)
1771     ops->to_is_async_p = delegate_is_async_p;
1772   if (ops->to_async == NULL)
1773     ops->to_async = delegate_async;
1774   if (ops->to_supports_non_stop == NULL)
1775     ops->to_supports_non_stop = delegate_supports_non_stop;
1776   if (ops->to_find_memory_regions == NULL)
1777     ops->to_find_memory_regions = delegate_find_memory_regions;
1778   if (ops->to_make_corefile_notes == NULL)
1779     ops->to_make_corefile_notes = delegate_make_corefile_notes;
1780   if (ops->to_get_bookmark == NULL)
1781     ops->to_get_bookmark = delegate_get_bookmark;
1782   if (ops->to_goto_bookmark == NULL)
1783     ops->to_goto_bookmark = delegate_goto_bookmark;
1784   if (ops->to_xfer_partial == NULL)
1785     ops->to_xfer_partial = delegate_xfer_partial;
1786   if (ops->to_memory_map == NULL)
1787     ops->to_memory_map = delegate_memory_map;
1788   if (ops->to_flash_erase == NULL)
1789     ops->to_flash_erase = delegate_flash_erase;
1790   if (ops->to_flash_done == NULL)
1791     ops->to_flash_done = delegate_flash_done;
1792   if (ops->to_read_description == NULL)
1793     ops->to_read_description = delegate_read_description;
1794   if (ops->to_get_ada_task_ptid == NULL)
1795     ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid;
1796   if (ops->to_auxv_parse == NULL)
1797     ops->to_auxv_parse = delegate_auxv_parse;
1798   if (ops->to_search_memory == NULL)
1799     ops->to_search_memory = delegate_search_memory;
1800   if (ops->to_can_execute_reverse == NULL)
1801     ops->to_can_execute_reverse = delegate_can_execute_reverse;
1802   if (ops->to_execution_direction == NULL)
1803     ops->to_execution_direction = delegate_execution_direction;
1804   if (ops->to_supports_multi_process == NULL)
1805     ops->to_supports_multi_process = delegate_supports_multi_process;
1806   if (ops->to_supports_enable_disable_tracepoint == NULL)
1807     ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint;
1808   if (ops->to_supports_string_tracing == NULL)
1809     ops->to_supports_string_tracing = delegate_supports_string_tracing;
1810   if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL)
1811     ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions;
1812   if (ops->to_can_run_breakpoint_commands == NULL)
1813     ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands;
1814   if (ops->to_thread_architecture == NULL)
1815     ops->to_thread_architecture = delegate_thread_architecture;
1816   if (ops->to_thread_address_space == NULL)
1817     ops->to_thread_address_space = delegate_thread_address_space;
1818   if (ops->to_trace_init == NULL)
1819     ops->to_trace_init = delegate_trace_init;
1820   if (ops->to_download_tracepoint == NULL)
1821     ops->to_download_tracepoint = delegate_download_tracepoint;
1822   if (ops->to_can_download_tracepoint == NULL)
1823     ops->to_can_download_tracepoint = delegate_can_download_tracepoint;
1824   if (ops->to_download_trace_state_variable == NULL)
1825     ops->to_download_trace_state_variable = delegate_download_trace_state_variable;
1826   if (ops->to_enable_tracepoint == NULL)
1827     ops->to_enable_tracepoint = delegate_enable_tracepoint;
1828   if (ops->to_disable_tracepoint == NULL)
1829     ops->to_disable_tracepoint = delegate_disable_tracepoint;
1830   if (ops->to_trace_set_readonly_regions == NULL)
1831     ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions;
1832   if (ops->to_trace_start == NULL)
1833     ops->to_trace_start = delegate_trace_start;
1834   if (ops->to_get_trace_status == NULL)
1835     ops->to_get_trace_status = delegate_get_trace_status;
1836   if (ops->to_get_tracepoint_status == NULL)
1837     ops->to_get_tracepoint_status = delegate_get_tracepoint_status;
1838   if (ops->to_trace_stop == NULL)
1839     ops->to_trace_stop = delegate_trace_stop;
1840   if (ops->to_trace_find == NULL)
1841     ops->to_trace_find = delegate_trace_find;
1842   if (ops->to_get_trace_state_variable_value == NULL)
1843     ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value;
1844   if (ops->to_save_trace_data == NULL)
1845     ops->to_save_trace_data = delegate_save_trace_data;
1846   if (ops->to_upload_tracepoints == NULL)
1847     ops->to_upload_tracepoints = delegate_upload_tracepoints;
1848   if (ops->to_upload_trace_state_variables == NULL)
1849     ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables;
1850   if (ops->to_get_raw_trace_data == NULL)
1851     ops->to_get_raw_trace_data = delegate_get_raw_trace_data;
1852   if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
1853     ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len;
1854   if (ops->to_set_disconnected_tracing == NULL)
1855     ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing;
1856   if (ops->to_set_circular_trace_buffer == NULL)
1857     ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer;
1858   if (ops->to_set_trace_buffer_size == NULL)
1859     ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size;
1860   if (ops->to_set_trace_notes == NULL)
1861     ops->to_set_trace_notes = delegate_set_trace_notes;
1862   if (ops->to_core_of_thread == NULL)
1863     ops->to_core_of_thread = delegate_core_of_thread;
1864   if (ops->to_verify_memory == NULL)
1865     ops->to_verify_memory = delegate_verify_memory;
1866   if (ops->to_get_tib_address == NULL)
1867     ops->to_get_tib_address = delegate_get_tib_address;
1868   if (ops->to_set_permissions == NULL)
1869     ops->to_set_permissions = delegate_set_permissions;
1870   if (ops->to_static_tracepoint_marker_at == NULL)
1871     ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at;
1872   if (ops->to_static_tracepoint_markers_by_strid == NULL)
1873     ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
1874   if (ops->to_traceframe_info == NULL)
1875     ops->to_traceframe_info = delegate_traceframe_info;
1876   if (ops->to_use_agent == NULL)
1877     ops->to_use_agent = delegate_use_agent;
1878   if (ops->to_can_use_agent == NULL)
1879     ops->to_can_use_agent = delegate_can_use_agent;
1880   if (ops->to_supports_btrace == NULL)
1881     ops->to_supports_btrace = delegate_supports_btrace;
1882   if (ops->to_enable_btrace == NULL)
1883     ops->to_enable_btrace = delegate_enable_btrace;
1884   if (ops->to_disable_btrace == NULL)
1885     ops->to_disable_btrace = delegate_disable_btrace;
1886   if (ops->to_teardown_btrace == NULL)
1887     ops->to_teardown_btrace = delegate_teardown_btrace;
1888   if (ops->to_read_btrace == NULL)
1889     ops->to_read_btrace = delegate_read_btrace;
1890   if (ops->to_stop_recording == NULL)
1891     ops->to_stop_recording = delegate_stop_recording;
1892   if (ops->to_save_record == NULL)
1893     ops->to_save_record = delegate_save_record;
1894   if (ops->to_delete_record == NULL)
1895     ops->to_delete_record = delegate_delete_record;
1896   if (ops->to_record_is_replaying == NULL)
1897     ops->to_record_is_replaying = delegate_record_is_replaying;
1898   if (ops->to_goto_record_begin == NULL)
1899     ops->to_goto_record_begin = delegate_goto_record_begin;
1900   if (ops->to_goto_record_end == NULL)
1901     ops->to_goto_record_end = delegate_goto_record_end;
1902   if (ops->to_goto_record == NULL)
1903     ops->to_goto_record = delegate_goto_record;
1904   if (ops->to_insn_history == NULL)
1905     ops->to_insn_history = delegate_insn_history;
1906   if (ops->to_insn_history_from == NULL)
1907     ops->to_insn_history_from = delegate_insn_history_from;
1908   if (ops->to_insn_history_range == NULL)
1909     ops->to_insn_history_range = delegate_insn_history_range;
1910   if (ops->to_call_history == NULL)
1911     ops->to_call_history = delegate_call_history;
1912   if (ops->to_call_history_from == NULL)
1913     ops->to_call_history_from = delegate_call_history_from;
1914   if (ops->to_call_history_range == NULL)
1915     ops->to_call_history_range = delegate_call_history_range;
1916   if (ops->to_augmented_libraries_svr4_read == NULL)
1917     ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read;
1918   if (ops->to_get_unwinder == NULL)
1919     ops->to_get_unwinder = delegate_get_unwinder;
1920   if (ops->to_get_tailcall_unwinder == NULL)
1921     ops->to_get_tailcall_unwinder = delegate_get_tailcall_unwinder;
1922   if (ops->to_decr_pc_after_break == NULL)
1923     ops->to_decr_pc_after_break = delegate_decr_pc_after_break;
1924   if (ops->to_prepare_to_generate_core == NULL)
1925     ops->to_prepare_to_generate_core = delegate_prepare_to_generate_core;
1926   if (ops->to_done_generating_core == NULL)
1927     ops->to_done_generating_core = delegate_done_generating_core;
1928 }
1929
1930 static void
1931 install_dummy_methods (struct target_ops *ops)
1932 {
1933   ops->to_post_attach = tdefault_post_attach;
1934   ops->to_detach = tdefault_detach;
1935   ops->to_disconnect = tdefault_disconnect;
1936   ops->to_resume = tdefault_resume;
1937   ops->to_wait = tdefault_wait;
1938   ops->to_fetch_registers = tdefault_fetch_registers;
1939   ops->to_store_registers = tdefault_store_registers;
1940   ops->to_prepare_to_store = tdefault_prepare_to_store;
1941   ops->to_files_info = tdefault_files_info;
1942   ops->to_insert_breakpoint = memory_insert_breakpoint;
1943   ops->to_remove_breakpoint = memory_remove_breakpoint;
1944   ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint;
1945   ops->to_ranged_break_num_registers = tdefault_ranged_break_num_registers;
1946   ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint;
1947   ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint;
1948   ops->to_remove_watchpoint = tdefault_remove_watchpoint;
1949   ops->to_insert_watchpoint = tdefault_insert_watchpoint;
1950   ops->to_insert_mask_watchpoint = tdefault_insert_mask_watchpoint;
1951   ops->to_remove_mask_watchpoint = tdefault_remove_mask_watchpoint;
1952   ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint;
1953   ops->to_stopped_data_address = tdefault_stopped_data_address;
1954   ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range;
1955   ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
1956   ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
1957   ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers;
1958   ops->to_terminal_init = tdefault_terminal_init;
1959   ops->to_terminal_inferior = tdefault_terminal_inferior;
1960   ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
1961   ops->to_terminal_ours = tdefault_terminal_ours;
1962   ops->to_terminal_save_ours = tdefault_terminal_save_ours;
1963   ops->to_terminal_info = default_terminal_info;
1964   ops->to_kill = tdefault_kill;
1965   ops->to_load = tdefault_load;
1966   ops->to_post_startup_inferior = tdefault_post_startup_inferior;
1967   ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint;
1968   ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint;
1969   ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint;
1970   ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint;
1971   ops->to_follow_fork = default_follow_fork;
1972   ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
1973   ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
1974   ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
1975   ops->to_has_exited = tdefault_has_exited;
1976   ops->to_mourn_inferior = default_mourn_inferior;
1977   ops->to_can_run = tdefault_can_run;
1978   ops->to_pass_signals = tdefault_pass_signals;
1979   ops->to_program_signals = tdefault_program_signals;
1980   ops->to_thread_alive = tdefault_thread_alive;
1981   ops->to_find_new_threads = tdefault_find_new_threads;
1982   ops->to_pid_to_str = default_pid_to_str;
1983   ops->to_extra_thread_info = tdefault_extra_thread_info;
1984   ops->to_thread_name = tdefault_thread_name;
1985   ops->to_stop = tdefault_stop;
1986   ops->to_rcmd = default_rcmd;
1987   ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
1988   ops->to_log_command = tdefault_log_command;
1989   ops->to_get_section_table = tdefault_get_section_table;
1990   ops->to_can_async_p = tdefault_can_async_p;
1991   ops->to_is_async_p = tdefault_is_async_p;
1992   ops->to_async = tdefault_async;
1993   ops->to_supports_non_stop = tdefault_supports_non_stop;
1994   ops->to_find_memory_regions = dummy_find_memory_regions;
1995   ops->to_make_corefile_notes = dummy_make_corefile_notes;
1996   ops->to_get_bookmark = tdefault_get_bookmark;
1997   ops->to_goto_bookmark = tdefault_goto_bookmark;
1998   ops->to_xfer_partial = tdefault_xfer_partial;
1999   ops->to_memory_map = tdefault_memory_map;
2000   ops->to_flash_erase = tdefault_flash_erase;
2001   ops->to_flash_done = tdefault_flash_done;
2002   ops->to_read_description = tdefault_read_description;
2003   ops->to_get_ada_task_ptid = default_get_ada_task_ptid;
2004   ops->to_auxv_parse = default_auxv_parse;
2005   ops->to_search_memory = default_search_memory;
2006   ops->to_can_execute_reverse = tdefault_can_execute_reverse;
2007   ops->to_execution_direction = default_execution_direction;
2008   ops->to_supports_multi_process = tdefault_supports_multi_process;
2009   ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint;
2010   ops->to_supports_string_tracing = tdefault_supports_string_tracing;
2011   ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions;
2012   ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands;
2013   ops->to_thread_architecture = default_thread_architecture;
2014   ops->to_thread_address_space = default_thread_address_space;
2015   ops->to_trace_init = tdefault_trace_init;
2016   ops->to_download_tracepoint = tdefault_download_tracepoint;
2017   ops->to_can_download_tracepoint = tdefault_can_download_tracepoint;
2018   ops->to_download_trace_state_variable = tdefault_download_trace_state_variable;
2019   ops->to_enable_tracepoint = tdefault_enable_tracepoint;
2020   ops->to_disable_tracepoint = tdefault_disable_tracepoint;
2021   ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions;
2022   ops->to_trace_start = tdefault_trace_start;
2023   ops->to_get_trace_status = tdefault_get_trace_status;
2024   ops->to_get_tracepoint_status = tdefault_get_tracepoint_status;
2025   ops->to_trace_stop = tdefault_trace_stop;
2026   ops->to_trace_find = tdefault_trace_find;
2027   ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value;
2028   ops->to_save_trace_data = tdefault_save_trace_data;
2029   ops->to_upload_tracepoints = tdefault_upload_tracepoints;
2030   ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables;
2031   ops->to_get_raw_trace_data = tdefault_get_raw_trace_data;
2032   ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len;
2033   ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing;
2034   ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer;
2035   ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size;
2036   ops->to_set_trace_notes = tdefault_set_trace_notes;
2037   ops->to_core_of_thread = tdefault_core_of_thread;
2038   ops->to_verify_memory = default_verify_memory;
2039   ops->to_get_tib_address = tdefault_get_tib_address;
2040   ops->to_set_permissions = tdefault_set_permissions;
2041   ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at;
2042   ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
2043   ops->to_traceframe_info = tdefault_traceframe_info;
2044   ops->to_use_agent = tdefault_use_agent;
2045   ops->to_can_use_agent = tdefault_can_use_agent;
2046   ops->to_supports_btrace = tdefault_supports_btrace;
2047   ops->to_enable_btrace = tdefault_enable_btrace;
2048   ops->to_disable_btrace = tdefault_disable_btrace;
2049   ops->to_teardown_btrace = tdefault_teardown_btrace;
2050   ops->to_read_btrace = tdefault_read_btrace;
2051   ops->to_stop_recording = tdefault_stop_recording;
2052   ops->to_save_record = tdefault_save_record;
2053   ops->to_delete_record = tdefault_delete_record;
2054   ops->to_record_is_replaying = tdefault_record_is_replaying;
2055   ops->to_goto_record_begin = tdefault_goto_record_begin;
2056   ops->to_goto_record_end = tdefault_goto_record_end;
2057   ops->to_goto_record = tdefault_goto_record;
2058   ops->to_insn_history = tdefault_insn_history;
2059   ops->to_insn_history_from = tdefault_insn_history_from;
2060   ops->to_insn_history_range = tdefault_insn_history_range;
2061   ops->to_call_history = tdefault_call_history;
2062   ops->to_call_history_from = tdefault_call_history_from;
2063   ops->to_call_history_range = tdefault_call_history_range;
2064   ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read;
2065   ops->to_get_unwinder = tdefault_get_unwinder;
2066   ops->to_get_tailcall_unwinder = tdefault_get_tailcall_unwinder;
2067   ops->to_decr_pc_after_break = default_target_decr_pc_after_break;
2068   ops->to_prepare_to_generate_core = tdefault_prepare_to_generate_core;
2069   ops->to_done_generating_core = tdefault_done_generating_core;
2070 }