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