1 /* THIS FILE IS GENERATED -*- buffer-read-only: t -*- */ 2 /* vi:set ro: */ 3 4 /* To regenerate this file, run:*/ 5 /* make-target-delegates target.h > target-delegates.c */ 6 static void 7 delegate_post_attach (struct target_ops *self, int arg1) 8 { 9 self = self->beneath; 10 self->to_post_attach (self, arg1); 11 } 12 13 static void 14 tdefault_post_attach (struct target_ops *self, int arg1) 15 { 16 } 17 18 static void 19 debug_post_attach (struct target_ops *self, int arg1) 20 { 21 fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_attach (...)\n", debug_target.to_shortname); 22 debug_target.to_post_attach (&debug_target, arg1); 23 fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_attach (", debug_target.to_shortname); 24 target_debug_print_struct_target_ops_p (&debug_target); 25 fputs_unfiltered (", ", gdb_stdlog); 26 target_debug_print_int (arg1); 27 fputs_unfiltered (")\n", gdb_stdlog); 28 } 29 30 static void 31 delegate_detach (struct target_ops *self, const char *arg1, int arg2) 32 { 33 self = self->beneath; 34 self->to_detach (self, arg1, arg2); 35 } 36 37 static void 38 tdefault_detach (struct target_ops *self, const char *arg1, int arg2) 39 { 40 } 41 42 static void 43 debug_detach (struct target_ops *self, const char *arg1, int arg2) 44 { 45 fprintf_unfiltered (gdb_stdlog, "-> %s->to_detach (...)\n", debug_target.to_shortname); 46 debug_target.to_detach (&debug_target, arg1, arg2); 47 fprintf_unfiltered (gdb_stdlog, "<- %s->to_detach (", debug_target.to_shortname); 48 target_debug_print_struct_target_ops_p (&debug_target); 49 fputs_unfiltered (", ", gdb_stdlog); 50 target_debug_print_const_char_p (arg1); 51 fputs_unfiltered (", ", gdb_stdlog); 52 target_debug_print_int (arg2); 53 fputs_unfiltered (")\n", gdb_stdlog); 54 } 55 56 static void 57 delegate_disconnect (struct target_ops *self, const char *arg1, int arg2) 58 { 59 self = self->beneath; 60 self->to_disconnect (self, arg1, arg2); 61 } 62 63 static void 64 tdefault_disconnect (struct target_ops *self, const char *arg1, int arg2) 65 { 66 tcomplain (); 67 } 68 69 static void 70 debug_disconnect (struct target_ops *self, const char *arg1, int arg2) 71 { 72 fprintf_unfiltered (gdb_stdlog, "-> %s->to_disconnect (...)\n", debug_target.to_shortname); 73 debug_target.to_disconnect (&debug_target, arg1, arg2); 74 fprintf_unfiltered (gdb_stdlog, "<- %s->to_disconnect (", debug_target.to_shortname); 75 target_debug_print_struct_target_ops_p (&debug_target); 76 fputs_unfiltered (", ", gdb_stdlog); 77 target_debug_print_const_char_p (arg1); 78 fputs_unfiltered (", ", gdb_stdlog); 79 target_debug_print_int (arg2); 80 fputs_unfiltered (")\n", gdb_stdlog); 81 } 82 83 static void 84 delegate_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3) 85 { 86 self = self->beneath; 87 self->to_resume (self, arg1, arg2, arg3); 88 } 89 90 static void 91 tdefault_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3) 92 { 93 noprocess (); 94 } 95 96 static void 97 debug_resume (struct target_ops *self, ptid_t arg1, int arg2, enum gdb_signal arg3) 98 { 99 fprintf_unfiltered (gdb_stdlog, "-> %s->to_resume (...)\n", debug_target.to_shortname); 100 debug_target.to_resume (&debug_target, arg1, arg2, arg3); 101 fprintf_unfiltered (gdb_stdlog, "<- %s->to_resume (", debug_target.to_shortname); 102 target_debug_print_struct_target_ops_p (&debug_target); 103 fputs_unfiltered (", ", gdb_stdlog); 104 target_debug_print_ptid_t (arg1); 105 fputs_unfiltered (", ", gdb_stdlog); 106 target_debug_print_step (arg2); 107 fputs_unfiltered (", ", gdb_stdlog); 108 target_debug_print_enum_gdb_signal (arg3); 109 fputs_unfiltered (")\n", gdb_stdlog); 110 } 111 112 static ptid_t 113 delegate_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3) 114 { 115 self = self->beneath; 116 return self->to_wait (self, arg1, arg2, arg3); 117 } 118 119 static ptid_t 120 tdefault_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3) 121 { 122 noprocess (); 123 } 124 125 static ptid_t 126 debug_wait (struct target_ops *self, ptid_t arg1, struct target_waitstatus *arg2, int arg3) 127 { 128 ptid_t result; 129 fprintf_unfiltered (gdb_stdlog, "-> %s->to_wait (...)\n", debug_target.to_shortname); 130 result = debug_target.to_wait (&debug_target, arg1, arg2, arg3); 131 fprintf_unfiltered (gdb_stdlog, "<- %s->to_wait (", debug_target.to_shortname); 132 target_debug_print_struct_target_ops_p (&debug_target); 133 fputs_unfiltered (", ", gdb_stdlog); 134 target_debug_print_ptid_t (arg1); 135 fputs_unfiltered (", ", gdb_stdlog); 136 target_debug_print_struct_target_waitstatus_p (arg2); 137 fputs_unfiltered (", ", gdb_stdlog); 138 target_debug_print_options (arg3); 139 fputs_unfiltered (") = ", gdb_stdlog); 140 target_debug_print_ptid_t (result); 141 fputs_unfiltered ("\n", gdb_stdlog); 142 return result; 143 } 144 145 static void 146 delegate_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2) 147 { 148 self = self->beneath; 149 self->to_fetch_registers (self, arg1, arg2); 150 } 151 152 static void 153 tdefault_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2) 154 { 155 } 156 157 static void 158 debug_fetch_registers (struct target_ops *self, struct regcache *arg1, int arg2) 159 { 160 fprintf_unfiltered (gdb_stdlog, "-> %s->to_fetch_registers (...)\n", debug_target.to_shortname); 161 debug_target.to_fetch_registers (&debug_target, arg1, arg2); 162 fprintf_unfiltered (gdb_stdlog, "<- %s->to_fetch_registers (", debug_target.to_shortname); 163 target_debug_print_struct_target_ops_p (&debug_target); 164 fputs_unfiltered (", ", gdb_stdlog); 165 target_debug_print_struct_regcache_p (arg1); 166 fputs_unfiltered (", ", gdb_stdlog); 167 target_debug_print_int (arg2); 168 fputs_unfiltered (")\n", gdb_stdlog); 169 } 170 171 static void 172 delegate_store_registers (struct target_ops *self, struct regcache *arg1, int arg2) 173 { 174 self = self->beneath; 175 self->to_store_registers (self, arg1, arg2); 176 } 177 178 static void 179 tdefault_store_registers (struct target_ops *self, struct regcache *arg1, int arg2) 180 { 181 noprocess (); 182 } 183 184 static void 185 debug_store_registers (struct target_ops *self, struct regcache *arg1, int arg2) 186 { 187 fprintf_unfiltered (gdb_stdlog, "-> %s->to_store_registers (...)\n", debug_target.to_shortname); 188 debug_target.to_store_registers (&debug_target, arg1, arg2); 189 fprintf_unfiltered (gdb_stdlog, "<- %s->to_store_registers (", debug_target.to_shortname); 190 target_debug_print_struct_target_ops_p (&debug_target); 191 fputs_unfiltered (", ", gdb_stdlog); 192 target_debug_print_struct_regcache_p (arg1); 193 fputs_unfiltered (", ", gdb_stdlog); 194 target_debug_print_int (arg2); 195 fputs_unfiltered (")\n", gdb_stdlog); 196 } 197 198 static void 199 delegate_prepare_to_store (struct target_ops *self, struct regcache *arg1) 200 { 201 self = self->beneath; 202 self->to_prepare_to_store (self, arg1); 203 } 204 205 static void 206 tdefault_prepare_to_store (struct target_ops *self, struct regcache *arg1) 207 { 208 noprocess (); 209 } 210 211 static void 212 debug_prepare_to_store (struct target_ops *self, struct regcache *arg1) 213 { 214 fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_store (...)\n", debug_target.to_shortname); 215 debug_target.to_prepare_to_store (&debug_target, arg1); 216 fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_store (", debug_target.to_shortname); 217 target_debug_print_struct_target_ops_p (&debug_target); 218 fputs_unfiltered (", ", gdb_stdlog); 219 target_debug_print_struct_regcache_p (arg1); 220 fputs_unfiltered (")\n", gdb_stdlog); 221 } 222 223 static void 224 delegate_files_info (struct target_ops *self) 225 { 226 self = self->beneath; 227 self->to_files_info (self); 228 } 229 230 static void 231 tdefault_files_info (struct target_ops *self) 232 { 233 } 234 235 static void 236 debug_files_info (struct target_ops *self) 237 { 238 fprintf_unfiltered (gdb_stdlog, "-> %s->to_files_info (...)\n", debug_target.to_shortname); 239 debug_target.to_files_info (&debug_target); 240 fprintf_unfiltered (gdb_stdlog, "<- %s->to_files_info (", debug_target.to_shortname); 241 target_debug_print_struct_target_ops_p (&debug_target); 242 fputs_unfiltered (")\n", gdb_stdlog); 243 } 244 245 static int 246 delegate_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 247 { 248 self = self->beneath; 249 return self->to_insert_breakpoint (self, arg1, arg2); 250 } 251 252 static int 253 debug_insert_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 254 { 255 int result; 256 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_breakpoint (...)\n", debug_target.to_shortname); 257 result = debug_target.to_insert_breakpoint (&debug_target, arg1, arg2); 258 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_breakpoint (", debug_target.to_shortname); 259 target_debug_print_struct_target_ops_p (&debug_target); 260 fputs_unfiltered (", ", gdb_stdlog); 261 target_debug_print_struct_gdbarch_p (arg1); 262 fputs_unfiltered (", ", gdb_stdlog); 263 target_debug_print_struct_bp_target_info_p (arg2); 264 fputs_unfiltered (") = ", gdb_stdlog); 265 target_debug_print_int (result); 266 fputs_unfiltered ("\n", gdb_stdlog); 267 return result; 268 } 269 270 static int 271 delegate_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 272 { 273 self = self->beneath; 274 return self->to_remove_breakpoint (self, arg1, arg2); 275 } 276 277 static int 278 debug_remove_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 279 { 280 int result; 281 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_breakpoint (...)\n", debug_target.to_shortname); 282 result = debug_target.to_remove_breakpoint (&debug_target, arg1, arg2); 283 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_breakpoint (", debug_target.to_shortname); 284 target_debug_print_struct_target_ops_p (&debug_target); 285 fputs_unfiltered (", ", gdb_stdlog); 286 target_debug_print_struct_gdbarch_p (arg1); 287 fputs_unfiltered (", ", gdb_stdlog); 288 target_debug_print_struct_bp_target_info_p (arg2); 289 fputs_unfiltered (") = ", gdb_stdlog); 290 target_debug_print_int (result); 291 fputs_unfiltered ("\n", gdb_stdlog); 292 return result; 293 } 294 295 static int 296 delegate_stopped_by_sw_breakpoint (struct target_ops *self) 297 { 298 self = self->beneath; 299 return self->to_stopped_by_sw_breakpoint (self); 300 } 301 302 static int 303 tdefault_stopped_by_sw_breakpoint (struct target_ops *self) 304 { 305 return 0; 306 } 307 308 static int 309 debug_stopped_by_sw_breakpoint (struct target_ops *self) 310 { 311 int result; 312 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname); 313 result = debug_target.to_stopped_by_sw_breakpoint (&debug_target); 314 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_sw_breakpoint (", debug_target.to_shortname); 315 target_debug_print_struct_target_ops_p (&debug_target); 316 fputs_unfiltered (") = ", gdb_stdlog); 317 target_debug_print_int (result); 318 fputs_unfiltered ("\n", gdb_stdlog); 319 return result; 320 } 321 322 static int 323 delegate_supports_stopped_by_sw_breakpoint (struct target_ops *self) 324 { 325 self = self->beneath; 326 return self->to_supports_stopped_by_sw_breakpoint (self); 327 } 328 329 static int 330 tdefault_supports_stopped_by_sw_breakpoint (struct target_ops *self) 331 { 332 return 0; 333 } 334 335 static int 336 debug_supports_stopped_by_sw_breakpoint (struct target_ops *self) 337 { 338 int result; 339 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_sw_breakpoint (...)\n", debug_target.to_shortname); 340 result = debug_target.to_supports_stopped_by_sw_breakpoint (&debug_target); 341 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_sw_breakpoint (", debug_target.to_shortname); 342 target_debug_print_struct_target_ops_p (&debug_target); 343 fputs_unfiltered (") = ", gdb_stdlog); 344 target_debug_print_int (result); 345 fputs_unfiltered ("\n", gdb_stdlog); 346 return result; 347 } 348 349 static int 350 delegate_stopped_by_hw_breakpoint (struct target_ops *self) 351 { 352 self = self->beneath; 353 return self->to_stopped_by_hw_breakpoint (self); 354 } 355 356 static int 357 tdefault_stopped_by_hw_breakpoint (struct target_ops *self) 358 { 359 return 0; 360 } 361 362 static int 363 debug_stopped_by_hw_breakpoint (struct target_ops *self) 364 { 365 int result; 366 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname); 367 result = debug_target.to_stopped_by_hw_breakpoint (&debug_target); 368 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_hw_breakpoint (", debug_target.to_shortname); 369 target_debug_print_struct_target_ops_p (&debug_target); 370 fputs_unfiltered (") = ", gdb_stdlog); 371 target_debug_print_int (result); 372 fputs_unfiltered ("\n", gdb_stdlog); 373 return result; 374 } 375 376 static int 377 delegate_supports_stopped_by_hw_breakpoint (struct target_ops *self) 378 { 379 self = self->beneath; 380 return self->to_supports_stopped_by_hw_breakpoint (self); 381 } 382 383 static int 384 tdefault_supports_stopped_by_hw_breakpoint (struct target_ops *self) 385 { 386 return 0; 387 } 388 389 static int 390 debug_supports_stopped_by_hw_breakpoint (struct target_ops *self) 391 { 392 int result; 393 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_stopped_by_hw_breakpoint (...)\n", debug_target.to_shortname); 394 result = debug_target.to_supports_stopped_by_hw_breakpoint (&debug_target); 395 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_stopped_by_hw_breakpoint (", debug_target.to_shortname); 396 target_debug_print_struct_target_ops_p (&debug_target); 397 fputs_unfiltered (") = ", gdb_stdlog); 398 target_debug_print_int (result); 399 fputs_unfiltered ("\n", gdb_stdlog); 400 return result; 401 } 402 403 static int 404 delegate_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3) 405 { 406 self = self->beneath; 407 return self->to_can_use_hw_breakpoint (self, arg1, arg2, arg3); 408 } 409 410 static int 411 tdefault_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3) 412 { 413 return 0; 414 } 415 416 static int 417 debug_can_use_hw_breakpoint (struct target_ops *self, int arg1, int arg2, int arg3) 418 { 419 int result; 420 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_hw_breakpoint (...)\n", debug_target.to_shortname); 421 result = debug_target.to_can_use_hw_breakpoint (&debug_target, arg1, arg2, arg3); 422 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_hw_breakpoint (", debug_target.to_shortname); 423 target_debug_print_struct_target_ops_p (&debug_target); 424 fputs_unfiltered (", ", gdb_stdlog); 425 target_debug_print_int (arg1); 426 fputs_unfiltered (", ", gdb_stdlog); 427 target_debug_print_int (arg2); 428 fputs_unfiltered (", ", gdb_stdlog); 429 target_debug_print_int (arg3); 430 fputs_unfiltered (") = ", gdb_stdlog); 431 target_debug_print_int (result); 432 fputs_unfiltered ("\n", gdb_stdlog); 433 return result; 434 } 435 436 static int 437 delegate_ranged_break_num_registers (struct target_ops *self) 438 { 439 self = self->beneath; 440 return self->to_ranged_break_num_registers (self); 441 } 442 443 static int 444 tdefault_ranged_break_num_registers (struct target_ops *self) 445 { 446 return -1; 447 } 448 449 static int 450 debug_ranged_break_num_registers (struct target_ops *self) 451 { 452 int result; 453 fprintf_unfiltered (gdb_stdlog, "-> %s->to_ranged_break_num_registers (...)\n", debug_target.to_shortname); 454 result = debug_target.to_ranged_break_num_registers (&debug_target); 455 fprintf_unfiltered (gdb_stdlog, "<- %s->to_ranged_break_num_registers (", debug_target.to_shortname); 456 target_debug_print_struct_target_ops_p (&debug_target); 457 fputs_unfiltered (") = ", gdb_stdlog); 458 target_debug_print_int (result); 459 fputs_unfiltered ("\n", gdb_stdlog); 460 return result; 461 } 462 463 static int 464 delegate_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 465 { 466 self = self->beneath; 467 return self->to_insert_hw_breakpoint (self, arg1, arg2); 468 } 469 470 static int 471 tdefault_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 472 { 473 return -1; 474 } 475 476 static int 477 debug_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 478 { 479 int result; 480 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_hw_breakpoint (...)\n", debug_target.to_shortname); 481 result = debug_target.to_insert_hw_breakpoint (&debug_target, arg1, arg2); 482 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_hw_breakpoint (", debug_target.to_shortname); 483 target_debug_print_struct_target_ops_p (&debug_target); 484 fputs_unfiltered (", ", gdb_stdlog); 485 target_debug_print_struct_gdbarch_p (arg1); 486 fputs_unfiltered (", ", gdb_stdlog); 487 target_debug_print_struct_bp_target_info_p (arg2); 488 fputs_unfiltered (") = ", gdb_stdlog); 489 target_debug_print_int (result); 490 fputs_unfiltered ("\n", gdb_stdlog); 491 return result; 492 } 493 494 static int 495 delegate_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 496 { 497 self = self->beneath; 498 return self->to_remove_hw_breakpoint (self, arg1, arg2); 499 } 500 501 static int 502 tdefault_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 503 { 504 return -1; 505 } 506 507 static int 508 debug_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *arg1, struct bp_target_info *arg2) 509 { 510 int result; 511 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_hw_breakpoint (...)\n", debug_target.to_shortname); 512 result = debug_target.to_remove_hw_breakpoint (&debug_target, arg1, arg2); 513 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_hw_breakpoint (", debug_target.to_shortname); 514 target_debug_print_struct_target_ops_p (&debug_target); 515 fputs_unfiltered (", ", gdb_stdlog); 516 target_debug_print_struct_gdbarch_p (arg1); 517 fputs_unfiltered (", ", gdb_stdlog); 518 target_debug_print_struct_bp_target_info_p (arg2); 519 fputs_unfiltered (") = ", gdb_stdlog); 520 target_debug_print_int (result); 521 fputs_unfiltered ("\n", gdb_stdlog); 522 return result; 523 } 524 525 static int 526 delegate_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4) 527 { 528 self = self->beneath; 529 return self->to_remove_watchpoint (self, arg1, arg2, arg3, arg4); 530 } 531 532 static int 533 tdefault_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4) 534 { 535 return -1; 536 } 537 538 static int 539 debug_remove_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4) 540 { 541 int result; 542 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_watchpoint (...)\n", debug_target.to_shortname); 543 result = debug_target.to_remove_watchpoint (&debug_target, arg1, arg2, arg3, arg4); 544 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_watchpoint (", debug_target.to_shortname); 545 target_debug_print_struct_target_ops_p (&debug_target); 546 fputs_unfiltered (", ", gdb_stdlog); 547 target_debug_print_CORE_ADDR (arg1); 548 fputs_unfiltered (", ", gdb_stdlog); 549 target_debug_print_int (arg2); 550 fputs_unfiltered (", ", gdb_stdlog); 551 target_debug_print_int (arg3); 552 fputs_unfiltered (", ", gdb_stdlog); 553 target_debug_print_struct_expression_p (arg4); 554 fputs_unfiltered (") = ", gdb_stdlog); 555 target_debug_print_int (result); 556 fputs_unfiltered ("\n", gdb_stdlog); 557 return result; 558 } 559 560 static int 561 delegate_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4) 562 { 563 self = self->beneath; 564 return self->to_insert_watchpoint (self, arg1, arg2, arg3, arg4); 565 } 566 567 static int 568 tdefault_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4) 569 { 570 return -1; 571 } 572 573 static int 574 debug_insert_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4) 575 { 576 int result; 577 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_watchpoint (...)\n", debug_target.to_shortname); 578 result = debug_target.to_insert_watchpoint (&debug_target, arg1, arg2, arg3, arg4); 579 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_watchpoint (", debug_target.to_shortname); 580 target_debug_print_struct_target_ops_p (&debug_target); 581 fputs_unfiltered (", ", gdb_stdlog); 582 target_debug_print_CORE_ADDR (arg1); 583 fputs_unfiltered (", ", gdb_stdlog); 584 target_debug_print_int (arg2); 585 fputs_unfiltered (", ", gdb_stdlog); 586 target_debug_print_int (arg3); 587 fputs_unfiltered (", ", gdb_stdlog); 588 target_debug_print_struct_expression_p (arg4); 589 fputs_unfiltered (") = ", gdb_stdlog); 590 target_debug_print_int (result); 591 fputs_unfiltered ("\n", gdb_stdlog); 592 return result; 593 } 594 595 static int 596 delegate_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3) 597 { 598 self = self->beneath; 599 return self->to_insert_mask_watchpoint (self, arg1, arg2, arg3); 600 } 601 602 static int 603 tdefault_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3) 604 { 605 return 1; 606 } 607 608 static int 609 debug_insert_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3) 610 { 611 int result; 612 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_mask_watchpoint (...)\n", debug_target.to_shortname); 613 result = debug_target.to_insert_mask_watchpoint (&debug_target, arg1, arg2, arg3); 614 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_mask_watchpoint (", debug_target.to_shortname); 615 target_debug_print_struct_target_ops_p (&debug_target); 616 fputs_unfiltered (", ", gdb_stdlog); 617 target_debug_print_CORE_ADDR (arg1); 618 fputs_unfiltered (", ", gdb_stdlog); 619 target_debug_print_CORE_ADDR (arg2); 620 fputs_unfiltered (", ", gdb_stdlog); 621 target_debug_print_int (arg3); 622 fputs_unfiltered (") = ", gdb_stdlog); 623 target_debug_print_int (result); 624 fputs_unfiltered ("\n", gdb_stdlog); 625 return result; 626 } 627 628 static int 629 delegate_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3) 630 { 631 self = self->beneath; 632 return self->to_remove_mask_watchpoint (self, arg1, arg2, arg3); 633 } 634 635 static int 636 tdefault_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3) 637 { 638 return 1; 639 } 640 641 static int 642 debug_remove_mask_watchpoint (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3) 643 { 644 int result; 645 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_mask_watchpoint (...)\n", debug_target.to_shortname); 646 result = debug_target.to_remove_mask_watchpoint (&debug_target, arg1, arg2, arg3); 647 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_mask_watchpoint (", debug_target.to_shortname); 648 target_debug_print_struct_target_ops_p (&debug_target); 649 fputs_unfiltered (", ", gdb_stdlog); 650 target_debug_print_CORE_ADDR (arg1); 651 fputs_unfiltered (", ", gdb_stdlog); 652 target_debug_print_CORE_ADDR (arg2); 653 fputs_unfiltered (", ", gdb_stdlog); 654 target_debug_print_int (arg3); 655 fputs_unfiltered (") = ", gdb_stdlog); 656 target_debug_print_int (result); 657 fputs_unfiltered ("\n", gdb_stdlog); 658 return result; 659 } 660 661 static int 662 delegate_stopped_by_watchpoint (struct target_ops *self) 663 { 664 self = self->beneath; 665 return self->to_stopped_by_watchpoint (self); 666 } 667 668 static int 669 tdefault_stopped_by_watchpoint (struct target_ops *self) 670 { 671 return 0; 672 } 673 674 static int 675 debug_stopped_by_watchpoint (struct target_ops *self) 676 { 677 int result; 678 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_by_watchpoint (...)\n", debug_target.to_shortname); 679 result = debug_target.to_stopped_by_watchpoint (&debug_target); 680 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_by_watchpoint (", debug_target.to_shortname); 681 target_debug_print_struct_target_ops_p (&debug_target); 682 fputs_unfiltered (") = ", gdb_stdlog); 683 target_debug_print_int (result); 684 fputs_unfiltered ("\n", gdb_stdlog); 685 return result; 686 } 687 688 static int 689 delegate_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1) 690 { 691 self = self->beneath; 692 return self->to_stopped_data_address (self, arg1); 693 } 694 695 static int 696 tdefault_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1) 697 { 698 return 0; 699 } 700 701 static int 702 debug_stopped_data_address (struct target_ops *self, CORE_ADDR *arg1) 703 { 704 int result; 705 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stopped_data_address (...)\n", debug_target.to_shortname); 706 result = debug_target.to_stopped_data_address (&debug_target, arg1); 707 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stopped_data_address (", debug_target.to_shortname); 708 target_debug_print_struct_target_ops_p (&debug_target); 709 fputs_unfiltered (", ", gdb_stdlog); 710 target_debug_print_CORE_ADDR_p (arg1); 711 fputs_unfiltered (") = ", gdb_stdlog); 712 target_debug_print_int (result); 713 fputs_unfiltered ("\n", gdb_stdlog); 714 return result; 715 } 716 717 static int 718 delegate_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3) 719 { 720 self = self->beneath; 721 return self->to_watchpoint_addr_within_range (self, arg1, arg2, arg3); 722 } 723 724 static int 725 debug_watchpoint_addr_within_range (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2, int arg3) 726 { 727 int result; 728 fprintf_unfiltered (gdb_stdlog, "-> %s->to_watchpoint_addr_within_range (...)\n", debug_target.to_shortname); 729 result = debug_target.to_watchpoint_addr_within_range (&debug_target, arg1, arg2, arg3); 730 fprintf_unfiltered (gdb_stdlog, "<- %s->to_watchpoint_addr_within_range (", debug_target.to_shortname); 731 target_debug_print_struct_target_ops_p (&debug_target); 732 fputs_unfiltered (", ", gdb_stdlog); 733 target_debug_print_CORE_ADDR (arg1); 734 fputs_unfiltered (", ", gdb_stdlog); 735 target_debug_print_CORE_ADDR (arg2); 736 fputs_unfiltered (", ", gdb_stdlog); 737 target_debug_print_int (arg3); 738 fputs_unfiltered (") = ", gdb_stdlog); 739 target_debug_print_int (result); 740 fputs_unfiltered ("\n", gdb_stdlog); 741 return result; 742 } 743 744 static int 745 delegate_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2) 746 { 747 self = self->beneath; 748 return self->to_region_ok_for_hw_watchpoint (self, arg1, arg2); 749 } 750 751 static int 752 debug_region_ok_for_hw_watchpoint (struct target_ops *self, CORE_ADDR arg1, int arg2) 753 { 754 int result; 755 fprintf_unfiltered (gdb_stdlog, "-> %s->to_region_ok_for_hw_watchpoint (...)\n", debug_target.to_shortname); 756 result = debug_target.to_region_ok_for_hw_watchpoint (&debug_target, arg1, arg2); 757 fprintf_unfiltered (gdb_stdlog, "<- %s->to_region_ok_for_hw_watchpoint (", debug_target.to_shortname); 758 target_debug_print_struct_target_ops_p (&debug_target); 759 fputs_unfiltered (", ", gdb_stdlog); 760 target_debug_print_CORE_ADDR (arg1); 761 fputs_unfiltered (", ", gdb_stdlog); 762 target_debug_print_int (arg2); 763 fputs_unfiltered (") = ", gdb_stdlog); 764 target_debug_print_int (result); 765 fputs_unfiltered ("\n", gdb_stdlog); 766 return result; 767 } 768 769 static int 770 delegate_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4) 771 { 772 self = self->beneath; 773 return self->to_can_accel_watchpoint_condition (self, arg1, arg2, arg3, arg4); 774 } 775 776 static int 777 tdefault_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4) 778 { 779 return 0; 780 } 781 782 static int 783 debug_can_accel_watchpoint_condition (struct target_ops *self, CORE_ADDR arg1, int arg2, int arg3, struct expression *arg4) 784 { 785 int result; 786 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_accel_watchpoint_condition (...)\n", debug_target.to_shortname); 787 result = debug_target.to_can_accel_watchpoint_condition (&debug_target, arg1, arg2, arg3, arg4); 788 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_accel_watchpoint_condition (", debug_target.to_shortname); 789 target_debug_print_struct_target_ops_p (&debug_target); 790 fputs_unfiltered (", ", gdb_stdlog); 791 target_debug_print_CORE_ADDR (arg1); 792 fputs_unfiltered (", ", gdb_stdlog); 793 target_debug_print_int (arg2); 794 fputs_unfiltered (", ", gdb_stdlog); 795 target_debug_print_int (arg3); 796 fputs_unfiltered (", ", gdb_stdlog); 797 target_debug_print_struct_expression_p (arg4); 798 fputs_unfiltered (") = ", gdb_stdlog); 799 target_debug_print_int (result); 800 fputs_unfiltered ("\n", gdb_stdlog); 801 return result; 802 } 803 804 static int 805 delegate_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2) 806 { 807 self = self->beneath; 808 return self->to_masked_watch_num_registers (self, arg1, arg2); 809 } 810 811 static int 812 tdefault_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2) 813 { 814 return -1; 815 } 816 817 static int 818 debug_masked_watch_num_registers (struct target_ops *self, CORE_ADDR arg1, CORE_ADDR arg2) 819 { 820 int result; 821 fprintf_unfiltered (gdb_stdlog, "-> %s->to_masked_watch_num_registers (...)\n", debug_target.to_shortname); 822 result = debug_target.to_masked_watch_num_registers (&debug_target, arg1, arg2); 823 fprintf_unfiltered (gdb_stdlog, "<- %s->to_masked_watch_num_registers (", debug_target.to_shortname); 824 target_debug_print_struct_target_ops_p (&debug_target); 825 fputs_unfiltered (", ", gdb_stdlog); 826 target_debug_print_CORE_ADDR (arg1); 827 fputs_unfiltered (", ", gdb_stdlog); 828 target_debug_print_CORE_ADDR (arg2); 829 fputs_unfiltered (") = ", gdb_stdlog); 830 target_debug_print_int (result); 831 fputs_unfiltered ("\n", gdb_stdlog); 832 return result; 833 } 834 835 static void 836 delegate_terminal_init (struct target_ops *self) 837 { 838 self = self->beneath; 839 self->to_terminal_init (self); 840 } 841 842 static void 843 tdefault_terminal_init (struct target_ops *self) 844 { 845 } 846 847 static void 848 debug_terminal_init (struct target_ops *self) 849 { 850 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_init (...)\n", debug_target.to_shortname); 851 debug_target.to_terminal_init (&debug_target); 852 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_init (", debug_target.to_shortname); 853 target_debug_print_struct_target_ops_p (&debug_target); 854 fputs_unfiltered (")\n", gdb_stdlog); 855 } 856 857 static void 858 delegate_terminal_inferior (struct target_ops *self) 859 { 860 self = self->beneath; 861 self->to_terminal_inferior (self); 862 } 863 864 static void 865 tdefault_terminal_inferior (struct target_ops *self) 866 { 867 } 868 869 static void 870 debug_terminal_inferior (struct target_ops *self) 871 { 872 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_inferior (...)\n", debug_target.to_shortname); 873 debug_target.to_terminal_inferior (&debug_target); 874 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_inferior (", debug_target.to_shortname); 875 target_debug_print_struct_target_ops_p (&debug_target); 876 fputs_unfiltered (")\n", gdb_stdlog); 877 } 878 879 static void 880 delegate_terminal_ours_for_output (struct target_ops *self) 881 { 882 self = self->beneath; 883 self->to_terminal_ours_for_output (self); 884 } 885 886 static void 887 tdefault_terminal_ours_for_output (struct target_ops *self) 888 { 889 } 890 891 static void 892 debug_terminal_ours_for_output (struct target_ops *self) 893 { 894 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours_for_output (...)\n", debug_target.to_shortname); 895 debug_target.to_terminal_ours_for_output (&debug_target); 896 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours_for_output (", debug_target.to_shortname); 897 target_debug_print_struct_target_ops_p (&debug_target); 898 fputs_unfiltered (")\n", gdb_stdlog); 899 } 900 901 static void 902 delegate_terminal_ours (struct target_ops *self) 903 { 904 self = self->beneath; 905 self->to_terminal_ours (self); 906 } 907 908 static void 909 tdefault_terminal_ours (struct target_ops *self) 910 { 911 } 912 913 static void 914 debug_terminal_ours (struct target_ops *self) 915 { 916 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_ours (...)\n", debug_target.to_shortname); 917 debug_target.to_terminal_ours (&debug_target); 918 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_ours (", debug_target.to_shortname); 919 target_debug_print_struct_target_ops_p (&debug_target); 920 fputs_unfiltered (")\n", gdb_stdlog); 921 } 922 923 static void 924 delegate_terminal_info (struct target_ops *self, const char *arg1, int arg2) 925 { 926 self = self->beneath; 927 self->to_terminal_info (self, arg1, arg2); 928 } 929 930 static void 931 debug_terminal_info (struct target_ops *self, const char *arg1, int arg2) 932 { 933 fprintf_unfiltered (gdb_stdlog, "-> %s->to_terminal_info (...)\n", debug_target.to_shortname); 934 debug_target.to_terminal_info (&debug_target, arg1, arg2); 935 fprintf_unfiltered (gdb_stdlog, "<- %s->to_terminal_info (", debug_target.to_shortname); 936 target_debug_print_struct_target_ops_p (&debug_target); 937 fputs_unfiltered (", ", gdb_stdlog); 938 target_debug_print_const_char_p (arg1); 939 fputs_unfiltered (", ", gdb_stdlog); 940 target_debug_print_int (arg2); 941 fputs_unfiltered (")\n", gdb_stdlog); 942 } 943 944 static void 945 delegate_kill (struct target_ops *self) 946 { 947 self = self->beneath; 948 self->to_kill (self); 949 } 950 951 static void 952 tdefault_kill (struct target_ops *self) 953 { 954 noprocess (); 955 } 956 957 static void 958 debug_kill (struct target_ops *self) 959 { 960 fprintf_unfiltered (gdb_stdlog, "-> %s->to_kill (...)\n", debug_target.to_shortname); 961 debug_target.to_kill (&debug_target); 962 fprintf_unfiltered (gdb_stdlog, "<- %s->to_kill (", debug_target.to_shortname); 963 target_debug_print_struct_target_ops_p (&debug_target); 964 fputs_unfiltered (")\n", gdb_stdlog); 965 } 966 967 static void 968 delegate_load (struct target_ops *self, const char *arg1, int arg2) 969 { 970 self = self->beneath; 971 self->to_load (self, arg1, arg2); 972 } 973 974 static void 975 tdefault_load (struct target_ops *self, const char *arg1, int arg2) 976 { 977 tcomplain (); 978 } 979 980 static void 981 debug_load (struct target_ops *self, const char *arg1, int arg2) 982 { 983 fprintf_unfiltered (gdb_stdlog, "-> %s->to_load (...)\n", debug_target.to_shortname); 984 debug_target.to_load (&debug_target, arg1, arg2); 985 fprintf_unfiltered (gdb_stdlog, "<- %s->to_load (", debug_target.to_shortname); 986 target_debug_print_struct_target_ops_p (&debug_target); 987 fputs_unfiltered (", ", gdb_stdlog); 988 target_debug_print_const_char_p (arg1); 989 fputs_unfiltered (", ", gdb_stdlog); 990 target_debug_print_int (arg2); 991 fputs_unfiltered (")\n", gdb_stdlog); 992 } 993 994 static void 995 delegate_post_startup_inferior (struct target_ops *self, ptid_t arg1) 996 { 997 self = self->beneath; 998 self->to_post_startup_inferior (self, arg1); 999 } 1000 1001 static void 1002 tdefault_post_startup_inferior (struct target_ops *self, ptid_t arg1) 1003 { 1004 } 1005 1006 static void 1007 debug_post_startup_inferior (struct target_ops *self, ptid_t arg1) 1008 { 1009 fprintf_unfiltered (gdb_stdlog, "-> %s->to_post_startup_inferior (...)\n", debug_target.to_shortname); 1010 debug_target.to_post_startup_inferior (&debug_target, arg1); 1011 fprintf_unfiltered (gdb_stdlog, "<- %s->to_post_startup_inferior (", debug_target.to_shortname); 1012 target_debug_print_struct_target_ops_p (&debug_target); 1013 fputs_unfiltered (", ", gdb_stdlog); 1014 target_debug_print_ptid_t (arg1); 1015 fputs_unfiltered (")\n", gdb_stdlog); 1016 } 1017 1018 static int 1019 delegate_insert_fork_catchpoint (struct target_ops *self, int arg1) 1020 { 1021 self = self->beneath; 1022 return self->to_insert_fork_catchpoint (self, arg1); 1023 } 1024 1025 static int 1026 tdefault_insert_fork_catchpoint (struct target_ops *self, int arg1) 1027 { 1028 return 1; 1029 } 1030 1031 static int 1032 debug_insert_fork_catchpoint (struct target_ops *self, int arg1) 1033 { 1034 int result; 1035 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_fork_catchpoint (...)\n", debug_target.to_shortname); 1036 result = debug_target.to_insert_fork_catchpoint (&debug_target, arg1); 1037 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_fork_catchpoint (", debug_target.to_shortname); 1038 target_debug_print_struct_target_ops_p (&debug_target); 1039 fputs_unfiltered (", ", gdb_stdlog); 1040 target_debug_print_int (arg1); 1041 fputs_unfiltered (") = ", gdb_stdlog); 1042 target_debug_print_int (result); 1043 fputs_unfiltered ("\n", gdb_stdlog); 1044 return result; 1045 } 1046 1047 static int 1048 delegate_remove_fork_catchpoint (struct target_ops *self, int arg1) 1049 { 1050 self = self->beneath; 1051 return self->to_remove_fork_catchpoint (self, arg1); 1052 } 1053 1054 static int 1055 tdefault_remove_fork_catchpoint (struct target_ops *self, int arg1) 1056 { 1057 return 1; 1058 } 1059 1060 static int 1061 debug_remove_fork_catchpoint (struct target_ops *self, int arg1) 1062 { 1063 int result; 1064 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_fork_catchpoint (...)\n", debug_target.to_shortname); 1065 result = debug_target.to_remove_fork_catchpoint (&debug_target, arg1); 1066 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_fork_catchpoint (", debug_target.to_shortname); 1067 target_debug_print_struct_target_ops_p (&debug_target); 1068 fputs_unfiltered (", ", gdb_stdlog); 1069 target_debug_print_int (arg1); 1070 fputs_unfiltered (") = ", gdb_stdlog); 1071 target_debug_print_int (result); 1072 fputs_unfiltered ("\n", gdb_stdlog); 1073 return result; 1074 } 1075 1076 static int 1077 delegate_insert_vfork_catchpoint (struct target_ops *self, int arg1) 1078 { 1079 self = self->beneath; 1080 return self->to_insert_vfork_catchpoint (self, arg1); 1081 } 1082 1083 static int 1084 tdefault_insert_vfork_catchpoint (struct target_ops *self, int arg1) 1085 { 1086 return 1; 1087 } 1088 1089 static int 1090 debug_insert_vfork_catchpoint (struct target_ops *self, int arg1) 1091 { 1092 int result; 1093 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_vfork_catchpoint (...)\n", debug_target.to_shortname); 1094 result = debug_target.to_insert_vfork_catchpoint (&debug_target, arg1); 1095 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_vfork_catchpoint (", debug_target.to_shortname); 1096 target_debug_print_struct_target_ops_p (&debug_target); 1097 fputs_unfiltered (", ", gdb_stdlog); 1098 target_debug_print_int (arg1); 1099 fputs_unfiltered (") = ", gdb_stdlog); 1100 target_debug_print_int (result); 1101 fputs_unfiltered ("\n", gdb_stdlog); 1102 return result; 1103 } 1104 1105 static int 1106 delegate_remove_vfork_catchpoint (struct target_ops *self, int arg1) 1107 { 1108 self = self->beneath; 1109 return self->to_remove_vfork_catchpoint (self, arg1); 1110 } 1111 1112 static int 1113 tdefault_remove_vfork_catchpoint (struct target_ops *self, int arg1) 1114 { 1115 return 1; 1116 } 1117 1118 static int 1119 debug_remove_vfork_catchpoint (struct target_ops *self, int arg1) 1120 { 1121 int result; 1122 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_vfork_catchpoint (...)\n", debug_target.to_shortname); 1123 result = debug_target.to_remove_vfork_catchpoint (&debug_target, arg1); 1124 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_vfork_catchpoint (", debug_target.to_shortname); 1125 target_debug_print_struct_target_ops_p (&debug_target); 1126 fputs_unfiltered (", ", gdb_stdlog); 1127 target_debug_print_int (arg1); 1128 fputs_unfiltered (") = ", gdb_stdlog); 1129 target_debug_print_int (result); 1130 fputs_unfiltered ("\n", gdb_stdlog); 1131 return result; 1132 } 1133 1134 static int 1135 delegate_follow_fork (struct target_ops *self, int arg1, int arg2) 1136 { 1137 self = self->beneath; 1138 return self->to_follow_fork (self, arg1, arg2); 1139 } 1140 1141 static int 1142 debug_follow_fork (struct target_ops *self, int arg1, int arg2) 1143 { 1144 int result; 1145 fprintf_unfiltered (gdb_stdlog, "-> %s->to_follow_fork (...)\n", debug_target.to_shortname); 1146 result = debug_target.to_follow_fork (&debug_target, arg1, arg2); 1147 fprintf_unfiltered (gdb_stdlog, "<- %s->to_follow_fork (", debug_target.to_shortname); 1148 target_debug_print_struct_target_ops_p (&debug_target); 1149 fputs_unfiltered (", ", gdb_stdlog); 1150 target_debug_print_int (arg1); 1151 fputs_unfiltered (", ", gdb_stdlog); 1152 target_debug_print_int (arg2); 1153 fputs_unfiltered (") = ", gdb_stdlog); 1154 target_debug_print_int (result); 1155 fputs_unfiltered ("\n", gdb_stdlog); 1156 return result; 1157 } 1158 1159 static int 1160 delegate_insert_exec_catchpoint (struct target_ops *self, int arg1) 1161 { 1162 self = self->beneath; 1163 return self->to_insert_exec_catchpoint (self, arg1); 1164 } 1165 1166 static int 1167 tdefault_insert_exec_catchpoint (struct target_ops *self, int arg1) 1168 { 1169 return 1; 1170 } 1171 1172 static int 1173 debug_insert_exec_catchpoint (struct target_ops *self, int arg1) 1174 { 1175 int result; 1176 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insert_exec_catchpoint (...)\n", debug_target.to_shortname); 1177 result = debug_target.to_insert_exec_catchpoint (&debug_target, arg1); 1178 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insert_exec_catchpoint (", debug_target.to_shortname); 1179 target_debug_print_struct_target_ops_p (&debug_target); 1180 fputs_unfiltered (", ", gdb_stdlog); 1181 target_debug_print_int (arg1); 1182 fputs_unfiltered (") = ", gdb_stdlog); 1183 target_debug_print_int (result); 1184 fputs_unfiltered ("\n", gdb_stdlog); 1185 return result; 1186 } 1187 1188 static int 1189 delegate_remove_exec_catchpoint (struct target_ops *self, int arg1) 1190 { 1191 self = self->beneath; 1192 return self->to_remove_exec_catchpoint (self, arg1); 1193 } 1194 1195 static int 1196 tdefault_remove_exec_catchpoint (struct target_ops *self, int arg1) 1197 { 1198 return 1; 1199 } 1200 1201 static int 1202 debug_remove_exec_catchpoint (struct target_ops *self, int arg1) 1203 { 1204 int result; 1205 fprintf_unfiltered (gdb_stdlog, "-> %s->to_remove_exec_catchpoint (...)\n", debug_target.to_shortname); 1206 result = debug_target.to_remove_exec_catchpoint (&debug_target, arg1); 1207 fprintf_unfiltered (gdb_stdlog, "<- %s->to_remove_exec_catchpoint (", debug_target.to_shortname); 1208 target_debug_print_struct_target_ops_p (&debug_target); 1209 fputs_unfiltered (", ", gdb_stdlog); 1210 target_debug_print_int (arg1); 1211 fputs_unfiltered (") = ", gdb_stdlog); 1212 target_debug_print_int (result); 1213 fputs_unfiltered ("\n", gdb_stdlog); 1214 return result; 1215 } 1216 1217 static int 1218 delegate_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5) 1219 { 1220 self = self->beneath; 1221 return self->to_set_syscall_catchpoint (self, arg1, arg2, arg3, arg4, arg5); 1222 } 1223 1224 static int 1225 tdefault_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5) 1226 { 1227 return 1; 1228 } 1229 1230 static int 1231 debug_set_syscall_catchpoint (struct target_ops *self, int arg1, int arg2, int arg3, int arg4, int *arg5) 1232 { 1233 int result; 1234 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_syscall_catchpoint (...)\n", debug_target.to_shortname); 1235 result = debug_target.to_set_syscall_catchpoint (&debug_target, arg1, arg2, arg3, arg4, arg5); 1236 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_syscall_catchpoint (", debug_target.to_shortname); 1237 target_debug_print_struct_target_ops_p (&debug_target); 1238 fputs_unfiltered (", ", gdb_stdlog); 1239 target_debug_print_int (arg1); 1240 fputs_unfiltered (", ", gdb_stdlog); 1241 target_debug_print_int (arg2); 1242 fputs_unfiltered (", ", gdb_stdlog); 1243 target_debug_print_int (arg3); 1244 fputs_unfiltered (", ", gdb_stdlog); 1245 target_debug_print_int (arg4); 1246 fputs_unfiltered (", ", gdb_stdlog); 1247 target_debug_print_int_p (arg5); 1248 fputs_unfiltered (") = ", gdb_stdlog); 1249 target_debug_print_int (result); 1250 fputs_unfiltered ("\n", gdb_stdlog); 1251 return result; 1252 } 1253 1254 static int 1255 delegate_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3) 1256 { 1257 self = self->beneath; 1258 return self->to_has_exited (self, arg1, arg2, arg3); 1259 } 1260 1261 static int 1262 tdefault_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3) 1263 { 1264 return 0; 1265 } 1266 1267 static int 1268 debug_has_exited (struct target_ops *self, int arg1, int arg2, int *arg3) 1269 { 1270 int result; 1271 fprintf_unfiltered (gdb_stdlog, "-> %s->to_has_exited (...)\n", debug_target.to_shortname); 1272 result = debug_target.to_has_exited (&debug_target, arg1, arg2, arg3); 1273 fprintf_unfiltered (gdb_stdlog, "<- %s->to_has_exited (", debug_target.to_shortname); 1274 target_debug_print_struct_target_ops_p (&debug_target); 1275 fputs_unfiltered (", ", gdb_stdlog); 1276 target_debug_print_int (arg1); 1277 fputs_unfiltered (", ", gdb_stdlog); 1278 target_debug_print_int (arg2); 1279 fputs_unfiltered (", ", gdb_stdlog); 1280 target_debug_print_int_p (arg3); 1281 fputs_unfiltered (") = ", gdb_stdlog); 1282 target_debug_print_int (result); 1283 fputs_unfiltered ("\n", gdb_stdlog); 1284 return result; 1285 } 1286 1287 static void 1288 delegate_mourn_inferior (struct target_ops *self) 1289 { 1290 self = self->beneath; 1291 self->to_mourn_inferior (self); 1292 } 1293 1294 static void 1295 debug_mourn_inferior (struct target_ops *self) 1296 { 1297 fprintf_unfiltered (gdb_stdlog, "-> %s->to_mourn_inferior (...)\n", debug_target.to_shortname); 1298 debug_target.to_mourn_inferior (&debug_target); 1299 fprintf_unfiltered (gdb_stdlog, "<- %s->to_mourn_inferior (", debug_target.to_shortname); 1300 target_debug_print_struct_target_ops_p (&debug_target); 1301 fputs_unfiltered (")\n", gdb_stdlog); 1302 } 1303 1304 static int 1305 delegate_can_run (struct target_ops *self) 1306 { 1307 self = self->beneath; 1308 return self->to_can_run (self); 1309 } 1310 1311 static int 1312 tdefault_can_run (struct target_ops *self) 1313 { 1314 return 0; 1315 } 1316 1317 static int 1318 debug_can_run (struct target_ops *self) 1319 { 1320 int result; 1321 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run (...)\n", debug_target.to_shortname); 1322 result = debug_target.to_can_run (&debug_target); 1323 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run (", debug_target.to_shortname); 1324 target_debug_print_struct_target_ops_p (&debug_target); 1325 fputs_unfiltered (") = ", gdb_stdlog); 1326 target_debug_print_int (result); 1327 fputs_unfiltered ("\n", gdb_stdlog); 1328 return result; 1329 } 1330 1331 static void 1332 delegate_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2) 1333 { 1334 self = self->beneath; 1335 self->to_pass_signals (self, arg1, arg2); 1336 } 1337 1338 static void 1339 tdefault_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2) 1340 { 1341 } 1342 1343 static void 1344 debug_pass_signals (struct target_ops *self, int arg1, unsigned char * arg2) 1345 { 1346 fprintf_unfiltered (gdb_stdlog, "-> %s->to_pass_signals (...)\n", debug_target.to_shortname); 1347 debug_target.to_pass_signals (&debug_target, arg1, arg2); 1348 fprintf_unfiltered (gdb_stdlog, "<- %s->to_pass_signals (", debug_target.to_shortname); 1349 target_debug_print_struct_target_ops_p (&debug_target); 1350 fputs_unfiltered (", ", gdb_stdlog); 1351 target_debug_print_int (arg1); 1352 fputs_unfiltered (", ", gdb_stdlog); 1353 target_debug_print_signals (arg2); 1354 fputs_unfiltered (")\n", gdb_stdlog); 1355 } 1356 1357 static void 1358 delegate_program_signals (struct target_ops *self, int arg1, unsigned char * arg2) 1359 { 1360 self = self->beneath; 1361 self->to_program_signals (self, arg1, arg2); 1362 } 1363 1364 static void 1365 tdefault_program_signals (struct target_ops *self, int arg1, unsigned char * arg2) 1366 { 1367 } 1368 1369 static void 1370 debug_program_signals (struct target_ops *self, int arg1, unsigned char * arg2) 1371 { 1372 fprintf_unfiltered (gdb_stdlog, "-> %s->to_program_signals (...)\n", debug_target.to_shortname); 1373 debug_target.to_program_signals (&debug_target, arg1, arg2); 1374 fprintf_unfiltered (gdb_stdlog, "<- %s->to_program_signals (", debug_target.to_shortname); 1375 target_debug_print_struct_target_ops_p (&debug_target); 1376 fputs_unfiltered (", ", gdb_stdlog); 1377 target_debug_print_int (arg1); 1378 fputs_unfiltered (", ", gdb_stdlog); 1379 target_debug_print_signals (arg2); 1380 fputs_unfiltered (")\n", gdb_stdlog); 1381 } 1382 1383 static int 1384 delegate_thread_alive (struct target_ops *self, ptid_t arg1) 1385 { 1386 self = self->beneath; 1387 return self->to_thread_alive (self, arg1); 1388 } 1389 1390 static int 1391 tdefault_thread_alive (struct target_ops *self, ptid_t arg1) 1392 { 1393 return 0; 1394 } 1395 1396 static int 1397 debug_thread_alive (struct target_ops *self, ptid_t arg1) 1398 { 1399 int result; 1400 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_alive (...)\n", debug_target.to_shortname); 1401 result = debug_target.to_thread_alive (&debug_target, arg1); 1402 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_alive (", debug_target.to_shortname); 1403 target_debug_print_struct_target_ops_p (&debug_target); 1404 fputs_unfiltered (", ", gdb_stdlog); 1405 target_debug_print_ptid_t (arg1); 1406 fputs_unfiltered (") = ", gdb_stdlog); 1407 target_debug_print_int (result); 1408 fputs_unfiltered ("\n", gdb_stdlog); 1409 return result; 1410 } 1411 1412 static void 1413 delegate_update_thread_list (struct target_ops *self) 1414 { 1415 self = self->beneath; 1416 self->to_update_thread_list (self); 1417 } 1418 1419 static void 1420 tdefault_update_thread_list (struct target_ops *self) 1421 { 1422 } 1423 1424 static void 1425 debug_update_thread_list (struct target_ops *self) 1426 { 1427 fprintf_unfiltered (gdb_stdlog, "-> %s->to_update_thread_list (...)\n", debug_target.to_shortname); 1428 debug_target.to_update_thread_list (&debug_target); 1429 fprintf_unfiltered (gdb_stdlog, "<- %s->to_update_thread_list (", debug_target.to_shortname); 1430 target_debug_print_struct_target_ops_p (&debug_target); 1431 fputs_unfiltered (")\n", gdb_stdlog); 1432 } 1433 1434 static char * 1435 delegate_pid_to_str (struct target_ops *self, ptid_t arg1) 1436 { 1437 self = self->beneath; 1438 return self->to_pid_to_str (self, arg1); 1439 } 1440 1441 static char * 1442 debug_pid_to_str (struct target_ops *self, ptid_t arg1) 1443 { 1444 char * result; 1445 fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_str (...)\n", debug_target.to_shortname); 1446 result = debug_target.to_pid_to_str (&debug_target, arg1); 1447 fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_str (", debug_target.to_shortname); 1448 target_debug_print_struct_target_ops_p (&debug_target); 1449 fputs_unfiltered (", ", gdb_stdlog); 1450 target_debug_print_ptid_t (arg1); 1451 fputs_unfiltered (") = ", gdb_stdlog); 1452 target_debug_print_char_p (result); 1453 fputs_unfiltered ("\n", gdb_stdlog); 1454 return result; 1455 } 1456 1457 static char * 1458 delegate_extra_thread_info (struct target_ops *self, struct thread_info *arg1) 1459 { 1460 self = self->beneath; 1461 return self->to_extra_thread_info (self, arg1); 1462 } 1463 1464 static char * 1465 tdefault_extra_thread_info (struct target_ops *self, struct thread_info *arg1) 1466 { 1467 return NULL; 1468 } 1469 1470 static char * 1471 debug_extra_thread_info (struct target_ops *self, struct thread_info *arg1) 1472 { 1473 char * result; 1474 fprintf_unfiltered (gdb_stdlog, "-> %s->to_extra_thread_info (...)\n", debug_target.to_shortname); 1475 result = debug_target.to_extra_thread_info (&debug_target, arg1); 1476 fprintf_unfiltered (gdb_stdlog, "<- %s->to_extra_thread_info (", debug_target.to_shortname); 1477 target_debug_print_struct_target_ops_p (&debug_target); 1478 fputs_unfiltered (", ", gdb_stdlog); 1479 target_debug_print_struct_thread_info_p (arg1); 1480 fputs_unfiltered (") = ", gdb_stdlog); 1481 target_debug_print_char_p (result); 1482 fputs_unfiltered ("\n", gdb_stdlog); 1483 return result; 1484 } 1485 1486 static char * 1487 delegate_thread_name (struct target_ops *self, struct thread_info *arg1) 1488 { 1489 self = self->beneath; 1490 return self->to_thread_name (self, arg1); 1491 } 1492 1493 static char * 1494 tdefault_thread_name (struct target_ops *self, struct thread_info *arg1) 1495 { 1496 return NULL; 1497 } 1498 1499 static char * 1500 debug_thread_name (struct target_ops *self, struct thread_info *arg1) 1501 { 1502 char * result; 1503 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_name (...)\n", debug_target.to_shortname); 1504 result = debug_target.to_thread_name (&debug_target, arg1); 1505 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_name (", debug_target.to_shortname); 1506 target_debug_print_struct_target_ops_p (&debug_target); 1507 fputs_unfiltered (", ", gdb_stdlog); 1508 target_debug_print_struct_thread_info_p (arg1); 1509 fputs_unfiltered (") = ", gdb_stdlog); 1510 target_debug_print_char_p (result); 1511 fputs_unfiltered ("\n", gdb_stdlog); 1512 return result; 1513 } 1514 1515 static void 1516 delegate_stop (struct target_ops *self, ptid_t arg1) 1517 { 1518 self = self->beneath; 1519 self->to_stop (self, arg1); 1520 } 1521 1522 static void 1523 tdefault_stop (struct target_ops *self, ptid_t arg1) 1524 { 1525 } 1526 1527 static void 1528 debug_stop (struct target_ops *self, ptid_t arg1) 1529 { 1530 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop (...)\n", debug_target.to_shortname); 1531 debug_target.to_stop (&debug_target, arg1); 1532 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop (", debug_target.to_shortname); 1533 target_debug_print_struct_target_ops_p (&debug_target); 1534 fputs_unfiltered (", ", gdb_stdlog); 1535 target_debug_print_ptid_t (arg1); 1536 fputs_unfiltered (")\n", gdb_stdlog); 1537 } 1538 1539 static void 1540 delegate_check_pending_interrupt (struct target_ops *self) 1541 { 1542 self = self->beneath; 1543 self->to_check_pending_interrupt (self); 1544 } 1545 1546 static void 1547 tdefault_check_pending_interrupt (struct target_ops *self) 1548 { 1549 } 1550 1551 static void 1552 debug_check_pending_interrupt (struct target_ops *self) 1553 { 1554 fprintf_unfiltered (gdb_stdlog, "-> %s->to_check_pending_interrupt (...)\n", debug_target.to_shortname); 1555 debug_target.to_check_pending_interrupt (&debug_target); 1556 fprintf_unfiltered (gdb_stdlog, "<- %s->to_check_pending_interrupt (", debug_target.to_shortname); 1557 target_debug_print_struct_target_ops_p (&debug_target); 1558 fputs_unfiltered (")\n", gdb_stdlog); 1559 } 1560 1561 static void 1562 delegate_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2) 1563 { 1564 self = self->beneath; 1565 self->to_rcmd (self, arg1, arg2); 1566 } 1567 1568 static void 1569 debug_rcmd (struct target_ops *self, const char *arg1, struct ui_file *arg2) 1570 { 1571 fprintf_unfiltered (gdb_stdlog, "-> %s->to_rcmd (...)\n", debug_target.to_shortname); 1572 debug_target.to_rcmd (&debug_target, arg1, arg2); 1573 fprintf_unfiltered (gdb_stdlog, "<- %s->to_rcmd (", debug_target.to_shortname); 1574 target_debug_print_struct_target_ops_p (&debug_target); 1575 fputs_unfiltered (", ", gdb_stdlog); 1576 target_debug_print_const_char_p (arg1); 1577 fputs_unfiltered (", ", gdb_stdlog); 1578 target_debug_print_struct_ui_file_p (arg2); 1579 fputs_unfiltered (")\n", gdb_stdlog); 1580 } 1581 1582 static char * 1583 delegate_pid_to_exec_file (struct target_ops *self, int arg1) 1584 { 1585 self = self->beneath; 1586 return self->to_pid_to_exec_file (self, arg1); 1587 } 1588 1589 static char * 1590 tdefault_pid_to_exec_file (struct target_ops *self, int arg1) 1591 { 1592 return NULL; 1593 } 1594 1595 static char * 1596 debug_pid_to_exec_file (struct target_ops *self, int arg1) 1597 { 1598 char * result; 1599 fprintf_unfiltered (gdb_stdlog, "-> %s->to_pid_to_exec_file (...)\n", debug_target.to_shortname); 1600 result = debug_target.to_pid_to_exec_file (&debug_target, arg1); 1601 fprintf_unfiltered (gdb_stdlog, "<- %s->to_pid_to_exec_file (", debug_target.to_shortname); 1602 target_debug_print_struct_target_ops_p (&debug_target); 1603 fputs_unfiltered (", ", gdb_stdlog); 1604 target_debug_print_int (arg1); 1605 fputs_unfiltered (") = ", gdb_stdlog); 1606 target_debug_print_char_p (result); 1607 fputs_unfiltered ("\n", gdb_stdlog); 1608 return result; 1609 } 1610 1611 static void 1612 delegate_log_command (struct target_ops *self, const char *arg1) 1613 { 1614 self = self->beneath; 1615 self->to_log_command (self, arg1); 1616 } 1617 1618 static void 1619 tdefault_log_command (struct target_ops *self, const char *arg1) 1620 { 1621 } 1622 1623 static void 1624 debug_log_command (struct target_ops *self, const char *arg1) 1625 { 1626 fprintf_unfiltered (gdb_stdlog, "-> %s->to_log_command (...)\n", debug_target.to_shortname); 1627 debug_target.to_log_command (&debug_target, arg1); 1628 fprintf_unfiltered (gdb_stdlog, "<- %s->to_log_command (", debug_target.to_shortname); 1629 target_debug_print_struct_target_ops_p (&debug_target); 1630 fputs_unfiltered (", ", gdb_stdlog); 1631 target_debug_print_const_char_p (arg1); 1632 fputs_unfiltered (")\n", gdb_stdlog); 1633 } 1634 1635 static struct target_section_table * 1636 delegate_get_section_table (struct target_ops *self) 1637 { 1638 self = self->beneath; 1639 return self->to_get_section_table (self); 1640 } 1641 1642 static struct target_section_table * 1643 tdefault_get_section_table (struct target_ops *self) 1644 { 1645 return NULL; 1646 } 1647 1648 static struct target_section_table * 1649 debug_get_section_table (struct target_ops *self) 1650 { 1651 struct target_section_table * result; 1652 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_section_table (...)\n", debug_target.to_shortname); 1653 result = debug_target.to_get_section_table (&debug_target); 1654 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_section_table (", debug_target.to_shortname); 1655 target_debug_print_struct_target_ops_p (&debug_target); 1656 fputs_unfiltered (") = ", gdb_stdlog); 1657 target_debug_print_struct_target_section_table_p (result); 1658 fputs_unfiltered ("\n", gdb_stdlog); 1659 return result; 1660 } 1661 1662 static int 1663 delegate_can_async_p (struct target_ops *self) 1664 { 1665 self = self->beneath; 1666 return self->to_can_async_p (self); 1667 } 1668 1669 static int 1670 tdefault_can_async_p (struct target_ops *self) 1671 { 1672 return 0; 1673 } 1674 1675 static int 1676 debug_can_async_p (struct target_ops *self) 1677 { 1678 int result; 1679 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_async_p (...)\n", debug_target.to_shortname); 1680 result = debug_target.to_can_async_p (&debug_target); 1681 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_async_p (", debug_target.to_shortname); 1682 target_debug_print_struct_target_ops_p (&debug_target); 1683 fputs_unfiltered (") = ", gdb_stdlog); 1684 target_debug_print_int (result); 1685 fputs_unfiltered ("\n", gdb_stdlog); 1686 return result; 1687 } 1688 1689 static int 1690 delegate_is_async_p (struct target_ops *self) 1691 { 1692 self = self->beneath; 1693 return self->to_is_async_p (self); 1694 } 1695 1696 static int 1697 tdefault_is_async_p (struct target_ops *self) 1698 { 1699 return 0; 1700 } 1701 1702 static int 1703 debug_is_async_p (struct target_ops *self) 1704 { 1705 int result; 1706 fprintf_unfiltered (gdb_stdlog, "-> %s->to_is_async_p (...)\n", debug_target.to_shortname); 1707 result = debug_target.to_is_async_p (&debug_target); 1708 fprintf_unfiltered (gdb_stdlog, "<- %s->to_is_async_p (", debug_target.to_shortname); 1709 target_debug_print_struct_target_ops_p (&debug_target); 1710 fputs_unfiltered (") = ", gdb_stdlog); 1711 target_debug_print_int (result); 1712 fputs_unfiltered ("\n", gdb_stdlog); 1713 return result; 1714 } 1715 1716 static void 1717 delegate_async (struct target_ops *self, int arg1) 1718 { 1719 self = self->beneath; 1720 self->to_async (self, arg1); 1721 } 1722 1723 static void 1724 tdefault_async (struct target_ops *self, int arg1) 1725 { 1726 tcomplain (); 1727 } 1728 1729 static void 1730 debug_async (struct target_ops *self, int arg1) 1731 { 1732 fprintf_unfiltered (gdb_stdlog, "-> %s->to_async (...)\n", debug_target.to_shortname); 1733 debug_target.to_async (&debug_target, arg1); 1734 fprintf_unfiltered (gdb_stdlog, "<- %s->to_async (", debug_target.to_shortname); 1735 target_debug_print_struct_target_ops_p (&debug_target); 1736 fputs_unfiltered (", ", gdb_stdlog); 1737 target_debug_print_int (arg1); 1738 fputs_unfiltered (")\n", gdb_stdlog); 1739 } 1740 1741 static int 1742 delegate_supports_non_stop (struct target_ops *self) 1743 { 1744 self = self->beneath; 1745 return self->to_supports_non_stop (self); 1746 } 1747 1748 static int 1749 tdefault_supports_non_stop (struct target_ops *self) 1750 { 1751 return 0; 1752 } 1753 1754 static int 1755 debug_supports_non_stop (struct target_ops *self) 1756 { 1757 int result; 1758 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_non_stop (...)\n", debug_target.to_shortname); 1759 result = debug_target.to_supports_non_stop (&debug_target); 1760 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_non_stop (", debug_target.to_shortname); 1761 target_debug_print_struct_target_ops_p (&debug_target); 1762 fputs_unfiltered (") = ", gdb_stdlog); 1763 target_debug_print_int (result); 1764 fputs_unfiltered ("\n", gdb_stdlog); 1765 return result; 1766 } 1767 1768 static int 1769 delegate_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2) 1770 { 1771 self = self->beneath; 1772 return self->to_find_memory_regions (self, arg1, arg2); 1773 } 1774 1775 static int 1776 debug_find_memory_regions (struct target_ops *self, find_memory_region_ftype arg1, void *arg2) 1777 { 1778 int result; 1779 fprintf_unfiltered (gdb_stdlog, "-> %s->to_find_memory_regions (...)\n", debug_target.to_shortname); 1780 result = debug_target.to_find_memory_regions (&debug_target, arg1, arg2); 1781 fprintf_unfiltered (gdb_stdlog, "<- %s->to_find_memory_regions (", debug_target.to_shortname); 1782 target_debug_print_struct_target_ops_p (&debug_target); 1783 fputs_unfiltered (", ", gdb_stdlog); 1784 target_debug_print_find_memory_region_ftype (arg1); 1785 fputs_unfiltered (", ", gdb_stdlog); 1786 target_debug_print_void_p (arg2); 1787 fputs_unfiltered (") = ", gdb_stdlog); 1788 target_debug_print_int (result); 1789 fputs_unfiltered ("\n", gdb_stdlog); 1790 return result; 1791 } 1792 1793 static char * 1794 delegate_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2) 1795 { 1796 self = self->beneath; 1797 return self->to_make_corefile_notes (self, arg1, arg2); 1798 } 1799 1800 static char * 1801 debug_make_corefile_notes (struct target_ops *self, bfd *arg1, int *arg2) 1802 { 1803 char * result; 1804 fprintf_unfiltered (gdb_stdlog, "-> %s->to_make_corefile_notes (...)\n", debug_target.to_shortname); 1805 result = debug_target.to_make_corefile_notes (&debug_target, arg1, arg2); 1806 fprintf_unfiltered (gdb_stdlog, "<- %s->to_make_corefile_notes (", debug_target.to_shortname); 1807 target_debug_print_struct_target_ops_p (&debug_target); 1808 fputs_unfiltered (", ", gdb_stdlog); 1809 target_debug_print_bfd_p (arg1); 1810 fputs_unfiltered (", ", gdb_stdlog); 1811 target_debug_print_int_p (arg2); 1812 fputs_unfiltered (") = ", gdb_stdlog); 1813 target_debug_print_char_p (result); 1814 fputs_unfiltered ("\n", gdb_stdlog); 1815 return result; 1816 } 1817 1818 static gdb_byte * 1819 delegate_get_bookmark (struct target_ops *self, const char *arg1, int arg2) 1820 { 1821 self = self->beneath; 1822 return self->to_get_bookmark (self, arg1, arg2); 1823 } 1824 1825 static gdb_byte * 1826 tdefault_get_bookmark (struct target_ops *self, const char *arg1, int arg2) 1827 { 1828 tcomplain (); 1829 } 1830 1831 static gdb_byte * 1832 debug_get_bookmark (struct target_ops *self, const char *arg1, int arg2) 1833 { 1834 gdb_byte * result; 1835 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_bookmark (...)\n", debug_target.to_shortname); 1836 result = debug_target.to_get_bookmark (&debug_target, arg1, arg2); 1837 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_bookmark (", debug_target.to_shortname); 1838 target_debug_print_struct_target_ops_p (&debug_target); 1839 fputs_unfiltered (", ", gdb_stdlog); 1840 target_debug_print_const_char_p (arg1); 1841 fputs_unfiltered (", ", gdb_stdlog); 1842 target_debug_print_int (arg2); 1843 fputs_unfiltered (") = ", gdb_stdlog); 1844 target_debug_print_gdb_byte_p (result); 1845 fputs_unfiltered ("\n", gdb_stdlog); 1846 return result; 1847 } 1848 1849 static void 1850 delegate_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2) 1851 { 1852 self = self->beneath; 1853 self->to_goto_bookmark (self, arg1, arg2); 1854 } 1855 1856 static void 1857 tdefault_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2) 1858 { 1859 tcomplain (); 1860 } 1861 1862 static void 1863 debug_goto_bookmark (struct target_ops *self, const gdb_byte *arg1, int arg2) 1864 { 1865 fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_bookmark (...)\n", debug_target.to_shortname); 1866 debug_target.to_goto_bookmark (&debug_target, arg1, arg2); 1867 fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_bookmark (", debug_target.to_shortname); 1868 target_debug_print_struct_target_ops_p (&debug_target); 1869 fputs_unfiltered (", ", gdb_stdlog); 1870 target_debug_print_const_gdb_byte_p (arg1); 1871 fputs_unfiltered (", ", gdb_stdlog); 1872 target_debug_print_int (arg2); 1873 fputs_unfiltered (")\n", gdb_stdlog); 1874 } 1875 1876 static CORE_ADDR 1877 delegate_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3) 1878 { 1879 self = self->beneath; 1880 return self->to_get_thread_local_address (self, arg1, arg2, arg3); 1881 } 1882 1883 static CORE_ADDR 1884 tdefault_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3) 1885 { 1886 generic_tls_error (); 1887 } 1888 1889 static CORE_ADDR 1890 debug_get_thread_local_address (struct target_ops *self, ptid_t arg1, CORE_ADDR arg2, CORE_ADDR arg3) 1891 { 1892 CORE_ADDR result; 1893 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_thread_local_address (...)\n", debug_target.to_shortname); 1894 result = debug_target.to_get_thread_local_address (&debug_target, arg1, arg2, arg3); 1895 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_thread_local_address (", debug_target.to_shortname); 1896 target_debug_print_struct_target_ops_p (&debug_target); 1897 fputs_unfiltered (", ", gdb_stdlog); 1898 target_debug_print_ptid_t (arg1); 1899 fputs_unfiltered (", ", gdb_stdlog); 1900 target_debug_print_CORE_ADDR (arg2); 1901 fputs_unfiltered (", ", gdb_stdlog); 1902 target_debug_print_CORE_ADDR (arg3); 1903 fputs_unfiltered (") = ", gdb_stdlog); 1904 target_debug_print_CORE_ADDR (result); 1905 fputs_unfiltered ("\n", gdb_stdlog); 1906 return result; 1907 } 1908 1909 static enum target_xfer_status 1910 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) 1911 { 1912 self = self->beneath; 1913 return self->to_xfer_partial (self, arg1, arg2, arg3, arg4, arg5, arg6, arg7); 1914 } 1915 1916 static enum target_xfer_status 1917 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) 1918 { 1919 return TARGET_XFER_E_IO; 1920 } 1921 1922 static enum target_xfer_status 1923 debug_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) 1924 { 1925 enum target_xfer_status result; 1926 fprintf_unfiltered (gdb_stdlog, "-> %s->to_xfer_partial (...)\n", debug_target.to_shortname); 1927 result = debug_target.to_xfer_partial (&debug_target, arg1, arg2, arg3, arg4, arg5, arg6, arg7); 1928 fprintf_unfiltered (gdb_stdlog, "<- %s->to_xfer_partial (", debug_target.to_shortname); 1929 target_debug_print_struct_target_ops_p (&debug_target); 1930 fputs_unfiltered (", ", gdb_stdlog); 1931 target_debug_print_enum_target_object (arg1); 1932 fputs_unfiltered (", ", gdb_stdlog); 1933 target_debug_print_const_char_p (arg2); 1934 fputs_unfiltered (", ", gdb_stdlog); 1935 target_debug_print_gdb_byte_p (arg3); 1936 fputs_unfiltered (", ", gdb_stdlog); 1937 target_debug_print_const_gdb_byte_p (arg4); 1938 fputs_unfiltered (", ", gdb_stdlog); 1939 target_debug_print_ULONGEST (arg5); 1940 fputs_unfiltered (", ", gdb_stdlog); 1941 target_debug_print_ULONGEST (arg6); 1942 fputs_unfiltered (", ", gdb_stdlog); 1943 target_debug_print_ULONGEST_p (arg7); 1944 fputs_unfiltered (") = ", gdb_stdlog); 1945 target_debug_print_enum_target_xfer_status (result); 1946 fputs_unfiltered ("\n", gdb_stdlog); 1947 return result; 1948 } 1949 1950 static VEC(mem_region_s) * 1951 delegate_memory_map (struct target_ops *self) 1952 { 1953 self = self->beneath; 1954 return self->to_memory_map (self); 1955 } 1956 1957 static VEC(mem_region_s) * 1958 tdefault_memory_map (struct target_ops *self) 1959 { 1960 return NULL; 1961 } 1962 1963 static VEC(mem_region_s) * 1964 debug_memory_map (struct target_ops *self) 1965 { 1966 VEC(mem_region_s) * result; 1967 fprintf_unfiltered (gdb_stdlog, "-> %s->to_memory_map (...)\n", debug_target.to_shortname); 1968 result = debug_target.to_memory_map (&debug_target); 1969 fprintf_unfiltered (gdb_stdlog, "<- %s->to_memory_map (", debug_target.to_shortname); 1970 target_debug_print_struct_target_ops_p (&debug_target); 1971 fputs_unfiltered (") = ", gdb_stdlog); 1972 target_debug_print_VEC_mem_region_s__p (result); 1973 fputs_unfiltered ("\n", gdb_stdlog); 1974 return result; 1975 } 1976 1977 static void 1978 delegate_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2) 1979 { 1980 self = self->beneath; 1981 self->to_flash_erase (self, arg1, arg2); 1982 } 1983 1984 static void 1985 tdefault_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2) 1986 { 1987 tcomplain (); 1988 } 1989 1990 static void 1991 debug_flash_erase (struct target_ops *self, ULONGEST arg1, LONGEST arg2) 1992 { 1993 fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_erase (...)\n", debug_target.to_shortname); 1994 debug_target.to_flash_erase (&debug_target, arg1, arg2); 1995 fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_erase (", debug_target.to_shortname); 1996 target_debug_print_struct_target_ops_p (&debug_target); 1997 fputs_unfiltered (", ", gdb_stdlog); 1998 target_debug_print_ULONGEST (arg1); 1999 fputs_unfiltered (", ", gdb_stdlog); 2000 target_debug_print_LONGEST (arg2); 2001 fputs_unfiltered (")\n", gdb_stdlog); 2002 } 2003 2004 static void 2005 delegate_flash_done (struct target_ops *self) 2006 { 2007 self = self->beneath; 2008 self->to_flash_done (self); 2009 } 2010 2011 static void 2012 tdefault_flash_done (struct target_ops *self) 2013 { 2014 tcomplain (); 2015 } 2016 2017 static void 2018 debug_flash_done (struct target_ops *self) 2019 { 2020 fprintf_unfiltered (gdb_stdlog, "-> %s->to_flash_done (...)\n", debug_target.to_shortname); 2021 debug_target.to_flash_done (&debug_target); 2022 fprintf_unfiltered (gdb_stdlog, "<- %s->to_flash_done (", debug_target.to_shortname); 2023 target_debug_print_struct_target_ops_p (&debug_target); 2024 fputs_unfiltered (")\n", gdb_stdlog); 2025 } 2026 2027 static const struct target_desc * 2028 delegate_read_description (struct target_ops *self) 2029 { 2030 self = self->beneath; 2031 return self->to_read_description (self); 2032 } 2033 2034 static const struct target_desc * 2035 tdefault_read_description (struct target_ops *self) 2036 { 2037 return NULL; 2038 } 2039 2040 static const struct target_desc * 2041 debug_read_description (struct target_ops *self) 2042 { 2043 const struct target_desc * result; 2044 fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_description (...)\n", debug_target.to_shortname); 2045 result = debug_target.to_read_description (&debug_target); 2046 fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_description (", debug_target.to_shortname); 2047 target_debug_print_struct_target_ops_p (&debug_target); 2048 fputs_unfiltered (") = ", gdb_stdlog); 2049 target_debug_print_const_struct_target_desc_p (result); 2050 fputs_unfiltered ("\n", gdb_stdlog); 2051 return result; 2052 } 2053 2054 static ptid_t 2055 delegate_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2) 2056 { 2057 self = self->beneath; 2058 return self->to_get_ada_task_ptid (self, arg1, arg2); 2059 } 2060 2061 static ptid_t 2062 debug_get_ada_task_ptid (struct target_ops *self, long arg1, long arg2) 2063 { 2064 ptid_t result; 2065 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_ada_task_ptid (...)\n", debug_target.to_shortname); 2066 result = debug_target.to_get_ada_task_ptid (&debug_target, arg1, arg2); 2067 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_ada_task_ptid (", debug_target.to_shortname); 2068 target_debug_print_struct_target_ops_p (&debug_target); 2069 fputs_unfiltered (", ", gdb_stdlog); 2070 target_debug_print_long (arg1); 2071 fputs_unfiltered (", ", gdb_stdlog); 2072 target_debug_print_long (arg2); 2073 fputs_unfiltered (") = ", gdb_stdlog); 2074 target_debug_print_ptid_t (result); 2075 fputs_unfiltered ("\n", gdb_stdlog); 2076 return result; 2077 } 2078 2079 static int 2080 delegate_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4) 2081 { 2082 self = self->beneath; 2083 return self->to_auxv_parse (self, arg1, arg2, arg3, arg4); 2084 } 2085 2086 static int 2087 debug_auxv_parse (struct target_ops *self, gdb_byte **arg1, gdb_byte *arg2, CORE_ADDR *arg3, CORE_ADDR *arg4) 2088 { 2089 int result; 2090 fprintf_unfiltered (gdb_stdlog, "-> %s->to_auxv_parse (...)\n", debug_target.to_shortname); 2091 result = debug_target.to_auxv_parse (&debug_target, arg1, arg2, arg3, arg4); 2092 fprintf_unfiltered (gdb_stdlog, "<- %s->to_auxv_parse (", debug_target.to_shortname); 2093 target_debug_print_struct_target_ops_p (&debug_target); 2094 fputs_unfiltered (", ", gdb_stdlog); 2095 target_debug_print_gdb_byte_pp (arg1); 2096 fputs_unfiltered (", ", gdb_stdlog); 2097 target_debug_print_gdb_byte_p (arg2); 2098 fputs_unfiltered (", ", gdb_stdlog); 2099 target_debug_print_CORE_ADDR_p (arg3); 2100 fputs_unfiltered (", ", gdb_stdlog); 2101 target_debug_print_CORE_ADDR_p (arg4); 2102 fputs_unfiltered (") = ", gdb_stdlog); 2103 target_debug_print_int (result); 2104 fputs_unfiltered ("\n", gdb_stdlog); 2105 return result; 2106 } 2107 2108 static int 2109 delegate_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5) 2110 { 2111 self = self->beneath; 2112 return self->to_search_memory (self, arg1, arg2, arg3, arg4, arg5); 2113 } 2114 2115 static int 2116 debug_search_memory (struct target_ops *self, CORE_ADDR arg1, ULONGEST arg2, const gdb_byte *arg3, ULONGEST arg4, CORE_ADDR *arg5) 2117 { 2118 int result; 2119 fprintf_unfiltered (gdb_stdlog, "-> %s->to_search_memory (...)\n", debug_target.to_shortname); 2120 result = debug_target.to_search_memory (&debug_target, arg1, arg2, arg3, arg4, arg5); 2121 fprintf_unfiltered (gdb_stdlog, "<- %s->to_search_memory (", debug_target.to_shortname); 2122 target_debug_print_struct_target_ops_p (&debug_target); 2123 fputs_unfiltered (", ", gdb_stdlog); 2124 target_debug_print_CORE_ADDR (arg1); 2125 fputs_unfiltered (", ", gdb_stdlog); 2126 target_debug_print_ULONGEST (arg2); 2127 fputs_unfiltered (", ", gdb_stdlog); 2128 target_debug_print_const_gdb_byte_p (arg3); 2129 fputs_unfiltered (", ", gdb_stdlog); 2130 target_debug_print_ULONGEST (arg4); 2131 fputs_unfiltered (", ", gdb_stdlog); 2132 target_debug_print_CORE_ADDR_p (arg5); 2133 fputs_unfiltered (") = ", gdb_stdlog); 2134 target_debug_print_int (result); 2135 fputs_unfiltered ("\n", gdb_stdlog); 2136 return result; 2137 } 2138 2139 static int 2140 delegate_can_execute_reverse (struct target_ops *self) 2141 { 2142 self = self->beneath; 2143 return self->to_can_execute_reverse (self); 2144 } 2145 2146 static int 2147 tdefault_can_execute_reverse (struct target_ops *self) 2148 { 2149 return 0; 2150 } 2151 2152 static int 2153 debug_can_execute_reverse (struct target_ops *self) 2154 { 2155 int result; 2156 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_execute_reverse (...)\n", debug_target.to_shortname); 2157 result = debug_target.to_can_execute_reverse (&debug_target); 2158 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_execute_reverse (", debug_target.to_shortname); 2159 target_debug_print_struct_target_ops_p (&debug_target); 2160 fputs_unfiltered (") = ", gdb_stdlog); 2161 target_debug_print_int (result); 2162 fputs_unfiltered ("\n", gdb_stdlog); 2163 return result; 2164 } 2165 2166 static enum exec_direction_kind 2167 delegate_execution_direction (struct target_ops *self) 2168 { 2169 self = self->beneath; 2170 return self->to_execution_direction (self); 2171 } 2172 2173 static enum exec_direction_kind 2174 debug_execution_direction (struct target_ops *self) 2175 { 2176 enum exec_direction_kind result; 2177 fprintf_unfiltered (gdb_stdlog, "-> %s->to_execution_direction (...)\n", debug_target.to_shortname); 2178 result = debug_target.to_execution_direction (&debug_target); 2179 fprintf_unfiltered (gdb_stdlog, "<- %s->to_execution_direction (", debug_target.to_shortname); 2180 target_debug_print_struct_target_ops_p (&debug_target); 2181 fputs_unfiltered (") = ", gdb_stdlog); 2182 target_debug_print_enum_exec_direction_kind (result); 2183 fputs_unfiltered ("\n", gdb_stdlog); 2184 return result; 2185 } 2186 2187 static int 2188 delegate_supports_multi_process (struct target_ops *self) 2189 { 2190 self = self->beneath; 2191 return self->to_supports_multi_process (self); 2192 } 2193 2194 static int 2195 tdefault_supports_multi_process (struct target_ops *self) 2196 { 2197 return 0; 2198 } 2199 2200 static int 2201 debug_supports_multi_process (struct target_ops *self) 2202 { 2203 int result; 2204 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_multi_process (...)\n", debug_target.to_shortname); 2205 result = debug_target.to_supports_multi_process (&debug_target); 2206 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_multi_process (", debug_target.to_shortname); 2207 target_debug_print_struct_target_ops_p (&debug_target); 2208 fputs_unfiltered (") = ", gdb_stdlog); 2209 target_debug_print_int (result); 2210 fputs_unfiltered ("\n", gdb_stdlog); 2211 return result; 2212 } 2213 2214 static int 2215 delegate_supports_enable_disable_tracepoint (struct target_ops *self) 2216 { 2217 self = self->beneath; 2218 return self->to_supports_enable_disable_tracepoint (self); 2219 } 2220 2221 static int 2222 tdefault_supports_enable_disable_tracepoint (struct target_ops *self) 2223 { 2224 return 0; 2225 } 2226 2227 static int 2228 debug_supports_enable_disable_tracepoint (struct target_ops *self) 2229 { 2230 int result; 2231 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_enable_disable_tracepoint (...)\n", debug_target.to_shortname); 2232 result = debug_target.to_supports_enable_disable_tracepoint (&debug_target); 2233 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_enable_disable_tracepoint (", debug_target.to_shortname); 2234 target_debug_print_struct_target_ops_p (&debug_target); 2235 fputs_unfiltered (") = ", gdb_stdlog); 2236 target_debug_print_int (result); 2237 fputs_unfiltered ("\n", gdb_stdlog); 2238 return result; 2239 } 2240 2241 static int 2242 delegate_supports_string_tracing (struct target_ops *self) 2243 { 2244 self = self->beneath; 2245 return self->to_supports_string_tracing (self); 2246 } 2247 2248 static int 2249 tdefault_supports_string_tracing (struct target_ops *self) 2250 { 2251 return 0; 2252 } 2253 2254 static int 2255 debug_supports_string_tracing (struct target_ops *self) 2256 { 2257 int result; 2258 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_string_tracing (...)\n", debug_target.to_shortname); 2259 result = debug_target.to_supports_string_tracing (&debug_target); 2260 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_string_tracing (", debug_target.to_shortname); 2261 target_debug_print_struct_target_ops_p (&debug_target); 2262 fputs_unfiltered (") = ", gdb_stdlog); 2263 target_debug_print_int (result); 2264 fputs_unfiltered ("\n", gdb_stdlog); 2265 return result; 2266 } 2267 2268 static int 2269 delegate_supports_evaluation_of_breakpoint_conditions (struct target_ops *self) 2270 { 2271 self = self->beneath; 2272 return self->to_supports_evaluation_of_breakpoint_conditions (self); 2273 } 2274 2275 static int 2276 tdefault_supports_evaluation_of_breakpoint_conditions (struct target_ops *self) 2277 { 2278 return 0; 2279 } 2280 2281 static int 2282 debug_supports_evaluation_of_breakpoint_conditions (struct target_ops *self) 2283 { 2284 int result; 2285 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_evaluation_of_breakpoint_conditions (...)\n", debug_target.to_shortname); 2286 result = debug_target.to_supports_evaluation_of_breakpoint_conditions (&debug_target); 2287 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_evaluation_of_breakpoint_conditions (", debug_target.to_shortname); 2288 target_debug_print_struct_target_ops_p (&debug_target); 2289 fputs_unfiltered (") = ", gdb_stdlog); 2290 target_debug_print_int (result); 2291 fputs_unfiltered ("\n", gdb_stdlog); 2292 return result; 2293 } 2294 2295 static int 2296 delegate_can_run_breakpoint_commands (struct target_ops *self) 2297 { 2298 self = self->beneath; 2299 return self->to_can_run_breakpoint_commands (self); 2300 } 2301 2302 static int 2303 tdefault_can_run_breakpoint_commands (struct target_ops *self) 2304 { 2305 return 0; 2306 } 2307 2308 static int 2309 debug_can_run_breakpoint_commands (struct target_ops *self) 2310 { 2311 int result; 2312 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_run_breakpoint_commands (...)\n", debug_target.to_shortname); 2313 result = debug_target.to_can_run_breakpoint_commands (&debug_target); 2314 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_run_breakpoint_commands (", debug_target.to_shortname); 2315 target_debug_print_struct_target_ops_p (&debug_target); 2316 fputs_unfiltered (") = ", gdb_stdlog); 2317 target_debug_print_int (result); 2318 fputs_unfiltered ("\n", gdb_stdlog); 2319 return result; 2320 } 2321 2322 static struct gdbarch * 2323 delegate_thread_architecture (struct target_ops *self, ptid_t arg1) 2324 { 2325 self = self->beneath; 2326 return self->to_thread_architecture (self, arg1); 2327 } 2328 2329 static struct gdbarch * 2330 debug_thread_architecture (struct target_ops *self, ptid_t arg1) 2331 { 2332 struct gdbarch * result; 2333 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_architecture (...)\n", debug_target.to_shortname); 2334 result = debug_target.to_thread_architecture (&debug_target, arg1); 2335 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_architecture (", debug_target.to_shortname); 2336 target_debug_print_struct_target_ops_p (&debug_target); 2337 fputs_unfiltered (", ", gdb_stdlog); 2338 target_debug_print_ptid_t (arg1); 2339 fputs_unfiltered (") = ", gdb_stdlog); 2340 target_debug_print_struct_gdbarch_p (result); 2341 fputs_unfiltered ("\n", gdb_stdlog); 2342 return result; 2343 } 2344 2345 static struct address_space * 2346 delegate_thread_address_space (struct target_ops *self, ptid_t arg1) 2347 { 2348 self = self->beneath; 2349 return self->to_thread_address_space (self, arg1); 2350 } 2351 2352 static struct address_space * 2353 debug_thread_address_space (struct target_ops *self, ptid_t arg1) 2354 { 2355 struct address_space * result; 2356 fprintf_unfiltered (gdb_stdlog, "-> %s->to_thread_address_space (...)\n", debug_target.to_shortname); 2357 result = debug_target.to_thread_address_space (&debug_target, arg1); 2358 fprintf_unfiltered (gdb_stdlog, "<- %s->to_thread_address_space (", debug_target.to_shortname); 2359 target_debug_print_struct_target_ops_p (&debug_target); 2360 fputs_unfiltered (", ", gdb_stdlog); 2361 target_debug_print_ptid_t (arg1); 2362 fputs_unfiltered (") = ", gdb_stdlog); 2363 target_debug_print_struct_address_space_p (result); 2364 fputs_unfiltered ("\n", gdb_stdlog); 2365 return result; 2366 } 2367 2368 static int 2369 delegate_filesystem_is_local (struct target_ops *self) 2370 { 2371 self = self->beneath; 2372 return self->to_filesystem_is_local (self); 2373 } 2374 2375 static int 2376 tdefault_filesystem_is_local (struct target_ops *self) 2377 { 2378 return 1; 2379 } 2380 2381 static int 2382 debug_filesystem_is_local (struct target_ops *self) 2383 { 2384 int result; 2385 fprintf_unfiltered (gdb_stdlog, "-> %s->to_filesystem_is_local (...)\n", debug_target.to_shortname); 2386 result = debug_target.to_filesystem_is_local (&debug_target); 2387 fprintf_unfiltered (gdb_stdlog, "<- %s->to_filesystem_is_local (", debug_target.to_shortname); 2388 target_debug_print_struct_target_ops_p (&debug_target); 2389 fputs_unfiltered (") = ", gdb_stdlog); 2390 target_debug_print_int (result); 2391 fputs_unfiltered ("\n", gdb_stdlog); 2392 return result; 2393 } 2394 2395 static void 2396 delegate_trace_init (struct target_ops *self) 2397 { 2398 self = self->beneath; 2399 self->to_trace_init (self); 2400 } 2401 2402 static void 2403 tdefault_trace_init (struct target_ops *self) 2404 { 2405 tcomplain (); 2406 } 2407 2408 static void 2409 debug_trace_init (struct target_ops *self) 2410 { 2411 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_init (...)\n", debug_target.to_shortname); 2412 debug_target.to_trace_init (&debug_target); 2413 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_init (", debug_target.to_shortname); 2414 target_debug_print_struct_target_ops_p (&debug_target); 2415 fputs_unfiltered (")\n", gdb_stdlog); 2416 } 2417 2418 static void 2419 delegate_download_tracepoint (struct target_ops *self, struct bp_location *arg1) 2420 { 2421 self = self->beneath; 2422 self->to_download_tracepoint (self, arg1); 2423 } 2424 2425 static void 2426 tdefault_download_tracepoint (struct target_ops *self, struct bp_location *arg1) 2427 { 2428 tcomplain (); 2429 } 2430 2431 static void 2432 debug_download_tracepoint (struct target_ops *self, struct bp_location *arg1) 2433 { 2434 fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_tracepoint (...)\n", debug_target.to_shortname); 2435 debug_target.to_download_tracepoint (&debug_target, arg1); 2436 fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_tracepoint (", debug_target.to_shortname); 2437 target_debug_print_struct_target_ops_p (&debug_target); 2438 fputs_unfiltered (", ", gdb_stdlog); 2439 target_debug_print_struct_bp_location_p (arg1); 2440 fputs_unfiltered (")\n", gdb_stdlog); 2441 } 2442 2443 static int 2444 delegate_can_download_tracepoint (struct target_ops *self) 2445 { 2446 self = self->beneath; 2447 return self->to_can_download_tracepoint (self); 2448 } 2449 2450 static int 2451 tdefault_can_download_tracepoint (struct target_ops *self) 2452 { 2453 return 0; 2454 } 2455 2456 static int 2457 debug_can_download_tracepoint (struct target_ops *self) 2458 { 2459 int result; 2460 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_download_tracepoint (...)\n", debug_target.to_shortname); 2461 result = debug_target.to_can_download_tracepoint (&debug_target); 2462 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_download_tracepoint (", debug_target.to_shortname); 2463 target_debug_print_struct_target_ops_p (&debug_target); 2464 fputs_unfiltered (") = ", gdb_stdlog); 2465 target_debug_print_int (result); 2466 fputs_unfiltered ("\n", gdb_stdlog); 2467 return result; 2468 } 2469 2470 static void 2471 delegate_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1) 2472 { 2473 self = self->beneath; 2474 self->to_download_trace_state_variable (self, arg1); 2475 } 2476 2477 static void 2478 tdefault_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1) 2479 { 2480 tcomplain (); 2481 } 2482 2483 static void 2484 debug_download_trace_state_variable (struct target_ops *self, struct trace_state_variable *arg1) 2485 { 2486 fprintf_unfiltered (gdb_stdlog, "-> %s->to_download_trace_state_variable (...)\n", debug_target.to_shortname); 2487 debug_target.to_download_trace_state_variable (&debug_target, arg1); 2488 fprintf_unfiltered (gdb_stdlog, "<- %s->to_download_trace_state_variable (", debug_target.to_shortname); 2489 target_debug_print_struct_target_ops_p (&debug_target); 2490 fputs_unfiltered (", ", gdb_stdlog); 2491 target_debug_print_struct_trace_state_variable_p (arg1); 2492 fputs_unfiltered (")\n", gdb_stdlog); 2493 } 2494 2495 static void 2496 delegate_enable_tracepoint (struct target_ops *self, struct bp_location *arg1) 2497 { 2498 self = self->beneath; 2499 self->to_enable_tracepoint (self, arg1); 2500 } 2501 2502 static void 2503 tdefault_enable_tracepoint (struct target_ops *self, struct bp_location *arg1) 2504 { 2505 tcomplain (); 2506 } 2507 2508 static void 2509 debug_enable_tracepoint (struct target_ops *self, struct bp_location *arg1) 2510 { 2511 fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_tracepoint (...)\n", debug_target.to_shortname); 2512 debug_target.to_enable_tracepoint (&debug_target, arg1); 2513 fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_tracepoint (", debug_target.to_shortname); 2514 target_debug_print_struct_target_ops_p (&debug_target); 2515 fputs_unfiltered (", ", gdb_stdlog); 2516 target_debug_print_struct_bp_location_p (arg1); 2517 fputs_unfiltered (")\n", gdb_stdlog); 2518 } 2519 2520 static void 2521 delegate_disable_tracepoint (struct target_ops *self, struct bp_location *arg1) 2522 { 2523 self = self->beneath; 2524 self->to_disable_tracepoint (self, arg1); 2525 } 2526 2527 static void 2528 tdefault_disable_tracepoint (struct target_ops *self, struct bp_location *arg1) 2529 { 2530 tcomplain (); 2531 } 2532 2533 static void 2534 debug_disable_tracepoint (struct target_ops *self, struct bp_location *arg1) 2535 { 2536 fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_tracepoint (...)\n", debug_target.to_shortname); 2537 debug_target.to_disable_tracepoint (&debug_target, arg1); 2538 fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_tracepoint (", debug_target.to_shortname); 2539 target_debug_print_struct_target_ops_p (&debug_target); 2540 fputs_unfiltered (", ", gdb_stdlog); 2541 target_debug_print_struct_bp_location_p (arg1); 2542 fputs_unfiltered (")\n", gdb_stdlog); 2543 } 2544 2545 static void 2546 delegate_trace_set_readonly_regions (struct target_ops *self) 2547 { 2548 self = self->beneath; 2549 self->to_trace_set_readonly_regions (self); 2550 } 2551 2552 static void 2553 tdefault_trace_set_readonly_regions (struct target_ops *self) 2554 { 2555 tcomplain (); 2556 } 2557 2558 static void 2559 debug_trace_set_readonly_regions (struct target_ops *self) 2560 { 2561 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_set_readonly_regions (...)\n", debug_target.to_shortname); 2562 debug_target.to_trace_set_readonly_regions (&debug_target); 2563 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_set_readonly_regions (", debug_target.to_shortname); 2564 target_debug_print_struct_target_ops_p (&debug_target); 2565 fputs_unfiltered (")\n", gdb_stdlog); 2566 } 2567 2568 static void 2569 delegate_trace_start (struct target_ops *self) 2570 { 2571 self = self->beneath; 2572 self->to_trace_start (self); 2573 } 2574 2575 static void 2576 tdefault_trace_start (struct target_ops *self) 2577 { 2578 tcomplain (); 2579 } 2580 2581 static void 2582 debug_trace_start (struct target_ops *self) 2583 { 2584 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_start (...)\n", debug_target.to_shortname); 2585 debug_target.to_trace_start (&debug_target); 2586 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_start (", debug_target.to_shortname); 2587 target_debug_print_struct_target_ops_p (&debug_target); 2588 fputs_unfiltered (")\n", gdb_stdlog); 2589 } 2590 2591 static int 2592 delegate_get_trace_status (struct target_ops *self, struct trace_status *arg1) 2593 { 2594 self = self->beneath; 2595 return self->to_get_trace_status (self, arg1); 2596 } 2597 2598 static int 2599 tdefault_get_trace_status (struct target_ops *self, struct trace_status *arg1) 2600 { 2601 return -1; 2602 } 2603 2604 static int 2605 debug_get_trace_status (struct target_ops *self, struct trace_status *arg1) 2606 { 2607 int result; 2608 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_status (...)\n", debug_target.to_shortname); 2609 result = debug_target.to_get_trace_status (&debug_target, arg1); 2610 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_status (", debug_target.to_shortname); 2611 target_debug_print_struct_target_ops_p (&debug_target); 2612 fputs_unfiltered (", ", gdb_stdlog); 2613 target_debug_print_struct_trace_status_p (arg1); 2614 fputs_unfiltered (") = ", gdb_stdlog); 2615 target_debug_print_int (result); 2616 fputs_unfiltered ("\n", gdb_stdlog); 2617 return result; 2618 } 2619 2620 static void 2621 delegate_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2) 2622 { 2623 self = self->beneath; 2624 self->to_get_tracepoint_status (self, arg1, arg2); 2625 } 2626 2627 static void 2628 tdefault_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2) 2629 { 2630 tcomplain (); 2631 } 2632 2633 static void 2634 debug_get_tracepoint_status (struct target_ops *self, struct breakpoint *arg1, struct uploaded_tp *arg2) 2635 { 2636 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tracepoint_status (...)\n", debug_target.to_shortname); 2637 debug_target.to_get_tracepoint_status (&debug_target, arg1, arg2); 2638 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tracepoint_status (", debug_target.to_shortname); 2639 target_debug_print_struct_target_ops_p (&debug_target); 2640 fputs_unfiltered (", ", gdb_stdlog); 2641 target_debug_print_struct_breakpoint_p (arg1); 2642 fputs_unfiltered (", ", gdb_stdlog); 2643 target_debug_print_struct_uploaded_tp_p (arg2); 2644 fputs_unfiltered (")\n", gdb_stdlog); 2645 } 2646 2647 static void 2648 delegate_trace_stop (struct target_ops *self) 2649 { 2650 self = self->beneath; 2651 self->to_trace_stop (self); 2652 } 2653 2654 static void 2655 tdefault_trace_stop (struct target_ops *self) 2656 { 2657 tcomplain (); 2658 } 2659 2660 static void 2661 debug_trace_stop (struct target_ops *self) 2662 { 2663 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_stop (...)\n", debug_target.to_shortname); 2664 debug_target.to_trace_stop (&debug_target); 2665 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_stop (", debug_target.to_shortname); 2666 target_debug_print_struct_target_ops_p (&debug_target); 2667 fputs_unfiltered (")\n", gdb_stdlog); 2668 } 2669 2670 static int 2671 delegate_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5) 2672 { 2673 self = self->beneath; 2674 return self->to_trace_find (self, arg1, arg2, arg3, arg4, arg5); 2675 } 2676 2677 static int 2678 tdefault_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5) 2679 { 2680 return -1; 2681 } 2682 2683 static int 2684 debug_trace_find (struct target_ops *self, enum trace_find_type arg1, int arg2, CORE_ADDR arg3, CORE_ADDR arg4, int *arg5) 2685 { 2686 int result; 2687 fprintf_unfiltered (gdb_stdlog, "-> %s->to_trace_find (...)\n", debug_target.to_shortname); 2688 result = debug_target.to_trace_find (&debug_target, arg1, arg2, arg3, arg4, arg5); 2689 fprintf_unfiltered (gdb_stdlog, "<- %s->to_trace_find (", debug_target.to_shortname); 2690 target_debug_print_struct_target_ops_p (&debug_target); 2691 fputs_unfiltered (", ", gdb_stdlog); 2692 target_debug_print_enum_trace_find_type (arg1); 2693 fputs_unfiltered (", ", gdb_stdlog); 2694 target_debug_print_int (arg2); 2695 fputs_unfiltered (", ", gdb_stdlog); 2696 target_debug_print_CORE_ADDR (arg3); 2697 fputs_unfiltered (", ", gdb_stdlog); 2698 target_debug_print_CORE_ADDR (arg4); 2699 fputs_unfiltered (", ", gdb_stdlog); 2700 target_debug_print_int_p (arg5); 2701 fputs_unfiltered (") = ", gdb_stdlog); 2702 target_debug_print_int (result); 2703 fputs_unfiltered ("\n", gdb_stdlog); 2704 return result; 2705 } 2706 2707 static int 2708 delegate_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2) 2709 { 2710 self = self->beneath; 2711 return self->to_get_trace_state_variable_value (self, arg1, arg2); 2712 } 2713 2714 static int 2715 tdefault_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2) 2716 { 2717 return 0; 2718 } 2719 2720 static int 2721 debug_get_trace_state_variable_value (struct target_ops *self, int arg1, LONGEST *arg2) 2722 { 2723 int result; 2724 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_trace_state_variable_value (...)\n", debug_target.to_shortname); 2725 result = debug_target.to_get_trace_state_variable_value (&debug_target, arg1, arg2); 2726 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_trace_state_variable_value (", debug_target.to_shortname); 2727 target_debug_print_struct_target_ops_p (&debug_target); 2728 fputs_unfiltered (", ", gdb_stdlog); 2729 target_debug_print_int (arg1); 2730 fputs_unfiltered (", ", gdb_stdlog); 2731 target_debug_print_LONGEST_p (arg2); 2732 fputs_unfiltered (") = ", gdb_stdlog); 2733 target_debug_print_int (result); 2734 fputs_unfiltered ("\n", gdb_stdlog); 2735 return result; 2736 } 2737 2738 static int 2739 delegate_save_trace_data (struct target_ops *self, const char *arg1) 2740 { 2741 self = self->beneath; 2742 return self->to_save_trace_data (self, arg1); 2743 } 2744 2745 static int 2746 tdefault_save_trace_data (struct target_ops *self, const char *arg1) 2747 { 2748 tcomplain (); 2749 } 2750 2751 static int 2752 debug_save_trace_data (struct target_ops *self, const char *arg1) 2753 { 2754 int result; 2755 fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_trace_data (...)\n", debug_target.to_shortname); 2756 result = debug_target.to_save_trace_data (&debug_target, arg1); 2757 fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_trace_data (", debug_target.to_shortname); 2758 target_debug_print_struct_target_ops_p (&debug_target); 2759 fputs_unfiltered (", ", gdb_stdlog); 2760 target_debug_print_const_char_p (arg1); 2761 fputs_unfiltered (") = ", gdb_stdlog); 2762 target_debug_print_int (result); 2763 fputs_unfiltered ("\n", gdb_stdlog); 2764 return result; 2765 } 2766 2767 static int 2768 delegate_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1) 2769 { 2770 self = self->beneath; 2771 return self->to_upload_tracepoints (self, arg1); 2772 } 2773 2774 static int 2775 tdefault_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1) 2776 { 2777 return 0; 2778 } 2779 2780 static int 2781 debug_upload_tracepoints (struct target_ops *self, struct uploaded_tp **arg1) 2782 { 2783 int result; 2784 fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_tracepoints (...)\n", debug_target.to_shortname); 2785 result = debug_target.to_upload_tracepoints (&debug_target, arg1); 2786 fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_tracepoints (", debug_target.to_shortname); 2787 target_debug_print_struct_target_ops_p (&debug_target); 2788 fputs_unfiltered (", ", gdb_stdlog); 2789 target_debug_print_struct_uploaded_tp_pp (arg1); 2790 fputs_unfiltered (") = ", gdb_stdlog); 2791 target_debug_print_int (result); 2792 fputs_unfiltered ("\n", gdb_stdlog); 2793 return result; 2794 } 2795 2796 static int 2797 delegate_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1) 2798 { 2799 self = self->beneath; 2800 return self->to_upload_trace_state_variables (self, arg1); 2801 } 2802 2803 static int 2804 tdefault_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1) 2805 { 2806 return 0; 2807 } 2808 2809 static int 2810 debug_upload_trace_state_variables (struct target_ops *self, struct uploaded_tsv **arg1) 2811 { 2812 int result; 2813 fprintf_unfiltered (gdb_stdlog, "-> %s->to_upload_trace_state_variables (...)\n", debug_target.to_shortname); 2814 result = debug_target.to_upload_trace_state_variables (&debug_target, arg1); 2815 fprintf_unfiltered (gdb_stdlog, "<- %s->to_upload_trace_state_variables (", debug_target.to_shortname); 2816 target_debug_print_struct_target_ops_p (&debug_target); 2817 fputs_unfiltered (", ", gdb_stdlog); 2818 target_debug_print_struct_uploaded_tsv_pp (arg1); 2819 fputs_unfiltered (") = ", gdb_stdlog); 2820 target_debug_print_int (result); 2821 fputs_unfiltered ("\n", gdb_stdlog); 2822 return result; 2823 } 2824 2825 static LONGEST 2826 delegate_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3) 2827 { 2828 self = self->beneath; 2829 return self->to_get_raw_trace_data (self, arg1, arg2, arg3); 2830 } 2831 2832 static LONGEST 2833 tdefault_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3) 2834 { 2835 tcomplain (); 2836 } 2837 2838 static LONGEST 2839 debug_get_raw_trace_data (struct target_ops *self, gdb_byte *arg1, ULONGEST arg2, LONGEST arg3) 2840 { 2841 LONGEST result; 2842 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_raw_trace_data (...)\n", debug_target.to_shortname); 2843 result = debug_target.to_get_raw_trace_data (&debug_target, arg1, arg2, arg3); 2844 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_raw_trace_data (", debug_target.to_shortname); 2845 target_debug_print_struct_target_ops_p (&debug_target); 2846 fputs_unfiltered (", ", gdb_stdlog); 2847 target_debug_print_gdb_byte_p (arg1); 2848 fputs_unfiltered (", ", gdb_stdlog); 2849 target_debug_print_ULONGEST (arg2); 2850 fputs_unfiltered (", ", gdb_stdlog); 2851 target_debug_print_LONGEST (arg3); 2852 fputs_unfiltered (") = ", gdb_stdlog); 2853 target_debug_print_LONGEST (result); 2854 fputs_unfiltered ("\n", gdb_stdlog); 2855 return result; 2856 } 2857 2858 static int 2859 delegate_get_min_fast_tracepoint_insn_len (struct target_ops *self) 2860 { 2861 self = self->beneath; 2862 return self->to_get_min_fast_tracepoint_insn_len (self); 2863 } 2864 2865 static int 2866 tdefault_get_min_fast_tracepoint_insn_len (struct target_ops *self) 2867 { 2868 return -1; 2869 } 2870 2871 static int 2872 debug_get_min_fast_tracepoint_insn_len (struct target_ops *self) 2873 { 2874 int result; 2875 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_min_fast_tracepoint_insn_len (...)\n", debug_target.to_shortname); 2876 result = debug_target.to_get_min_fast_tracepoint_insn_len (&debug_target); 2877 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_min_fast_tracepoint_insn_len (", debug_target.to_shortname); 2878 target_debug_print_struct_target_ops_p (&debug_target); 2879 fputs_unfiltered (") = ", gdb_stdlog); 2880 target_debug_print_int (result); 2881 fputs_unfiltered ("\n", gdb_stdlog); 2882 return result; 2883 } 2884 2885 static void 2886 delegate_set_disconnected_tracing (struct target_ops *self, int arg1) 2887 { 2888 self = self->beneath; 2889 self->to_set_disconnected_tracing (self, arg1); 2890 } 2891 2892 static void 2893 tdefault_set_disconnected_tracing (struct target_ops *self, int arg1) 2894 { 2895 } 2896 2897 static void 2898 debug_set_disconnected_tracing (struct target_ops *self, int arg1) 2899 { 2900 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_disconnected_tracing (...)\n", debug_target.to_shortname); 2901 debug_target.to_set_disconnected_tracing (&debug_target, arg1); 2902 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_disconnected_tracing (", debug_target.to_shortname); 2903 target_debug_print_struct_target_ops_p (&debug_target); 2904 fputs_unfiltered (", ", gdb_stdlog); 2905 target_debug_print_int (arg1); 2906 fputs_unfiltered (")\n", gdb_stdlog); 2907 } 2908 2909 static void 2910 delegate_set_circular_trace_buffer (struct target_ops *self, int arg1) 2911 { 2912 self = self->beneath; 2913 self->to_set_circular_trace_buffer (self, arg1); 2914 } 2915 2916 static void 2917 tdefault_set_circular_trace_buffer (struct target_ops *self, int arg1) 2918 { 2919 } 2920 2921 static void 2922 debug_set_circular_trace_buffer (struct target_ops *self, int arg1) 2923 { 2924 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_circular_trace_buffer (...)\n", debug_target.to_shortname); 2925 debug_target.to_set_circular_trace_buffer (&debug_target, arg1); 2926 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_circular_trace_buffer (", debug_target.to_shortname); 2927 target_debug_print_struct_target_ops_p (&debug_target); 2928 fputs_unfiltered (", ", gdb_stdlog); 2929 target_debug_print_int (arg1); 2930 fputs_unfiltered (")\n", gdb_stdlog); 2931 } 2932 2933 static void 2934 delegate_set_trace_buffer_size (struct target_ops *self, LONGEST arg1) 2935 { 2936 self = self->beneath; 2937 self->to_set_trace_buffer_size (self, arg1); 2938 } 2939 2940 static void 2941 tdefault_set_trace_buffer_size (struct target_ops *self, LONGEST arg1) 2942 { 2943 } 2944 2945 static void 2946 debug_set_trace_buffer_size (struct target_ops *self, LONGEST arg1) 2947 { 2948 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_buffer_size (...)\n", debug_target.to_shortname); 2949 debug_target.to_set_trace_buffer_size (&debug_target, arg1); 2950 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_buffer_size (", debug_target.to_shortname); 2951 target_debug_print_struct_target_ops_p (&debug_target); 2952 fputs_unfiltered (", ", gdb_stdlog); 2953 target_debug_print_LONGEST (arg1); 2954 fputs_unfiltered (")\n", gdb_stdlog); 2955 } 2956 2957 static int 2958 delegate_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3) 2959 { 2960 self = self->beneath; 2961 return self->to_set_trace_notes (self, arg1, arg2, arg3); 2962 } 2963 2964 static int 2965 tdefault_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3) 2966 { 2967 return 0; 2968 } 2969 2970 static int 2971 debug_set_trace_notes (struct target_ops *self, const char *arg1, const char *arg2, const char *arg3) 2972 { 2973 int result; 2974 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_trace_notes (...)\n", debug_target.to_shortname); 2975 result = debug_target.to_set_trace_notes (&debug_target, arg1, arg2, arg3); 2976 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_trace_notes (", debug_target.to_shortname); 2977 target_debug_print_struct_target_ops_p (&debug_target); 2978 fputs_unfiltered (", ", gdb_stdlog); 2979 target_debug_print_const_char_p (arg1); 2980 fputs_unfiltered (", ", gdb_stdlog); 2981 target_debug_print_const_char_p (arg2); 2982 fputs_unfiltered (", ", gdb_stdlog); 2983 target_debug_print_const_char_p (arg3); 2984 fputs_unfiltered (") = ", gdb_stdlog); 2985 target_debug_print_int (result); 2986 fputs_unfiltered ("\n", gdb_stdlog); 2987 return result; 2988 } 2989 2990 static int 2991 delegate_core_of_thread (struct target_ops *self, ptid_t arg1) 2992 { 2993 self = self->beneath; 2994 return self->to_core_of_thread (self, arg1); 2995 } 2996 2997 static int 2998 tdefault_core_of_thread (struct target_ops *self, ptid_t arg1) 2999 { 3000 return -1; 3001 } 3002 3003 static int 3004 debug_core_of_thread (struct target_ops *self, ptid_t arg1) 3005 { 3006 int result; 3007 fprintf_unfiltered (gdb_stdlog, "-> %s->to_core_of_thread (...)\n", debug_target.to_shortname); 3008 result = debug_target.to_core_of_thread (&debug_target, arg1); 3009 fprintf_unfiltered (gdb_stdlog, "<- %s->to_core_of_thread (", debug_target.to_shortname); 3010 target_debug_print_struct_target_ops_p (&debug_target); 3011 fputs_unfiltered (", ", gdb_stdlog); 3012 target_debug_print_ptid_t (arg1); 3013 fputs_unfiltered (") = ", gdb_stdlog); 3014 target_debug_print_int (result); 3015 fputs_unfiltered ("\n", gdb_stdlog); 3016 return result; 3017 } 3018 3019 static int 3020 delegate_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3) 3021 { 3022 self = self->beneath; 3023 return self->to_verify_memory (self, arg1, arg2, arg3); 3024 } 3025 3026 static int 3027 debug_verify_memory (struct target_ops *self, const gdb_byte *arg1, CORE_ADDR arg2, ULONGEST arg3) 3028 { 3029 int result; 3030 fprintf_unfiltered (gdb_stdlog, "-> %s->to_verify_memory (...)\n", debug_target.to_shortname); 3031 result = debug_target.to_verify_memory (&debug_target, arg1, arg2, arg3); 3032 fprintf_unfiltered (gdb_stdlog, "<- %s->to_verify_memory (", debug_target.to_shortname); 3033 target_debug_print_struct_target_ops_p (&debug_target); 3034 fputs_unfiltered (", ", gdb_stdlog); 3035 target_debug_print_const_gdb_byte_p (arg1); 3036 fputs_unfiltered (", ", gdb_stdlog); 3037 target_debug_print_CORE_ADDR (arg2); 3038 fputs_unfiltered (", ", gdb_stdlog); 3039 target_debug_print_ULONGEST (arg3); 3040 fputs_unfiltered (") = ", gdb_stdlog); 3041 target_debug_print_int (result); 3042 fputs_unfiltered ("\n", gdb_stdlog); 3043 return result; 3044 } 3045 3046 static int 3047 delegate_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2) 3048 { 3049 self = self->beneath; 3050 return self->to_get_tib_address (self, arg1, arg2); 3051 } 3052 3053 static int 3054 tdefault_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2) 3055 { 3056 tcomplain (); 3057 } 3058 3059 static int 3060 debug_get_tib_address (struct target_ops *self, ptid_t arg1, CORE_ADDR *arg2) 3061 { 3062 int result; 3063 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tib_address (...)\n", debug_target.to_shortname); 3064 result = debug_target.to_get_tib_address (&debug_target, arg1, arg2); 3065 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tib_address (", debug_target.to_shortname); 3066 target_debug_print_struct_target_ops_p (&debug_target); 3067 fputs_unfiltered (", ", gdb_stdlog); 3068 target_debug_print_ptid_t (arg1); 3069 fputs_unfiltered (", ", gdb_stdlog); 3070 target_debug_print_CORE_ADDR_p (arg2); 3071 fputs_unfiltered (") = ", gdb_stdlog); 3072 target_debug_print_int (result); 3073 fputs_unfiltered ("\n", gdb_stdlog); 3074 return result; 3075 } 3076 3077 static void 3078 delegate_set_permissions (struct target_ops *self) 3079 { 3080 self = self->beneath; 3081 self->to_set_permissions (self); 3082 } 3083 3084 static void 3085 tdefault_set_permissions (struct target_ops *self) 3086 { 3087 } 3088 3089 static void 3090 debug_set_permissions (struct target_ops *self) 3091 { 3092 fprintf_unfiltered (gdb_stdlog, "-> %s->to_set_permissions (...)\n", debug_target.to_shortname); 3093 debug_target.to_set_permissions (&debug_target); 3094 fprintf_unfiltered (gdb_stdlog, "<- %s->to_set_permissions (", debug_target.to_shortname); 3095 target_debug_print_struct_target_ops_p (&debug_target); 3096 fputs_unfiltered (")\n", gdb_stdlog); 3097 } 3098 3099 static int 3100 delegate_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2) 3101 { 3102 self = self->beneath; 3103 return self->to_static_tracepoint_marker_at (self, arg1, arg2); 3104 } 3105 3106 static int 3107 tdefault_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2) 3108 { 3109 return 0; 3110 } 3111 3112 static int 3113 debug_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR arg1, struct static_tracepoint_marker *arg2) 3114 { 3115 int result; 3116 fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_marker_at (...)\n", debug_target.to_shortname); 3117 result = debug_target.to_static_tracepoint_marker_at (&debug_target, arg1, arg2); 3118 fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_marker_at (", debug_target.to_shortname); 3119 target_debug_print_struct_target_ops_p (&debug_target); 3120 fputs_unfiltered (", ", gdb_stdlog); 3121 target_debug_print_CORE_ADDR (arg1); 3122 fputs_unfiltered (", ", gdb_stdlog); 3123 target_debug_print_struct_static_tracepoint_marker_p (arg2); 3124 fputs_unfiltered (") = ", gdb_stdlog); 3125 target_debug_print_int (result); 3126 fputs_unfiltered ("\n", gdb_stdlog); 3127 return result; 3128 } 3129 3130 static VEC(static_tracepoint_marker_p) * 3131 delegate_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1) 3132 { 3133 self = self->beneath; 3134 return self->to_static_tracepoint_markers_by_strid (self, arg1); 3135 } 3136 3137 static VEC(static_tracepoint_marker_p) * 3138 tdefault_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1) 3139 { 3140 tcomplain (); 3141 } 3142 3143 static VEC(static_tracepoint_marker_p) * 3144 debug_static_tracepoint_markers_by_strid (struct target_ops *self, const char *arg1) 3145 { 3146 VEC(static_tracepoint_marker_p) * result; 3147 fprintf_unfiltered (gdb_stdlog, "-> %s->to_static_tracepoint_markers_by_strid (...)\n", debug_target.to_shortname); 3148 result = debug_target.to_static_tracepoint_markers_by_strid (&debug_target, arg1); 3149 fprintf_unfiltered (gdb_stdlog, "<- %s->to_static_tracepoint_markers_by_strid (", debug_target.to_shortname); 3150 target_debug_print_struct_target_ops_p (&debug_target); 3151 fputs_unfiltered (", ", gdb_stdlog); 3152 target_debug_print_const_char_p (arg1); 3153 fputs_unfiltered (") = ", gdb_stdlog); 3154 target_debug_print_VEC_static_tracepoint_marker_p__p (result); 3155 fputs_unfiltered ("\n", gdb_stdlog); 3156 return result; 3157 } 3158 3159 static struct traceframe_info * 3160 delegate_traceframe_info (struct target_ops *self) 3161 { 3162 self = self->beneath; 3163 return self->to_traceframe_info (self); 3164 } 3165 3166 static struct traceframe_info * 3167 tdefault_traceframe_info (struct target_ops *self) 3168 { 3169 tcomplain (); 3170 } 3171 3172 static struct traceframe_info * 3173 debug_traceframe_info (struct target_ops *self) 3174 { 3175 struct traceframe_info * result; 3176 fprintf_unfiltered (gdb_stdlog, "-> %s->to_traceframe_info (...)\n", debug_target.to_shortname); 3177 result = debug_target.to_traceframe_info (&debug_target); 3178 fprintf_unfiltered (gdb_stdlog, "<- %s->to_traceframe_info (", debug_target.to_shortname); 3179 target_debug_print_struct_target_ops_p (&debug_target); 3180 fputs_unfiltered (") = ", gdb_stdlog); 3181 target_debug_print_struct_traceframe_info_p (result); 3182 fputs_unfiltered ("\n", gdb_stdlog); 3183 return result; 3184 } 3185 3186 static int 3187 delegate_use_agent (struct target_ops *self, int arg1) 3188 { 3189 self = self->beneath; 3190 return self->to_use_agent (self, arg1); 3191 } 3192 3193 static int 3194 tdefault_use_agent (struct target_ops *self, int arg1) 3195 { 3196 tcomplain (); 3197 } 3198 3199 static int 3200 debug_use_agent (struct target_ops *self, int arg1) 3201 { 3202 int result; 3203 fprintf_unfiltered (gdb_stdlog, "-> %s->to_use_agent (...)\n", debug_target.to_shortname); 3204 result = debug_target.to_use_agent (&debug_target, arg1); 3205 fprintf_unfiltered (gdb_stdlog, "<- %s->to_use_agent (", debug_target.to_shortname); 3206 target_debug_print_struct_target_ops_p (&debug_target); 3207 fputs_unfiltered (", ", gdb_stdlog); 3208 target_debug_print_int (arg1); 3209 fputs_unfiltered (") = ", gdb_stdlog); 3210 target_debug_print_int (result); 3211 fputs_unfiltered ("\n", gdb_stdlog); 3212 return result; 3213 } 3214 3215 static int 3216 delegate_can_use_agent (struct target_ops *self) 3217 { 3218 self = self->beneath; 3219 return self->to_can_use_agent (self); 3220 } 3221 3222 static int 3223 tdefault_can_use_agent (struct target_ops *self) 3224 { 3225 return 0; 3226 } 3227 3228 static int 3229 debug_can_use_agent (struct target_ops *self) 3230 { 3231 int result; 3232 fprintf_unfiltered (gdb_stdlog, "-> %s->to_can_use_agent (...)\n", debug_target.to_shortname); 3233 result = debug_target.to_can_use_agent (&debug_target); 3234 fprintf_unfiltered (gdb_stdlog, "<- %s->to_can_use_agent (", debug_target.to_shortname); 3235 target_debug_print_struct_target_ops_p (&debug_target); 3236 fputs_unfiltered (") = ", gdb_stdlog); 3237 target_debug_print_int (result); 3238 fputs_unfiltered ("\n", gdb_stdlog); 3239 return result; 3240 } 3241 3242 static int 3243 delegate_supports_btrace (struct target_ops *self, enum btrace_format arg1) 3244 { 3245 self = self->beneath; 3246 return self->to_supports_btrace (self, arg1); 3247 } 3248 3249 static int 3250 tdefault_supports_btrace (struct target_ops *self, enum btrace_format arg1) 3251 { 3252 return 0; 3253 } 3254 3255 static int 3256 debug_supports_btrace (struct target_ops *self, enum btrace_format arg1) 3257 { 3258 int result; 3259 fprintf_unfiltered (gdb_stdlog, "-> %s->to_supports_btrace (...)\n", debug_target.to_shortname); 3260 result = debug_target.to_supports_btrace (&debug_target, arg1); 3261 fprintf_unfiltered (gdb_stdlog, "<- %s->to_supports_btrace (", debug_target.to_shortname); 3262 target_debug_print_struct_target_ops_p (&debug_target); 3263 fputs_unfiltered (", ", gdb_stdlog); 3264 target_debug_print_enum_btrace_format (arg1); 3265 fputs_unfiltered (") = ", gdb_stdlog); 3266 target_debug_print_int (result); 3267 fputs_unfiltered ("\n", gdb_stdlog); 3268 return result; 3269 } 3270 3271 static struct btrace_target_info * 3272 delegate_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2) 3273 { 3274 self = self->beneath; 3275 return self->to_enable_btrace (self, arg1, arg2); 3276 } 3277 3278 static struct btrace_target_info * 3279 tdefault_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2) 3280 { 3281 tcomplain (); 3282 } 3283 3284 static struct btrace_target_info * 3285 debug_enable_btrace (struct target_ops *self, ptid_t arg1, const struct btrace_config *arg2) 3286 { 3287 struct btrace_target_info * result; 3288 fprintf_unfiltered (gdb_stdlog, "-> %s->to_enable_btrace (...)\n", debug_target.to_shortname); 3289 result = debug_target.to_enable_btrace (&debug_target, arg1, arg2); 3290 fprintf_unfiltered (gdb_stdlog, "<- %s->to_enable_btrace (", debug_target.to_shortname); 3291 target_debug_print_struct_target_ops_p (&debug_target); 3292 fputs_unfiltered (", ", gdb_stdlog); 3293 target_debug_print_ptid_t (arg1); 3294 fputs_unfiltered (", ", gdb_stdlog); 3295 target_debug_print_const_struct_btrace_config_p (arg2); 3296 fputs_unfiltered (") = ", gdb_stdlog); 3297 target_debug_print_struct_btrace_target_info_p (result); 3298 fputs_unfiltered ("\n", gdb_stdlog); 3299 return result; 3300 } 3301 3302 static void 3303 delegate_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1) 3304 { 3305 self = self->beneath; 3306 self->to_disable_btrace (self, arg1); 3307 } 3308 3309 static void 3310 tdefault_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1) 3311 { 3312 tcomplain (); 3313 } 3314 3315 static void 3316 debug_disable_btrace (struct target_ops *self, struct btrace_target_info *arg1) 3317 { 3318 fprintf_unfiltered (gdb_stdlog, "-> %s->to_disable_btrace (...)\n", debug_target.to_shortname); 3319 debug_target.to_disable_btrace (&debug_target, arg1); 3320 fprintf_unfiltered (gdb_stdlog, "<- %s->to_disable_btrace (", debug_target.to_shortname); 3321 target_debug_print_struct_target_ops_p (&debug_target); 3322 fputs_unfiltered (", ", gdb_stdlog); 3323 target_debug_print_struct_btrace_target_info_p (arg1); 3324 fputs_unfiltered (")\n", gdb_stdlog); 3325 } 3326 3327 static void 3328 delegate_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1) 3329 { 3330 self = self->beneath; 3331 self->to_teardown_btrace (self, arg1); 3332 } 3333 3334 static void 3335 tdefault_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1) 3336 { 3337 tcomplain (); 3338 } 3339 3340 static void 3341 debug_teardown_btrace (struct target_ops *self, struct btrace_target_info *arg1) 3342 { 3343 fprintf_unfiltered (gdb_stdlog, "-> %s->to_teardown_btrace (...)\n", debug_target.to_shortname); 3344 debug_target.to_teardown_btrace (&debug_target, arg1); 3345 fprintf_unfiltered (gdb_stdlog, "<- %s->to_teardown_btrace (", debug_target.to_shortname); 3346 target_debug_print_struct_target_ops_p (&debug_target); 3347 fputs_unfiltered (", ", gdb_stdlog); 3348 target_debug_print_struct_btrace_target_info_p (arg1); 3349 fputs_unfiltered (")\n", gdb_stdlog); 3350 } 3351 3352 static enum btrace_error 3353 delegate_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3) 3354 { 3355 self = self->beneath; 3356 return self->to_read_btrace (self, arg1, arg2, arg3); 3357 } 3358 3359 static enum btrace_error 3360 tdefault_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3) 3361 { 3362 tcomplain (); 3363 } 3364 3365 static enum btrace_error 3366 debug_read_btrace (struct target_ops *self, struct btrace_data *arg1, struct btrace_target_info *arg2, enum btrace_read_type arg3) 3367 { 3368 enum btrace_error result; 3369 fprintf_unfiltered (gdb_stdlog, "-> %s->to_read_btrace (...)\n", debug_target.to_shortname); 3370 result = debug_target.to_read_btrace (&debug_target, arg1, arg2, arg3); 3371 fprintf_unfiltered (gdb_stdlog, "<- %s->to_read_btrace (", debug_target.to_shortname); 3372 target_debug_print_struct_target_ops_p (&debug_target); 3373 fputs_unfiltered (", ", gdb_stdlog); 3374 target_debug_print_struct_btrace_data_p (arg1); 3375 fputs_unfiltered (", ", gdb_stdlog); 3376 target_debug_print_struct_btrace_target_info_p (arg2); 3377 fputs_unfiltered (", ", gdb_stdlog); 3378 target_debug_print_enum_btrace_read_type (arg3); 3379 fputs_unfiltered (") = ", gdb_stdlog); 3380 target_debug_print_enum_btrace_error (result); 3381 fputs_unfiltered ("\n", gdb_stdlog); 3382 return result; 3383 } 3384 3385 static const struct btrace_config * 3386 delegate_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1) 3387 { 3388 self = self->beneath; 3389 return self->to_btrace_conf (self, arg1); 3390 } 3391 3392 static const struct btrace_config * 3393 tdefault_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1) 3394 { 3395 return NULL; 3396 } 3397 3398 static const struct btrace_config * 3399 debug_btrace_conf (struct target_ops *self, const struct btrace_target_info *arg1) 3400 { 3401 const struct btrace_config * result; 3402 fprintf_unfiltered (gdb_stdlog, "-> %s->to_btrace_conf (...)\n", debug_target.to_shortname); 3403 result = debug_target.to_btrace_conf (&debug_target, arg1); 3404 fprintf_unfiltered (gdb_stdlog, "<- %s->to_btrace_conf (", debug_target.to_shortname); 3405 target_debug_print_struct_target_ops_p (&debug_target); 3406 fputs_unfiltered (", ", gdb_stdlog); 3407 target_debug_print_const_struct_btrace_target_info_p (arg1); 3408 fputs_unfiltered (") = ", gdb_stdlog); 3409 target_debug_print_const_struct_btrace_config_p (result); 3410 fputs_unfiltered ("\n", gdb_stdlog); 3411 return result; 3412 } 3413 3414 static void 3415 delegate_stop_recording (struct target_ops *self) 3416 { 3417 self = self->beneath; 3418 self->to_stop_recording (self); 3419 } 3420 3421 static void 3422 tdefault_stop_recording (struct target_ops *self) 3423 { 3424 } 3425 3426 static void 3427 debug_stop_recording (struct target_ops *self) 3428 { 3429 fprintf_unfiltered (gdb_stdlog, "-> %s->to_stop_recording (...)\n", debug_target.to_shortname); 3430 debug_target.to_stop_recording (&debug_target); 3431 fprintf_unfiltered (gdb_stdlog, "<- %s->to_stop_recording (", debug_target.to_shortname); 3432 target_debug_print_struct_target_ops_p (&debug_target); 3433 fputs_unfiltered (")\n", gdb_stdlog); 3434 } 3435 3436 static void 3437 delegate_info_record (struct target_ops *self) 3438 { 3439 self = self->beneath; 3440 self->to_info_record (self); 3441 } 3442 3443 static void 3444 tdefault_info_record (struct target_ops *self) 3445 { 3446 } 3447 3448 static void 3449 debug_info_record (struct target_ops *self) 3450 { 3451 fprintf_unfiltered (gdb_stdlog, "-> %s->to_info_record (...)\n", debug_target.to_shortname); 3452 debug_target.to_info_record (&debug_target); 3453 fprintf_unfiltered (gdb_stdlog, "<- %s->to_info_record (", debug_target.to_shortname); 3454 target_debug_print_struct_target_ops_p (&debug_target); 3455 fputs_unfiltered (")\n", gdb_stdlog); 3456 } 3457 3458 static void 3459 delegate_save_record (struct target_ops *self, const char *arg1) 3460 { 3461 self = self->beneath; 3462 self->to_save_record (self, arg1); 3463 } 3464 3465 static void 3466 tdefault_save_record (struct target_ops *self, const char *arg1) 3467 { 3468 tcomplain (); 3469 } 3470 3471 static void 3472 debug_save_record (struct target_ops *self, const char *arg1) 3473 { 3474 fprintf_unfiltered (gdb_stdlog, "-> %s->to_save_record (...)\n", debug_target.to_shortname); 3475 debug_target.to_save_record (&debug_target, arg1); 3476 fprintf_unfiltered (gdb_stdlog, "<- %s->to_save_record (", debug_target.to_shortname); 3477 target_debug_print_struct_target_ops_p (&debug_target); 3478 fputs_unfiltered (", ", gdb_stdlog); 3479 target_debug_print_const_char_p (arg1); 3480 fputs_unfiltered (")\n", gdb_stdlog); 3481 } 3482 3483 static void 3484 delegate_delete_record (struct target_ops *self) 3485 { 3486 self = self->beneath; 3487 self->to_delete_record (self); 3488 } 3489 3490 static void 3491 tdefault_delete_record (struct target_ops *self) 3492 { 3493 tcomplain (); 3494 } 3495 3496 static void 3497 debug_delete_record (struct target_ops *self) 3498 { 3499 fprintf_unfiltered (gdb_stdlog, "-> %s->to_delete_record (...)\n", debug_target.to_shortname); 3500 debug_target.to_delete_record (&debug_target); 3501 fprintf_unfiltered (gdb_stdlog, "<- %s->to_delete_record (", debug_target.to_shortname); 3502 target_debug_print_struct_target_ops_p (&debug_target); 3503 fputs_unfiltered (")\n", gdb_stdlog); 3504 } 3505 3506 static int 3507 delegate_record_is_replaying (struct target_ops *self) 3508 { 3509 self = self->beneath; 3510 return self->to_record_is_replaying (self); 3511 } 3512 3513 static int 3514 tdefault_record_is_replaying (struct target_ops *self) 3515 { 3516 return 0; 3517 } 3518 3519 static int 3520 debug_record_is_replaying (struct target_ops *self) 3521 { 3522 int result; 3523 fprintf_unfiltered (gdb_stdlog, "-> %s->to_record_is_replaying (...)\n", debug_target.to_shortname); 3524 result = debug_target.to_record_is_replaying (&debug_target); 3525 fprintf_unfiltered (gdb_stdlog, "<- %s->to_record_is_replaying (", debug_target.to_shortname); 3526 target_debug_print_struct_target_ops_p (&debug_target); 3527 fputs_unfiltered (") = ", gdb_stdlog); 3528 target_debug_print_int (result); 3529 fputs_unfiltered ("\n", gdb_stdlog); 3530 return result; 3531 } 3532 3533 static void 3534 delegate_goto_record_begin (struct target_ops *self) 3535 { 3536 self = self->beneath; 3537 self->to_goto_record_begin (self); 3538 } 3539 3540 static void 3541 tdefault_goto_record_begin (struct target_ops *self) 3542 { 3543 tcomplain (); 3544 } 3545 3546 static void 3547 debug_goto_record_begin (struct target_ops *self) 3548 { 3549 fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_begin (...)\n", debug_target.to_shortname); 3550 debug_target.to_goto_record_begin (&debug_target); 3551 fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_begin (", debug_target.to_shortname); 3552 target_debug_print_struct_target_ops_p (&debug_target); 3553 fputs_unfiltered (")\n", gdb_stdlog); 3554 } 3555 3556 static void 3557 delegate_goto_record_end (struct target_ops *self) 3558 { 3559 self = self->beneath; 3560 self->to_goto_record_end (self); 3561 } 3562 3563 static void 3564 tdefault_goto_record_end (struct target_ops *self) 3565 { 3566 tcomplain (); 3567 } 3568 3569 static void 3570 debug_goto_record_end (struct target_ops *self) 3571 { 3572 fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record_end (...)\n", debug_target.to_shortname); 3573 debug_target.to_goto_record_end (&debug_target); 3574 fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record_end (", debug_target.to_shortname); 3575 target_debug_print_struct_target_ops_p (&debug_target); 3576 fputs_unfiltered (")\n", gdb_stdlog); 3577 } 3578 3579 static void 3580 delegate_goto_record (struct target_ops *self, ULONGEST arg1) 3581 { 3582 self = self->beneath; 3583 self->to_goto_record (self, arg1); 3584 } 3585 3586 static void 3587 tdefault_goto_record (struct target_ops *self, ULONGEST arg1) 3588 { 3589 tcomplain (); 3590 } 3591 3592 static void 3593 debug_goto_record (struct target_ops *self, ULONGEST arg1) 3594 { 3595 fprintf_unfiltered (gdb_stdlog, "-> %s->to_goto_record (...)\n", debug_target.to_shortname); 3596 debug_target.to_goto_record (&debug_target, arg1); 3597 fprintf_unfiltered (gdb_stdlog, "<- %s->to_goto_record (", debug_target.to_shortname); 3598 target_debug_print_struct_target_ops_p (&debug_target); 3599 fputs_unfiltered (", ", gdb_stdlog); 3600 target_debug_print_ULONGEST (arg1); 3601 fputs_unfiltered (")\n", gdb_stdlog); 3602 } 3603 3604 static void 3605 delegate_insn_history (struct target_ops *self, int arg1, int arg2) 3606 { 3607 self = self->beneath; 3608 self->to_insn_history (self, arg1, arg2); 3609 } 3610 3611 static void 3612 tdefault_insn_history (struct target_ops *self, int arg1, int arg2) 3613 { 3614 tcomplain (); 3615 } 3616 3617 static void 3618 debug_insn_history (struct target_ops *self, int arg1, int arg2) 3619 { 3620 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history (...)\n", debug_target.to_shortname); 3621 debug_target.to_insn_history (&debug_target, arg1, arg2); 3622 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history (", debug_target.to_shortname); 3623 target_debug_print_struct_target_ops_p (&debug_target); 3624 fputs_unfiltered (", ", gdb_stdlog); 3625 target_debug_print_int (arg1); 3626 fputs_unfiltered (", ", gdb_stdlog); 3627 target_debug_print_int (arg2); 3628 fputs_unfiltered (")\n", gdb_stdlog); 3629 } 3630 3631 static void 3632 delegate_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3) 3633 { 3634 self = self->beneath; 3635 self->to_insn_history_from (self, arg1, arg2, arg3); 3636 } 3637 3638 static void 3639 tdefault_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3) 3640 { 3641 tcomplain (); 3642 } 3643 3644 static void 3645 debug_insn_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3) 3646 { 3647 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_from (...)\n", debug_target.to_shortname); 3648 debug_target.to_insn_history_from (&debug_target, arg1, arg2, arg3); 3649 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_from (", debug_target.to_shortname); 3650 target_debug_print_struct_target_ops_p (&debug_target); 3651 fputs_unfiltered (", ", gdb_stdlog); 3652 target_debug_print_ULONGEST (arg1); 3653 fputs_unfiltered (", ", gdb_stdlog); 3654 target_debug_print_int (arg2); 3655 fputs_unfiltered (", ", gdb_stdlog); 3656 target_debug_print_int (arg3); 3657 fputs_unfiltered (")\n", gdb_stdlog); 3658 } 3659 3660 static void 3661 delegate_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3) 3662 { 3663 self = self->beneath; 3664 self->to_insn_history_range (self, arg1, arg2, arg3); 3665 } 3666 3667 static void 3668 tdefault_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3) 3669 { 3670 tcomplain (); 3671 } 3672 3673 static void 3674 debug_insn_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3) 3675 { 3676 fprintf_unfiltered (gdb_stdlog, "-> %s->to_insn_history_range (...)\n", debug_target.to_shortname); 3677 debug_target.to_insn_history_range (&debug_target, arg1, arg2, arg3); 3678 fprintf_unfiltered (gdb_stdlog, "<- %s->to_insn_history_range (", debug_target.to_shortname); 3679 target_debug_print_struct_target_ops_p (&debug_target); 3680 fputs_unfiltered (", ", gdb_stdlog); 3681 target_debug_print_ULONGEST (arg1); 3682 fputs_unfiltered (", ", gdb_stdlog); 3683 target_debug_print_ULONGEST (arg2); 3684 fputs_unfiltered (", ", gdb_stdlog); 3685 target_debug_print_int (arg3); 3686 fputs_unfiltered (")\n", gdb_stdlog); 3687 } 3688 3689 static void 3690 delegate_call_history (struct target_ops *self, int arg1, int arg2) 3691 { 3692 self = self->beneath; 3693 self->to_call_history (self, arg1, arg2); 3694 } 3695 3696 static void 3697 tdefault_call_history (struct target_ops *self, int arg1, int arg2) 3698 { 3699 tcomplain (); 3700 } 3701 3702 static void 3703 debug_call_history (struct target_ops *self, int arg1, int arg2) 3704 { 3705 fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history (...)\n", debug_target.to_shortname); 3706 debug_target.to_call_history (&debug_target, arg1, arg2); 3707 fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history (", debug_target.to_shortname); 3708 target_debug_print_struct_target_ops_p (&debug_target); 3709 fputs_unfiltered (", ", gdb_stdlog); 3710 target_debug_print_int (arg1); 3711 fputs_unfiltered (", ", gdb_stdlog); 3712 target_debug_print_int (arg2); 3713 fputs_unfiltered (")\n", gdb_stdlog); 3714 } 3715 3716 static void 3717 delegate_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3) 3718 { 3719 self = self->beneath; 3720 self->to_call_history_from (self, arg1, arg2, arg3); 3721 } 3722 3723 static void 3724 tdefault_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3) 3725 { 3726 tcomplain (); 3727 } 3728 3729 static void 3730 debug_call_history_from (struct target_ops *self, ULONGEST arg1, int arg2, int arg3) 3731 { 3732 fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_from (...)\n", debug_target.to_shortname); 3733 debug_target.to_call_history_from (&debug_target, arg1, arg2, arg3); 3734 fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_from (", debug_target.to_shortname); 3735 target_debug_print_struct_target_ops_p (&debug_target); 3736 fputs_unfiltered (", ", gdb_stdlog); 3737 target_debug_print_ULONGEST (arg1); 3738 fputs_unfiltered (", ", gdb_stdlog); 3739 target_debug_print_int (arg2); 3740 fputs_unfiltered (", ", gdb_stdlog); 3741 target_debug_print_int (arg3); 3742 fputs_unfiltered (")\n", gdb_stdlog); 3743 } 3744 3745 static void 3746 delegate_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3) 3747 { 3748 self = self->beneath; 3749 self->to_call_history_range (self, arg1, arg2, arg3); 3750 } 3751 3752 static void 3753 tdefault_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3) 3754 { 3755 tcomplain (); 3756 } 3757 3758 static void 3759 debug_call_history_range (struct target_ops *self, ULONGEST arg1, ULONGEST arg2, int arg3) 3760 { 3761 fprintf_unfiltered (gdb_stdlog, "-> %s->to_call_history_range (...)\n", debug_target.to_shortname); 3762 debug_target.to_call_history_range (&debug_target, arg1, arg2, arg3); 3763 fprintf_unfiltered (gdb_stdlog, "<- %s->to_call_history_range (", debug_target.to_shortname); 3764 target_debug_print_struct_target_ops_p (&debug_target); 3765 fputs_unfiltered (", ", gdb_stdlog); 3766 target_debug_print_ULONGEST (arg1); 3767 fputs_unfiltered (", ", gdb_stdlog); 3768 target_debug_print_ULONGEST (arg2); 3769 fputs_unfiltered (", ", gdb_stdlog); 3770 target_debug_print_int (arg3); 3771 fputs_unfiltered (")\n", gdb_stdlog); 3772 } 3773 3774 static int 3775 delegate_augmented_libraries_svr4_read (struct target_ops *self) 3776 { 3777 self = self->beneath; 3778 return self->to_augmented_libraries_svr4_read (self); 3779 } 3780 3781 static int 3782 tdefault_augmented_libraries_svr4_read (struct target_ops *self) 3783 { 3784 return 0; 3785 } 3786 3787 static int 3788 debug_augmented_libraries_svr4_read (struct target_ops *self) 3789 { 3790 int result; 3791 fprintf_unfiltered (gdb_stdlog, "-> %s->to_augmented_libraries_svr4_read (...)\n", debug_target.to_shortname); 3792 result = debug_target.to_augmented_libraries_svr4_read (&debug_target); 3793 fprintf_unfiltered (gdb_stdlog, "<- %s->to_augmented_libraries_svr4_read (", debug_target.to_shortname); 3794 target_debug_print_struct_target_ops_p (&debug_target); 3795 fputs_unfiltered (") = ", gdb_stdlog); 3796 target_debug_print_int (result); 3797 fputs_unfiltered ("\n", gdb_stdlog); 3798 return result; 3799 } 3800 3801 static const struct frame_unwind * 3802 delegate_get_unwinder (struct target_ops *self) 3803 { 3804 self = self->beneath; 3805 return self->to_get_unwinder (self); 3806 } 3807 3808 static const struct frame_unwind * 3809 tdefault_get_unwinder (struct target_ops *self) 3810 { 3811 return NULL; 3812 } 3813 3814 static const struct frame_unwind * 3815 debug_get_unwinder (struct target_ops *self) 3816 { 3817 const struct frame_unwind * result; 3818 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_unwinder (...)\n", debug_target.to_shortname); 3819 result = debug_target.to_get_unwinder (&debug_target); 3820 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_unwinder (", debug_target.to_shortname); 3821 target_debug_print_struct_target_ops_p (&debug_target); 3822 fputs_unfiltered (") = ", gdb_stdlog); 3823 target_debug_print_const_struct_frame_unwind_p (result); 3824 fputs_unfiltered ("\n", gdb_stdlog); 3825 return result; 3826 } 3827 3828 static const struct frame_unwind * 3829 delegate_get_tailcall_unwinder (struct target_ops *self) 3830 { 3831 self = self->beneath; 3832 return self->to_get_tailcall_unwinder (self); 3833 } 3834 3835 static const struct frame_unwind * 3836 tdefault_get_tailcall_unwinder (struct target_ops *self) 3837 { 3838 return NULL; 3839 } 3840 3841 static const struct frame_unwind * 3842 debug_get_tailcall_unwinder (struct target_ops *self) 3843 { 3844 const struct frame_unwind * result; 3845 fprintf_unfiltered (gdb_stdlog, "-> %s->to_get_tailcall_unwinder (...)\n", debug_target.to_shortname); 3846 result = debug_target.to_get_tailcall_unwinder (&debug_target); 3847 fprintf_unfiltered (gdb_stdlog, "<- %s->to_get_tailcall_unwinder (", debug_target.to_shortname); 3848 target_debug_print_struct_target_ops_p (&debug_target); 3849 fputs_unfiltered (") = ", gdb_stdlog); 3850 target_debug_print_const_struct_frame_unwind_p (result); 3851 fputs_unfiltered ("\n", gdb_stdlog); 3852 return result; 3853 } 3854 3855 static void 3856 delegate_prepare_to_generate_core (struct target_ops *self) 3857 { 3858 self = self->beneath; 3859 self->to_prepare_to_generate_core (self); 3860 } 3861 3862 static void 3863 tdefault_prepare_to_generate_core (struct target_ops *self) 3864 { 3865 } 3866 3867 static void 3868 debug_prepare_to_generate_core (struct target_ops *self) 3869 { 3870 fprintf_unfiltered (gdb_stdlog, "-> %s->to_prepare_to_generate_core (...)\n", debug_target.to_shortname); 3871 debug_target.to_prepare_to_generate_core (&debug_target); 3872 fprintf_unfiltered (gdb_stdlog, "<- %s->to_prepare_to_generate_core (", debug_target.to_shortname); 3873 target_debug_print_struct_target_ops_p (&debug_target); 3874 fputs_unfiltered (")\n", gdb_stdlog); 3875 } 3876 3877 static void 3878 delegate_done_generating_core (struct target_ops *self) 3879 { 3880 self = self->beneath; 3881 self->to_done_generating_core (self); 3882 } 3883 3884 static void 3885 tdefault_done_generating_core (struct target_ops *self) 3886 { 3887 } 3888 3889 static void 3890 debug_done_generating_core (struct target_ops *self) 3891 { 3892 fprintf_unfiltered (gdb_stdlog, "-> %s->to_done_generating_core (...)\n", debug_target.to_shortname); 3893 debug_target.to_done_generating_core (&debug_target); 3894 fprintf_unfiltered (gdb_stdlog, "<- %s->to_done_generating_core (", debug_target.to_shortname); 3895 target_debug_print_struct_target_ops_p (&debug_target); 3896 fputs_unfiltered (")\n", gdb_stdlog); 3897 } 3898 3899 static void 3900 install_delegators (struct target_ops *ops) 3901 { 3902 if (ops->to_post_attach == NULL) 3903 ops->to_post_attach = delegate_post_attach; 3904 if (ops->to_detach == NULL) 3905 ops->to_detach = delegate_detach; 3906 if (ops->to_disconnect == NULL) 3907 ops->to_disconnect = delegate_disconnect; 3908 if (ops->to_resume == NULL) 3909 ops->to_resume = delegate_resume; 3910 if (ops->to_wait == NULL) 3911 ops->to_wait = delegate_wait; 3912 if (ops->to_fetch_registers == NULL) 3913 ops->to_fetch_registers = delegate_fetch_registers; 3914 if (ops->to_store_registers == NULL) 3915 ops->to_store_registers = delegate_store_registers; 3916 if (ops->to_prepare_to_store == NULL) 3917 ops->to_prepare_to_store = delegate_prepare_to_store; 3918 if (ops->to_files_info == NULL) 3919 ops->to_files_info = delegate_files_info; 3920 if (ops->to_insert_breakpoint == NULL) 3921 ops->to_insert_breakpoint = delegate_insert_breakpoint; 3922 if (ops->to_remove_breakpoint == NULL) 3923 ops->to_remove_breakpoint = delegate_remove_breakpoint; 3924 if (ops->to_stopped_by_sw_breakpoint == NULL) 3925 ops->to_stopped_by_sw_breakpoint = delegate_stopped_by_sw_breakpoint; 3926 if (ops->to_supports_stopped_by_sw_breakpoint == NULL) 3927 ops->to_supports_stopped_by_sw_breakpoint = delegate_supports_stopped_by_sw_breakpoint; 3928 if (ops->to_stopped_by_hw_breakpoint == NULL) 3929 ops->to_stopped_by_hw_breakpoint = delegate_stopped_by_hw_breakpoint; 3930 if (ops->to_supports_stopped_by_hw_breakpoint == NULL) 3931 ops->to_supports_stopped_by_hw_breakpoint = delegate_supports_stopped_by_hw_breakpoint; 3932 if (ops->to_can_use_hw_breakpoint == NULL) 3933 ops->to_can_use_hw_breakpoint = delegate_can_use_hw_breakpoint; 3934 if (ops->to_ranged_break_num_registers == NULL) 3935 ops->to_ranged_break_num_registers = delegate_ranged_break_num_registers; 3936 if (ops->to_insert_hw_breakpoint == NULL) 3937 ops->to_insert_hw_breakpoint = delegate_insert_hw_breakpoint; 3938 if (ops->to_remove_hw_breakpoint == NULL) 3939 ops->to_remove_hw_breakpoint = delegate_remove_hw_breakpoint; 3940 if (ops->to_remove_watchpoint == NULL) 3941 ops->to_remove_watchpoint = delegate_remove_watchpoint; 3942 if (ops->to_insert_watchpoint == NULL) 3943 ops->to_insert_watchpoint = delegate_insert_watchpoint; 3944 if (ops->to_insert_mask_watchpoint == NULL) 3945 ops->to_insert_mask_watchpoint = delegate_insert_mask_watchpoint; 3946 if (ops->to_remove_mask_watchpoint == NULL) 3947 ops->to_remove_mask_watchpoint = delegate_remove_mask_watchpoint; 3948 if (ops->to_stopped_by_watchpoint == NULL) 3949 ops->to_stopped_by_watchpoint = delegate_stopped_by_watchpoint; 3950 if (ops->to_stopped_data_address == NULL) 3951 ops->to_stopped_data_address = delegate_stopped_data_address; 3952 if (ops->to_watchpoint_addr_within_range == NULL) 3953 ops->to_watchpoint_addr_within_range = delegate_watchpoint_addr_within_range; 3954 if (ops->to_region_ok_for_hw_watchpoint == NULL) 3955 ops->to_region_ok_for_hw_watchpoint = delegate_region_ok_for_hw_watchpoint; 3956 if (ops->to_can_accel_watchpoint_condition == NULL) 3957 ops->to_can_accel_watchpoint_condition = delegate_can_accel_watchpoint_condition; 3958 if (ops->to_masked_watch_num_registers == NULL) 3959 ops->to_masked_watch_num_registers = delegate_masked_watch_num_registers; 3960 if (ops->to_terminal_init == NULL) 3961 ops->to_terminal_init = delegate_terminal_init; 3962 if (ops->to_terminal_inferior == NULL) 3963 ops->to_terminal_inferior = delegate_terminal_inferior; 3964 if (ops->to_terminal_ours_for_output == NULL) 3965 ops->to_terminal_ours_for_output = delegate_terminal_ours_for_output; 3966 if (ops->to_terminal_ours == NULL) 3967 ops->to_terminal_ours = delegate_terminal_ours; 3968 if (ops->to_terminal_info == NULL) 3969 ops->to_terminal_info = delegate_terminal_info; 3970 if (ops->to_kill == NULL) 3971 ops->to_kill = delegate_kill; 3972 if (ops->to_load == NULL) 3973 ops->to_load = delegate_load; 3974 if (ops->to_post_startup_inferior == NULL) 3975 ops->to_post_startup_inferior = delegate_post_startup_inferior; 3976 if (ops->to_insert_fork_catchpoint == NULL) 3977 ops->to_insert_fork_catchpoint = delegate_insert_fork_catchpoint; 3978 if (ops->to_remove_fork_catchpoint == NULL) 3979 ops->to_remove_fork_catchpoint = delegate_remove_fork_catchpoint; 3980 if (ops->to_insert_vfork_catchpoint == NULL) 3981 ops->to_insert_vfork_catchpoint = delegate_insert_vfork_catchpoint; 3982 if (ops->to_remove_vfork_catchpoint == NULL) 3983 ops->to_remove_vfork_catchpoint = delegate_remove_vfork_catchpoint; 3984 if (ops->to_follow_fork == NULL) 3985 ops->to_follow_fork = delegate_follow_fork; 3986 if (ops->to_insert_exec_catchpoint == NULL) 3987 ops->to_insert_exec_catchpoint = delegate_insert_exec_catchpoint; 3988 if (ops->to_remove_exec_catchpoint == NULL) 3989 ops->to_remove_exec_catchpoint = delegate_remove_exec_catchpoint; 3990 if (ops->to_set_syscall_catchpoint == NULL) 3991 ops->to_set_syscall_catchpoint = delegate_set_syscall_catchpoint; 3992 if (ops->to_has_exited == NULL) 3993 ops->to_has_exited = delegate_has_exited; 3994 if (ops->to_mourn_inferior == NULL) 3995 ops->to_mourn_inferior = delegate_mourn_inferior; 3996 if (ops->to_can_run == NULL) 3997 ops->to_can_run = delegate_can_run; 3998 if (ops->to_pass_signals == NULL) 3999 ops->to_pass_signals = delegate_pass_signals; 4000 if (ops->to_program_signals == NULL) 4001 ops->to_program_signals = delegate_program_signals; 4002 if (ops->to_thread_alive == NULL) 4003 ops->to_thread_alive = delegate_thread_alive; 4004 if (ops->to_update_thread_list == NULL) 4005 ops->to_update_thread_list = delegate_update_thread_list; 4006 if (ops->to_pid_to_str == NULL) 4007 ops->to_pid_to_str = delegate_pid_to_str; 4008 if (ops->to_extra_thread_info == NULL) 4009 ops->to_extra_thread_info = delegate_extra_thread_info; 4010 if (ops->to_thread_name == NULL) 4011 ops->to_thread_name = delegate_thread_name; 4012 if (ops->to_stop == NULL) 4013 ops->to_stop = delegate_stop; 4014 if (ops->to_check_pending_interrupt == NULL) 4015 ops->to_check_pending_interrupt = delegate_check_pending_interrupt; 4016 if (ops->to_rcmd == NULL) 4017 ops->to_rcmd = delegate_rcmd; 4018 if (ops->to_pid_to_exec_file == NULL) 4019 ops->to_pid_to_exec_file = delegate_pid_to_exec_file; 4020 if (ops->to_log_command == NULL) 4021 ops->to_log_command = delegate_log_command; 4022 if (ops->to_get_section_table == NULL) 4023 ops->to_get_section_table = delegate_get_section_table; 4024 if (ops->to_can_async_p == NULL) 4025 ops->to_can_async_p = delegate_can_async_p; 4026 if (ops->to_is_async_p == NULL) 4027 ops->to_is_async_p = delegate_is_async_p; 4028 if (ops->to_async == NULL) 4029 ops->to_async = delegate_async; 4030 if (ops->to_supports_non_stop == NULL) 4031 ops->to_supports_non_stop = delegate_supports_non_stop; 4032 if (ops->to_find_memory_regions == NULL) 4033 ops->to_find_memory_regions = delegate_find_memory_regions; 4034 if (ops->to_make_corefile_notes == NULL) 4035 ops->to_make_corefile_notes = delegate_make_corefile_notes; 4036 if (ops->to_get_bookmark == NULL) 4037 ops->to_get_bookmark = delegate_get_bookmark; 4038 if (ops->to_goto_bookmark == NULL) 4039 ops->to_goto_bookmark = delegate_goto_bookmark; 4040 if (ops->to_get_thread_local_address == NULL) 4041 ops->to_get_thread_local_address = delegate_get_thread_local_address; 4042 if (ops->to_xfer_partial == NULL) 4043 ops->to_xfer_partial = delegate_xfer_partial; 4044 if (ops->to_memory_map == NULL) 4045 ops->to_memory_map = delegate_memory_map; 4046 if (ops->to_flash_erase == NULL) 4047 ops->to_flash_erase = delegate_flash_erase; 4048 if (ops->to_flash_done == NULL) 4049 ops->to_flash_done = delegate_flash_done; 4050 if (ops->to_read_description == NULL) 4051 ops->to_read_description = delegate_read_description; 4052 if (ops->to_get_ada_task_ptid == NULL) 4053 ops->to_get_ada_task_ptid = delegate_get_ada_task_ptid; 4054 if (ops->to_auxv_parse == NULL) 4055 ops->to_auxv_parse = delegate_auxv_parse; 4056 if (ops->to_search_memory == NULL) 4057 ops->to_search_memory = delegate_search_memory; 4058 if (ops->to_can_execute_reverse == NULL) 4059 ops->to_can_execute_reverse = delegate_can_execute_reverse; 4060 if (ops->to_execution_direction == NULL) 4061 ops->to_execution_direction = delegate_execution_direction; 4062 if (ops->to_supports_multi_process == NULL) 4063 ops->to_supports_multi_process = delegate_supports_multi_process; 4064 if (ops->to_supports_enable_disable_tracepoint == NULL) 4065 ops->to_supports_enable_disable_tracepoint = delegate_supports_enable_disable_tracepoint; 4066 if (ops->to_supports_string_tracing == NULL) 4067 ops->to_supports_string_tracing = delegate_supports_string_tracing; 4068 if (ops->to_supports_evaluation_of_breakpoint_conditions == NULL) 4069 ops->to_supports_evaluation_of_breakpoint_conditions = delegate_supports_evaluation_of_breakpoint_conditions; 4070 if (ops->to_can_run_breakpoint_commands == NULL) 4071 ops->to_can_run_breakpoint_commands = delegate_can_run_breakpoint_commands; 4072 if (ops->to_thread_architecture == NULL) 4073 ops->to_thread_architecture = delegate_thread_architecture; 4074 if (ops->to_thread_address_space == NULL) 4075 ops->to_thread_address_space = delegate_thread_address_space; 4076 if (ops->to_filesystem_is_local == NULL) 4077 ops->to_filesystem_is_local = delegate_filesystem_is_local; 4078 if (ops->to_trace_init == NULL) 4079 ops->to_trace_init = delegate_trace_init; 4080 if (ops->to_download_tracepoint == NULL) 4081 ops->to_download_tracepoint = delegate_download_tracepoint; 4082 if (ops->to_can_download_tracepoint == NULL) 4083 ops->to_can_download_tracepoint = delegate_can_download_tracepoint; 4084 if (ops->to_download_trace_state_variable == NULL) 4085 ops->to_download_trace_state_variable = delegate_download_trace_state_variable; 4086 if (ops->to_enable_tracepoint == NULL) 4087 ops->to_enable_tracepoint = delegate_enable_tracepoint; 4088 if (ops->to_disable_tracepoint == NULL) 4089 ops->to_disable_tracepoint = delegate_disable_tracepoint; 4090 if (ops->to_trace_set_readonly_regions == NULL) 4091 ops->to_trace_set_readonly_regions = delegate_trace_set_readonly_regions; 4092 if (ops->to_trace_start == NULL) 4093 ops->to_trace_start = delegate_trace_start; 4094 if (ops->to_get_trace_status == NULL) 4095 ops->to_get_trace_status = delegate_get_trace_status; 4096 if (ops->to_get_tracepoint_status == NULL) 4097 ops->to_get_tracepoint_status = delegate_get_tracepoint_status; 4098 if (ops->to_trace_stop == NULL) 4099 ops->to_trace_stop = delegate_trace_stop; 4100 if (ops->to_trace_find == NULL) 4101 ops->to_trace_find = delegate_trace_find; 4102 if (ops->to_get_trace_state_variable_value == NULL) 4103 ops->to_get_trace_state_variable_value = delegate_get_trace_state_variable_value; 4104 if (ops->to_save_trace_data == NULL) 4105 ops->to_save_trace_data = delegate_save_trace_data; 4106 if (ops->to_upload_tracepoints == NULL) 4107 ops->to_upload_tracepoints = delegate_upload_tracepoints; 4108 if (ops->to_upload_trace_state_variables == NULL) 4109 ops->to_upload_trace_state_variables = delegate_upload_trace_state_variables; 4110 if (ops->to_get_raw_trace_data == NULL) 4111 ops->to_get_raw_trace_data = delegate_get_raw_trace_data; 4112 if (ops->to_get_min_fast_tracepoint_insn_len == NULL) 4113 ops->to_get_min_fast_tracepoint_insn_len = delegate_get_min_fast_tracepoint_insn_len; 4114 if (ops->to_set_disconnected_tracing == NULL) 4115 ops->to_set_disconnected_tracing = delegate_set_disconnected_tracing; 4116 if (ops->to_set_circular_trace_buffer == NULL) 4117 ops->to_set_circular_trace_buffer = delegate_set_circular_trace_buffer; 4118 if (ops->to_set_trace_buffer_size == NULL) 4119 ops->to_set_trace_buffer_size = delegate_set_trace_buffer_size; 4120 if (ops->to_set_trace_notes == NULL) 4121 ops->to_set_trace_notes = delegate_set_trace_notes; 4122 if (ops->to_core_of_thread == NULL) 4123 ops->to_core_of_thread = delegate_core_of_thread; 4124 if (ops->to_verify_memory == NULL) 4125 ops->to_verify_memory = delegate_verify_memory; 4126 if (ops->to_get_tib_address == NULL) 4127 ops->to_get_tib_address = delegate_get_tib_address; 4128 if (ops->to_set_permissions == NULL) 4129 ops->to_set_permissions = delegate_set_permissions; 4130 if (ops->to_static_tracepoint_marker_at == NULL) 4131 ops->to_static_tracepoint_marker_at = delegate_static_tracepoint_marker_at; 4132 if (ops->to_static_tracepoint_markers_by_strid == NULL) 4133 ops->to_static_tracepoint_markers_by_strid = delegate_static_tracepoint_markers_by_strid; 4134 if (ops->to_traceframe_info == NULL) 4135 ops->to_traceframe_info = delegate_traceframe_info; 4136 if (ops->to_use_agent == NULL) 4137 ops->to_use_agent = delegate_use_agent; 4138 if (ops->to_can_use_agent == NULL) 4139 ops->to_can_use_agent = delegate_can_use_agent; 4140 if (ops->to_supports_btrace == NULL) 4141 ops->to_supports_btrace = delegate_supports_btrace; 4142 if (ops->to_enable_btrace == NULL) 4143 ops->to_enable_btrace = delegate_enable_btrace; 4144 if (ops->to_disable_btrace == NULL) 4145 ops->to_disable_btrace = delegate_disable_btrace; 4146 if (ops->to_teardown_btrace == NULL) 4147 ops->to_teardown_btrace = delegate_teardown_btrace; 4148 if (ops->to_read_btrace == NULL) 4149 ops->to_read_btrace = delegate_read_btrace; 4150 if (ops->to_btrace_conf == NULL) 4151 ops->to_btrace_conf = delegate_btrace_conf; 4152 if (ops->to_stop_recording == NULL) 4153 ops->to_stop_recording = delegate_stop_recording; 4154 if (ops->to_info_record == NULL) 4155 ops->to_info_record = delegate_info_record; 4156 if (ops->to_save_record == NULL) 4157 ops->to_save_record = delegate_save_record; 4158 if (ops->to_delete_record == NULL) 4159 ops->to_delete_record = delegate_delete_record; 4160 if (ops->to_record_is_replaying == NULL) 4161 ops->to_record_is_replaying = delegate_record_is_replaying; 4162 if (ops->to_goto_record_begin == NULL) 4163 ops->to_goto_record_begin = delegate_goto_record_begin; 4164 if (ops->to_goto_record_end == NULL) 4165 ops->to_goto_record_end = delegate_goto_record_end; 4166 if (ops->to_goto_record == NULL) 4167 ops->to_goto_record = delegate_goto_record; 4168 if (ops->to_insn_history == NULL) 4169 ops->to_insn_history = delegate_insn_history; 4170 if (ops->to_insn_history_from == NULL) 4171 ops->to_insn_history_from = delegate_insn_history_from; 4172 if (ops->to_insn_history_range == NULL) 4173 ops->to_insn_history_range = delegate_insn_history_range; 4174 if (ops->to_call_history == NULL) 4175 ops->to_call_history = delegate_call_history; 4176 if (ops->to_call_history_from == NULL) 4177 ops->to_call_history_from = delegate_call_history_from; 4178 if (ops->to_call_history_range == NULL) 4179 ops->to_call_history_range = delegate_call_history_range; 4180 if (ops->to_augmented_libraries_svr4_read == NULL) 4181 ops->to_augmented_libraries_svr4_read = delegate_augmented_libraries_svr4_read; 4182 if (ops->to_get_unwinder == NULL) 4183 ops->to_get_unwinder = delegate_get_unwinder; 4184 if (ops->to_get_tailcall_unwinder == NULL) 4185 ops->to_get_tailcall_unwinder = delegate_get_tailcall_unwinder; 4186 if (ops->to_prepare_to_generate_core == NULL) 4187 ops->to_prepare_to_generate_core = delegate_prepare_to_generate_core; 4188 if (ops->to_done_generating_core == NULL) 4189 ops->to_done_generating_core = delegate_done_generating_core; 4190 } 4191 4192 static void 4193 install_dummy_methods (struct target_ops *ops) 4194 { 4195 ops->to_post_attach = tdefault_post_attach; 4196 ops->to_detach = tdefault_detach; 4197 ops->to_disconnect = tdefault_disconnect; 4198 ops->to_resume = tdefault_resume; 4199 ops->to_wait = tdefault_wait; 4200 ops->to_fetch_registers = tdefault_fetch_registers; 4201 ops->to_store_registers = tdefault_store_registers; 4202 ops->to_prepare_to_store = tdefault_prepare_to_store; 4203 ops->to_files_info = tdefault_files_info; 4204 ops->to_insert_breakpoint = memory_insert_breakpoint; 4205 ops->to_remove_breakpoint = memory_remove_breakpoint; 4206 ops->to_stopped_by_sw_breakpoint = tdefault_stopped_by_sw_breakpoint; 4207 ops->to_supports_stopped_by_sw_breakpoint = tdefault_supports_stopped_by_sw_breakpoint; 4208 ops->to_stopped_by_hw_breakpoint = tdefault_stopped_by_hw_breakpoint; 4209 ops->to_supports_stopped_by_hw_breakpoint = tdefault_supports_stopped_by_hw_breakpoint; 4210 ops->to_can_use_hw_breakpoint = tdefault_can_use_hw_breakpoint; 4211 ops->to_ranged_break_num_registers = tdefault_ranged_break_num_registers; 4212 ops->to_insert_hw_breakpoint = tdefault_insert_hw_breakpoint; 4213 ops->to_remove_hw_breakpoint = tdefault_remove_hw_breakpoint; 4214 ops->to_remove_watchpoint = tdefault_remove_watchpoint; 4215 ops->to_insert_watchpoint = tdefault_insert_watchpoint; 4216 ops->to_insert_mask_watchpoint = tdefault_insert_mask_watchpoint; 4217 ops->to_remove_mask_watchpoint = tdefault_remove_mask_watchpoint; 4218 ops->to_stopped_by_watchpoint = tdefault_stopped_by_watchpoint; 4219 ops->to_stopped_data_address = tdefault_stopped_data_address; 4220 ops->to_watchpoint_addr_within_range = default_watchpoint_addr_within_range; 4221 ops->to_region_ok_for_hw_watchpoint = default_region_ok_for_hw_watchpoint; 4222 ops->to_can_accel_watchpoint_condition = tdefault_can_accel_watchpoint_condition; 4223 ops->to_masked_watch_num_registers = tdefault_masked_watch_num_registers; 4224 ops->to_terminal_init = tdefault_terminal_init; 4225 ops->to_terminal_inferior = tdefault_terminal_inferior; 4226 ops->to_terminal_ours_for_output = tdefault_terminal_ours_for_output; 4227 ops->to_terminal_ours = tdefault_terminal_ours; 4228 ops->to_terminal_info = default_terminal_info; 4229 ops->to_kill = tdefault_kill; 4230 ops->to_load = tdefault_load; 4231 ops->to_post_startup_inferior = tdefault_post_startup_inferior; 4232 ops->to_insert_fork_catchpoint = tdefault_insert_fork_catchpoint; 4233 ops->to_remove_fork_catchpoint = tdefault_remove_fork_catchpoint; 4234 ops->to_insert_vfork_catchpoint = tdefault_insert_vfork_catchpoint; 4235 ops->to_remove_vfork_catchpoint = tdefault_remove_vfork_catchpoint; 4236 ops->to_follow_fork = default_follow_fork; 4237 ops->to_insert_exec_catchpoint = tdefault_insert_exec_catchpoint; 4238 ops->to_remove_exec_catchpoint = tdefault_remove_exec_catchpoint; 4239 ops->to_set_syscall_catchpoint = tdefault_set_syscall_catchpoint; 4240 ops->to_has_exited = tdefault_has_exited; 4241 ops->to_mourn_inferior = default_mourn_inferior; 4242 ops->to_can_run = tdefault_can_run; 4243 ops->to_pass_signals = tdefault_pass_signals; 4244 ops->to_program_signals = tdefault_program_signals; 4245 ops->to_thread_alive = tdefault_thread_alive; 4246 ops->to_update_thread_list = tdefault_update_thread_list; 4247 ops->to_pid_to_str = default_pid_to_str; 4248 ops->to_extra_thread_info = tdefault_extra_thread_info; 4249 ops->to_thread_name = tdefault_thread_name; 4250 ops->to_stop = tdefault_stop; 4251 ops->to_check_pending_interrupt = tdefault_check_pending_interrupt; 4252 ops->to_rcmd = default_rcmd; 4253 ops->to_pid_to_exec_file = tdefault_pid_to_exec_file; 4254 ops->to_log_command = tdefault_log_command; 4255 ops->to_get_section_table = tdefault_get_section_table; 4256 ops->to_can_async_p = tdefault_can_async_p; 4257 ops->to_is_async_p = tdefault_is_async_p; 4258 ops->to_async = tdefault_async; 4259 ops->to_supports_non_stop = tdefault_supports_non_stop; 4260 ops->to_find_memory_regions = dummy_find_memory_regions; 4261 ops->to_make_corefile_notes = dummy_make_corefile_notes; 4262 ops->to_get_bookmark = tdefault_get_bookmark; 4263 ops->to_goto_bookmark = tdefault_goto_bookmark; 4264 ops->to_get_thread_local_address = tdefault_get_thread_local_address; 4265 ops->to_xfer_partial = tdefault_xfer_partial; 4266 ops->to_memory_map = tdefault_memory_map; 4267 ops->to_flash_erase = tdefault_flash_erase; 4268 ops->to_flash_done = tdefault_flash_done; 4269 ops->to_read_description = tdefault_read_description; 4270 ops->to_get_ada_task_ptid = default_get_ada_task_ptid; 4271 ops->to_auxv_parse = default_auxv_parse; 4272 ops->to_search_memory = default_search_memory; 4273 ops->to_can_execute_reverse = tdefault_can_execute_reverse; 4274 ops->to_execution_direction = default_execution_direction; 4275 ops->to_supports_multi_process = tdefault_supports_multi_process; 4276 ops->to_supports_enable_disable_tracepoint = tdefault_supports_enable_disable_tracepoint; 4277 ops->to_supports_string_tracing = tdefault_supports_string_tracing; 4278 ops->to_supports_evaluation_of_breakpoint_conditions = tdefault_supports_evaluation_of_breakpoint_conditions; 4279 ops->to_can_run_breakpoint_commands = tdefault_can_run_breakpoint_commands; 4280 ops->to_thread_architecture = default_thread_architecture; 4281 ops->to_thread_address_space = default_thread_address_space; 4282 ops->to_filesystem_is_local = tdefault_filesystem_is_local; 4283 ops->to_trace_init = tdefault_trace_init; 4284 ops->to_download_tracepoint = tdefault_download_tracepoint; 4285 ops->to_can_download_tracepoint = tdefault_can_download_tracepoint; 4286 ops->to_download_trace_state_variable = tdefault_download_trace_state_variable; 4287 ops->to_enable_tracepoint = tdefault_enable_tracepoint; 4288 ops->to_disable_tracepoint = tdefault_disable_tracepoint; 4289 ops->to_trace_set_readonly_regions = tdefault_trace_set_readonly_regions; 4290 ops->to_trace_start = tdefault_trace_start; 4291 ops->to_get_trace_status = tdefault_get_trace_status; 4292 ops->to_get_tracepoint_status = tdefault_get_tracepoint_status; 4293 ops->to_trace_stop = tdefault_trace_stop; 4294 ops->to_trace_find = tdefault_trace_find; 4295 ops->to_get_trace_state_variable_value = tdefault_get_trace_state_variable_value; 4296 ops->to_save_trace_data = tdefault_save_trace_data; 4297 ops->to_upload_tracepoints = tdefault_upload_tracepoints; 4298 ops->to_upload_trace_state_variables = tdefault_upload_trace_state_variables; 4299 ops->to_get_raw_trace_data = tdefault_get_raw_trace_data; 4300 ops->to_get_min_fast_tracepoint_insn_len = tdefault_get_min_fast_tracepoint_insn_len; 4301 ops->to_set_disconnected_tracing = tdefault_set_disconnected_tracing; 4302 ops->to_set_circular_trace_buffer = tdefault_set_circular_trace_buffer; 4303 ops->to_set_trace_buffer_size = tdefault_set_trace_buffer_size; 4304 ops->to_set_trace_notes = tdefault_set_trace_notes; 4305 ops->to_core_of_thread = tdefault_core_of_thread; 4306 ops->to_verify_memory = default_verify_memory; 4307 ops->to_get_tib_address = tdefault_get_tib_address; 4308 ops->to_set_permissions = tdefault_set_permissions; 4309 ops->to_static_tracepoint_marker_at = tdefault_static_tracepoint_marker_at; 4310 ops->to_static_tracepoint_markers_by_strid = tdefault_static_tracepoint_markers_by_strid; 4311 ops->to_traceframe_info = tdefault_traceframe_info; 4312 ops->to_use_agent = tdefault_use_agent; 4313 ops->to_can_use_agent = tdefault_can_use_agent; 4314 ops->to_supports_btrace = tdefault_supports_btrace; 4315 ops->to_enable_btrace = tdefault_enable_btrace; 4316 ops->to_disable_btrace = tdefault_disable_btrace; 4317 ops->to_teardown_btrace = tdefault_teardown_btrace; 4318 ops->to_read_btrace = tdefault_read_btrace; 4319 ops->to_btrace_conf = tdefault_btrace_conf; 4320 ops->to_stop_recording = tdefault_stop_recording; 4321 ops->to_info_record = tdefault_info_record; 4322 ops->to_save_record = tdefault_save_record; 4323 ops->to_delete_record = tdefault_delete_record; 4324 ops->to_record_is_replaying = tdefault_record_is_replaying; 4325 ops->to_goto_record_begin = tdefault_goto_record_begin; 4326 ops->to_goto_record_end = tdefault_goto_record_end; 4327 ops->to_goto_record = tdefault_goto_record; 4328 ops->to_insn_history = tdefault_insn_history; 4329 ops->to_insn_history_from = tdefault_insn_history_from; 4330 ops->to_insn_history_range = tdefault_insn_history_range; 4331 ops->to_call_history = tdefault_call_history; 4332 ops->to_call_history_from = tdefault_call_history_from; 4333 ops->to_call_history_range = tdefault_call_history_range; 4334 ops->to_augmented_libraries_svr4_read = tdefault_augmented_libraries_svr4_read; 4335 ops->to_get_unwinder = tdefault_get_unwinder; 4336 ops->to_get_tailcall_unwinder = tdefault_get_tailcall_unwinder; 4337 ops->to_prepare_to_generate_core = tdefault_prepare_to_generate_core; 4338 ops->to_done_generating_core = tdefault_done_generating_core; 4339 } 4340 4341 static void 4342 init_debug_target (struct target_ops *ops) 4343 { 4344 ops->to_post_attach = debug_post_attach; 4345 ops->to_detach = debug_detach; 4346 ops->to_disconnect = debug_disconnect; 4347 ops->to_resume = debug_resume; 4348 ops->to_wait = debug_wait; 4349 ops->to_fetch_registers = debug_fetch_registers; 4350 ops->to_store_registers = debug_store_registers; 4351 ops->to_prepare_to_store = debug_prepare_to_store; 4352 ops->to_files_info = debug_files_info; 4353 ops->to_insert_breakpoint = debug_insert_breakpoint; 4354 ops->to_remove_breakpoint = debug_remove_breakpoint; 4355 ops->to_stopped_by_sw_breakpoint = debug_stopped_by_sw_breakpoint; 4356 ops->to_supports_stopped_by_sw_breakpoint = debug_supports_stopped_by_sw_breakpoint; 4357 ops->to_stopped_by_hw_breakpoint = debug_stopped_by_hw_breakpoint; 4358 ops->to_supports_stopped_by_hw_breakpoint = debug_supports_stopped_by_hw_breakpoint; 4359 ops->to_can_use_hw_breakpoint = debug_can_use_hw_breakpoint; 4360 ops->to_ranged_break_num_registers = debug_ranged_break_num_registers; 4361 ops->to_insert_hw_breakpoint = debug_insert_hw_breakpoint; 4362 ops->to_remove_hw_breakpoint = debug_remove_hw_breakpoint; 4363 ops->to_remove_watchpoint = debug_remove_watchpoint; 4364 ops->to_insert_watchpoint = debug_insert_watchpoint; 4365 ops->to_insert_mask_watchpoint = debug_insert_mask_watchpoint; 4366 ops->to_remove_mask_watchpoint = debug_remove_mask_watchpoint; 4367 ops->to_stopped_by_watchpoint = debug_stopped_by_watchpoint; 4368 ops->to_stopped_data_address = debug_stopped_data_address; 4369 ops->to_watchpoint_addr_within_range = debug_watchpoint_addr_within_range; 4370 ops->to_region_ok_for_hw_watchpoint = debug_region_ok_for_hw_watchpoint; 4371 ops->to_can_accel_watchpoint_condition = debug_can_accel_watchpoint_condition; 4372 ops->to_masked_watch_num_registers = debug_masked_watch_num_registers; 4373 ops->to_terminal_init = debug_terminal_init; 4374 ops->to_terminal_inferior = debug_terminal_inferior; 4375 ops->to_terminal_ours_for_output = debug_terminal_ours_for_output; 4376 ops->to_terminal_ours = debug_terminal_ours; 4377 ops->to_terminal_info = debug_terminal_info; 4378 ops->to_kill = debug_kill; 4379 ops->to_load = debug_load; 4380 ops->to_post_startup_inferior = debug_post_startup_inferior; 4381 ops->to_insert_fork_catchpoint = debug_insert_fork_catchpoint; 4382 ops->to_remove_fork_catchpoint = debug_remove_fork_catchpoint; 4383 ops->to_insert_vfork_catchpoint = debug_insert_vfork_catchpoint; 4384 ops->to_remove_vfork_catchpoint = debug_remove_vfork_catchpoint; 4385 ops->to_follow_fork = debug_follow_fork; 4386 ops->to_insert_exec_catchpoint = debug_insert_exec_catchpoint; 4387 ops->to_remove_exec_catchpoint = debug_remove_exec_catchpoint; 4388 ops->to_set_syscall_catchpoint = debug_set_syscall_catchpoint; 4389 ops->to_has_exited = debug_has_exited; 4390 ops->to_mourn_inferior = debug_mourn_inferior; 4391 ops->to_can_run = debug_can_run; 4392 ops->to_pass_signals = debug_pass_signals; 4393 ops->to_program_signals = debug_program_signals; 4394 ops->to_thread_alive = debug_thread_alive; 4395 ops->to_update_thread_list = debug_update_thread_list; 4396 ops->to_pid_to_str = debug_pid_to_str; 4397 ops->to_extra_thread_info = debug_extra_thread_info; 4398 ops->to_thread_name = debug_thread_name; 4399 ops->to_stop = debug_stop; 4400 ops->to_check_pending_interrupt = debug_check_pending_interrupt; 4401 ops->to_rcmd = debug_rcmd; 4402 ops->to_pid_to_exec_file = debug_pid_to_exec_file; 4403 ops->to_log_command = debug_log_command; 4404 ops->to_get_section_table = debug_get_section_table; 4405 ops->to_can_async_p = debug_can_async_p; 4406 ops->to_is_async_p = debug_is_async_p; 4407 ops->to_async = debug_async; 4408 ops->to_supports_non_stop = debug_supports_non_stop; 4409 ops->to_find_memory_regions = debug_find_memory_regions; 4410 ops->to_make_corefile_notes = debug_make_corefile_notes; 4411 ops->to_get_bookmark = debug_get_bookmark; 4412 ops->to_goto_bookmark = debug_goto_bookmark; 4413 ops->to_get_thread_local_address = debug_get_thread_local_address; 4414 ops->to_xfer_partial = debug_xfer_partial; 4415 ops->to_memory_map = debug_memory_map; 4416 ops->to_flash_erase = debug_flash_erase; 4417 ops->to_flash_done = debug_flash_done; 4418 ops->to_read_description = debug_read_description; 4419 ops->to_get_ada_task_ptid = debug_get_ada_task_ptid; 4420 ops->to_auxv_parse = debug_auxv_parse; 4421 ops->to_search_memory = debug_search_memory; 4422 ops->to_can_execute_reverse = debug_can_execute_reverse; 4423 ops->to_execution_direction = debug_execution_direction; 4424 ops->to_supports_multi_process = debug_supports_multi_process; 4425 ops->to_supports_enable_disable_tracepoint = debug_supports_enable_disable_tracepoint; 4426 ops->to_supports_string_tracing = debug_supports_string_tracing; 4427 ops->to_supports_evaluation_of_breakpoint_conditions = debug_supports_evaluation_of_breakpoint_conditions; 4428 ops->to_can_run_breakpoint_commands = debug_can_run_breakpoint_commands; 4429 ops->to_thread_architecture = debug_thread_architecture; 4430 ops->to_thread_address_space = debug_thread_address_space; 4431 ops->to_filesystem_is_local = debug_filesystem_is_local; 4432 ops->to_trace_init = debug_trace_init; 4433 ops->to_download_tracepoint = debug_download_tracepoint; 4434 ops->to_can_download_tracepoint = debug_can_download_tracepoint; 4435 ops->to_download_trace_state_variable = debug_download_trace_state_variable; 4436 ops->to_enable_tracepoint = debug_enable_tracepoint; 4437 ops->to_disable_tracepoint = debug_disable_tracepoint; 4438 ops->to_trace_set_readonly_regions = debug_trace_set_readonly_regions; 4439 ops->to_trace_start = debug_trace_start; 4440 ops->to_get_trace_status = debug_get_trace_status; 4441 ops->to_get_tracepoint_status = debug_get_tracepoint_status; 4442 ops->to_trace_stop = debug_trace_stop; 4443 ops->to_trace_find = debug_trace_find; 4444 ops->to_get_trace_state_variable_value = debug_get_trace_state_variable_value; 4445 ops->to_save_trace_data = debug_save_trace_data; 4446 ops->to_upload_tracepoints = debug_upload_tracepoints; 4447 ops->to_upload_trace_state_variables = debug_upload_trace_state_variables; 4448 ops->to_get_raw_trace_data = debug_get_raw_trace_data; 4449 ops->to_get_min_fast_tracepoint_insn_len = debug_get_min_fast_tracepoint_insn_len; 4450 ops->to_set_disconnected_tracing = debug_set_disconnected_tracing; 4451 ops->to_set_circular_trace_buffer = debug_set_circular_trace_buffer; 4452 ops->to_set_trace_buffer_size = debug_set_trace_buffer_size; 4453 ops->to_set_trace_notes = debug_set_trace_notes; 4454 ops->to_core_of_thread = debug_core_of_thread; 4455 ops->to_verify_memory = debug_verify_memory; 4456 ops->to_get_tib_address = debug_get_tib_address; 4457 ops->to_set_permissions = debug_set_permissions; 4458 ops->to_static_tracepoint_marker_at = debug_static_tracepoint_marker_at; 4459 ops->to_static_tracepoint_markers_by_strid = debug_static_tracepoint_markers_by_strid; 4460 ops->to_traceframe_info = debug_traceframe_info; 4461 ops->to_use_agent = debug_use_agent; 4462 ops->to_can_use_agent = debug_can_use_agent; 4463 ops->to_supports_btrace = debug_supports_btrace; 4464 ops->to_enable_btrace = debug_enable_btrace; 4465 ops->to_disable_btrace = debug_disable_btrace; 4466 ops->to_teardown_btrace = debug_teardown_btrace; 4467 ops->to_read_btrace = debug_read_btrace; 4468 ops->to_btrace_conf = debug_btrace_conf; 4469 ops->to_stop_recording = debug_stop_recording; 4470 ops->to_info_record = debug_info_record; 4471 ops->to_save_record = debug_save_record; 4472 ops->to_delete_record = debug_delete_record; 4473 ops->to_record_is_replaying = debug_record_is_replaying; 4474 ops->to_goto_record_begin = debug_goto_record_begin; 4475 ops->to_goto_record_end = debug_goto_record_end; 4476 ops->to_goto_record = debug_goto_record; 4477 ops->to_insn_history = debug_insn_history; 4478 ops->to_insn_history_from = debug_insn_history_from; 4479 ops->to_insn_history_range = debug_insn_history_range; 4480 ops->to_call_history = debug_call_history; 4481 ops->to_call_history_from = debug_call_history_from; 4482 ops->to_call_history_range = debug_call_history_range; 4483 ops->to_augmented_libraries_svr4_read = debug_augmented_libraries_svr4_read; 4484 ops->to_get_unwinder = debug_get_unwinder; 4485 ops->to_get_tailcall_unwinder = debug_get_tailcall_unwinder; 4486 ops->to_prepare_to_generate_core = debug_prepare_to_generate_core; 4487 ops->to_done_generating_core = debug_done_generating_core; 4488 } 4489