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