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