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, 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, 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, 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, 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, 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, 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, char *arg1, int arg2)
 753 {
 754   tcomplain ();
 755 }
 756
 757 static void
 758 delegate_goto_bookmark (struct target_ops *self, 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, 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 void
 949 delegate_trace_init (struct target_ops *self)
 950 {
 951   self = self->beneath;
 952   self->to_trace_init (self);
 953 }
 954
 955 static void
 956 tdefault_trace_init (struct target_ops *self)
 957 {
 958   tcomplain ();
 959 }
 960
 961 static void
 962 delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
 963 {
 964   self = self->beneath;
 965   self->to_download_tracepoint (self, arg1);
 966 }
 967
 968 static void
 969 tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
 970 {
 971   tcomplain ();
 972 }
 973
 974 static int
 975 delegate_can_download_tracepoint (struct target_ops *self)
 976 {
 977   self = self->beneath;
 978   return self->to_can_download_tracepoint (self);
 979 }
 980
 981 static int
 982 tdefault_can_download_tracepoint (struct target_ops *self)
 983 {
 984   return 0;
 985 }
 986
 987 static void
 988 delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
 989 {
 990   self = self->beneath;
 991   self->to_download_trace_state_variable (self, arg1);
 992 }
 993
 994 static void
 995 tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
 996 {
 997   tcomplain ();
 998 }
 999
1000 static void
1001 delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
1002 {
1003   self = self->beneath;
1004   self->to_enable_tracepoint (self, arg1);
1005 }
1006
1007 static void
1008 tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
1009 {
1010   tcomplain ();
1011 }
1012
1013 static void
1014 delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
1015 {
1016   self = self->beneath;
1017   self->to_disable_tracepoint (self, arg1);
1018 }
1019
1020 static void
1021 tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
1022 {
1023   tcomplain ();
1024 }
1025
1026 static void
1027 delegate_trace_set_readonly_regions (struct target_ops *self)
1028 {
1029   self = self->beneath;
1030   self->to_trace_set_readonly_regions (self);
1031 }
1032
1033 static void
1034 tdefault_trace_set_readonly_regions (struct target_ops *self)
1035 {
1036   tcomplain ();
1037 }
1038
1039 static void
1040 delegate_trace_start (struct target_ops *self)
1041 {
1042   self = self->beneath;
1043   self->to_trace_start (self);
1044 }
1045
1046 static void
1047 tdefault_trace_start (struct target_ops *self)
1048 {
1049   tcomplain ();
1050 }
1051
1052 static int
1053 delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
1054 {
1055   self = self->beneath;
1056   return self->to_get_trace_status (self, arg1);
1057 }
1058
1059 static int
1060 tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
1061 {
1062   return -1;
1063 }
1064
1065 static void
1066 delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
1067 {
1068   self = self->beneath;
1069   self->to_get_tracepoint_status (self, arg1, arg2);
1070 }
1071
1072 static void
1073 tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
1074 {
1075   tcomplain ();
1076 }
1077
1078 static void
1079 delegate_trace_stop (struct target_ops *self)
1080 {
1081   self = self->beneath;
1082   self->to_trace_stop (self);
1083 }
1084
1085 static void
1086 tdefault_trace_stop (struct target_ops *self)
1087 {
1088   tcomplain ();
1089 }
1090
1091 static int
1092 delegate_trace_find (struct target_ops *self, enum trace_find_type  arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
1093 {
1094   self = self->beneath;
1095   return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5);
1096 }
1097
1098 static int
1099 tdefault_trace_find (struct target_ops *self, enum trace_find_type  arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
1100 {
1101   return -1;
1102 }
1103
1104 static int
1105 delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
1106 {
1107   self = self->beneath;
1108   return self->to_get_trace_state_variable_value (self, arg1, arg2);
1109 }
1110
1111 static int
1112 tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
1113 {
1114   return 0;
1115 }
1116
1117 static int
1118 delegate_save_trace_data (struct target_ops *self, const char *arg1)
1119 {
1120   self = self->beneath;
1121   return self->to_save_trace_data (self, arg1);
1122 }
1123
1124 static int
1125 tdefault_save_trace_data (struct target_ops *self, const char *arg1)
1126 {
1127   tcomplain ();
1128 }
1129
1130 static int
1131 delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
1132 {
1133   self = self->beneath;
1134   return self->to_upload_tracepoints (self, arg1);
1135 }
1136
1137 static int
1138 tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
1139 {
1140   return 0;
1141 }
1142
1143 static int
1144 delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
1145 {
1146   self = self->beneath;
1147   return self->to_upload_trace_state_variables (self, arg1);
1148 }
1149
1150 static int
1151 tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
1152 {
1153   return 0;
1154 }
1155
1156 static LONGEST
1157 delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
1158 {
1159   self = self->beneath;
1160   return self->to_get_raw_trace_data (self, arg1, arg2, arg3);
1161 }
1162
1163 static LONGEST
1164 tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
1165 {
1166   tcomplain ();
1167 }
1168
1169 static int
1170 delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
1171 {
1172   self = self->beneath;
1173   return self->to_get_min_fast_tracepoint_insn_len (self);
1174 }
1175
1176 static int
1177 tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
1178 {
1179   return -1;
1180 }
1181
1182 static void
1183 delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
1184 {
1185   self = self->beneath;
1186   self->to_set_disconnected_tracing (self, arg1);
1187 }
1188
1189 static void
1190 tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
1191 {
1192 }
1193
1194 static void
1195 delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
1196 {
1197   self = self->beneath;
1198   self->to_set_circular_trace_buffer (self, arg1);
1199 }
1200
1201 static void
1202 tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
1203 {
1204 }
1205
1206 static void
1207 delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
1208 {
1209   self = self->beneath;
1210   self->to_set_trace_buffer_size (self, arg1);
1211 }
1212
1213 static void
1214 tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
1215 {
1216 }
1217
1218 static int
1219 delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
1220 {
1221   self = self->beneath;
1222   return self->to_set_trace_notes (self, arg1, arg2, arg3);
1223 }
1224
1225 static int
1226 tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
1227 {
1228   return 0;
1229 }
1230
1231 static int
1232 delegate_core_of_thread (struct target_ops *self, ptid_t arg1)
1233 {
1234   self = self->beneath;
1235   return self->to_core_of_thread (self, arg1);
1236 }
1237
1238 static int
1239 tdefault_core_of_thread (struct target_ops *self, ptid_t arg1)
1240 {
1241   return -1;
1242 }
1243
1244 static int
1245 delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
1246 {
1247   self = self->beneath;
1248   return self->to_verify_memory (self, arg1, arg2, arg3);
1249 }
1250
1251 static int
1252 tdefault_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3)
1253 {
1254   tcomplain ();
1255 }
1256
1257 static int
1258 delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
1259 {
1260   self = self->beneath;
1261   return self->to_get_tib_address (self, arg1, arg2);
1262 }
1263
1264 static int
1265 tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
1266 {
1267   tcomplain ();
1268 }
1269
1270 static void
1271 delegate_set_permissions (struct target_ops *self)
1272 {
1273   self = self->beneath;
1274   self->to_set_permissions (self);
1275 }
1276
1277 static void
1278 tdefault_set_permissions (struct target_ops *self)
1279 {
1280 }
1281
1282 static int
1283 delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
1284 {
1285   self = self->beneath;
1286   return self->to_static_tracepoint_marker_at (self, arg1, arg2);
1287 }
1288
1289 static int
1290 tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
1291 {
1292   return 0;
1293 }
1294
1295 static VEC(static_tracepoint_marker_p) *
1296 delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
1297 {
1298   self = self->beneath;
1299   return self->to_static_tracepoint_markers_by_strid (self, arg1);
1300 }
1301
1302 static VEC(static_tracepoint_marker_p) *
1303 tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
1304 {
1305   tcomplain ();
1306 }
1307
1308 static struct traceframe_info *
1309 delegate_traceframe_info (struct target_ops *self)
1310 {
1311   self = self->beneath;
1312   return self->to_traceframe_info (self);
1313 }
1314
1315 static struct traceframe_info *
1316 tdefault_traceframe_info (struct target_ops *self)
1317 {
1318   tcomplain ();
1319 }
1320
1321 static int
1322 delegate_use_agent (struct target_ops *self, int arg1)
1323 {
1324   self = self->beneath;
1325   return self->to_use_agent (self, arg1);
1326 }
1327
1328 static int
1329 tdefault_use_agent (struct target_ops *self, int arg1)
1330 {
1331   tcomplain ();
1332 }
1333
1334 static int
1335 delegate_can_use_agent (struct target_ops *self)
1336 {
1337   self = self->beneath;
1338   return self->to_can_use_agent (self);
1339 }
1340
1341 static int
1342 tdefault_can_use_agent (struct target_ops *self)
1343 {
1344   return 0;
1345 }
1346
1347 static int
1348 delegate_supports_btrace (struct target_ops *self)
1349 {
1350   self = self->beneath;
1351   return self->to_supports_btrace (self);
1352 }
1353
1354 static int
1355 tdefault_supports_btrace (struct target_ops *self)
1356 {
1357   return 0;
1358 }
1359
1360 static struct btrace_target_info *
1361 delegate_enable_btrace (struct target_ops *self, ptid_t arg1)
1362 {
1363   self = self->beneath;
1364   return self->to_enable_btrace (self, arg1);
1365 }
1366
1367 static struct btrace_target_info *
1368 tdefault_enable_btrace (struct target_ops *self, ptid_t arg1)
1369 {
1370   tcomplain ();
1371 }
1372
1373 static void
1374 delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
1375 {
1376   self = self->beneath;
1377   self->to_disable_btrace (self, arg1);
1378 }
1379
1380 static void
1381 tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1)
1382 {
1383   tcomplain ();
1384 }
1385
1386 static void
1387 delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
1388 {
1389   self = self->beneath;
1390   self->to_teardown_btrace (self, arg1);
1391 }
1392
1393 static void
1394 tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1)
1395 {
1396   tcomplain ();
1397 }
1398
1399 static enum btrace_error
1400 delegate_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type  arg3)
1401 {
1402   self = self->beneath;
1403   return self->to_read_btrace (self, arg1, arg2, arg3);
1404 }
1405
1406 static enum btrace_error
1407 tdefault_read_btrace (struct target_ops *self, VEC (btrace_block_s) **arg1, struct btrace_target_info *arg2, enum btrace_read_type  arg3)
1408 {
1409   tcomplain ();
1410 }
1411
1412 static void
1413 delegate_stop_recording (struct target_ops *self)
1414 {
1415   self = self->beneath;
1416   self->to_stop_recording (self);
1417 }
1418
1419 static void
1420 tdefault_stop_recording (struct target_ops *self)
1421 {
1422 }
1423
1424 static void
1425 delegate_save_record (struct target_ops *self, const char *arg1)
1426 {
1427   self = self->beneath;
1428   self->to_save_record (self, arg1);
1429 }
1430
1431 static void
1432 tdefault_save_record (struct target_ops *self, const char *arg1)
1433 {
1434   tcomplain ();
1435 }
1436
1437 static void
1438 delegate_delete_record (struct target_ops *self)
1439 {
1440   self = self->beneath;
1441   self->to_delete_record (self);
1442 }
1443
1444 static void
1445 tdefault_delete_record (struct target_ops *self)
1446 {
1447   tcomplain ();
1448 }
1449
1450 static int
1451 delegate_record_is_replaying (struct target_ops *self)
1452 {
1453   self = self->beneath;
1454   return self->to_record_is_replaying (self);
1455 }
1456
1457 static int
1458 tdefault_record_is_replaying (struct target_ops *self)
1459 {
1460   return 0;
1461 }
1462
1463 static void
1464 delegate_goto_record_begin (struct target_ops *self)
1465 {
1466   self = self->beneath;
1467   self->to_goto_record_begin (self);
1468 }
1469
1470 static void
1471 tdefault_goto_record_begin (struct target_ops *self)
1472 {
1473   tcomplain ();
1474 }
1475
1476 static void
1477 delegate_goto_record_end (struct target_ops *self)
1478 {
1479   self = self->beneath;
1480   self->to_goto_record_end (self);
1481 }
1482
1483 static void
1484 tdefault_goto_record_end (struct target_ops *self)
1485 {
1486   tcomplain ();
1487 }
1488
1489 static void
1490 delegate_goto_record (struct target_ops *self, ULONGEST arg1)
1491 {
1492   self = self->beneath;
1493   self->to_goto_record (self, arg1);
1494 }
1495
1496 static void
1497 tdefault_goto_record (struct target_ops *self, ULONGEST arg1)
1498 {
1499   tcomplain ();
1500 }
1501
1502 static void
1503 delegate_insn_history (struct target_ops *self, int arg1, int arg2)
1504 {
1505   self = self->beneath;
1506   self->to_insn_history (self, arg1, arg2);
1507 }
1508
1509 static void
1510 tdefault_insn_history (struct target_ops *self, int arg1, int arg2)
1511 {
1512   tcomplain ();
1513 }
1514
1515 static void
1516 delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
1517 {
1518   self = self->beneath;
1519   self->to_insn_history_from (self, arg1, arg2, arg3);
1520 }
1521
1522 static void
1523 tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
1524 {
1525   tcomplain ();
1526 }
1527
1528 static void
1529 delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
1530 {
1531   self = self->beneath;
1532   self->to_insn_history_range (self, arg1, arg2, arg3);
1533 }
1534
1535 static void
1536 tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
1537 {
1538   tcomplain ();
1539 }
1540
1541 static void
1542 delegate_call_history (struct target_ops *self, int arg1, int arg2)
1543 {
1544   self = self->beneath;
1545   self->to_call_history (self, arg1, arg2);
1546 }
1547
1548 static void
1549 tdefault_call_history (struct target_ops *self, int arg1, int arg2)
1550 {
1551   tcomplain ();
1552 }
1553
1554 static void
1555 delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
1556 {
1557   self = self->beneath;
1558   self->to_call_history_from (self, arg1, arg2, arg3);
1559 }
1560
1561 static void
1562 tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3)
1563 {
1564   tcomplain ();
1565 }
1566
1567 static void
1568 delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
1569 {
1570   self = self->beneath;
1571   self->to_call_history_range (self, arg1, arg2, arg3);
1572 }
1573
1574 static void
1575 tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3)
1576 {
1577   tcomplain ();
1578 }
1579
1580 static int
1581 delegate_augmented_libraries_svr4_read (struct target_ops *self)
1582 {
1583   self = self->beneath;
1584   return self->to_augmented_libraries_svr4_read (self);
1585 }
1586
1587 static int
1588 tdefault_augmented_libraries_svr4_read (struct target_ops *self)
1589 {
1590   return 0;
1591 }
1592
1593 static const struct frame_unwind *
1594 delegate_get_unwinder (struct target_ops *self)
1595 {
1596   self = self->beneath;
1597   return self->to_get_unwinder (self);
1598 }
1599
1600 static const struct frame_unwind *
1601 tdefault_get_unwinder (struct target_ops *self)
1602 {
1603   return NULL;
1604 }
1605
1606 static const struct frame_unwind *
1607 delegate_get_tailcall_unwinder (struct target_ops *self)
1608 {
1609   self = self->beneath;
1610   return self->to_get_tailcall_unwinder (self);
1611 }
1612
1613 static const struct frame_unwind *
1614 tdefault_get_tailcall_unwinder (struct target_ops *self)
1615 {
1616   return NULL;
1617 }
1618
1619 static CORE_ADDR
1620 delegate_decr_pc_after_break (struct target_ops *self, struct gdbarch *arg1)
1621 {
1622   self = self->beneath;
1623   return self->to_decr_pc_after_break (self, arg1);
1624 }
1625
1626 static void
1627 install_delegators (struct target_ops *ops)
1628 {
1629   if (ops->to_post_attach == NULL)
1630     ops->to_post_attach = delegate_post_attach;
1631   if (ops->to_detach == NULL)
1632     ops->to_detach = delegate_detach;
1633   if (ops->to_disconnect == NULL)
1634     ops->to_disconnect = delegate_disconnect;
1635   if (ops->to_resume == NULL)
1636     ops->to_resume = delegate_resume;
1637   if (ops->to_wait == NULL)
1638     ops->to_wait = delegate_wait;
1639   if (ops->to_fetch_registers == NULL)
1640     ops->to_fetch_registers = delegate_fetch_registers;
1641   if (ops->to_store_registers == NULL)
1642     ops->to_store_registers = delegate_store_registers;
1643   if (ops->to_prepare_to_store == NULL)
1644     ops->to_prepare_to_store = delegate_prepare_to_store;
1645   if (ops->to_files_info == NULL)
1646     ops->to_files_info = delegate_files_info;
1647   if (ops->to_insert_breakpoint == NULL)
1648     ops->to_insert_breakpoint = delegate_insert_breakpoint;
1649   if (ops->to_remove_breakpoint == NULL)
1650     ops->to_remove_breakpoint = delegate_remove_breakpoint;
1651   if (ops->to_can_use_hw_breakpoint == NULL)
1652     ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint;
1653   if (ops->to_ranged_break_num_registers == NULL)
1654     ops->to_ranged_break_num_registers = delegate_ranged_break_num_registers;
1655   if (ops->to_insert_hw_breakpoint == NULL)
1656     ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint;
1657   if (ops->to_remove_hw_breakpoint == NULL)
1658     ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint;
1659   if (ops->to_remove_watchpoint == NULL)
1660     ops->to_remove_watchpoint = delegate_remove_watchpoint;
1661   if (ops->to_insert_watchpoint == NULL)
1662     ops->to_insert_watchpoint = delegate_insert_watchpoint;
1663   if (ops->to_insert_mask_watchpoint == NULL)
1664     ops->to_insert_mask_watchpoint = delegate_insert_mask_watchpoint;
1665   if (ops->to_remove_mask_watchpoint == NULL)
1666     ops->to_remove_mask_watchpoint = delegate_remove_mask_watchpoint;
1667   if (ops->to_stopped_by_watchpoint == NULL)
1668     ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint;
1669   if (ops->to_stopped_data_address == NULL)
1670     ops->to_stopped_data_address = delegate_stopped_data_address;
1671   if (ops->to_watchpoint_addr_within_range == NULL)
1672     ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range;
1673   if (ops->to_region_ok_for_hw_watchpoint == NULL)
1674     ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint;
1675   if (ops->to_can_accel_watchpoint_condition == NULL)
1676     ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
1677   if (ops->to_masked_watch_num_registers == NULL)
1678     ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers;
1679   if (ops->to_terminal_init == NULL)
1680     ops->to_terminal_init = delegate_terminal_init;
1681   if (ops->to_terminal_inferior == NULL)
1682     ops->to_terminal_inferior = delegate_terminal_inferior;
1683   if (ops->to_terminal_ours_for_output == NULL)
1684     ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
1685   if (ops->to_terminal_ours == NULL)
1686     ops->to_terminal_ours = delegate_terminal_ours;
1687   if (ops->to_terminal_save_ours == NULL)
1688     ops->to_terminal_save_ours = delegate_terminal_save_ours;
1689   if (ops->to_terminal_info == NULL)
1690     ops->to_terminal_info = delegate_terminal_info;
1691   if (ops->to_kill == NULL)
1692     ops->to_kill = delegate_kill;
1693   if (ops->to_load == NULL)
1694     ops->to_load = delegate_load;
1695   if (ops->to_post_startup_inferior == NULL)
1696     ops->to_post_startup_inferior = delegate_post_startup_inferior;
1697   if (ops->to_insert_fork_catchpoint == NULL)
1698     ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint;
1699   if (ops->to_remove_fork_catchpoint == NULL)
1700     ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint;
1701   if (ops->to_insert_vfork_catchpoint == NULL)
1702     ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint;
1703   if (ops->to_remove_vfork_catchpoint == NULL)
1704     ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint;
1705   if (ops->to_follow_fork == NULL)
1706     ops->to_follow_fork = delegate_follow_fork;
1707   if (ops->to_insert_exec_catchpoint == NULL)
1708     ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
1709   if (ops->to_remove_exec_catchpoint == NULL)
1710     ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
1711   if (ops->to_set_syscall_catchpoint == NULL)
1712     ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
1713   if (ops->to_has_exited == NULL)
1714     ops->to_has_exited = delegate_has_exited;
1715   if (ops->to_mourn_inferior == NULL)
1716     ops->to_mourn_inferior = delegate_mourn_inferior;
1717   if (ops->to_can_run == NULL)
1718     ops->to_can_run = delegate_can_run;
1719   if (ops->to_pass_signals == NULL)
1720     ops->to_pass_signals = delegate_pass_signals;
1721   if (ops->to_program_signals == NULL)
1722     ops->to_program_signals = delegate_program_signals;
1723   if (ops->to_thread_alive == NULL)
1724     ops->to_thread_alive = delegate_thread_alive;
1725   if (ops->to_find_new_threads == NULL)
1726     ops->to_find_new_threads = delegate_find_new_threads;
1727   if (ops->to_pid_to_str == NULL)
1728     ops->to_pid_to_str = delegate_pid_to_str;
1729   if (ops->to_extra_thread_info == NULL)
1730     ops->to_extra_thread_info = delegate_extra_thread_info;
1731   if (ops->to_thread_name == NULL)
1732     ops->to_thread_name = delegate_thread_name;
1733   if (ops->to_stop == NULL)
1734     ops->to_stop = delegate_stop;
1735   if (ops->to_rcmd == NULL)
1736     ops->to_rcmd = delegate_rcmd;
1737   if (ops->to_pid_to_exec_file == NULL)
1738     ops->to_pid_to_exec_file = delegate_pid_to_exec_file;
1739   if (ops->to_log_command == NULL)
1740     ops->to_log_command = delegate_log_command;
1741   if (ops->to_get_section_table == NULL)
1742     ops->to_get_section_table = delegate_get_section_table;
1743   if (ops->to_can_async_p == NULL)
1744     ops->to_can_async_p = delegate_can_async_p;
1745   if (ops->to_is_async_p == NULL)
1746     ops->to_is_async_p = delegate_is_async_p;
1747   if (ops->to_async == NULL)
1748     ops->to_async = delegate_async;
1749   if (ops->to_supports_non_stop == NULL)
1750     ops->to_supports_non_stop = delegate_supports_non_stop;
1751   if (ops->to_find_memory_regions == NULL)
1752     ops->to_find_memory_regions = delegate_find_memory_regions;
1753   if (ops->to_make_corefile_notes == NULL)
1754     ops->to_make_corefile_notes = delegate_make_corefile_notes;
1755   if (ops->to_get_bookmark == NULL)
1756     ops->to_get_bookmark = delegate_get_bookmark;
1757   if (ops->to_goto_bookmark == NULL)
1758     ops->to_goto_bookmark = delegate_goto_bookmark;
1759   if (ops->to_xfer_partial == NULL)
1760     ops->to_xfer_partial = delegate_xfer_partial;
1761   if (ops->to_memory_map == NULL)
1762     ops->to_memory_map = delegate_memory_map;
1763   if (ops->to_flash_erase == NULL)
1764     ops->to_flash_erase = delegate_flash_erase;
1765   if (ops->to_flash_done == NULL)
1766     ops->to_flash_done = delegate_flash_done;
1767   if (ops->to_read_description == NULL)
1768     ops->to_read_description = delegate_read_description;
1769   if (ops->to_get_ada_task_ptid == NULL)
1770     ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid;
1771   if (ops->to_auxv_parse == NULL)
1772     ops->to_auxv_parse = delegate_auxv_parse;
1773   if (ops->to_search_memory == NULL)
1774     ops->to_search_memory = delegate_search_memory;
1775   if (ops->to_can_execute_reverse == NULL)
1776     ops->to_can_execute_reverse = delegate_can_execute_reverse;
1777   if (ops->to_execution_direction == NULL)
1778     ops->to_execution_direction = delegate_execution_direction;
1779   if (ops->to_supports_multi_process == NULL)
1780     ops->to_supports_multi_process = delegate_supports_multi_process;
1781   if (ops->to_supports_enable_disable_tracepoint == NULL)
1782     ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint;
1783   if (ops->to_supports_string_tracing == NULL)
1784     ops->to_supports_string_tracing = delegate_supports_string_tracing;
1785   if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL)
1786     ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions;
1787   if (ops->to_can_run_breakpoint_commands == NULL)
1788     ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands;
1789   if (ops->to_thread_architecture == NULL)
1790     ops->to_thread_architecture = delegate_thread_architecture;
1791   if (ops->to_trace_init == NULL)
1792     ops->to_trace_init = delegate_trace_init;
1793   if (ops->to_download_tracepoint == NULL)
1794     ops->to_download_tracepoint = delegate_download_tracepoint;
1795   if (ops->to_can_download_tracepoint == NULL)
1796     ops->to_can_download_tracepoint = delegate_can_download_tracepoint;
1797   if (ops->to_download_trace_state_variable == NULL)
1798     ops->to_download_trace_state_variable = delegate_download_trace_state_variable;
1799   if (ops->to_enable_tracepoint == NULL)
1800     ops->to_enable_tracepoint = delegate_enable_tracepoint;
1801   if (ops->to_disable_tracepoint == NULL)
1802     ops->to_disable_tracepoint = delegate_disable_tracepoint;
1803   if (ops->to_trace_set_readonly_regions == NULL)
1804     ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions;
1805   if (ops->to_trace_start == NULL)
1806     ops->to_trace_start = delegate_trace_start;
1807   if (ops->to_get_trace_status == NULL)
1808     ops->to_get_trace_status = delegate_get_trace_status;
1809   if (ops->to_get_tracepoint_status == NULL)
1810     ops->to_get_tracepoint_status = delegate_get_tracepoint_status;
1811   if (ops->to_trace_stop == NULL)
1812     ops->to_trace_stop = delegate_trace_stop;
1813   if (ops->to_trace_find == NULL)
1814     ops->to_trace_find = delegate_trace_find;
1815   if (ops->to_get_trace_state_variable_value == NULL)
1816     ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value;
1817   if (ops->to_save_trace_data == NULL)
1818     ops->to_save_trace_data = delegate_save_trace_data;
1819   if (ops->to_upload_tracepoints == NULL)
1820     ops->to_upload_tracepoints = delegate_upload_tracepoints;
1821   if (ops->to_upload_trace_state_variables == NULL)
1822     ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables;
1823   if (ops->to_get_raw_trace_data == NULL)
1824     ops->to_get_raw_trace_data = delegate_get_raw_trace_data;
1825   if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
1826     ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len;
1827   if (ops->to_set_disconnected_tracing == NULL)
1828     ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing;
1829   if (ops->to_set_circular_trace_buffer == NULL)
1830     ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer;
1831   if (ops->to_set_trace_buffer_size == NULL)
1832     ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size;
1833   if (ops->to_set_trace_notes == NULL)
1834     ops->to_set_trace_notes = delegate_set_trace_notes;
1835   if (ops->to_core_of_thread == NULL)
1836     ops->to_core_of_thread = delegate_core_of_thread;
1837   if (ops->to_verify_memory == NULL)
1838     ops->to_verify_memory = delegate_verify_memory;
1839   if (ops->to_get_tib_address == NULL)
1840     ops->to_get_tib_address = delegate_get_tib_address;
1841   if (ops->to_set_permissions == NULL)
1842     ops->to_set_permissions = delegate_set_permissions;
1843   if (ops->to_static_tracepoint_marker_at == NULL)
1844     ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at;
1845   if (ops->to_static_tracepoint_markers_by_strid == NULL)
1846     ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
1847   if (ops->to_traceframe_info == NULL)
1848     ops->to_traceframe_info = delegate_traceframe_info;
1849   if (ops->to_use_agent == NULL)
1850     ops->to_use_agent = delegate_use_agent;
1851   if (ops->to_can_use_agent == NULL)
1852     ops->to_can_use_agent = delegate_can_use_agent;
1853   if (ops->to_supports_btrace == NULL)
1854     ops->to_supports_btrace = delegate_supports_btrace;
1855   if (ops->to_enable_btrace == NULL)
1856     ops->to_enable_btrace = delegate_enable_btrace;
1857   if (ops->to_disable_btrace == NULL)
1858     ops->to_disable_btrace = delegate_disable_btrace;
1859   if (ops->to_teardown_btrace == NULL)
1860     ops->to_teardown_btrace = delegate_teardown_btrace;
1861   if (ops->to_read_btrace == NULL)
1862     ops->to_read_btrace = delegate_read_btrace;
1863   if (ops->to_stop_recording == NULL)
1864     ops->to_stop_recording = delegate_stop_recording;
1865   if (ops->to_save_record == NULL)
1866     ops->to_save_record = delegate_save_record;
1867   if (ops->to_delete_record == NULL)
1868     ops->to_delete_record = delegate_delete_record;
1869   if (ops->to_record_is_replaying == NULL)
1870     ops->to_record_is_replaying = delegate_record_is_replaying;
1871   if (ops->to_goto_record_begin == NULL)
1872     ops->to_goto_record_begin = delegate_goto_record_begin;
1873   if (ops->to_goto_record_end == NULL)
1874     ops->to_goto_record_end = delegate_goto_record_end;
1875   if (ops->to_goto_record == NULL)
1876     ops->to_goto_record = delegate_goto_record;
1877   if (ops->to_insn_history == NULL)
1878     ops->to_insn_history = delegate_insn_history;
1879   if (ops->to_insn_history_from == NULL)
1880     ops->to_insn_history_from = delegate_insn_history_from;
1881   if (ops->to_insn_history_range == NULL)
1882     ops->to_insn_history_range = delegate_insn_history_range;
1883   if (ops->to_call_history == NULL)
1884     ops->to_call_history = delegate_call_history;
1885   if (ops->to_call_history_from == NULL)
1886     ops->to_call_history_from = delegate_call_history_from;
1887   if (ops->to_call_history_range == NULL)
1888     ops->to_call_history_range = delegate_call_history_range;
1889   if (ops->to_augmented_libraries_svr4_read == NULL)
1890     ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read;
1891   if (ops->to_get_unwinder == NULL)
1892     ops->to_get_unwinder = delegate_get_unwinder;
1893   if (ops->to_get_tailcall_unwinder == NULL)
1894     ops->to_get_tailcall_unwinder = delegate_get_tailcall_unwinder;
1895   if (ops->to_decr_pc_after_break == NULL)
1896     ops->to_decr_pc_after_break = delegate_decr_pc_after_break;
1897 }
1898
1899 static void
1900 install_dummy_methods (struct target_ops *ops)
1901 {
1902   ops->to_post_attach = tdefault_post_attach;
1903   ops->to_detach = tdefault_detach;
1904   ops->to_disconnect = tdefault_disconnect;
1905   ops->to_resume = tdefault_resume;
1906   ops->to_wait = tdefault_wait;
1907   ops->to_fetch_registers = tdefault_fetch_registers;
1908   ops->to_store_registers = tdefault_store_registers;
1909   ops->to_prepare_to_store = tdefault_prepare_to_store;
1910   ops->to_files_info = tdefault_files_info;
1911   ops->to_insert_breakpoint = memory_insert_breakpoint;
1912   ops->to_remove_breakpoint = memory_remove_breakpoint;
1913   ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint;
1914   ops->to_ranged_break_num_registers = tdefault_ranged_break_num_registers;
1915   ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint;
1916   ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint;
1917   ops->to_remove_watchpoint = tdefault_remove_watchpoint;
1918   ops->to_insert_watchpoint = tdefault_insert_watchpoint;
1919   ops->to_insert_mask_watchpoint = tdefault_insert_mask_watchpoint;
1920   ops->to_remove_mask_watchpoint = tdefault_remove_mask_watchpoint;
1921   ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint;
1922   ops->to_stopped_data_address = tdefault_stopped_data_address;
1923   ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range;
1924   ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
1925   ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
1926   ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers;
1927   ops->to_terminal_init = tdefault_terminal_init;
1928   ops->to_terminal_inferior = tdefault_terminal_inferior;
1929   ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
1930   ops->to_terminal_ours = tdefault_terminal_ours;
1931   ops->to_terminal_save_ours = tdefault_terminal_save_ours;
1932   ops->to_terminal_info = default_terminal_info;
1933   ops->to_kill = tdefault_kill;
1934   ops->to_load = tdefault_load;
1935   ops->to_post_startup_inferior = tdefault_post_startup_inferior;
1936   ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint;
1937   ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint;
1938   ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint;
1939   ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint;
1940   ops->to_follow_fork = default_follow_fork;
1941   ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
1942   ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
1943   ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
1944   ops->to_has_exited = tdefault_has_exited;
1945   ops->to_mourn_inferior = default_mourn_inferior;
1946   ops->to_can_run = tdefault_can_run;
1947   ops->to_pass_signals = tdefault_pass_signals;
1948   ops->to_program_signals = tdefault_program_signals;
1949   ops->to_thread_alive = tdefault_thread_alive;
1950   ops->to_find_new_threads = tdefault_find_new_threads;
1951   ops->to_pid_to_str = default_pid_to_str;
1952   ops->to_extra_thread_info = tdefault_extra_thread_info;
1953   ops->to_thread_name = tdefault_thread_name;
1954   ops->to_stop = tdefault_stop;
1955   ops->to_rcmd = default_rcmd;
1956   ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
1957   ops->to_log_command = tdefault_log_command;
1958   ops->to_get_section_table = tdefault_get_section_table;
1959   ops->to_can_async_p = tdefault_can_async_p;
1960   ops->to_is_async_p = tdefault_is_async_p;
1961   ops->to_async = tdefault_async;
1962   ops->to_supports_non_stop = tdefault_supports_non_stop;
1963   ops->to_find_memory_regions = dummy_find_memory_regions;
1964   ops->to_make_corefile_notes = dummy_make_corefile_notes;
1965   ops->to_get_bookmark = tdefault_get_bookmark;
1966   ops->to_goto_bookmark = tdefault_goto_bookmark;
1967   ops->to_xfer_partial = tdefault_xfer_partial;
1968   ops->to_memory_map = tdefault_memory_map;
1969   ops->to_flash_erase = tdefault_flash_erase;
1970   ops->to_flash_done = tdefault_flash_done;
1971   ops->to_read_description = tdefault_read_description;
1972   ops->to_get_ada_task_ptid = default_get_ada_task_ptid;
1973   ops->to_auxv_parse = default_auxv_parse;
1974   ops->to_search_memory = default_search_memory;
1975   ops->to_can_execute_reverse = tdefault_can_execute_reverse;
1976   ops->to_execution_direction = default_execution_direction;
1977   ops->to_supports_multi_process = tdefault_supports_multi_process;
1978   ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint;
1979   ops->to_supports_string_tracing = tdefault_supports_string_tracing;
1980   ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions;
1981   ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands;
1982   ops->to_thread_architecture = default_thread_architecture;
1983   ops->to_trace_init = tdefault_trace_init;
1984   ops->to_download_tracepoint = tdefault_download_tracepoint;
1985   ops->to_can_download_tracepoint = tdefault_can_download_tracepoint;
1986   ops->to_download_trace_state_variable = tdefault_download_trace_state_variable;
1987   ops->to_enable_tracepoint = tdefault_enable_tracepoint;
1988   ops->to_disable_tracepoint = tdefault_disable_tracepoint;
1989   ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions;
1990   ops->to_trace_start = tdefault_trace_start;
1991   ops->to_get_trace_status = tdefault_get_trace_status;
1992   ops->to_get_tracepoint_status = tdefault_get_tracepoint_status;
1993   ops->to_trace_stop = tdefault_trace_stop;
1994   ops->to_trace_find = tdefault_trace_find;
1995   ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value;
1996   ops->to_save_trace_data = tdefault_save_trace_data;
1997   ops->to_upload_tracepoints = tdefault_upload_tracepoints;
1998   ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables;
1999   ops->to_get_raw_trace_data = tdefault_get_raw_trace_data;
2000   ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len;
2001   ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing;
2002   ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer;
2003   ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size;
2004   ops->to_set_trace_notes = tdefault_set_trace_notes;
2005   ops->to_core_of_thread = tdefault_core_of_thread;
2006   ops->to_verify_memory = tdefault_verify_memory;
2007   ops->to_get_tib_address = tdefault_get_tib_address;
2008   ops->to_set_permissions = tdefault_set_permissions;
2009   ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at;
2010   ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
2011   ops->to_traceframe_info = tdefault_traceframe_info;
2012   ops->to_use_agent = tdefault_use_agent;
2013   ops->to_can_use_agent = tdefault_can_use_agent;
2014   ops->to_supports_btrace = tdefault_supports_btrace;
2015   ops->to_enable_btrace = tdefault_enable_btrace;
2016   ops->to_disable_btrace = tdefault_disable_btrace;
2017   ops->to_teardown_btrace = tdefault_teardown_btrace;
2018   ops->to_read_btrace = tdefault_read_btrace;
2019   ops->to_stop_recording = tdefault_stop_recording;
2020   ops->to_save_record = tdefault_save_record;
2021   ops->to_delete_record = tdefault_delete_record;
2022   ops->to_record_is_replaying = tdefault_record_is_replaying;
2023   ops->to_goto_record_begin = tdefault_goto_record_begin;
2024   ops->to_goto_record_end = tdefault_goto_record_end;
2025   ops->to_goto_record = tdefault_goto_record;
2026   ops->to_insn_history = tdefault_insn_history;
2027   ops->to_insn_history_from = tdefault_insn_history_from;
2028   ops->to_insn_history_range = tdefault_insn_history_range;
2029   ops->to_call_history = tdefault_call_history;
2030   ops->to_call_history_from = tdefault_call_history_from;
2031   ops->to_call_history_range = tdefault_call_history_range;
2032   ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read;
2033   ops->to_get_unwinder = tdefault_get_unwinder;
2034   ops->to_get_tailcall_unwinder = tdefault_get_tailcall_unwinder;
2035   ops->to_decr_pc_after_break = default_target_decr_pc_after_break;
2036 }