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_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
  65 {
  66   self = self->beneath;
  67   self->to_store_registers (self, arg1, arg2);
  68 }
  69
  70 static void
  71 tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2)
  72 {
  73   noprocess ();
  74 }
  75
  76 static void
  77 delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1)
  78 {
  79   self = self->beneath;
  80   self->to_prepare_to_store (self, arg1);
  81 }
  82
  83 static void
  84 tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1)
  85 {
  86   noprocess ();
  87 }
  88
  89 static void
  90 delegate_files_info (struct target_ops *self)
  91 {
  92   self = self->beneath;
  93   self->to_files_info (self);
  94 }
  95
  96 static void
  97 tdefault_files_info (struct target_ops *self)
  98 {
  99 }
 100
 101 static int
 102 delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 103 {
 104   self = self->beneath;
 105   return self->to_insert_breakpoint (self, arg1, arg2);
 106 }
 107
 108 static int
 109 delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 110 {
 111   self = self->beneath;
 112   return self->to_remove_breakpoint (self, arg1, arg2);
 113 }
 114
 115 static int
 116 delegate_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
 117 {
 118   self = self->beneath;
 119   return self->to_can_use_hw_breakpoint (self, arg1, arg2, arg3);
 120 }
 121
 122 static int
 123 tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3)
 124 {
 125   return 0;
 126 }
 127
 128 static int
 129 delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 130 {
 131   self = self->beneath;
 132   return self->to_insert_hw_breakpoint (self, arg1, arg2);
 133 }
 134
 135 static int
 136 tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 137 {
 138   return -1;
 139 }
 140
 141 static int
 142 delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 143 {
 144   self = self->beneath;
 145   return self->to_remove_hw_breakpoint (self, arg1, arg2);
 146 }
 147
 148 static int
 149 tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2)
 150 {
 151   return -1;
 152 }
 153
 154 static int
 155 delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 156 {
 157   self = self->beneath;
 158   return self->to_remove_watchpoint (self, arg1, arg2, arg3, arg4);
 159 }
 160
 161 static int
 162 tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 163 {
 164   return -1;
 165 }
 166
 167 static int
 168 delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 169 {
 170   self = self->beneath;
 171   return self->to_insert_watchpoint (self, arg1, arg2, arg3, arg4);
 172 }
 173
 174 static int
 175 tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 176 {
 177   return -1;
 178 }
 179
 180 static int
 181 delegate_stopped_by_watchpoint (struct target_ops *self)
 182 {
 183   self = self->beneath;
 184   return self->to_stopped_by_watchpoint (self);
 185 }
 186
 187 static int
 188 tdefault_stopped_by_watchpoint (struct target_ops *self)
 189 {
 190   return 0;
 191 }
 192
 193 static int
 194 delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
 195 {
 196   self = self->beneath;
 197   return self->to_stopped_data_address (self, arg1);
 198 }
 199
 200 static int
 201 tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1)
 202 {
 203   return 0;
 204 }
 205
 206 static int
 207 delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3)
 208 {
 209   self = self->beneath;
 210   return self->to_watchpoint_addr_within_range (self, arg1, arg2, arg3);
 211 }
 212
 213 static int
 214 delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2)
 215 {
 216   self = self->beneath;
 217   return self->to_region_ok_for_hw_watchpoint (self, arg1, arg2);
 218 }
 219
 220 static int
 221 delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 222 {
 223   self = self->beneath;
 224   return self->to_can_accel_watchpoint_condition (self, arg1, arg2, arg3, arg4);
 225 }
 226
 227 static int
 228 tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4)
 229 {
 230   return 0;
 231 }
 232
 233 static void
 234 delegate_terminal_init (struct target_ops *self)
 235 {
 236   self = self->beneath;
 237   self->to_terminal_init (self);
 238 }
 239
 240 static void
 241 tdefault_terminal_init (struct target_ops *self)
 242 {
 243 }
 244
 245 static void
 246 delegate_terminal_inferior (struct target_ops *self)
 247 {
 248   self = self->beneath;
 249   self->to_terminal_inferior (self);
 250 }
 251
 252 static void
 253 tdefault_terminal_inferior (struct target_ops *self)
 254 {
 255 }
 256
 257 static void
 258 delegate_terminal_ours_for_output (struct target_ops *self)
 259 {
 260   self = self->beneath;
 261   self->to_terminal_ours_for_output (self);
 262 }
 263
 264 static void
 265 tdefault_terminal_ours_for_output (struct target_ops *self)
 266 {
 267 }
 268
 269 static void
 270 delegate_terminal_ours (struct target_ops *self)
 271 {
 272   self = self->beneath;
 273   self->to_terminal_ours (self);
 274 }
 275
 276 static void
 277 tdefault_terminal_ours (struct target_ops *self)
 278 {
 279 }
 280
 281 static void
 282 delegate_terminal_save_ours (struct target_ops *self)
 283 {
 284   self = self->beneath;
 285   self->to_terminal_save_ours (self);
 286 }
 287
 288 static void
 289 tdefault_terminal_save_ours (struct target_ops *self)
 290 {
 291 }
 292
 293 static void
 294 delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2)
 295 {
 296   self = self->beneath;
 297   self->to_terminal_info (self, arg1, arg2);
 298 }
 299
 300 static void
 301 delegate_load (struct target_ops *self, char *arg1, int arg2)
 302 {
 303   self = self->beneath;
 304   self->to_load (self, arg1, arg2);
 305 }
 306
 307 static void
 308 tdefault_load (struct target_ops *self, char *arg1, int arg2)
 309 {
 310   tcomplain ();
 311 }
 312
 313 static void
 314 delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1)
 315 {
 316   self = self->beneath;
 317   self->to_post_startup_inferior (self, arg1);
 318 }
 319
 320 static void
 321 tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1)
 322 {
 323 }
 324
 325 static int
 326 delegate_insert_fork_catchpoint (struct target_ops *self, int arg1)
 327 {
 328   self = self->beneath;
 329   return self->to_insert_fork_catchpoint (self, arg1);
 330 }
 331
 332 static int
 333 tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1)
 334 {
 335   return 1;
 336 }
 337
 338 static int
 339 delegate_remove_fork_catchpoint (struct target_ops *self, int arg1)
 340 {
 341   self = self->beneath;
 342   return self->to_remove_fork_catchpoint (self, arg1);
 343 }
 344
 345 static int
 346 tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1)
 347 {
 348   return 1;
 349 }
 350
 351 static int
 352 delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1)
 353 {
 354   self = self->beneath;
 355   return self->to_insert_vfork_catchpoint (self, arg1);
 356 }
 357
 358 static int
 359 tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1)
 360 {
 361   return 1;
 362 }
 363
 364 static int
 365 delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1)
 366 {
 367   self = self->beneath;
 368   return self->to_remove_vfork_catchpoint (self, arg1);
 369 }
 370
 371 static int
 372 tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1)
 373 {
 374   return 1;
 375 }
 376
 377 static int
 378 delegate_insert_exec_catchpoint (struct target_ops *self, int arg1)
 379 {
 380   self = self->beneath;
 381   return self->to_insert_exec_catchpoint (self, arg1);
 382 }
 383
 384 static int
 385 tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1)
 386 {
 387   return 1;
 388 }
 389
 390 static int
 391 delegate_remove_exec_catchpoint (struct target_ops *self, int arg1)
 392 {
 393   self = self->beneath;
 394   return self->to_remove_exec_catchpoint (self, arg1);
 395 }
 396
 397 static int
 398 tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1)
 399 {
 400   return 1;
 401 }
 402
 403 static int
 404 delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
 405 {
 406   self = self->beneath;
 407   return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4, arg5);
 408 }
 409
 410 static int
 411 tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5)
 412 {
 413   return 1;
 414 }
 415
 416 static int
 417 delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
 418 {
 419   self = self->beneath;
 420   return self->to_has_exited (self, arg1, arg2, arg3);
 421 }
 422
 423 static int
 424 tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3)
 425 {
 426   return 0;
 427 }
 428
 429 static char *
 430 delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
 431 {
 432   self = self->beneath;
 433   return self->to_extra_thread_info (self, arg1);
 434 }
 435
 436 static char *
 437 tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1)
 438 {
 439   return 0;
 440 }
 441
 442 static char *
 443 delegate_thread_name (struct target_ops *self, struct thread_info *arg1)
 444 {
 445   self = self->beneath;
 446   return self->to_thread_name (self, arg1);
 447 }
 448
 449 static char *
 450 tdefault_thread_name (struct target_ops *self, struct thread_info *arg1)
 451 {
 452   return 0;
 453 }
 454
 455 static void
 456 delegate_stop (struct target_ops *self, ptid_t arg1)
 457 {
 458   self = self->beneath;
 459   self->to_stop (self, arg1);
 460 }
 461
 462 static void
 463 tdefault_stop (struct target_ops *self, ptid_t arg1)
 464 {
 465 }
 466
 467 static void
 468 delegate_rcmd (struct target_ops *self, char *arg1, struct ui_file *arg2)
 469 {
 470   self = self->beneath;
 471   self->to_rcmd (self, arg1, arg2);
 472 }
 473
 474 static char *
 475 delegate_pid_to_exec_file (struct target_ops *self, int arg1)
 476 {
 477   self = self->beneath;
 478   return self->to_pid_to_exec_file (self, arg1);
 479 }
 480
 481 static char *
 482 tdefault_pid_to_exec_file (struct target_ops *self, int arg1)
 483 {
 484   return 0;
 485 }
 486
 487 static void
 488 delegate_log_command (struct target_ops *self, const char *arg1)
 489 {
 490   self = self->beneath;
 491   self->to_log_command (self, arg1);
 492 }
 493
 494 static void
 495 tdefault_log_command (struct target_ops *self, const char *arg1)
 496 {
 497 }
 498
 499 static int
 500 delegate_can_async_p (struct target_ops *self)
 501 {
 502   self = self->beneath;
 503   return self->to_can_async_p (self);
 504 }
 505
 506 static int
 507 delegate_is_async_p (struct target_ops *self)
 508 {
 509   self = self->beneath;
 510   return self->to_is_async_p (self);
 511 }
 512
 513 static void
 514 delegate_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
 515 {
 516   self = self->beneath;
 517   self->to_async (self, arg1, arg2);
 518 }
 519
 520 static void
 521 tdefault_async (struct target_ops *self, async_callback_ftype *arg1, void *arg2)
 522 {
 523   tcomplain ();
 524 }
 525
 526 static int
 527 delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2)
 528 {
 529   self = self->beneath;
 530   return self->to_find_memory_regions (self, arg1, arg2);
 531 }
 532
 533 static char *
 534 delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2)
 535 {
 536   self = self->beneath;
 537   return self->to_make_corefile_notes (self, arg1, arg2);
 538 }
 539
 540 static gdb_byte *
 541 delegate_get_bookmark (struct target_ops *self, char *arg1, int arg2)
 542 {
 543   self = self->beneath;
 544   return self->to_get_bookmark (self, arg1, arg2);
 545 }
 546
 547 static gdb_byte *
 548 tdefault_get_bookmark (struct target_ops *self, char *arg1, int arg2)
 549 {
 550   tcomplain ();
 551 }
 552
 553 static void
 554 delegate_goto_bookmark (struct target_ops *self, gdb_byte *arg1, int arg2)
 555 {
 556   self = self->beneath;
 557   self->to_goto_bookmark (self, arg1, arg2);
 558 }
 559
 560 static void
 561 tdefault_goto_bookmark (struct target_ops *self, gdb_byte *arg1, int arg2)
 562 {
 563   tcomplain ();
 564 }
 565
 566 static enum target_xfer_status
 567 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)
 568 {
 569   self = self->beneath;
 570   return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 571 }
 572
 573 static enum target_xfer_status
 574 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)
 575 {
 576   return TARGET_XFER_E_IO;
 577 }
 578
 579 static ptid_t
 580 delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2)
 581 {
 582   self = self->beneath;
 583   return self->to_get_ada_task_ptid (self, arg1, arg2);
 584 }
 585
 586 static int
 587 delegate_can_execute_reverse (struct target_ops *self)
 588 {
 589   self = self->beneath;
 590   return self->to_can_execute_reverse (self);
 591 }
 592
 593 static int
 594 tdefault_can_execute_reverse (struct target_ops *self)
 595 {
 596   return 0;
 597 }
 598
 599 static enum exec_direction_kind
 600 delegate_execution_direction (struct target_ops *self)
 601 {
 602   self = self->beneath;
 603   return self->to_execution_direction (self);
 604 }
 605
 606 static int
 607 delegate_supports_multi_process (struct target_ops *self)
 608 {
 609   self = self->beneath;
 610   return self->to_supports_multi_process (self);
 611 }
 612
 613 static int
 614 tdefault_supports_multi_process (struct target_ops *self)
 615 {
 616   return 0;
 617 }
 618
 619 static int
 620 delegate_supports_enable_disable_tracepoint (struct target_ops *self)
 621 {
 622   self = self->beneath;
 623   return self->to_supports_enable_disable_tracepoint (self);
 624 }
 625
 626 static int
 627 tdefault_supports_enable_disable_tracepoint (struct target_ops *self)
 628 {
 629   return 0;
 630 }
 631
 632 static int
 633 delegate_supports_string_tracing (struct target_ops *self)
 634 {
 635   self = self->beneath;
 636   return self->to_supports_string_tracing (self);
 637 }
 638
 639 static int
 640 tdefault_supports_string_tracing (struct target_ops *self)
 641 {
 642   return 0;
 643 }
 644
 645 static int
 646 delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
 647 {
 648   self = self->beneath;
 649   return self->to_supports_evaluation_of_breakpoint_conditions (self);
 650 }
 651
 652 static int
 653 tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self)
 654 {
 655   return 0;
 656 }
 657
 658 static int
 659 delegate_can_run_breakpoint_commands (struct target_ops *self)
 660 {
 661   self = self->beneath;
 662   return self->to_can_run_breakpoint_commands (self);
 663 }
 664
 665 static int
 666 tdefault_can_run_breakpoint_commands (struct target_ops *self)
 667 {
 668   return 0;
 669 }
 670
 671 static struct gdbarch *
 672 delegate_thread_architecture (struct target_ops *self, ptid_t arg1)
 673 {
 674   self = self->beneath;
 675   return self->to_thread_architecture (self, arg1);
 676 }
 677
 678 static void
 679 delegate_trace_init (struct target_ops *self)
 680 {
 681   self = self->beneath;
 682   self->to_trace_init (self);
 683 }
 684
 685 static void
 686 tdefault_trace_init (struct target_ops *self)
 687 {
 688   tcomplain ();
 689 }
 690
 691 static void
 692 delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
 693 {
 694   self = self->beneath;
 695   self->to_download_tracepoint (self, arg1);
 696 }
 697
 698 static void
 699 tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1)
 700 {
 701   tcomplain ();
 702 }
 703
 704 static int
 705 delegate_can_download_tracepoint (struct target_ops *self)
 706 {
 707   self = self->beneath;
 708   return self->to_can_download_tracepoint (self);
 709 }
 710
 711 static int
 712 tdefault_can_download_tracepoint (struct target_ops *self)
 713 {
 714   return 0;
 715 }
 716
 717 static void
 718 delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
 719 {
 720   self = self->beneath;
 721   self->to_download_trace_state_variable (self, arg1);
 722 }
 723
 724 static void
 725 tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1)
 726 {
 727   tcomplain ();
 728 }
 729
 730 static void
 731 delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 732 {
 733   self = self->beneath;
 734   self->to_enable_tracepoint (self, arg1);
 735 }
 736
 737 static void
 738 tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 739 {
 740   tcomplain ();
 741 }
 742
 743 static void
 744 delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 745 {
 746   self = self->beneath;
 747   self->to_disable_tracepoint (self, arg1);
 748 }
 749
 750 static void
 751 tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1)
 752 {
 753   tcomplain ();
 754 }
 755
 756 static void
 757 delegate_trace_set_readonly_regions (struct target_ops *self)
 758 {
 759   self = self->beneath;
 760   self->to_trace_set_readonly_regions (self);
 761 }
 762
 763 static void
 764 tdefault_trace_set_readonly_regions (struct target_ops *self)
 765 {
 766   tcomplain ();
 767 }
 768
 769 static void
 770 delegate_trace_start (struct target_ops *self)
 771 {
 772   self = self->beneath;
 773   self->to_trace_start (self);
 774 }
 775
 776 static void
 777 tdefault_trace_start (struct target_ops *self)
 778 {
 779   tcomplain ();
 780 }
 781
 782 static int
 783 delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1)
 784 {
 785   self = self->beneath;
 786   return self->to_get_trace_status (self, arg1);
 787 }
 788
 789 static int
 790 tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1)
 791 {
 792   return -1;
 793 }
 794
 795 static void
 796 delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
 797 {
 798   self = self->beneath;
 799   self->to_get_tracepoint_status (self, arg1, arg2);
 800 }
 801
 802 static void
 803 tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2)
 804 {
 805   tcomplain ();
 806 }
 807
 808 static void
 809 delegate_trace_stop (struct target_ops *self)
 810 {
 811   self = self->beneath;
 812   self->to_trace_stop (self);
 813 }
 814
 815 static void
 816 tdefault_trace_stop (struct target_ops *self)
 817 {
 818   tcomplain ();
 819 }
 820
 821 static int
 822 delegate_trace_find (struct target_ops *self, enum trace_find_type  arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
 823 {
 824   self = self->beneath;
 825   return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5);
 826 }
 827
 828 static int
 829 tdefault_trace_find (struct target_ops *self, enum trace_find_type  arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5)
 830 {
 831   return -1;
 832 }
 833
 834 static int
 835 delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
 836 {
 837   self = self->beneath;
 838   return self->to_get_trace_state_variable_value (self, arg1, arg2);
 839 }
 840
 841 static int
 842 tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2)
 843 {
 844   return 0;
 845 }
 846
 847 static int
 848 delegate_save_trace_data (struct target_ops *self, const char *arg1)
 849 {
 850   self = self->beneath;
 851   return self->to_save_trace_data (self, arg1);
 852 }
 853
 854 static int
 855 tdefault_save_trace_data (struct target_ops *self, const char *arg1)
 856 {
 857   tcomplain ();
 858 }
 859
 860 static int
 861 delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
 862 {
 863   self = self->beneath;
 864   return self->to_upload_tracepoints (self, arg1);
 865 }
 866
 867 static int
 868 tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1)
 869 {
 870   return 0;
 871 }
 872
 873 static int
 874 delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
 875 {
 876   self = self->beneath;
 877   return self->to_upload_trace_state_variables (self, arg1);
 878 }
 879
 880 static int
 881 tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1)
 882 {
 883   return 0;
 884 }
 885
 886 static LONGEST
 887 delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
 888 {
 889   self = self->beneath;
 890   return self->to_get_raw_trace_data (self, arg1, arg2, arg3);
 891 }
 892
 893 static LONGEST
 894 tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3)
 895 {
 896   tcomplain ();
 897 }
 898
 899 static int
 900 delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self)
 901 {
 902   self = self->beneath;
 903   return self->to_get_min_fast_tracepoint_insn_len (self);
 904 }
 905
 906 static int
 907 tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self)
 908 {
 909   return -1;
 910 }
 911
 912 static void
 913 delegate_set_disconnected_tracing (struct target_ops *self, int arg1)
 914 {
 915   self = self->beneath;
 916   self->to_set_disconnected_tracing (self, arg1);
 917 }
 918
 919 static void
 920 tdefault_set_disconnected_tracing (struct target_ops *self, int arg1)
 921 {
 922 }
 923
 924 static void
 925 delegate_set_circular_trace_buffer (struct target_ops *self, int arg1)
 926 {
 927   self = self->beneath;
 928   self->to_set_circular_trace_buffer (self, arg1);
 929 }
 930
 931 static void
 932 tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1)
 933 {
 934 }
 935
 936 static void
 937 delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
 938 {
 939   self = self->beneath;
 940   self->to_set_trace_buffer_size (self, arg1);
 941 }
 942
 943 static void
 944 tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1)
 945 {
 946 }
 947
 948 static int
 949 delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
 950 {
 951   self = self->beneath;
 952   return self->to_set_trace_notes (self, arg1, arg2, arg3);
 953 }
 954
 955 static int
 956 tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3)
 957 {
 958   return 0;
 959 }
 960
 961 static int
 962 delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
 963 {
 964   self = self->beneath;
 965   return self->to_get_tib_address (self, arg1, arg2);
 966 }
 967
 968 static int
 969 tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2)
 970 {
 971   tcomplain ();
 972 }
 973
 974 static void
 975 delegate_set_permissions (struct target_ops *self)
 976 {
 977   self = self->beneath;
 978   self->to_set_permissions (self);
 979 }
 980
 981 static void
 982 tdefault_set_permissions (struct target_ops *self)
 983 {
 984 }
 985
 986 static int
 987 delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
 988 {
 989   self = self->beneath;
 990   return self->to_static_tracepoint_marker_at (self, arg1, arg2);
 991 }
 992
 993 static int
 994 tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2)
 995 {
 996   return 0;
 997 }
 998
 999 static VEC(static_tracepoint_marker_p) *
1000 delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
1001 {
1002   self = self->beneath;
1003   return self->to_static_tracepoint_markers_by_strid (self, arg1);
1004 }
1005
1006 static VEC(static_tracepoint_marker_p) *
1007 tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1)
1008 {
1009   tcomplain ();
1010 }
1011
1012 static struct traceframe_info *
1013 delegate_traceframe_info (struct target_ops *self)
1014 {
1015   self = self->beneath;
1016   return self->to_traceframe_info (self);
1017 }
1018
1019 static struct traceframe_info *
1020 tdefault_traceframe_info (struct target_ops *self)
1021 {
1022   return 0;
1023 }
1024
1025 static int
1026 delegate_use_agent (struct target_ops *self, int arg1)
1027 {
1028   self = self->beneath;
1029   return self->to_use_agent (self, arg1);
1030 }
1031
1032 static int
1033 tdefault_use_agent (struct target_ops *self, int arg1)
1034 {
1035   tcomplain ();
1036 }
1037
1038 static int
1039 delegate_can_use_agent (struct target_ops *self)
1040 {
1041   self = self->beneath;
1042   return self->to_can_use_agent (self);
1043 }
1044
1045 static int
1046 tdefault_can_use_agent (struct target_ops *self)
1047 {
1048   return 0;
1049 }
1050
1051 static int
1052 delegate_supports_btrace (struct target_ops *self)
1053 {
1054   self = self->beneath;
1055   return self->to_supports_btrace (self);
1056 }
1057
1058 static int
1059 tdefault_supports_btrace (struct target_ops *self)
1060 {
1061   return 0;
1062 }
1063
1064 static int
1065 delegate_augmented_libraries_svr4_read (struct target_ops *self)
1066 {
1067   self = self->beneath;
1068   return self->to_augmented_libraries_svr4_read (self);
1069 }
1070
1071 static int
1072 tdefault_augmented_libraries_svr4_read (struct target_ops *self)
1073 {
1074   return 0;
1075 }
1076
1077 static void
1078 install_delegators (struct target_ops *ops)
1079 {
1080   if (ops->to_attach == NULL)
1081     ops->to_attach = delegate_attach;
1082   if (ops->to_post_attach == NULL)
1083     ops->to_post_attach = delegate_post_attach;
1084   if (ops->to_detach == NULL)
1085     ops->to_detach = delegate_detach;
1086   if (ops->to_resume == NULL)
1087     ops->to_resume = delegate_resume;
1088   if (ops->to_wait == NULL)
1089     ops->to_wait = delegate_wait;
1090   if (ops->to_store_registers == NULL)
1091     ops->to_store_registers = delegate_store_registers;
1092   if (ops->to_prepare_to_store == NULL)
1093     ops->to_prepare_to_store = delegate_prepare_to_store;
1094   if (ops->to_files_info == NULL)
1095     ops->to_files_info = delegate_files_info;
1096   if (ops->to_insert_breakpoint == NULL)
1097     ops->to_insert_breakpoint = delegate_insert_breakpoint;
1098   if (ops->to_remove_breakpoint == NULL)
1099     ops->to_remove_breakpoint = delegate_remove_breakpoint;
1100   if (ops->to_can_use_hw_breakpoint == NULL)
1101     ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint;
1102   if (ops->to_insert_hw_breakpoint == NULL)
1103     ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint;
1104   if (ops->to_remove_hw_breakpoint == NULL)
1105     ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint;
1106   if (ops->to_remove_watchpoint == NULL)
1107     ops->to_remove_watchpoint = delegate_remove_watchpoint;
1108   if (ops->to_insert_watchpoint == NULL)
1109     ops->to_insert_watchpoint = delegate_insert_watchpoint;
1110   if (ops->to_stopped_by_watchpoint == NULL)
1111     ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint;
1112   if (ops->to_stopped_data_address == NULL)
1113     ops->to_stopped_data_address = delegate_stopped_data_address;
1114   if (ops->to_watchpoint_addr_within_range == NULL)
1115     ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range;
1116   if (ops->to_region_ok_for_hw_watchpoint == NULL)
1117     ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint;
1118   if (ops->to_can_accel_watchpoint_condition == NULL)
1119     ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition;
1120   if (ops->to_terminal_init == NULL)
1121     ops->to_terminal_init = delegate_terminal_init;
1122   if (ops->to_terminal_inferior == NULL)
1123     ops->to_terminal_inferior = delegate_terminal_inferior;
1124   if (ops->to_terminal_ours_for_output == NULL)
1125     ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output;
1126   if (ops->to_terminal_ours == NULL)
1127     ops->to_terminal_ours = delegate_terminal_ours;
1128   if (ops->to_terminal_save_ours == NULL)
1129     ops->to_terminal_save_ours = delegate_terminal_save_ours;
1130   if (ops->to_terminal_info == NULL)
1131     ops->to_terminal_info = delegate_terminal_info;
1132   if (ops->to_load == NULL)
1133     ops->to_load = delegate_load;
1134   if (ops->to_post_startup_inferior == NULL)
1135     ops->to_post_startup_inferior = delegate_post_startup_inferior;
1136   if (ops->to_insert_fork_catchpoint == NULL)
1137     ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint;
1138   if (ops->to_remove_fork_catchpoint == NULL)
1139     ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint;
1140   if (ops->to_insert_vfork_catchpoint == NULL)
1141     ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint;
1142   if (ops->to_remove_vfork_catchpoint == NULL)
1143     ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint;
1144   if (ops->to_insert_exec_catchpoint == NULL)
1145     ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint;
1146   if (ops->to_remove_exec_catchpoint == NULL)
1147     ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint;
1148   if (ops->to_set_syscall_catchpoint == NULL)
1149     ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint;
1150   if (ops->to_has_exited == NULL)
1151     ops->to_has_exited = delegate_has_exited;
1152   if (ops->to_extra_thread_info == NULL)
1153     ops->to_extra_thread_info = delegate_extra_thread_info;
1154   if (ops->to_thread_name == NULL)
1155     ops->to_thread_name = delegate_thread_name;
1156   if (ops->to_stop == NULL)
1157     ops->to_stop = delegate_stop;
1158   if (ops->to_rcmd == NULL)
1159     ops->to_rcmd = delegate_rcmd;
1160   if (ops->to_pid_to_exec_file == NULL)
1161     ops->to_pid_to_exec_file = delegate_pid_to_exec_file;
1162   if (ops->to_log_command == NULL)
1163     ops->to_log_command = delegate_log_command;
1164   if (ops->to_can_async_p == NULL)
1165     ops->to_can_async_p = delegate_can_async_p;
1166   if (ops->to_is_async_p == NULL)
1167     ops->to_is_async_p = delegate_is_async_p;
1168   if (ops->to_async == NULL)
1169     ops->to_async = delegate_async;
1170   if (ops->to_find_memory_regions == NULL)
1171     ops->to_find_memory_regions = delegate_find_memory_regions;
1172   if (ops->to_make_corefile_notes == NULL)
1173     ops->to_make_corefile_notes = delegate_make_corefile_notes;
1174   if (ops->to_get_bookmark == NULL)
1175     ops->to_get_bookmark = delegate_get_bookmark;
1176   if (ops->to_goto_bookmark == NULL)
1177     ops->to_goto_bookmark = delegate_goto_bookmark;
1178   if (ops->to_xfer_partial == NULL)
1179     ops->to_xfer_partial = delegate_xfer_partial;
1180   if (ops->to_get_ada_task_ptid == NULL)
1181     ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid;
1182   if (ops->to_can_execute_reverse == NULL)
1183     ops->to_can_execute_reverse = delegate_can_execute_reverse;
1184   if (ops->to_execution_direction == NULL)
1185     ops->to_execution_direction = delegate_execution_direction;
1186   if (ops->to_supports_multi_process == NULL)
1187     ops->to_supports_multi_process = delegate_supports_multi_process;
1188   if (ops->to_supports_enable_disable_tracepoint == NULL)
1189     ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint;
1190   if (ops->to_supports_string_tracing == NULL)
1191     ops->to_supports_string_tracing = delegate_supports_string_tracing;
1192   if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL)
1193     ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions;
1194   if (ops->to_can_run_breakpoint_commands == NULL)
1195     ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands;
1196   if (ops->to_thread_architecture == NULL)
1197     ops->to_thread_architecture = delegate_thread_architecture;
1198   if (ops->to_trace_init == NULL)
1199     ops->to_trace_init = delegate_trace_init;
1200   if (ops->to_download_tracepoint == NULL)
1201     ops->to_download_tracepoint = delegate_download_tracepoint;
1202   if (ops->to_can_download_tracepoint == NULL)
1203     ops->to_can_download_tracepoint = delegate_can_download_tracepoint;
1204   if (ops->to_download_trace_state_variable == NULL)
1205     ops->to_download_trace_state_variable = delegate_download_trace_state_variable;
1206   if (ops->to_enable_tracepoint == NULL)
1207     ops->to_enable_tracepoint = delegate_enable_tracepoint;
1208   if (ops->to_disable_tracepoint == NULL)
1209     ops->to_disable_tracepoint = delegate_disable_tracepoint;
1210   if (ops->to_trace_set_readonly_regions == NULL)
1211     ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions;
1212   if (ops->to_trace_start == NULL)
1213     ops->to_trace_start = delegate_trace_start;
1214   if (ops->to_get_trace_status == NULL)
1215     ops->to_get_trace_status = delegate_get_trace_status;
1216   if (ops->to_get_tracepoint_status == NULL)
1217     ops->to_get_tracepoint_status = delegate_get_tracepoint_status;
1218   if (ops->to_trace_stop == NULL)
1219     ops->to_trace_stop = delegate_trace_stop;
1220   if (ops->to_trace_find == NULL)
1221     ops->to_trace_find = delegate_trace_find;
1222   if (ops->to_get_trace_state_variable_value == NULL)
1223     ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value;
1224   if (ops->to_save_trace_data == NULL)
1225     ops->to_save_trace_data = delegate_save_trace_data;
1226   if (ops->to_upload_tracepoints == NULL)
1227     ops->to_upload_tracepoints = delegate_upload_tracepoints;
1228   if (ops->to_upload_trace_state_variables == NULL)
1229     ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables;
1230   if (ops->to_get_raw_trace_data == NULL)
1231     ops->to_get_raw_trace_data = delegate_get_raw_trace_data;
1232   if (ops->to_get_min_fast_tracepoint_insn_len == NULL)
1233     ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len;
1234   if (ops->to_set_disconnected_tracing == NULL)
1235     ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing;
1236   if (ops->to_set_circular_trace_buffer == NULL)
1237     ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer;
1238   if (ops->to_set_trace_buffer_size == NULL)
1239     ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size;
1240   if (ops->to_set_trace_notes == NULL)
1241     ops->to_set_trace_notes = delegate_set_trace_notes;
1242   if (ops->to_get_tib_address == NULL)
1243     ops->to_get_tib_address = delegate_get_tib_address;
1244   if (ops->to_set_permissions == NULL)
1245     ops->to_set_permissions = delegate_set_permissions;
1246   if (ops->to_static_tracepoint_marker_at == NULL)
1247     ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at;
1248   if (ops->to_static_tracepoint_markers_by_strid == NULL)
1249     ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid;
1250   if (ops->to_traceframe_info == NULL)
1251     ops->to_traceframe_info = delegate_traceframe_info;
1252   if (ops->to_use_agent == NULL)
1253     ops->to_use_agent = delegate_use_agent;
1254   if (ops->to_can_use_agent == NULL)
1255     ops->to_can_use_agent = delegate_can_use_agent;
1256   if (ops->to_supports_btrace == NULL)
1257     ops->to_supports_btrace = delegate_supports_btrace;
1258   if (ops->to_augmented_libraries_svr4_read == NULL)
1259     ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read;
1260 }
1261
1262 static void
1263 install_dummy_methods (struct target_ops *ops)
1264 {
1265   ops->to_attach = find_default_attach;
1266   ops->to_post_attach = tdefault_post_attach;
1267   ops->to_detach = tdefault_detach;
1268   ops->to_resume = tdefault_resume;
1269   ops->to_wait = tdefault_wait;
1270   ops->to_store_registers = tdefault_store_registers;
1271   ops->to_prepare_to_store = tdefault_prepare_to_store;
1272   ops->to_files_info = tdefault_files_info;
1273   ops->to_insert_breakpoint = memory_insert_breakpoint;
1274   ops->to_remove_breakpoint = memory_remove_breakpoint;
1275   ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint;
1276   ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint;
1277   ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint;
1278   ops->to_remove_watchpoint = tdefault_remove_watchpoint;
1279   ops->to_insert_watchpoint = tdefault_insert_watchpoint;
1280   ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint;
1281   ops->to_stopped_data_address = tdefault_stopped_data_address;
1282   ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range;
1283   ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint;
1284   ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition;
1285   ops->to_terminal_init = tdefault_terminal_init;
1286   ops->to_terminal_inferior = tdefault_terminal_inferior;
1287   ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output;
1288   ops->to_terminal_ours = tdefault_terminal_ours;
1289   ops->to_terminal_save_ours = tdefault_terminal_save_ours;
1290   ops->to_terminal_info = default_terminal_info;
1291   ops->to_load = tdefault_load;
1292   ops->to_post_startup_inferior = tdefault_post_startup_inferior;
1293   ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint;
1294   ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint;
1295   ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint;
1296   ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint;
1297   ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint;
1298   ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint;
1299   ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint;
1300   ops->to_has_exited = tdefault_has_exited;
1301   ops->to_extra_thread_info = tdefault_extra_thread_info;
1302   ops->to_thread_name = tdefault_thread_name;
1303   ops->to_stop = tdefault_stop;
1304   ops->to_rcmd = default_rcmd;
1305   ops->to_pid_to_exec_file = tdefault_pid_to_exec_file;
1306   ops->to_log_command = tdefault_log_command;
1307   ops->to_can_async_p = find_default_can_async_p;
1308   ops->to_is_async_p = find_default_is_async_p;
1309   ops->to_async = tdefault_async;
1310   ops->to_find_memory_regions = dummy_find_memory_regions;
1311   ops->to_make_corefile_notes = dummy_make_corefile_notes;
1312   ops->to_get_bookmark = tdefault_get_bookmark;
1313   ops->to_goto_bookmark = tdefault_goto_bookmark;
1314   ops->to_xfer_partial = tdefault_xfer_partial;
1315   ops->to_get_ada_task_ptid = default_get_ada_task_ptid;
1316   ops->to_can_execute_reverse = tdefault_can_execute_reverse;
1317   ops->to_execution_direction = default_execution_direction;
1318   ops->to_supports_multi_process = tdefault_supports_multi_process;
1319   ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint;
1320   ops->to_supports_string_tracing = tdefault_supports_string_tracing;
1321   ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions;
1322   ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands;
1323   ops->to_thread_architecture = default_thread_architecture;
1324   ops->to_trace_init = tdefault_trace_init;
1325   ops->to_download_tracepoint = tdefault_download_tracepoint;
1326   ops->to_can_download_tracepoint = tdefault_can_download_tracepoint;
1327   ops->to_download_trace_state_variable = tdefault_download_trace_state_variable;
1328   ops->to_enable_tracepoint = tdefault_enable_tracepoint;
1329   ops->to_disable_tracepoint = tdefault_disable_tracepoint;
1330   ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions;
1331   ops->to_trace_start = tdefault_trace_start;
1332   ops->to_get_trace_status = tdefault_get_trace_status;
1333   ops->to_get_tracepoint_status = tdefault_get_tracepoint_status;
1334   ops->to_trace_stop = tdefault_trace_stop;
1335   ops->to_trace_find = tdefault_trace_find;
1336   ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value;
1337   ops->to_save_trace_data = tdefault_save_trace_data;
1338   ops->to_upload_tracepoints = tdefault_upload_tracepoints;
1339   ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables;
1340   ops->to_get_raw_trace_data = tdefault_get_raw_trace_data;
1341   ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len;
1342   ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing;
1343   ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer;
1344   ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size;
1345   ops->to_set_trace_notes = tdefault_set_trace_notes;
1346   ops->to_get_tib_address = tdefault_get_tib_address;
1347   ops->to_set_permissions = tdefault_set_permissions;
1348   ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at;
1349   ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid;
1350   ops->to_traceframe_info = tdefault_traceframe_info;
1351   ops->to_use_agent = tdefault_use_agent;
1352   ops->to_can_use_agent = tdefault_can_use_agent;
1353   ops->to_supports_btrace = tdefault_supports_btrace;
1354   ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read;
1355 }