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