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