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 char *
 521 delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
 522 {
 523   self = self->beneath;
 524   return self->to_extra_thread_info (self, arg1);
 525 }
 526
 527 static char *
 528 tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
 529 {
 530   return 0;
 531 }
 532
 533 static char *
 534 delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
 535 {
 536   self = self->beneath;
 537   return self->to_thread_name (self, arg1);
 538 }
 539
 540 static char *
 541 tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
 542 {
 543   return 0;
 544 }
 545
 546 static void
 547 delegate_stop (struct target_ops *self, ptid_t arg1)
 548 {
 549   self = self->beneath;
 550   self->to_stop (self, arg1);
 551 }
 552
 553 static void
 554 tdefault_stop (struct target_ops *self, ptid_t arg1)
 555 {
 556 }
 557
 558 static void
 559 delegate_rcmd (struct target_ops *self, char *arg1, struct ui_file *arg2)
 560 {
 561   self = self->beneath;
 562   self->to_rcmd (self, arg1, arg2);
 563 }
 564
 565 static char *
 566 delegate_pid_to_exec_file (struct target_ops *self, int arg1)
 567 {
 568   self = self->beneath;
 569   return self->to_pid_to_exec_file (self, arg1);
 570 }
 571
 572 static char *
 573 tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
 574 {
 575   return 0;
 576 }
 577
 578 static void
 579 delegate_log_command (struct target_ops *self, const char *arg1)
 580 {
 581   self = self->beneath;
 582   self->to_log_command (self, arg1);
 583 }
 584
 585 static void
 586 tdefault_log_command (struct target_ops *self, const char *arg1)
 587 {
 588 }
 589
 590 static int
 591 delegate_can_async_p (struct target_ops *self)
 592 {
 593   self = self->beneath;
 594   return self->to_can_async_p (self);
 595 }
 596
 597 static int
 598 delegate_is_async_p (struct target_ops *self)
 599 {
 600   self = self->beneath;
 601   return self->to_is_async_p (self);
 602 }
 603
 604 static void
 605 delegate_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
 606 {
 607   self = self->beneath;
 608   self->to_async (self, arg1, arg2);
 609 }
 610
 611 static void
 612 tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
 613 {
 614   tcomplain ();
 615 }
 616
 617 static int
 618 delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
 619 {
 620   self = self->beneath;
 621   return self->to_find_memory_regions (self, arg1, arg2);
 622 }
 623
 624 static char *
 625 delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
 626 {
 627   self = self->beneath;
 628   return self->to_make_corefile_notes (self, arg1, arg2);
 629 }
 630
 631 static gdb_byte *
 632 delegate_get_bookmark (struct target_ops *self, char *arg1, int arg2)
 633 {
 634   self = self->beneath;
 635   return self->to_get_bookmark (self, arg1, arg2);
 636 }
 637
 638 static gdb_byte *
 639 tdefault_get_bookmark (struct target_ops *self, char *arg1, int arg2)
 640 {
 641   tcomplain ();
 642 }
 643
 644 static void
 645 delegate_goto_bookmark (struct target_ops *self, gdb_byte *arg1, int arg2)
 646 {
 647   self = self->beneath;
 648   self->to_goto_bookmark (self, arg1, arg2);
 649 }
 650
 651 static void
 652 tdefault_goto_bookmark (struct target_ops *self, gdb_byte *arg1, int arg2)
 653 {
 654   tcomplain ();
 655 }
 656
 657 static enum target_xfer_status
 658 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)
 659 {
 660   self = self->beneath;
 661   return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 662 }
 663
 664 static enum target_xfer_status
 665 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)
 666 {
 667   return TARGET_XFER_E_IO;
 668 }
 669
 670 static ptid_t
 671 delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
 672 {
 673   self = self->beneath;
 674   return self->to_get_ada_task_ptid (self, arg1, arg2);
 675 }
 676
 677 static int
 678 delegate_can_execute_reverse (struct target_ops *self)
 679 {
 680   self = self->beneath;
 681   return self->to_can_execute_reverse (self);
 682 }
 683
 684 static int
 685 tdefault_can_execute_reverse (struct target_ops *self)
 686 {
 687   return 0;
 688 }
 689
 690 static enum exec_direction_kind
 691 delegate_execution_direction (struct target_ops *self)
 692 {
 693   self = self->beneath;
 694   return self->to_execution_direction (self);
 695 }
 696
 697 static int
 698 delegate_supports_multi_process (struct target_ops *self)
 699 {
 700   self = self->beneath;
 701   return self->to_supports_multi_process (self);
 702 }
 703
 704 static int
 705 tdefault_supports_multi_process (struct target_ops *self)
 706 {
 707   return 0;
 708 }
 709
 710 static int
 711 delegate_supports_enable_disable_tracepoint (struct target_ops *self)
 712 {
 713   self = self->beneath;
 714   return self->to_supports_enable_disable_tracepoint (self);
 715 }
 716
 717 static int
 718 tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
 719 {
 720   return 0;
 721 }
 722
 723 static int
 724 delegate_supports_string_tracing (struct target_ops *self)
 725 {
 726   self = self->beneath;
 727   return self->to_supports_string_tracing (self);
 728 }
 729
 730 static int
 731 tdefault_supports_string_tracing (struct target_ops *self)
 732 {
 733   return 0;
 734 }
 735
 736 static int
 737 delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
 738 {
 739   self = self->beneath;
 740   return self->to_supports_evaluation_of_breakpoint_conditions (self);
 741 }
 742
 743 static int
 744 tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
 745 {
 746   return 0;
 747 }
 748
 749 static int
 750 delegate_can_run_breakpoint_commands (struct target_ops *self)
 751 {
 752   self = self->beneath;
 753   return self->to_can_run_breakpoint_commands (self);
 754 }
 755
 756 static int
 757 tdefault_can_run_breakpoint_commands (struct target_ops *self)
 758 {
 759   return 0;
 760 }
 761
 762 static struct gdbarch *
 763 delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
 764 {
 765   self = self->beneath;
 766   return self->to_thread_architecture (self, arg1);
 767 }
 768
 769 static void
 770 delegate_trace_init (struct target_ops *self)
 771 {
 772   self = self->beneath;
 773   self->to_trace_init (self);
 774 }
 775
 776 static void
 777 tdefault_trace_init (struct target_ops *self)
 778 {
 779   tcomplain ();
 780 }
 781
 782 static void
 783 delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
 784 {
 785   self = self->beneath;
 786   self->to_download_tracepoint (self, arg1);
 787 }
 788
 789 static void
 790 tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
 791 {
 792   tcomplain ();
 793 }
 794
 795 static int
 796 delegate_can_download_tracepoint (struct target_ops *self)
 797 {
 798   self = self->beneath;
 799   return self->to_can_download_tracepoint (self);
 800 }
 801
 802 static int
 803 tdefault_can_download_tracepoint (struct target_ops *self)
 804 {
 805   return 0;
 806 }
 807
 808 static void
 809 delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
 810 {
 811   self = self->beneath;
 812   self->to_download_trace_state_variable (self, arg1);
 813 }
 814
 815 static void
 816 tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
 817 {
 818   tcomplain ();
 819 }
 820
 821 static void
 822 delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 823 {
 824   self = self->beneath;
 825   self->to_enable_tracepoint (self, arg1);
 826 }
 827
 828 static void
 829 tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 830 {
 831   tcomplain ();
 832 }
 833
 834 static void
 835 delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 836 {
 837   self = self->beneath;
 838   self->to_disable_tracepoint (self, arg1);
 839 }
 840
 841 static void
 842 tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 843 {
 844   tcomplain ();
 845 }
 846
 847 static void
 848 delegate_trace_set_readonly_regions (struct target_ops *self)
 849 {
 850   self = self->beneath;
 851   self->to_trace_set_readonly_regions (self);
 852 }
 853
 854 static void
 855 tdefault_trace_set_readonly_regions (struct target_ops *self)
 856 {
 857   tcomplain ();
 858 }
 859
 860 static void
 861 delegate_trace_start (struct target_ops *self)
 862 {
 863   self = self->beneath;
 864   self->to_trace_start (self);
 865 }
 866
 867 static void
 868 tdefault_trace_start (struct target_ops *self)
 869 {
 870   tcomplain ();
 871 }
 872
 873 static int
 874 delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
 875 {
 876   self = self->beneath;
 877   return self->to_get_trace_status (self, arg1);
 878 }
 879
 880 static int
 881 tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
 882 {
 883   return -1;
 884 }
 885
 886 static void
 887 delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
 888 {
 889   self = self->beneath;
 890   self->to_get_tracepoint_status (self, arg1, arg2);
 891 }
 892
 893 static void
 894 tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
 895 {
 896   tcomplain ();
 897 }
 898
 899 static void
 900 delegate_trace_stop (struct target_ops *self)
 901 {
 902   self = self->beneath;
 903   self->to_trace_stop (self);
 904 }
 905
 906 static void
 907 tdefault_trace_stop (struct target_ops *self)
 908 {
 909   tcomplain ();
 910 }
 911
 912 static int
 913 delegate_trace_find (struct target_ops *self, enum trace_find_type  arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
 914 {
 915   self = self->beneath;
 916   return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5);
 917 }
 918
 919 static int
 920 tdefault_trace_find (struct target_ops *self, enum trace_find_type  arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
 921 {
 922   return -1;
 923 }
 924
 925 static int
 926 delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
 927 {
 928   self = self->beneath;
 929   return self->to_get_trace_state_variable_value (self, arg1, arg2);
 930 }
 931
 932 static int
 933 tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
 934 {
 935   return 0;
 936 }
 937
 938 static int
 939 delegate_save_trace_data (struct target_ops *self, const char *arg1)
 940 {
 941   self = self->beneath;
 942   return self->to_save_trace_data (self, arg1);
 943 }
 944
 945 static int
 946 tdefault_save_trace_data (struct target_ops *self, const char *arg1)
 947 {
 948   tcomplain ();
 949 }
 950
 951 static int
 952 delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
 953 {
 954   self = self->beneath;
 955   return self->to_upload_tracepoints (self, arg1);
 956 }
 957
 958 static int
 959 tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
 960 {
 961   return 0;
 962 }
 963
 964 static int
 965 delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
 966 {
 967   self = self->beneath;
 968   return self->to_upload_trace_state_variables (self, arg1);
 969 }
 970
 971 static int
 972 tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
 973 {
 974   return 0;
 975 }
 976
 977 static LONGEST
 978 delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
 979 {
 980   self = self->beneath;
 981   return self->to_get_raw_trace_data (self, arg1, arg2, arg3);
 982 }
 983
 984 static LONGEST
 985 tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
 986 {
 987   tcomplain ();
 988 }
 989
 990 static int
 991 delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
 992 {
 993   self = self->beneath;
 994   return self->to_get_min_fast_tracepoint_insn_len (self);
 995 }
 996
 997 static int
 998 tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
 999 {
1000   return -1;
1001 }
1002
1003 static void
1004 delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
1005 {
1006   self = self->beneath;
1007   self->to_set_disconnected_tracing (self, arg1);
1008 }
1009
1010 static void
1011 tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
1012 {
1013 }
1014
1015 static void
1016 delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
1017 {
1018   self = self->beneath;
1019   self->to_set_circular_trace_buffer (self, arg1);
1020 }
1021
1022 static void
1023 tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
1024 {
1025 }
1026
1027 static void
1028 delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
1029 {
1030   self = self->beneath;
1031   self->to_set_trace_buffer_size (self, arg1);
1032 }
1033
1034 static void
1035 tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
1036 {
1037 }
1038
1039 static int
1040 delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
1041 {
1042   self = self->beneath;
1043   return self->to_set_trace_notes (self, arg1, arg2, arg3);
1044 }
1045
1046 static int
1047 tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
1048 {
1049   return 0;
1050 }
1051
1052 static int
1053 delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
1054 {
1055   self = self->beneath;
1056   return self->to_get_tib_address (self, arg1, arg2);
1057 }
1058
1059 static int
1060 tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
1061 {
1062   tcomplain ();
1063 }
1064
1065 static void
1066 delegate_set_permissions (struct target_ops *self)
1067 {
1068   self = self->beneath;
1069   self->to_set_permissions (self);
1070 }
1071
1072 static void
1073 tdefault_set_permissions (struct target_ops *self)
1074 {
1075 }
1076
1077 static int
1078 delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
1079 {
1080   self = self->beneath;
1081   return self->to_static_tracepoint_marker_at (self, arg1, arg2);
1082 }
1083
1084 static int
1085 tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
1086 {
1087   return 0;
1088 }
1089
1090 static VEC(static_tracepoint_marker_p) *
1091 delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
1092 {
1093   self = self->beneath;
1094   return self->to_static_tracepoint_markers_by_strid (self, arg1);
1095 }
1096
1097 static VEC(static_tracepoint_marker_p) *
1098 tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
1099 {
1100   tcomplain ();
1101 }
1102
1103 static struct traceframe_info *
1104 delegate_traceframe_info (struct target_ops *self)
1105 {
1106   self = self->beneath;
1107   return self->to_traceframe_info (self);
1108 }
1109
1110 static struct traceframe_info *
1111 tdefault_traceframe_info (struct target_ops *self)
1112 {
1113   return 0;
1114 }
1115
1116 static int
1117 delegate_use_agent (struct target_ops *self, int arg1)
1118 {
1119   self = self->beneath;
1120   return self->to_use_agent (self, arg1);
1121 }
1122
1123 static int
1124 tdefault_use_agent (struct target_ops *self, int arg1)
1125 {
1126   tcomplain ();
1127 }
1128
1129 static int
1130 delegate_can_use_agent (struct target_ops *self)
1131 {
1132   self = self->beneath;
1133   return self->to_can_use_agent (self);
1134 }
1135
1136 static int
1137 tdefault_can_use_agent (struct target_ops *self)
1138 {
1139   return 0;
1140 }
1141
1142 static int
1143 delegate_supports_btrace (struct target_ops *self)
1144 {
1145   self = self->beneath;
1146   return self->to_supports_btrace (self);
1147 }
1148
1149 static int
1150 tdefault_supports_btrace (struct target_ops *self)
1151 {
1152   return 0;
1153 }
1154
1155 static int
1156 delegate_augmented_libraries_svr4_read (struct target_ops *self)
1157 {
1158   self = self->beneath;
1159   return self->to_augmented_libraries_svr4_read (self);
1160 }
1161
1162 static int
1163 tdefault_augmented_libraries_svr4_read (struct target_ops *self)
1164 {
1165   return 0;
1166 }
1167
1168 static void
1169 install_delegators (struct target_ops *ops)
1170 {
1171   if (ops->to_attach == NULL)
1172     ops->to_attach = delegate_attach;
1173   if (ops->to_post_attach == NULL)
1174     ops->to_post_attach = delegate_post_attach;
1175   if (ops->to_detach == NULL)
1176     ops->to_detach = delegate_detach;
1177   if (ops->to_resume == NULL)
1178     ops->to_resume = delegate_resume;
1179   if (ops->to_wait == NULL)
1180     ops->to_wait = delegate_wait;
1181   if (ops->to_fetch_registers == NULL)
1182     ops->to_fetch_registers = delegate_fetch_registers;
1183   if (ops->to_store_registers == NULL)
1184     ops->to_store_registers = delegate_store_registers;
1185   if (ops->to_prepare_to_store == NULL)
1186     ops->to_prepare_to_store = delegate_prepare_to_store;
1187   if (ops->to_files_info == NULL)
1188     ops->to_files_info = delegate_files_info;
1189   if (ops->to_insert_breakpoint == NULL)
1190     ops->to_insert_breakpoint = delegate_insert_breakpoint;
1191   if (ops->to_remove_breakpoint == NULL)
1192     ops->to_remove_breakpoint = delegate_remove_breakpoint;
1193   if (ops->to_can_use_hw_breakpoint == NULL)
1194     ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint;
1195   if (ops->to_ranged_break_num_registers == NULL)
1196     ops->to_ranged_break_num_registers = delegate_ranged_break_num_registers;
1197   if (ops->to_insert_hw_breakpoint == NULL)
1198     ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint;
1199   if (ops->to_remove_hw_breakpoint == NULL)
1200     ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint;
1201   if (ops->to_remove_watchpoint == NULL)
1202     ops->to_remove_watchpoint = delegate_remove_watchpoint;
1203   if (ops->to_insert_watchpoint == NULL)
1204     ops->to_insert_watchpoint = delegate_insert_watchpoint;
1205   if (ops->to_insert_mask_watchpoint == NULL)
1206     ops->to_insert_mask_watchpoint = delegate_insert_mask_watchpoint;
1207   if (ops->to_remove_mask_watchpoint == NULL)
1208     ops->to_remove_mask_watchpoint = delegate_remove_mask_watchpoint;
1209   if (ops->to_stopped_by_watchpoint == NULL)
1210     ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint;
1211   if (ops->to_stopped_data_address == NULL)
1212     ops->to_stopped_data_address = delegate_stopped_data_address;
1213   if (ops->to_watchpoint_addr_within_range == NULL)
1214     ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range;
1215   if (ops->to_region_ok_for_hw_watchpoint == NULL)
1216     ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint;
1217   if (ops->to_can_accel_watchpoint_condition == NULL)
1218     ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
1219   if (ops->to_masked_watch_num_registers == NULL)
1220     ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers;
1221   if (ops->to_terminal_init == NULL)
1222     ops->to_terminal_init = delegate_terminal_init;
1223   if (ops->to_terminal_inferior == NULL)
1224     ops->to_terminal_inferior = delegate_terminal_inferior;
1225   if (ops->to_terminal_ours_for_output == NULL)
1226     ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
1227   if (ops->to_terminal_ours == NULL)
1228     ops->to_terminal_ours = delegate_terminal_ours;
1229   if (ops->to_terminal_save_ours == NULL)
1230     ops->to_terminal_save_ours = delegate_terminal_save_ours;
1231   if (ops->to_terminal_info == NULL)
1232     ops->to_terminal_info = delegate_terminal_info;
1233   if (ops->to_kill == NULL)
1234     ops->to_kill = delegate_kill;
1235   if (ops->to_load == NULL)
1236     ops->to_load = delegate_load;
1237   if (ops->to_post_startup_inferior == NULL)
1238     ops->to_post_startup_inferior = delegate_post_startup_inferior;
1239   if (ops->to_insert_fork_catchpoint == NULL)
1240     ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint;
1241   if (ops->to_remove_fork_catchpoint == NULL)
1242     ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint;
1243   if (ops->to_insert_vfork_catchpoint == NULL)
1244     ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint;
1245   if (ops->to_remove_vfork_catchpoint == NULL)
1246     ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint;
1247   if (ops->to_follow_fork == NULL)
1248     ops->to_follow_fork = delegate_follow_fork;
1249   if (ops->to_insert_exec_catchpoint == NULL)
1250     ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
1251   if (ops->to_remove_exec_catchpoint == NULL)
1252     ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
1253   if (ops->to_set_syscall_catchpoint == NULL)
1254     ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
1255   if (ops->to_has_exited == NULL)
1256     ops->to_has_exited = delegate_has_exited;
1257   if (ops->to_mourn_inferior == NULL)
1258     ops->to_mourn_inferior = delegate_mourn_inferior;
1259   if (ops->to_extra_thread_info == NULL)
1260     ops->to_extra_thread_info = delegate_extra_thread_info;
1261   if (ops->to_thread_name == NULL)
1262     ops->to_thread_name = delegate_thread_name;
1263   if (ops->to_stop == NULL)
1264     ops->to_stop = delegate_stop;
1265   if (ops->to_rcmd == NULL)
1266     ops->to_rcmd = delegate_rcmd;
1267   if (ops->to_pid_to_exec_file == NULL)
1268     ops->to_pid_to_exec_file = delegate_pid_to_exec_file;
1269   if (ops->to_log_command == NULL)
1270     ops->to_log_command = delegate_log_command;
1271   if (ops->to_can_async_p == NULL)
1272     ops->to_can_async_p = delegate_can_async_p;
1273   if (ops->to_is_async_p == NULL)
1274     ops->to_is_async_p = delegate_is_async_p;
1275   if (ops->to_async == NULL)
1276     ops->to_async = delegate_async;
1277   if (ops->to_find_memory_regions == NULL)
1278     ops->to_find_memory_regions = delegate_find_memory_regions;
1279   if (ops->to_make_corefile_notes == NULL)
1280     ops->to_make_corefile_notes = delegate_make_corefile_notes;
1281   if (ops->to_get_bookmark == NULL)
1282     ops->to_get_bookmark = delegate_get_bookmark;
1283   if (ops->to_goto_bookmark == NULL)
1284     ops->to_goto_bookmark = delegate_goto_bookmark;
1285   if (ops->to_xfer_partial == NULL)
1286     ops->to_xfer_partial = delegate_xfer_partial;
1287   if (ops->to_get_ada_task_ptid == NULL)
1288     ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid;
1289   if (ops->to_can_execute_reverse == NULL)
1290     ops->to_can_execute_reverse = delegate_can_execute_reverse;
1291   if (ops->to_execution_direction == NULL)
1292     ops->to_execution_direction = delegate_execution_direction;
1293   if (ops->to_supports_multi_process == NULL)
1294     ops->to_supports_multi_process = delegate_supports_multi_process;
1295   if (ops->to_supports_enable_disable_tracepoint == NULL)
1296     ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint;
1297   if (ops->to_supports_string_tracing == NULL)
1298     ops->to_supports_string_tracing = delegate_supports_string_tracing;
1299   if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL)
1300     ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions;
1301   if (ops->to_can_run_breakpoint_commands == NULL)
1302     ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands;
1303   if (ops->to_thread_architecture == NULL)
1304     ops->to_thread_architecture = delegate_thread_architecture;
1305   if (ops->to_trace_init == NULL)
1306     ops->to_trace_init = delegate_trace_init;
1307   if (ops->to_download_tracepoint == NULL)
1308     ops->to_download_tracepoint = delegate_download_tracepoint;
1309   if (ops->to_can_download_tracepoint == NULL)
1310     ops->to_can_download_tracepoint = delegate_can_download_tracepoint;
1311   if (ops->to_download_trace_state_variable == NULL)
1312     ops->to_download_trace_state_variable = delegate_download_trace_state_variable;
1313   if (ops->to_enable_tracepoint == NULL)
1314     ops->to_enable_tracepoint = delegate_enable_tracepoint;
1315   if (ops->to_disable_tracepoint == NULL)
1316     ops->to_disable_tracepoint = delegate_disable_tracepoint;
1317   if (ops->to_trace_set_readonly_regions == NULL)
1318     ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions;
1319   if (ops->to_trace_start == NULL)
1320     ops->to_trace_start = delegate_trace_start;
1321   if (ops->to_get_trace_status == NULL)
1322     ops->to_get_trace_status = delegate_get_trace_status;
1323   if (ops->to_get_tracepoint_status == NULL)
1324     ops->to_get_tracepoint_status = delegate_get_tracepoint_status;
1325   if (ops->to_trace_stop == NULL)
1326     ops->to_trace_stop = delegate_trace_stop;
1327   if (ops->to_trace_find == NULL)
1328     ops->to_trace_find = delegate_trace_find;
1329   if (ops->to_get_trace_state_variable_value == NULL)
1330     ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value;
1331   if (ops->to_save_trace_data == NULL)
1332     ops->to_save_trace_data = delegate_save_trace_data;
1333   if (ops->to_upload_tracepoints == NULL)
1334     ops->to_upload_tracepoints = delegate_upload_tracepoints;
1335   if (ops->to_upload_trace_state_variables == NULL)
1336     ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables;
1337   if (ops->to_get_raw_trace_data == NULL)
1338     ops->to_get_raw_trace_data = delegate_get_raw_trace_data;
1339   if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
1340     ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len;
1341   if (ops->to_set_disconnected_tracing == NULL)
1342     ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing;
1343   if (ops->to_set_circular_trace_buffer == NULL)
1344     ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer;
1345   if (ops->to_set_trace_buffer_size == NULL)
1346     ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size;
1347   if (ops->to_set_trace_notes == NULL)
1348     ops->to_set_trace_notes = delegate_set_trace_notes;
1349   if (ops->to_get_tib_address == NULL)
1350     ops->to_get_tib_address = delegate_get_tib_address;
1351   if (ops->to_set_permissions == NULL)
1352     ops->to_set_permissions = delegate_set_permissions;
1353   if (ops->to_static_tracepoint_marker_at == NULL)
1354     ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at;
1355   if (ops->to_static_tracepoint_markers_by_strid == NULL)
1356     ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
1357   if (ops->to_traceframe_info == NULL)
1358     ops->to_traceframe_info = delegate_traceframe_info;
1359   if (ops->to_use_agent == NULL)
1360     ops->to_use_agent = delegate_use_agent;
1361   if (ops->to_can_use_agent == NULL)
1362     ops->to_can_use_agent = delegate_can_use_agent;
1363   if (ops->to_supports_btrace == NULL)
1364     ops->to_supports_btrace = delegate_supports_btrace;
1365   if (ops->to_augmented_libraries_svr4_read == NULL)
1366     ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read;
1367 }
1368
1369 static void
1370 install_dummy_methods (struct target_ops *ops)
1371 {
1372   ops->to_attach = find_default_attach;
1373   ops->to_post_attach = tdefault_post_attach;
1374   ops->to_detach = tdefault_detach;
1375   ops->to_resume = tdefault_resume;
1376   ops->to_wait = tdefault_wait;
1377   ops->to_fetch_registers = tdefault_fetch_registers;
1378   ops->to_store_registers = tdefault_store_registers;
1379   ops->to_prepare_to_store = tdefault_prepare_to_store;
1380   ops->to_files_info = tdefault_files_info;
1381   ops->to_insert_breakpoint = memory_insert_breakpoint;
1382   ops->to_remove_breakpoint = memory_remove_breakpoint;
1383   ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint;
1384   ops->to_ranged_break_num_registers = tdefault_ranged_break_num_registers;
1385   ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint;
1386   ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint;
1387   ops->to_remove_watchpoint = tdefault_remove_watchpoint;
1388   ops->to_insert_watchpoint = tdefault_insert_watchpoint;
1389   ops->to_insert_mask_watchpoint = tdefault_insert_mask_watchpoint;
1390   ops->to_remove_mask_watchpoint = tdefault_remove_mask_watchpoint;
1391   ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint;
1392   ops->to_stopped_data_address = tdefault_stopped_data_address;
1393   ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range;
1394   ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
1395   ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
1396   ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers;
1397   ops->to_terminal_init = tdefault_terminal_init;
1398   ops->to_terminal_inferior = tdefault_terminal_inferior;
1399   ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
1400   ops->to_terminal_ours = tdefault_terminal_ours;
1401   ops->to_terminal_save_ours = tdefault_terminal_save_ours;
1402   ops->to_terminal_info = default_terminal_info;
1403   ops->to_kill = tdefault_kill;
1404   ops->to_load = tdefault_load;
1405   ops->to_post_startup_inferior = tdefault_post_startup_inferior;
1406   ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint;
1407   ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint;
1408   ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint;
1409   ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint;
1410   ops->to_follow_fork = default_follow_fork;
1411   ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
1412   ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
1413   ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
1414   ops->to_has_exited = tdefault_has_exited;
1415   ops->to_mourn_inferior = default_mourn_inferior;
1416   ops->to_extra_thread_info = tdefault_extra_thread_info;
1417   ops->to_thread_name = tdefault_thread_name;
1418   ops->to_stop = tdefault_stop;
1419   ops->to_rcmd = default_rcmd;
1420   ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
1421   ops->to_log_command = tdefault_log_command;
1422   ops->to_can_async_p = find_default_can_async_p;
1423   ops->to_is_async_p = find_default_is_async_p;
1424   ops->to_async = tdefault_async;
1425   ops->to_find_memory_regions = dummy_find_memory_regions;
1426   ops->to_make_corefile_notes = dummy_make_corefile_notes;
1427   ops->to_get_bookmark = tdefault_get_bookmark;
1428   ops->to_goto_bookmark = tdefault_goto_bookmark;
1429   ops->to_xfer_partial = tdefault_xfer_partial;
1430   ops->to_get_ada_task_ptid = default_get_ada_task_ptid;
1431   ops->to_can_execute_reverse = tdefault_can_execute_reverse;
1432   ops->to_execution_direction = default_execution_direction;
1433   ops->to_supports_multi_process = tdefault_supports_multi_process;
1434   ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint;
1435   ops->to_supports_string_tracing = tdefault_supports_string_tracing;
1436   ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions;
1437   ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands;
1438   ops->to_thread_architecture = default_thread_architecture;
1439   ops->to_trace_init = tdefault_trace_init;
1440   ops->to_download_tracepoint = tdefault_download_tracepoint;
1441   ops->to_can_download_tracepoint = tdefault_can_download_tracepoint;
1442   ops->to_download_trace_state_variable = tdefault_download_trace_state_variable;
1443   ops->to_enable_tracepoint = tdefault_enable_tracepoint;
1444   ops->to_disable_tracepoint = tdefault_disable_tracepoint;
1445   ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions;
1446   ops->to_trace_start = tdefault_trace_start;
1447   ops->to_get_trace_status = tdefault_get_trace_status;
1448   ops->to_get_tracepoint_status = tdefault_get_tracepoint_status;
1449   ops->to_trace_stop = tdefault_trace_stop;
1450   ops->to_trace_find = tdefault_trace_find;
1451   ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value;
1452   ops->to_save_trace_data = tdefault_save_trace_data;
1453   ops->to_upload_tracepoints = tdefault_upload_tracepoints;
1454   ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables;
1455   ops->to_get_raw_trace_data = tdefault_get_raw_trace_data;
1456   ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len;
1457   ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing;
1458   ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer;
1459   ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size;
1460   ops->to_set_trace_notes = tdefault_set_trace_notes;
1461   ops->to_get_tib_address = tdefault_get_tib_address;
1462   ops->to_set_permissions = tdefault_set_permissions;
1463   ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at;
1464   ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
1465   ops->to_traceframe_info = tdefault_traceframe_info;
1466   ops->to_use_agent = tdefault_use_agent;
1467   ops->to_can_use_agent = tdefault_can_use_agent;
1468   ops->to_supports_btrace = tdefault_supports_btrace;
1469   ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read;
1470 }