1/* Select target systems and architectures at runtime for GDB. 2 3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 4 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 5 6 Contributed by Cygnus Support. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 59 Temple Place - Suite 330, 23 Boston, MA 02111-1307, USA. */ 24 25#include "defs.h" 26#include <errno.h> 27#include "gdb_string.h" 28#include "target.h" 29#include "gdbcmd.h" 30#include "symtab.h" 31#include "inferior.h" 32#include "bfd.h" 33#include "symfile.h" 34#include "objfiles.h" 35#include "gdb_wait.h" 36#include "dcache.h" 37#include <signal.h> 38#include "regcache.h" 39#include "gdb_assert.h" 40#include "gdbcore.h" 41 42static void target_info (char *, int); 43 44static void maybe_kill_then_attach (char *, int); 45 46static void kill_or_be_killed (int); 47 48static void default_terminal_info (char *, int); 49 50static int default_region_size_ok_for_hw_watchpoint (int); 51 52static int nosymbol (char *, CORE_ADDR *); 53 54static void tcomplain (void); 55 56static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *); 57 58static int return_zero (void); 59 60static int return_one (void); 61 62static int return_minus_one (void); 63 64void target_ignore (void); 65 66static void target_command (char *, int); 67 68static struct target_ops *find_default_run_target (char *); 69 70static void nosupport_runtime (void); 71 72static LONGEST default_xfer_partial (struct target_ops *ops, 73 enum target_object object, 74 const char *annex, void *readbuf, 75 const void *writebuf, 76 ULONGEST offset, LONGEST len); 77 78/* Transfer LEN bytes between target address MEMADDR and GDB address 79 MYADDR. Returns 0 for success, errno code for failure (which 80 includes partial transfers -- if you want a more useful response to 81 partial transfers, try either target_read_memory_partial or 82 target_write_memory_partial). */ 83 84static int target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, 85 int write); 86 87static void init_dummy_target (void); 88 89static struct target_ops debug_target; 90 91static void debug_to_open (char *, int); 92 93static void debug_to_close (int); 94 95static void debug_to_attach (char *, int); 96 97static void debug_to_detach (char *, int); 98 99static void debug_to_disconnect (char *, int); 100 101static void debug_to_resume (ptid_t, int, enum target_signal); 102 103static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *); 104 105static void debug_to_fetch_registers (int); 106 107static void debug_to_store_registers (int); 108 109static void debug_to_prepare_to_store (void); 110 111static int deprecated_debug_xfer_memory (CORE_ADDR, char *, int, int, 112 struct mem_attrib *, 113 struct target_ops *); 114 115static void debug_to_files_info (struct target_ops *); 116 117static int debug_to_insert_breakpoint (CORE_ADDR, char *); 118 119static int debug_to_remove_breakpoint (CORE_ADDR, char *); 120 121static int debug_to_can_use_hw_breakpoint (int, int, int); 122 123static int debug_to_insert_hw_breakpoint (CORE_ADDR, char *); 124 125static int debug_to_remove_hw_breakpoint (CORE_ADDR, char *); 126 127static int debug_to_insert_watchpoint (CORE_ADDR, int, int); 128 129static int debug_to_remove_watchpoint (CORE_ADDR, int, int); 130 131static int debug_to_stopped_by_watchpoint (void); 132 133static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *); 134 135static int debug_to_region_size_ok_for_hw_watchpoint (int); 136 137static void debug_to_terminal_init (void); 138 139static void debug_to_terminal_inferior (void); 140 141static void debug_to_terminal_ours_for_output (void); 142 143static void debug_to_terminal_save_ours (void); 144 145static void debug_to_terminal_ours (void); 146 147static void debug_to_terminal_info (char *, int); 148 149static void debug_to_kill (void); 150 151static void debug_to_load (char *, int); 152 153static int debug_to_lookup_symbol (char *, CORE_ADDR *); 154 155static void debug_to_mourn_inferior (void); 156 157static int debug_to_can_run (void); 158 159static void debug_to_notice_signals (ptid_t); 160 161static int debug_to_thread_alive (ptid_t); 162 163static void debug_to_stop (void); 164 165/* NOTE: cagney/2004-09-29: Many targets reference this variable in 166 wierd and mysterious ways. Putting the variable here lets those 167 wierd and mysterious ways keep building while they are being 168 converted to the inferior inheritance structure. */ 169struct target_ops deprecated_child_ops; 170 171/* Pointer to array of target architecture structures; the size of the 172 array; the current index into the array; the allocated size of the 173 array. */ 174struct target_ops **target_structs; 175unsigned target_struct_size; 176unsigned target_struct_index; 177unsigned target_struct_allocsize; 178#define DEFAULT_ALLOCSIZE 10 179 180/* The initial current target, so that there is always a semi-valid 181 current target. */ 182 183static struct target_ops dummy_target; 184 185/* Top of target stack. */ 186 187static struct target_ops *target_stack; 188 189/* The target structure we are currently using to talk to a process 190 or file or whatever "inferior" we have. */ 191 192struct target_ops current_target; 193 194/* Command list for target. */ 195 196static struct cmd_list_element *targetlist = NULL; 197 198/* Nonzero if we are debugging an attached outside process 199 rather than an inferior. */ 200 201int attach_flag; 202 203/* Non-zero if we want to see trace of target level stuff. */ 204 205static int targetdebug = 0; 206 207static void setup_target_debug (void); 208 209DCACHE *target_dcache; 210 211/* The user just typed 'target' without the name of a target. */ 212 213static void 214target_command (char *arg, int from_tty) 215{ 216 fputs_filtered ("Argument required (target name). Try `help target'\n", 217 gdb_stdout); 218} 219 220/* Add a possible target architecture to the list. */ 221 222void 223add_target (struct target_ops *t) 224{ 225 /* Provide default values for all "must have" methods. */ 226 if (t->to_xfer_partial == NULL) 227 t->to_xfer_partial = default_xfer_partial; 228 229 if (!target_structs) 230 { 231 target_struct_allocsize = DEFAULT_ALLOCSIZE; 232 target_structs = (struct target_ops **) xmalloc 233 (target_struct_allocsize * sizeof (*target_structs)); 234 } 235 if (target_struct_size >= target_struct_allocsize) 236 { 237 target_struct_allocsize *= 2; 238 target_structs = (struct target_ops **) 239 xrealloc ((char *) target_structs, 240 target_struct_allocsize * sizeof (*target_structs)); 241 } 242 target_structs[target_struct_size++] = t; 243 244 if (targetlist == NULL) 245 add_prefix_cmd ("target", class_run, target_command, 246 "Connect to a target machine or process.\n\ 247The first argument is the type or protocol of the target machine.\n\ 248Remaining arguments are interpreted by the target protocol. For more\n\ 249information on the arguments for a particular protocol, type\n\ 250`help target ' followed by the protocol name.", 251 &targetlist, "target ", 0, &cmdlist); 252 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist); 253} 254 255/* Stub functions */ 256 257void 258target_ignore (void) 259{ 260} 261 262void 263target_load (char *arg, int from_tty) 264{ 265 dcache_invalidate (target_dcache); 266 (*current_target.to_load) (arg, from_tty); 267} 268 269static int 270nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write, 271 struct target_ops *t) 272{ 273 errno = EIO; /* Can't read/write this location */ 274 return 0; /* No bytes handled */ 275} 276 277static void 278tcomplain (void) 279{ 280 error ("You can't do that when your target is `%s'", 281 current_target.to_shortname); 282} 283 284void 285noprocess (void) 286{ 287 error ("You can't do that without a process to debug."); 288} 289 290static int 291nosymbol (char *name, CORE_ADDR *addrp) 292{ 293 return 1; /* Symbol does not exist in target env */ 294} 295 296static void 297nosupport_runtime (void) 298{ 299 if (ptid_equal (inferior_ptid, null_ptid)) 300 noprocess (); 301 else 302 error ("No run-time support for this"); 303} 304 305 306static void 307default_terminal_info (char *args, int from_tty) 308{ 309 printf_unfiltered ("No saved terminal information.\n"); 310} 311 312/* This is the default target_create_inferior and target_attach function. 313 If the current target is executing, it asks whether to kill it off. 314 If this function returns without calling error(), it has killed off 315 the target, and the operation should be attempted. */ 316 317static void 318kill_or_be_killed (int from_tty) 319{ 320 if (target_has_execution) 321 { 322 printf_unfiltered ("You are already running a program:\n"); 323 target_files_info (); 324 if (query ("Kill it? ")) 325 { 326 target_kill (); 327 if (target_has_execution) 328 error ("Killing the program did not help."); 329 return; 330 } 331 else 332 { 333 error ("Program not killed."); 334 } 335 } 336 tcomplain (); 337} 338 339static void 340maybe_kill_then_attach (char *args, int from_tty) 341{ 342 kill_or_be_killed (from_tty); 343 target_attach (args, from_tty); 344} 345 346static void 347maybe_kill_then_create_inferior (char *exec, char *args, char **env, 348 int from_tty) 349{ 350 kill_or_be_killed (0); 351 target_create_inferior (exec, args, env, from_tty); 352} 353 354/* Go through the target stack from top to bottom, copying over zero 355 entries in current_target, then filling in still empty entries. In 356 effect, we are doing class inheritance through the pushed target 357 vectors. 358 359 NOTE: cagney/2003-10-17: The problem with this inheritance, as it 360 is currently implemented, is that it discards any knowledge of 361 which target an inherited method originally belonged to. 362 Consequently, new new target methods should instead explicitly and 363 locally search the target stack for the target that can handle the 364 request. */ 365 366static void 367update_current_target (void) 368{ 369 struct target_ops *t; 370 371 /* First, reset curren'ts contents. */ 372 memset (¤t_target, 0, sizeof (current_target)); 373 374#define INHERIT(FIELD, TARGET) \ 375 if (!current_target.FIELD) \ 376 current_target.FIELD = (TARGET)->FIELD 377 378 for (t = target_stack; t; t = t->beneath) 379 { 380 INHERIT (to_shortname, t); 381 INHERIT (to_longname, t); 382 INHERIT (to_doc, t); 383 INHERIT (to_open, t); 384 INHERIT (to_close, t); 385 INHERIT (to_attach, t); 386 INHERIT (to_post_attach, t); 387 INHERIT (to_detach, t); 388 INHERIT (to_disconnect, t); 389 INHERIT (to_resume, t); 390 INHERIT (to_wait, t); 391 INHERIT (to_fetch_registers, t); 392 INHERIT (to_store_registers, t); 393 INHERIT (to_prepare_to_store, t); 394 INHERIT (deprecated_xfer_memory, t); 395 INHERIT (to_files_info, t); 396 INHERIT (to_insert_breakpoint, t); 397 INHERIT (to_remove_breakpoint, t); 398 INHERIT (to_can_use_hw_breakpoint, t); 399 INHERIT (to_insert_hw_breakpoint, t); 400 INHERIT (to_remove_hw_breakpoint, t); 401 INHERIT (to_insert_watchpoint, t); 402 INHERIT (to_remove_watchpoint, t); 403 INHERIT (to_stopped_data_address, t); 404 INHERIT (to_stopped_by_watchpoint, t); 405 INHERIT (to_have_continuable_watchpoint, t); 406 INHERIT (to_region_size_ok_for_hw_watchpoint, t); 407 INHERIT (to_terminal_init, t); 408 INHERIT (to_terminal_inferior, t); 409 INHERIT (to_terminal_ours_for_output, t); 410 INHERIT (to_terminal_ours, t); 411 INHERIT (to_terminal_save_ours, t); 412 INHERIT (to_terminal_info, t); 413 INHERIT (to_kill, t); 414 INHERIT (to_load, t); 415 INHERIT (to_lookup_symbol, t); 416 INHERIT (to_create_inferior, t); 417 INHERIT (to_post_startup_inferior, t); 418 INHERIT (to_acknowledge_created_inferior, t); 419 INHERIT (to_insert_fork_catchpoint, t); 420 INHERIT (to_remove_fork_catchpoint, t); 421 INHERIT (to_insert_vfork_catchpoint, t); 422 INHERIT (to_remove_vfork_catchpoint, t); 423 INHERIT (to_follow_fork, t); 424 INHERIT (to_insert_exec_catchpoint, t); 425 INHERIT (to_remove_exec_catchpoint, t); 426 INHERIT (to_reported_exec_events_per_exec_call, t); 427 INHERIT (to_has_exited, t); 428 INHERIT (to_mourn_inferior, t); 429 INHERIT (to_can_run, t); 430 INHERIT (to_notice_signals, t); 431 INHERIT (to_thread_alive, t); 432 INHERIT (to_find_new_threads, t); 433 INHERIT (to_pid_to_str, t); 434 INHERIT (to_extra_thread_info, t); 435 INHERIT (to_stop, t); 436 /* Do not inherit to_xfer_partial. */ 437 INHERIT (to_rcmd, t); 438 INHERIT (to_enable_exception_callback, t); 439 INHERIT (to_get_current_exception_event, t); 440 INHERIT (to_pid_to_exec_file, t); 441 INHERIT (to_stratum, t); 442 INHERIT (to_has_all_memory, t); 443 INHERIT (to_has_memory, t); 444 INHERIT (to_has_stack, t); 445 INHERIT (to_has_registers, t); 446 INHERIT (to_has_execution, t); 447 INHERIT (to_has_thread_control, t); 448 INHERIT (to_sections, t); 449 INHERIT (to_sections_end, t); 450 INHERIT (to_can_async_p, t); 451 INHERIT (to_is_async_p, t); 452 INHERIT (to_async, t); 453 INHERIT (to_async_mask_value, t); 454 INHERIT (to_find_memory_regions, t); 455 INHERIT (to_make_corefile_notes, t); 456 INHERIT (to_get_thread_local_address, t); 457 INHERIT (to_magic, t); 458 } 459#undef INHERIT 460 461 /* Clean up a target struct so it no longer has any zero pointers in 462 it. Some entries are defaulted to a method that print an error, 463 others are hard-wired to a standard recursive default. */ 464 465#define de_fault(field, value) \ 466 if (!current_target.field) \ 467 current_target.field = value 468 469 de_fault (to_open, 470 (void (*) (char *, int)) 471 tcomplain); 472 de_fault (to_close, 473 (void (*) (int)) 474 target_ignore); 475 de_fault (to_attach, 476 maybe_kill_then_attach); 477 de_fault (to_post_attach, 478 (void (*) (int)) 479 target_ignore); 480 de_fault (to_detach, 481 (void (*) (char *, int)) 482 target_ignore); 483 de_fault (to_disconnect, 484 (void (*) (char *, int)) 485 tcomplain); 486 de_fault (to_resume, 487 (void (*) (ptid_t, int, enum target_signal)) 488 noprocess); 489 de_fault (to_wait, 490 (ptid_t (*) (ptid_t, struct target_waitstatus *)) 491 noprocess); 492 de_fault (to_fetch_registers, 493 (void (*) (int)) 494 target_ignore); 495 de_fault (to_store_registers, 496 (void (*) (int)) 497 noprocess); 498 de_fault (to_prepare_to_store, 499 (void (*) (void)) 500 noprocess); 501 de_fault (deprecated_xfer_memory, 502 (int (*) (CORE_ADDR, char *, int, int, struct mem_attrib *, struct target_ops *)) 503 nomemory); 504 de_fault (to_files_info, 505 (void (*) (struct target_ops *)) 506 target_ignore); 507 de_fault (to_insert_breakpoint, 508 memory_insert_breakpoint); 509 de_fault (to_remove_breakpoint, 510 memory_remove_breakpoint); 511 de_fault (to_can_use_hw_breakpoint, 512 (int (*) (int, int, int)) 513 return_zero); 514 de_fault (to_insert_hw_breakpoint, 515 (int (*) (CORE_ADDR, char *)) 516 return_minus_one); 517 de_fault (to_remove_hw_breakpoint, 518 (int (*) (CORE_ADDR, char *)) 519 return_minus_one); 520 de_fault (to_insert_watchpoint, 521 (int (*) (CORE_ADDR, int, int)) 522 return_minus_one); 523 de_fault (to_remove_watchpoint, 524 (int (*) (CORE_ADDR, int, int)) 525 return_minus_one); 526 de_fault (to_stopped_by_watchpoint, 527 (int (*) (void)) 528 return_zero); 529 de_fault (to_stopped_data_address, 530 (int (*) (struct target_ops *, CORE_ADDR *)) 531 return_zero); 532 de_fault (to_region_size_ok_for_hw_watchpoint, 533 default_region_size_ok_for_hw_watchpoint); 534 de_fault (to_terminal_init, 535 (void (*) (void)) 536 target_ignore); 537 de_fault (to_terminal_inferior, 538 (void (*) (void)) 539 target_ignore); 540 de_fault (to_terminal_ours_for_output, 541 (void (*) (void)) 542 target_ignore); 543 de_fault (to_terminal_ours, 544 (void (*) (void)) 545 target_ignore); 546 de_fault (to_terminal_save_ours, 547 (void (*) (void)) 548 target_ignore); 549 de_fault (to_terminal_info, 550 default_terminal_info); 551 de_fault (to_kill, 552 (void (*) (void)) 553 noprocess); 554 de_fault (to_load, 555 (void (*) (char *, int)) 556 tcomplain); 557 de_fault (to_lookup_symbol, 558 (int (*) (char *, CORE_ADDR *)) 559 nosymbol); 560 de_fault (to_create_inferior, 561 maybe_kill_then_create_inferior); 562 de_fault (to_post_startup_inferior, 563 (void (*) (ptid_t)) 564 target_ignore); 565 de_fault (to_acknowledge_created_inferior, 566 (void (*) (int)) 567 target_ignore); 568 de_fault (to_insert_fork_catchpoint, 569 (int (*) (int)) 570 tcomplain); 571 de_fault (to_remove_fork_catchpoint, 572 (int (*) (int)) 573 tcomplain); 574 de_fault (to_insert_vfork_catchpoint, 575 (int (*) (int)) 576 tcomplain); 577 de_fault (to_remove_vfork_catchpoint, 578 (int (*) (int)) 579 tcomplain); 580 de_fault (to_follow_fork, 581 (int (*) (int)) 582 target_ignore); 583 de_fault (to_insert_exec_catchpoint, 584 (int (*) (int)) 585 tcomplain); 586 de_fault (to_remove_exec_catchpoint, 587 (int (*) (int)) 588 tcomplain); 589 de_fault (to_reported_exec_events_per_exec_call, 590 (int (*) (void)) 591 return_one); 592 de_fault (to_has_exited, 593 (int (*) (int, int, int *)) 594 return_zero); 595 de_fault (to_mourn_inferior, 596 (void (*) (void)) 597 noprocess); 598 de_fault (to_can_run, 599 return_zero); 600 de_fault (to_notice_signals, 601 (void (*) (ptid_t)) 602 target_ignore); 603 de_fault (to_thread_alive, 604 (int (*) (ptid_t)) 605 return_zero); 606 de_fault (to_find_new_threads, 607 (void (*) (void)) 608 target_ignore); 609 de_fault (to_extra_thread_info, 610 (char *(*) (struct thread_info *)) 611 return_zero); 612 de_fault (to_stop, 613 (void (*) (void)) 614 target_ignore); 615 current_target.to_xfer_partial = default_xfer_partial; 616 de_fault (to_rcmd, 617 (void (*) (char *, struct ui_file *)) 618 tcomplain); 619 de_fault (to_enable_exception_callback, 620 (struct symtab_and_line * (*) (enum exception_event_kind, int)) 621 nosupport_runtime); 622 de_fault (to_get_current_exception_event, 623 (struct exception_event_record * (*) (void)) 624 nosupport_runtime); 625 de_fault (to_pid_to_exec_file, 626 (char *(*) (int)) 627 return_zero); 628 de_fault (to_can_async_p, 629 (int (*) (void)) 630 return_zero); 631 de_fault (to_is_async_p, 632 (int (*) (void)) 633 return_zero); 634 de_fault (to_async, 635 (void (*) (void (*) (enum inferior_event_type, void*), void*)) 636 tcomplain); 637#undef de_fault 638 639 /* Finally, position the target-stack beneath the squashed 640 "current_target". That way code looking for a non-inherited 641 target method can quickly and simply find it. */ 642 current_target.beneath = target_stack; 643} 644 645/* Push a new target type into the stack of the existing target accessors, 646 possibly superseding some of the existing accessors. 647 648 Result is zero if the pushed target ended up on top of the stack, 649 nonzero if at least one target is on top of it. 650 651 Rather than allow an empty stack, we always have the dummy target at 652 the bottom stratum, so we can call the function vectors without 653 checking them. */ 654 655int 656push_target (struct target_ops *t) 657{ 658 struct target_ops **cur; 659 660 /* Check magic number. If wrong, it probably means someone changed 661 the struct definition, but not all the places that initialize one. */ 662 if (t->to_magic != OPS_MAGIC) 663 { 664 fprintf_unfiltered (gdb_stderr, 665 "Magic number of %s target struct wrong\n", 666 t->to_shortname); 667 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 668 } 669 670 /* Find the proper stratum to install this target in. */ 671 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath) 672 { 673 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum) 674 break; 675 } 676 677 /* If there's already targets at this stratum, remove them. */ 678 /* FIXME: cagney/2003-10-15: I think this should be poping all 679 targets to CUR, and not just those at this stratum level. */ 680 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum) 681 { 682 /* There's already something at this stratum level. Close it, 683 and un-hook it from the stack. */ 684 struct target_ops *tmp = (*cur); 685 (*cur) = (*cur)->beneath; 686 tmp->beneath = NULL; 687 target_close (tmp, 0); 688 } 689 690 /* We have removed all targets in our stratum, now add the new one. */ 691 t->beneath = (*cur); 692 (*cur) = t; 693 694 update_current_target (); 695 696 if (targetdebug) 697 setup_target_debug (); 698 699 /* Not on top? */ 700 return (t != target_stack); 701} 702 703/* Remove a target_ops vector from the stack, wherever it may be. 704 Return how many times it was removed (0 or 1). */ 705 706int 707unpush_target (struct target_ops *t) 708{ 709 struct target_ops **cur; 710 struct target_ops *tmp; 711 712 /* Look for the specified target. Note that we assume that a target 713 can only occur once in the target stack. */ 714 715 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath) 716 { 717 if ((*cur) == t) 718 break; 719 } 720 721 if ((*cur) == NULL) 722 return 0; /* Didn't find target_ops, quit now */ 723 724 /* NOTE: cagney/2003-12-06: In '94 the close call was made 725 unconditional by moving it to before the above check that the 726 target was in the target stack (something about "Change the way 727 pushing and popping of targets work to support target overlays 728 and inheritance"). This doesn't make much sense - only open 729 targets should be closed. */ 730 target_close (t, 0); 731 732 /* Unchain the target */ 733 tmp = (*cur); 734 (*cur) = (*cur)->beneath; 735 tmp->beneath = NULL; 736 737 update_current_target (); 738 739 return 1; 740} 741 742void 743pop_target (void) 744{ 745 target_close (¤t_target, 0); /* Let it clean up */ 746 if (unpush_target (target_stack) == 1) 747 return; 748 749 fprintf_unfiltered (gdb_stderr, 750 "pop_target couldn't find target %s\n", 751 current_target.to_shortname); 752 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 753} 754 755#undef MIN 756#define MIN(A, B) (((A) <= (B)) ? (A) : (B)) 757 758/* target_read_string -- read a null terminated string, up to LEN bytes, 759 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful. 760 Set *STRING to a pointer to malloc'd memory containing the data; the caller 761 is responsible for freeing it. Return the number of bytes successfully 762 read. */ 763 764int 765target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop) 766{ 767 int tlen, origlen, offset, i; 768 char buf[4]; 769 int errcode = 0; 770 char *buffer; 771 int buffer_allocated; 772 char *bufptr; 773 unsigned int nbytes_read = 0; 774 775 /* Small for testing. */ 776 buffer_allocated = 4; 777 buffer = xmalloc (buffer_allocated); 778 bufptr = buffer; 779 780 origlen = len; 781 782 while (len > 0) 783 { 784 tlen = MIN (len, 4 - (memaddr & 3)); 785 offset = memaddr & 3; 786 787 errcode = target_read_memory (memaddr & ~3, buf, 4); 788 if (errcode != 0) 789 { 790 /* The transfer request might have crossed the boundary to an 791 unallocated region of memory. Retry the transfer, requesting 792 a single byte. */ 793 tlen = 1; 794 offset = 0; 795 errcode = target_read_memory (memaddr, buf, 1); 796 if (errcode != 0) 797 goto done; 798 } 799 800 if (bufptr - buffer + tlen > buffer_allocated) 801 { 802 unsigned int bytes; 803 bytes = bufptr - buffer; 804 buffer_allocated *= 2; 805 buffer = xrealloc (buffer, buffer_allocated); 806 bufptr = buffer + bytes; 807 } 808 809 for (i = 0; i < tlen; i++) 810 { 811 *bufptr++ = buf[i + offset]; 812 if (buf[i + offset] == '\000') 813 { 814 nbytes_read += i + 1; 815 goto done; 816 } 817 } 818 819 memaddr += tlen; 820 len -= tlen; 821 nbytes_read += tlen; 822 } 823done: 824 if (errnop != NULL) 825 *errnop = errcode; 826 if (string != NULL) 827 *string = buffer; 828 return nbytes_read; 829} 830 831/* Find a section containing ADDR. */ 832struct section_table * 833target_section_by_addr (struct target_ops *target, CORE_ADDR addr) 834{ 835 struct section_table *secp; 836 for (secp = target->to_sections; 837 secp < target->to_sections_end; 838 secp++) 839 { 840 if (addr >= secp->addr && addr < secp->endaddr) 841 return secp; 842 } 843 return NULL; 844} 845 846/* Return non-zero when the target vector has supplied an xfer_partial 847 method and it, rather than xfer_memory, should be used. */ 848static int 849target_xfer_partial_p (void) 850{ 851 return (target_stack != NULL 852 && target_stack->to_xfer_partial != default_xfer_partial); 853} 854 855static LONGEST 856target_xfer_partial (struct target_ops *ops, 857 enum target_object object, const char *annex, 858 void *readbuf, const void *writebuf, 859 ULONGEST offset, LONGEST len) 860{ 861 LONGEST retval; 862 863 gdb_assert (ops->to_xfer_partial != NULL); 864 retval = ops->to_xfer_partial (ops, object, annex, readbuf, writebuf, 865 offset, len); 866 if (targetdebug) 867 { 868 const unsigned char *myaddr = NULL; 869 870 fprintf_unfiltered (gdb_stdlog, 871 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s", 872 ops->to_shortname, 873 (int) object, 874 (annex ? annex : "(null)"), 875 (long) readbuf, (long) writebuf, 876 paddr_nz (offset), paddr_d (len), paddr_d (retval)); 877 878 if (readbuf) 879 myaddr = readbuf; 880 if (writebuf) 881 myaddr = writebuf; 882 if (retval > 0 && myaddr != NULL) 883 { 884 int i; 885 886 fputs_unfiltered (", bytes =", gdb_stdlog); 887 for (i = 0; i < retval; i++) 888 { 889 if ((((long) &(myaddr[i])) & 0xf) == 0) 890 { 891 if (targetdebug < 2 && i > 0) 892 { 893 fprintf_unfiltered (gdb_stdlog, " ..."); 894 break; 895 } 896 fprintf_unfiltered (gdb_stdlog, "\n"); 897 } 898 899 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff); 900 } 901 } 902 903 fputc_unfiltered ('\n', gdb_stdlog); 904 } 905 return retval; 906} 907 908/* Attempt a transfer all LEN bytes starting at OFFSET between the 909 inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer. If 910 the transfer succeeds, return zero, otherwize the host ERRNO is 911 returned. 912 913 The inferior is formed from several layers. In the case of 914 corefiles, inf-corefile is layered above inf-exec and a request for 915 text (corefiles do not include text pages) will be first sent to 916 the core-stratum, fail, and then sent to the object-file where it 917 will succeed. 918 919 NOTE: cagney/2004-09-30: 920 921 The old code tried to use four separate mechanisms for mapping an 922 object:offset:len tuple onto an inferior and its address space: the 923 target stack; the inferior's TO_SECTIONS; solib's SO_LIST; 924 overlays. 925 926 This is stupid. 927 928 The code below is instead using a single mechanism (currently 929 strata). If that mechanism proves insufficient then re-factor it 930 implementing another singluar mechanism (for instance, a generic 931 object:annex onto inferior:object:annex say). */ 932 933static LONGEST 934xfer_using_stratum (enum target_object object, const char *annex, 935 ULONGEST offset, LONGEST len, void *readbuf, 936 const void *writebuf) 937{ 938 LONGEST xfered; 939 struct target_ops *target; 940 941 /* Always successful. */ 942 if (len == 0) 943 return 0; 944 /* Never successful. */ 945 if (target_stack == NULL) 946 return EIO; 947 948 target = target_stack; 949 while (1) 950 { 951 xfered = target_xfer_partial (target, object, annex, 952 readbuf, writebuf, offset, len); 953 if (xfered > 0) 954 { 955 /* The partial xfer succeeded, update the counts, check that 956 the xfer hasn't finished and if it hasn't set things up 957 for the next round. */ 958 len -= xfered; 959 if (len <= 0) 960 return 0; 961 offset += xfered; 962 if (readbuf != NULL) 963 readbuf = (bfd_byte *) readbuf + xfered; 964 if (writebuf != NULL) 965 writebuf = (bfd_byte *) writebuf + xfered; 966 target = target_stack; 967 } 968 else if (xfered < 0) 969 { 970 /* Something totally screwed up, abandon the attempt to 971 xfer. */ 972 if (errno) 973 return errno; 974 else 975 return EIO; 976 } 977 else 978 { 979 /* This "stratum" didn't work, try the next one down. */ 980 target = target->beneath; 981 if (target == NULL) 982 return EIO; 983 } 984 } 985} 986 987/* Read LEN bytes of target memory at address MEMADDR, placing the results in 988 GDB's memory at MYADDR. Returns either 0 for success or an errno value 989 if any error occurs. 990 991 If an error occurs, no guarantee is made about the contents of the data at 992 MYADDR. In particular, the caller should not depend upon partial reads 993 filling the buffer with good data. There is no way for the caller to know 994 how much good data might have been transfered anyway. Callers that can 995 deal with partial reads should call target_read_memory_partial. */ 996 997int 998target_read_memory (CORE_ADDR memaddr, char *myaddr, int len) 999{ 1000 if (target_xfer_partial_p ()) 1001 return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL, 1002 memaddr, len, myaddr, NULL); 1003 else 1004 return target_xfer_memory (memaddr, myaddr, len, 0); 1005} 1006 1007int 1008target_write_memory (CORE_ADDR memaddr, char *myaddr, int len) 1009{ 1010 if (target_xfer_partial_p ()) 1011 return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL, 1012 memaddr, len, NULL, myaddr); 1013 else 1014 return target_xfer_memory (memaddr, myaddr, len, 1); 1015} 1016 1017#ifndef target_stopped_data_address_p 1018int 1019target_stopped_data_address_p (struct target_ops *target) 1020{ 1021 if (target->to_stopped_data_address 1022 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero) 1023 return 0; 1024 if (target->to_stopped_data_address == debug_to_stopped_data_address 1025 && (debug_target.to_stopped_data_address 1026 == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)) 1027 return 0; 1028 return 1; 1029} 1030#endif 1031 1032static int trust_readonly = 0; 1033 1034/* Move memory to or from the targets. The top target gets priority; 1035 if it cannot handle it, it is offered to the next one down, etc. 1036 1037 Result is -1 on error, or the number of bytes transfered. */ 1038 1039int 1040do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, 1041 struct mem_attrib *attrib) 1042{ 1043 int res; 1044 int done = 0; 1045 struct target_ops *t; 1046 1047 /* Zero length requests are ok and require no work. */ 1048 if (len == 0) 1049 return 0; 1050 1051 /* deprecated_xfer_memory is not guaranteed to set errno, even when 1052 it returns 0. */ 1053 errno = 0; 1054 1055 if (!write && trust_readonly) 1056 { 1057 struct section_table *secp; 1058 /* User-settable option, "trust-readonly-sections". If true, 1059 then memory from any SEC_READONLY bfd section may be read 1060 directly from the bfd file. */ 1061 secp = target_section_by_addr (¤t_target, memaddr); 1062 if (secp != NULL 1063 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section) 1064 & SEC_READONLY)) 1065 return xfer_memory (memaddr, myaddr, len, 0, attrib, ¤t_target); 1066 } 1067 1068 /* The quick case is that the top target can handle the transfer. */ 1069 res = current_target.deprecated_xfer_memory 1070 (memaddr, myaddr, len, write, attrib, ¤t_target); 1071 1072 /* If res <= 0 then we call it again in the loop. Ah well. */ 1073 if (res <= 0) 1074 { 1075 for (t = target_stack; t != NULL; t = t->beneath) 1076 { 1077 if (!t->to_has_memory) 1078 continue; 1079 1080 res = t->deprecated_xfer_memory (memaddr, myaddr, len, write, attrib, t); 1081 if (res > 0) 1082 break; /* Handled all or part of xfer */ 1083 if (t->to_has_all_memory) 1084 break; 1085 } 1086 1087 if (res <= 0) 1088 return -1; 1089 } 1090 1091 return res; 1092} 1093 1094 1095/* Perform a memory transfer. Iterate until the entire region has 1096 been transfered. 1097 1098 Result is 0 or errno value. */ 1099 1100static int 1101target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write) 1102{ 1103 int res; 1104 int reg_len; 1105 struct mem_region *region; 1106 1107 /* Zero length requests are ok and require no work. */ 1108 if (len == 0) 1109 { 1110 return 0; 1111 } 1112 1113 while (len > 0) 1114 { 1115 region = lookup_mem_region(memaddr); 1116 if (memaddr + len < region->hi) 1117 reg_len = len; 1118 else 1119 reg_len = region->hi - memaddr; 1120 1121 switch (region->attrib.mode) 1122 { 1123 case MEM_RO: 1124 if (write) 1125 return EIO; 1126 break; 1127 1128 case MEM_WO: 1129 if (!write) 1130 return EIO; 1131 break; 1132 } 1133 1134 while (reg_len > 0) 1135 { 1136 if (region->attrib.cache) 1137 res = dcache_xfer_memory (target_dcache, memaddr, myaddr, 1138 reg_len, write); 1139 else 1140 res = do_xfer_memory (memaddr, myaddr, reg_len, write, 1141 ®ion->attrib); 1142 1143 if (res <= 0) 1144 { 1145 /* If this address is for nonexistent memory, read zeros 1146 if reading, or do nothing if writing. Return 1147 error. */ 1148 if (!write) 1149 memset (myaddr, 0, len); 1150 if (errno == 0) 1151 return EIO; 1152 else 1153 return errno; 1154 } 1155 1156 memaddr += res; 1157 myaddr += res; 1158 len -= res; 1159 reg_len -= res; 1160 } 1161 } 1162 1163 return 0; /* We managed to cover it all somehow. */ 1164} 1165 1166 1167/* Perform a partial memory transfer. 1168 1169 Result is -1 on error, or the number of bytes transfered. */ 1170 1171static int 1172target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len, 1173 int write_p, int *err) 1174{ 1175 int res; 1176 int reg_len; 1177 struct mem_region *region; 1178 1179 /* Zero length requests are ok and require no work. */ 1180 if (len == 0) 1181 { 1182 *err = 0; 1183 return 0; 1184 } 1185 1186 region = lookup_mem_region(memaddr); 1187 if (memaddr + len < region->hi) 1188 reg_len = len; 1189 else 1190 reg_len = region->hi - memaddr; 1191 1192 switch (region->attrib.mode) 1193 { 1194 case MEM_RO: 1195 if (write_p) 1196 { 1197 *err = EIO; 1198 return -1; 1199 } 1200 break; 1201 1202 case MEM_WO: 1203 if (write_p) 1204 { 1205 *err = EIO; 1206 return -1; 1207 } 1208 break; 1209 } 1210 1211 if (region->attrib.cache) 1212 res = dcache_xfer_memory (target_dcache, memaddr, myaddr, 1213 reg_len, write_p); 1214 else 1215 res = do_xfer_memory (memaddr, myaddr, reg_len, write_p, 1216 ®ion->attrib); 1217 1218 if (res <= 0) 1219 { 1220 if (errno != 0) 1221 *err = errno; 1222 else 1223 *err = EIO; 1224 1225 return -1; 1226 } 1227 1228 *err = 0; 1229 return res; 1230} 1231 1232int 1233target_read_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err) 1234{ 1235 if (target_xfer_partial_p ()) 1236 return target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY, NULL, 1237 buf, NULL, memaddr, len); 1238 else 1239 return target_xfer_memory_partial (memaddr, buf, len, 0, err); 1240} 1241 1242int 1243target_write_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err) 1244{ 1245 if (target_xfer_partial_p ()) 1246 return target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY, NULL, 1247 NULL, buf, memaddr, len); 1248 else 1249 return target_xfer_memory_partial (memaddr, buf, len, 1, err); 1250} 1251 1252/* More generic transfers. */ 1253 1254static LONGEST 1255default_xfer_partial (struct target_ops *ops, enum target_object object, 1256 const char *annex, void *readbuf, 1257 const void *writebuf, ULONGEST offset, LONGEST len) 1258{ 1259 if (object == TARGET_OBJECT_MEMORY 1260 && ops->deprecated_xfer_memory != NULL) 1261 /* If available, fall back to the target's 1262 "deprecated_xfer_memory" method. */ 1263 { 1264 int xfered = -1; 1265 errno = 0; 1266 if (writebuf != NULL) 1267 { 1268 void *buffer = xmalloc (len); 1269 struct cleanup *cleanup = make_cleanup (xfree, buffer); 1270 memcpy (buffer, writebuf, len); 1271 xfered = ops->deprecated_xfer_memory (offset, buffer, len, 1272 1/*write*/, NULL, ops); 1273 do_cleanups (cleanup); 1274 } 1275 if (readbuf != NULL) 1276 xfered = ops->deprecated_xfer_memory (offset, readbuf, len, 0/*read*/, 1277 NULL, ops); 1278 if (xfered > 0) 1279 return xfered; 1280 else if (xfered == 0 && errno == 0) 1281 /* "deprecated_xfer_memory" uses 0, cross checked against 1282 ERRNO as one indication of an error. */ 1283 return 0; 1284 else 1285 return -1; 1286 } 1287 else if (ops->beneath != NULL) 1288 return target_xfer_partial (ops->beneath, object, annex, 1289 readbuf, writebuf, offset, len); 1290 else 1291 return -1; 1292} 1293 1294/* Target vector read/write partial wrapper functions. 1295 1296 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial 1297 (inbuf, outbuf)", instead of separate read/write methods, make life 1298 easier. */ 1299 1300LONGEST 1301target_read_partial (struct target_ops *ops, 1302 enum target_object object, 1303 const char *annex, void *buf, 1304 ULONGEST offset, LONGEST len) 1305{ 1306 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len); 1307} 1308 1309LONGEST 1310target_write_partial (struct target_ops *ops, 1311 enum target_object object, 1312 const char *annex, const void *buf, 1313 ULONGEST offset, LONGEST len) 1314{ 1315 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len); 1316} 1317 1318/* Wrappers to perform the full transfer. */ 1319LONGEST 1320target_read (struct target_ops *ops, 1321 enum target_object object, 1322 const char *annex, void *buf, 1323 ULONGEST offset, LONGEST len) 1324{ 1325 LONGEST xfered = 0; 1326 while (xfered < len) 1327 { 1328 LONGEST xfer = target_read_partial (ops, object, annex, 1329 (bfd_byte *) buf + xfered, 1330 offset + xfered, len - xfered); 1331 /* Call an observer, notifying them of the xfer progress? */ 1332 if (xfer <= 0) 1333 /* Call memory_error? */ 1334 return -1; 1335 xfered += xfer; 1336 QUIT; 1337 } 1338 return len; 1339} 1340 1341LONGEST 1342target_write (struct target_ops *ops, 1343 enum target_object object, 1344 const char *annex, const void *buf, 1345 ULONGEST offset, LONGEST len) 1346{ 1347 LONGEST xfered = 0; 1348 while (xfered < len) 1349 { 1350 LONGEST xfer = target_write_partial (ops, object, annex, 1351 (bfd_byte *) buf + xfered, 1352 offset + xfered, len - xfered); 1353 /* Call an observer, notifying them of the xfer progress? */ 1354 if (xfer <= 0) 1355 /* Call memory_error? */ 1356 return -1; 1357 xfered += xfer; 1358 QUIT; 1359 } 1360 return len; 1361} 1362 1363/* Memory transfer methods. */ 1364 1365void 1366get_target_memory (struct target_ops *ops, CORE_ADDR addr, void *buf, 1367 LONGEST len) 1368{ 1369 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len) 1370 != len) 1371 memory_error (EIO, addr); 1372} 1373 1374ULONGEST 1375get_target_memory_unsigned (struct target_ops *ops, 1376 CORE_ADDR addr, int len) 1377{ 1378 char buf[sizeof (ULONGEST)]; 1379 1380 gdb_assert (len <= sizeof (buf)); 1381 get_target_memory (ops, addr, buf, len); 1382 return extract_unsigned_integer (buf, len); 1383} 1384 1385static void 1386target_info (char *args, int from_tty) 1387{ 1388 struct target_ops *t; 1389 int has_all_mem = 0; 1390 1391 if (symfile_objfile != NULL) 1392 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name); 1393 1394 for (t = target_stack; t != NULL; t = t->beneath) 1395 { 1396 if (!t->to_has_memory) 1397 continue; 1398 1399 if ((int) (t->to_stratum) <= (int) dummy_stratum) 1400 continue; 1401 if (has_all_mem) 1402 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n"); 1403 printf_unfiltered ("%s:\n", t->to_longname); 1404 (t->to_files_info) (t); 1405 has_all_mem = t->to_has_all_memory; 1406 } 1407} 1408 1409/* This is to be called by the open routine before it does 1410 anything. */ 1411 1412void 1413target_preopen (int from_tty) 1414{ 1415 dont_repeat (); 1416 1417 if (target_has_execution) 1418 { 1419 if (!from_tty 1420 || query ("A program is being debugged already. Kill it? ")) 1421 target_kill (); 1422 else 1423 error ("Program not killed."); 1424 } 1425 1426 /* Calling target_kill may remove the target from the stack. But if 1427 it doesn't (which seems like a win for UDI), remove it now. */ 1428 1429 if (target_has_execution) 1430 pop_target (); 1431} 1432 1433/* Detach a target after doing deferred register stores. */ 1434 1435void 1436target_detach (char *args, int from_tty) 1437{ 1438 (current_target.to_detach) (args, from_tty); 1439} 1440 1441void 1442target_disconnect (char *args, int from_tty) 1443{ 1444 (current_target.to_disconnect) (args, from_tty); 1445} 1446 1447void 1448target_link (char *modname, CORE_ADDR *t_reloc) 1449{ 1450 if (DEPRECATED_STREQ (current_target.to_shortname, "rombug")) 1451 { 1452 (current_target.to_lookup_symbol) (modname, t_reloc); 1453 if (*t_reloc == 0) 1454 error ("Unable to link to %s and get relocation in rombug", modname); 1455 } 1456 else 1457 *t_reloc = (CORE_ADDR) -1; 1458} 1459 1460int 1461target_async_mask (int mask) 1462{ 1463 int saved_async_masked_status = target_async_mask_value; 1464 target_async_mask_value = mask; 1465 return saved_async_masked_status; 1466} 1467 1468/* Look through the list of possible targets for a target that can 1469 execute a run or attach command without any other data. This is 1470 used to locate the default process stratum. 1471 1472 Result is always valid (error() is called for errors). */ 1473 1474static struct target_ops * 1475find_default_run_target (char *do_mesg) 1476{ 1477 struct target_ops **t; 1478 struct target_ops *runable = NULL; 1479 int count; 1480 1481 count = 0; 1482 1483 for (t = target_structs; t < target_structs + target_struct_size; 1484 ++t) 1485 { 1486 if ((*t)->to_can_run && target_can_run (*t)) 1487 { 1488 runable = *t; 1489 ++count; 1490 } 1491 } 1492 1493 if (count != 1) 1494 error ("Don't know how to %s. Try \"help target\".", do_mesg); 1495 1496 return runable; 1497} 1498 1499void 1500find_default_attach (char *args, int from_tty) 1501{ 1502 struct target_ops *t; 1503 1504 t = find_default_run_target ("attach"); 1505 (t->to_attach) (args, from_tty); 1506 return; 1507} 1508 1509void 1510find_default_create_inferior (char *exec_file, char *allargs, char **env, 1511 int from_tty) 1512{ 1513 struct target_ops *t; 1514 1515 t = find_default_run_target ("run"); 1516 (t->to_create_inferior) (exec_file, allargs, env, from_tty); 1517 return; 1518} 1519 1520static int 1521default_region_size_ok_for_hw_watchpoint (int byte_count) 1522{ 1523 return (byte_count <= TYPE_LENGTH (builtin_type_void_data_ptr)); 1524} 1525 1526static int 1527return_zero (void) 1528{ 1529 return 0; 1530} 1531 1532static int 1533return_one (void) 1534{ 1535 return 1; 1536} 1537 1538static int 1539return_minus_one (void) 1540{ 1541 return -1; 1542} 1543 1544/* 1545 * Resize the to_sections pointer. Also make sure that anyone that 1546 * was holding on to an old value of it gets updated. 1547 * Returns the old size. 1548 */ 1549 1550int 1551target_resize_to_sections (struct target_ops *target, int num_added) 1552{ 1553 struct target_ops **t; 1554 struct section_table *old_value; 1555 int old_count; 1556 1557 old_value = target->to_sections; 1558 1559 if (target->to_sections) 1560 { 1561 old_count = target->to_sections_end - target->to_sections; 1562 target->to_sections = (struct section_table *) 1563 xrealloc ((char *) target->to_sections, 1564 (sizeof (struct section_table)) * (num_added + old_count)); 1565 } 1566 else 1567 { 1568 old_count = 0; 1569 target->to_sections = (struct section_table *) 1570 xmalloc ((sizeof (struct section_table)) * num_added); 1571 } 1572 target->to_sections_end = target->to_sections + (num_added + old_count); 1573 1574 /* Check to see if anyone else was pointing to this structure. 1575 If old_value was null, then no one was. */ 1576 1577 if (old_value) 1578 { 1579 for (t = target_structs; t < target_structs + target_struct_size; 1580 ++t) 1581 { 1582 if ((*t)->to_sections == old_value) 1583 { 1584 (*t)->to_sections = target->to_sections; 1585 (*t)->to_sections_end = target->to_sections_end; 1586 } 1587 } 1588 /* There is a flattened view of the target stack in current_target, 1589 so its to_sections pointer might also need updating. */ 1590 if (current_target.to_sections == old_value) 1591 { 1592 current_target.to_sections = target->to_sections; 1593 current_target.to_sections_end = target->to_sections_end; 1594 } 1595 } 1596 1597 return old_count; 1598 1599} 1600 1601/* Remove all target sections taken from ABFD. 1602 1603 Scan the current target stack for targets whose section tables 1604 refer to sections from BFD, and remove those sections. We use this 1605 when we notice that the inferior has unloaded a shared object, for 1606 example. */ 1607void 1608remove_target_sections (bfd *abfd) 1609{ 1610 struct target_ops **t; 1611 1612 for (t = target_structs; t < target_structs + target_struct_size; t++) 1613 { 1614 struct section_table *src, *dest; 1615 1616 dest = (*t)->to_sections; 1617 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++) 1618 if (src->bfd != abfd) 1619 { 1620 /* Keep this section. */ 1621 if (dest < src) *dest = *src; 1622 dest++; 1623 } 1624 1625 /* If we've dropped any sections, resize the section table. */ 1626 if (dest < src) 1627 target_resize_to_sections (*t, dest - src); 1628 } 1629} 1630 1631 1632 1633 1634/* Find a single runnable target in the stack and return it. If for 1635 some reason there is more than one, return NULL. */ 1636 1637struct target_ops * 1638find_run_target (void) 1639{ 1640 struct target_ops **t; 1641 struct target_ops *runable = NULL; 1642 int count; 1643 1644 count = 0; 1645 1646 for (t = target_structs; t < target_structs + target_struct_size; ++t) 1647 { 1648 if ((*t)->to_can_run && target_can_run (*t)) 1649 { 1650 runable = *t; 1651 ++count; 1652 } 1653 } 1654 1655 return (count == 1 ? runable : NULL); 1656} 1657 1658/* Find a single core_stratum target in the list of targets and return it. 1659 If for some reason there is more than one, return NULL. */ 1660 1661struct target_ops * 1662find_core_target (void) 1663{ 1664 struct target_ops **t; 1665 struct target_ops *runable = NULL; 1666 int count; 1667 1668 count = 0; 1669 1670 for (t = target_structs; t < target_structs + target_struct_size; 1671 ++t) 1672 { 1673 if ((*t)->to_stratum == core_stratum) 1674 { 1675 runable = *t; 1676 ++count; 1677 } 1678 } 1679 1680 return (count == 1 ? runable : NULL); 1681} 1682 1683/* 1684 * Find the next target down the stack from the specified target. 1685 */ 1686 1687struct target_ops * 1688find_target_beneath (struct target_ops *t) 1689{ 1690 return t->beneath; 1691} 1692 1693 1694/* The inferior process has died. Long live the inferior! */ 1695 1696void 1697generic_mourn_inferior (void) 1698{ 1699 extern int show_breakpoint_hit_counts; 1700 1701 inferior_ptid = null_ptid; 1702 attach_flag = 0; 1703 breakpoint_init_inferior (inf_exited); 1704 registers_changed (); 1705 1706 reopen_exec_file (); 1707 reinit_frame_cache (); 1708 1709 /* It is confusing to the user for ignore counts to stick around 1710 from previous runs of the inferior. So clear them. */ 1711 /* However, it is more confusing for the ignore counts to disappear when 1712 using hit counts. So don't clear them if we're counting hits. */ 1713 if (!show_breakpoint_hit_counts) 1714 breakpoint_clear_ignore_counts (); 1715 1716 if (deprecated_detach_hook) 1717 deprecated_detach_hook (); 1718} 1719 1720/* Helper function for child_wait and the Lynx derivatives of child_wait. 1721 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our 1722 translation of that in OURSTATUS. */ 1723void 1724store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus) 1725{ 1726#ifdef CHILD_SPECIAL_WAITSTATUS 1727 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS 1728 if it wants to deal with hoststatus. */ 1729 if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus)) 1730 return; 1731#endif 1732 1733 if (WIFEXITED (hoststatus)) 1734 { 1735 ourstatus->kind = TARGET_WAITKIND_EXITED; 1736 ourstatus->value.integer = WEXITSTATUS (hoststatus); 1737 } 1738 else if (!WIFSTOPPED (hoststatus)) 1739 { 1740 ourstatus->kind = TARGET_WAITKIND_SIGNALLED; 1741 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus)); 1742 } 1743 else 1744 { 1745 ourstatus->kind = TARGET_WAITKIND_STOPPED; 1746 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus)); 1747 } 1748} 1749 1750/* Returns zero to leave the inferior alone, one to interrupt it. */ 1751int (*target_activity_function) (void); 1752int target_activity_fd; 1753 1754/* Convert a normal process ID to a string. Returns the string in a static 1755 buffer. */ 1756 1757char * 1758normal_pid_to_str (ptid_t ptid) 1759{ 1760 static char buf[30]; 1761 1762 sprintf (buf, "process %d", PIDGET (ptid)); 1763 return buf; 1764} 1765 1766/* Error-catcher for target_find_memory_regions */ 1767static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2) 1768{ 1769 error ("No target."); 1770 return 0; 1771} 1772 1773/* Error-catcher for target_make_corefile_notes */ 1774static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2) 1775{ 1776 error ("No target."); 1777 return NULL; 1778} 1779 1780/* Set up the handful of non-empty slots needed by the dummy target 1781 vector. */ 1782 1783static void 1784init_dummy_target (void) 1785{ 1786 dummy_target.to_shortname = "None"; 1787 dummy_target.to_longname = "None"; 1788 dummy_target.to_doc = ""; 1789 dummy_target.to_attach = find_default_attach; 1790 dummy_target.to_create_inferior = find_default_create_inferior; 1791 dummy_target.to_pid_to_str = normal_pid_to_str; 1792 dummy_target.to_stratum = dummy_stratum; 1793 dummy_target.to_find_memory_regions = dummy_find_memory_regions; 1794 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes; 1795 dummy_target.to_xfer_partial = default_xfer_partial; 1796 dummy_target.to_magic = OPS_MAGIC; 1797} 1798 1799static void 1800debug_to_open (char *args, int from_tty) 1801{ 1802 debug_target.to_open (args, from_tty); 1803 1804 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty); 1805} 1806 1807static void 1808debug_to_close (int quitting) 1809{ 1810 target_close (&debug_target, quitting); 1811 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting); 1812} 1813 1814void 1815target_close (struct target_ops *targ, int quitting) 1816{ 1817 if (targ->to_xclose != NULL) 1818 targ->to_xclose (targ, quitting); 1819 else if (targ->to_close != NULL) 1820 targ->to_close (quitting); 1821} 1822 1823static void 1824debug_to_attach (char *args, int from_tty) 1825{ 1826 debug_target.to_attach (args, from_tty); 1827 1828 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty); 1829} 1830 1831 1832static void 1833debug_to_post_attach (int pid) 1834{ 1835 debug_target.to_post_attach (pid); 1836 1837 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid); 1838} 1839 1840static void 1841debug_to_detach (char *args, int from_tty) 1842{ 1843 debug_target.to_detach (args, from_tty); 1844 1845 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty); 1846} 1847 1848static void 1849debug_to_disconnect (char *args, int from_tty) 1850{ 1851 debug_target.to_disconnect (args, from_tty); 1852 1853 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n", 1854 args, from_tty); 1855} 1856 1857static void 1858debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal) 1859{ 1860 debug_target.to_resume (ptid, step, siggnal); 1861 1862 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid), 1863 step ? "step" : "continue", 1864 target_signal_to_name (siggnal)); 1865} 1866 1867static ptid_t 1868debug_to_wait (ptid_t ptid, struct target_waitstatus *status) 1869{ 1870 ptid_t retval; 1871 1872 retval = debug_target.to_wait (ptid, status); 1873 1874 fprintf_unfiltered (gdb_stdlog, 1875 "target_wait (%d, status) = %d, ", PIDGET (ptid), 1876 PIDGET (retval)); 1877 fprintf_unfiltered (gdb_stdlog, "status->kind = "); 1878 switch (status->kind) 1879 { 1880 case TARGET_WAITKIND_EXITED: 1881 fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n", 1882 status->value.integer); 1883 break; 1884 case TARGET_WAITKIND_STOPPED: 1885 fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n", 1886 target_signal_to_name (status->value.sig)); 1887 break; 1888 case TARGET_WAITKIND_SIGNALLED: 1889 fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n", 1890 target_signal_to_name (status->value.sig)); 1891 break; 1892 case TARGET_WAITKIND_LOADED: 1893 fprintf_unfiltered (gdb_stdlog, "loaded\n"); 1894 break; 1895 case TARGET_WAITKIND_FORKED: 1896 fprintf_unfiltered (gdb_stdlog, "forked\n"); 1897 break; 1898 case TARGET_WAITKIND_VFORKED: 1899 fprintf_unfiltered (gdb_stdlog, "vforked\n"); 1900 break; 1901 case TARGET_WAITKIND_EXECD: 1902 fprintf_unfiltered (gdb_stdlog, "execd\n"); 1903 break; 1904 case TARGET_WAITKIND_SPURIOUS: 1905 fprintf_unfiltered (gdb_stdlog, "spurious\n"); 1906 break; 1907 default: 1908 fprintf_unfiltered (gdb_stdlog, "unknown???\n"); 1909 break; 1910 } 1911 1912 return retval; 1913} 1914 1915static void 1916debug_print_register (const char * func, int regno) 1917{ 1918 fprintf_unfiltered (gdb_stdlog, "%s ", func); 1919 if (regno >= 0 && regno < NUM_REGS + NUM_PSEUDO_REGS 1920 && REGISTER_NAME (regno) != NULL && REGISTER_NAME (regno)[0] != '\0') 1921 fprintf_unfiltered (gdb_stdlog, "(%s)", REGISTER_NAME (regno)); 1922 else 1923 fprintf_unfiltered (gdb_stdlog, "(%d)", regno); 1924 if (regno >= 0) 1925 { 1926 int i; 1927 unsigned char buf[MAX_REGISTER_SIZE]; 1928 deprecated_read_register_gen (regno, buf); 1929 fprintf_unfiltered (gdb_stdlog, " = "); 1930 for (i = 0; i < register_size (current_gdbarch, regno); i++) 1931 { 1932 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]); 1933 } 1934 if (register_size (current_gdbarch, regno) <= sizeof (LONGEST)) 1935 { 1936 fprintf_unfiltered (gdb_stdlog, " 0x%s %s", 1937 paddr_nz (read_register (regno)), 1938 paddr_d (read_register (regno))); 1939 } 1940 } 1941 fprintf_unfiltered (gdb_stdlog, "\n"); 1942} 1943 1944static void 1945debug_to_fetch_registers (int regno) 1946{ 1947 debug_target.to_fetch_registers (regno); 1948 debug_print_register ("target_fetch_registers", regno); 1949} 1950 1951static void 1952debug_to_store_registers (int regno) 1953{ 1954 debug_target.to_store_registers (regno); 1955 debug_print_register ("target_store_registers", regno); 1956 fprintf_unfiltered (gdb_stdlog, "\n"); 1957} 1958 1959static void 1960debug_to_prepare_to_store (void) 1961{ 1962 debug_target.to_prepare_to_store (); 1963 1964 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n"); 1965} 1966 1967static int 1968deprecated_debug_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, 1969 int write, struct mem_attrib *attrib, 1970 struct target_ops *target) 1971{ 1972 int retval; 1973 1974 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write, 1975 attrib, target); 1976 1977 fprintf_unfiltered (gdb_stdlog, 1978 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d", 1979 (unsigned int) memaddr, /* possable truncate long long */ 1980 len, write ? "write" : "read", retval); 1981 1982 if (retval > 0) 1983 { 1984 int i; 1985 1986 fputs_unfiltered (", bytes =", gdb_stdlog); 1987 for (i = 0; i < retval; i++) 1988 { 1989 if ((((long) &(myaddr[i])) & 0xf) == 0) 1990 { 1991 if (targetdebug < 2 && i > 0) 1992 { 1993 fprintf_unfiltered (gdb_stdlog, " ..."); 1994 break; 1995 } 1996 fprintf_unfiltered (gdb_stdlog, "\n"); 1997 } 1998 1999 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff); 2000 } 2001 } 2002 2003 fputc_unfiltered ('\n', gdb_stdlog); 2004 2005 return retval; 2006} 2007 2008static void 2009debug_to_files_info (struct target_ops *target) 2010{ 2011 debug_target.to_files_info (target); 2012 2013 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n"); 2014} 2015 2016static int 2017debug_to_insert_breakpoint (CORE_ADDR addr, char *save) 2018{ 2019 int retval; 2020 2021 retval = debug_target.to_insert_breakpoint (addr, save); 2022 2023 fprintf_unfiltered (gdb_stdlog, 2024 "target_insert_breakpoint (0x%lx, xxx) = %ld\n", 2025 (unsigned long) addr, 2026 (unsigned long) retval); 2027 return retval; 2028} 2029 2030static int 2031debug_to_remove_breakpoint (CORE_ADDR addr, char *save) 2032{ 2033 int retval; 2034 2035 retval = debug_target.to_remove_breakpoint (addr, save); 2036 2037 fprintf_unfiltered (gdb_stdlog, 2038 "target_remove_breakpoint (0x%lx, xxx) = %ld\n", 2039 (unsigned long) addr, 2040 (unsigned long) retval); 2041 return retval; 2042} 2043 2044static int 2045debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty) 2046{ 2047 int retval; 2048 2049 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty); 2050 2051 fprintf_unfiltered (gdb_stdlog, 2052 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n", 2053 (unsigned long) type, 2054 (unsigned long) cnt, 2055 (unsigned long) from_tty, 2056 (unsigned long) retval); 2057 return retval; 2058} 2059 2060static int 2061debug_to_region_size_ok_for_hw_watchpoint (int byte_count) 2062{ 2063 CORE_ADDR retval; 2064 2065 retval = debug_target.to_region_size_ok_for_hw_watchpoint (byte_count); 2066 2067 fprintf_unfiltered (gdb_stdlog, 2068 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n", 2069 (unsigned long) byte_count, 2070 (unsigned long) retval); 2071 return retval; 2072} 2073 2074static int 2075debug_to_stopped_by_watchpoint (void) 2076{ 2077 int retval; 2078 2079 retval = debug_target.to_stopped_by_watchpoint (); 2080 2081 fprintf_unfiltered (gdb_stdlog, 2082 "STOPPED_BY_WATCHPOINT () = %ld\n", 2083 (unsigned long) retval); 2084 return retval; 2085} 2086 2087static int 2088debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr) 2089{ 2090 int retval; 2091 2092 retval = debug_target.to_stopped_data_address (target, addr); 2093 2094 fprintf_unfiltered (gdb_stdlog, 2095 "target_stopped_data_address ([0x%lx]) = %ld\n", 2096 (unsigned long)*addr, 2097 (unsigned long)retval); 2098 return retval; 2099} 2100 2101static int 2102debug_to_insert_hw_breakpoint (CORE_ADDR addr, char *save) 2103{ 2104 int retval; 2105 2106 retval = debug_target.to_insert_hw_breakpoint (addr, save); 2107 2108 fprintf_unfiltered (gdb_stdlog, 2109 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n", 2110 (unsigned long) addr, 2111 (unsigned long) retval); 2112 return retval; 2113} 2114 2115static int 2116debug_to_remove_hw_breakpoint (CORE_ADDR addr, char *save) 2117{ 2118 int retval; 2119 2120 retval = debug_target.to_remove_hw_breakpoint (addr, save); 2121 2122 fprintf_unfiltered (gdb_stdlog, 2123 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n", 2124 (unsigned long) addr, 2125 (unsigned long) retval); 2126 return retval; 2127} 2128 2129static int 2130debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type) 2131{ 2132 int retval; 2133 2134 retval = debug_target.to_insert_watchpoint (addr, len, type); 2135 2136 fprintf_unfiltered (gdb_stdlog, 2137 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n", 2138 (unsigned long) addr, len, type, (unsigned long) retval); 2139 return retval; 2140} 2141 2142static int 2143debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type) 2144{ 2145 int retval; 2146 2147 retval = debug_target.to_insert_watchpoint (addr, len, type); 2148 2149 fprintf_unfiltered (gdb_stdlog, 2150 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n", 2151 (unsigned long) addr, len, type, (unsigned long) retval); 2152 return retval; 2153} 2154 2155static void 2156debug_to_terminal_init (void) 2157{ 2158 debug_target.to_terminal_init (); 2159 2160 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n"); 2161} 2162 2163static void 2164debug_to_terminal_inferior (void) 2165{ 2166 debug_target.to_terminal_inferior (); 2167 2168 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n"); 2169} 2170 2171static void 2172debug_to_terminal_ours_for_output (void) 2173{ 2174 debug_target.to_terminal_ours_for_output (); 2175 2176 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n"); 2177} 2178 2179static void 2180debug_to_terminal_ours (void) 2181{ 2182 debug_target.to_terminal_ours (); 2183 2184 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n"); 2185} 2186 2187static void 2188debug_to_terminal_save_ours (void) 2189{ 2190 debug_target.to_terminal_save_ours (); 2191 2192 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n"); 2193} 2194 2195static void 2196debug_to_terminal_info (char *arg, int from_tty) 2197{ 2198 debug_target.to_terminal_info (arg, from_tty); 2199 2200 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg, 2201 from_tty); 2202} 2203 2204static void 2205debug_to_kill (void) 2206{ 2207 debug_target.to_kill (); 2208 2209 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n"); 2210} 2211 2212static void 2213debug_to_load (char *args, int from_tty) 2214{ 2215 debug_target.to_load (args, from_tty); 2216 2217 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty); 2218} 2219 2220static int 2221debug_to_lookup_symbol (char *name, CORE_ADDR *addrp) 2222{ 2223 int retval; 2224 2225 retval = debug_target.to_lookup_symbol (name, addrp); 2226 2227 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name); 2228 2229 return retval; 2230} 2231 2232static void 2233debug_to_create_inferior (char *exec_file, char *args, char **env, 2234 int from_tty) 2235{ 2236 debug_target.to_create_inferior (exec_file, args, env, from_tty); 2237 2238 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n", 2239 exec_file, args, from_tty); 2240} 2241 2242static void 2243debug_to_post_startup_inferior (ptid_t ptid) 2244{ 2245 debug_target.to_post_startup_inferior (ptid); 2246 2247 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n", 2248 PIDGET (ptid)); 2249} 2250 2251static void 2252debug_to_acknowledge_created_inferior (int pid) 2253{ 2254 debug_target.to_acknowledge_created_inferior (pid); 2255 2256 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n", 2257 pid); 2258} 2259 2260static int 2261debug_to_insert_fork_catchpoint (int pid) 2262{ 2263 int retval; 2264 2265 retval = debug_target.to_insert_fork_catchpoint (pid); 2266 2267 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n", 2268 pid, retval); 2269 2270 return retval; 2271} 2272 2273static int 2274debug_to_remove_fork_catchpoint (int pid) 2275{ 2276 int retval; 2277 2278 retval = debug_target.to_remove_fork_catchpoint (pid); 2279 2280 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n", 2281 pid, retval); 2282 2283 return retval; 2284} 2285 2286static int 2287debug_to_insert_vfork_catchpoint (int pid) 2288{ 2289 int retval; 2290 2291 retval = debug_target.to_insert_vfork_catchpoint (pid); 2292 2293 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n", 2294 pid, retval); 2295 2296 return retval; 2297} 2298 2299static int 2300debug_to_remove_vfork_catchpoint (int pid) 2301{ 2302 int retval; 2303 2304 retval = debug_target.to_remove_vfork_catchpoint (pid); 2305 2306 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n", 2307 pid, retval); 2308 2309 return retval; 2310} 2311 2312static int 2313debug_to_follow_fork (int follow_child) 2314{ 2315 int retval = debug_target.to_follow_fork (follow_child); 2316 2317 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n", 2318 follow_child, retval); 2319 2320 return retval; 2321} 2322 2323static int 2324debug_to_insert_exec_catchpoint (int pid) 2325{ 2326 int retval; 2327 2328 retval = debug_target.to_insert_exec_catchpoint (pid); 2329 2330 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n", 2331 pid, retval); 2332 2333 return retval; 2334} 2335 2336static int 2337debug_to_remove_exec_catchpoint (int pid) 2338{ 2339 int retval; 2340 2341 retval = debug_target.to_remove_exec_catchpoint (pid); 2342 2343 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n", 2344 pid, retval); 2345 2346 return retval; 2347} 2348 2349static int 2350debug_to_reported_exec_events_per_exec_call (void) 2351{ 2352 int reported_exec_events; 2353 2354 reported_exec_events = debug_target.to_reported_exec_events_per_exec_call (); 2355 2356 fprintf_unfiltered (gdb_stdlog, 2357 "target_reported_exec_events_per_exec_call () = %d\n", 2358 reported_exec_events); 2359 2360 return reported_exec_events; 2361} 2362 2363static int 2364debug_to_has_exited (int pid, int wait_status, int *exit_status) 2365{ 2366 int has_exited; 2367 2368 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status); 2369 2370 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n", 2371 pid, wait_status, *exit_status, has_exited); 2372 2373 return has_exited; 2374} 2375 2376static void 2377debug_to_mourn_inferior (void) 2378{ 2379 debug_target.to_mourn_inferior (); 2380 2381 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n"); 2382} 2383 2384static int 2385debug_to_can_run (void) 2386{ 2387 int retval; 2388 2389 retval = debug_target.to_can_run (); 2390 2391 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval); 2392 2393 return retval; 2394} 2395 2396static void 2397debug_to_notice_signals (ptid_t ptid) 2398{ 2399 debug_target.to_notice_signals (ptid); 2400 2401 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n", 2402 PIDGET (ptid)); 2403} 2404 2405static int 2406debug_to_thread_alive (ptid_t ptid) 2407{ 2408 int retval; 2409 2410 retval = debug_target.to_thread_alive (ptid); 2411 2412 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n", 2413 PIDGET (ptid), retval); 2414 2415 return retval; 2416} 2417 2418static void 2419debug_to_find_new_threads (void) 2420{ 2421 debug_target.to_find_new_threads (); 2422 2423 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog); 2424} 2425 2426static void 2427debug_to_stop (void) 2428{ 2429 debug_target.to_stop (); 2430 2431 fprintf_unfiltered (gdb_stdlog, "target_stop ()\n"); 2432} 2433 2434static void 2435debug_to_rcmd (char *command, 2436 struct ui_file *outbuf) 2437{ 2438 debug_target.to_rcmd (command, outbuf); 2439 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command); 2440} 2441 2442static struct symtab_and_line * 2443debug_to_enable_exception_callback (enum exception_event_kind kind, int enable) 2444{ 2445 struct symtab_and_line *result; 2446 result = debug_target.to_enable_exception_callback (kind, enable); 2447 fprintf_unfiltered (gdb_stdlog, 2448 "target get_exception_callback_sal (%d, %d)\n", 2449 kind, enable); 2450 return result; 2451} 2452 2453static struct exception_event_record * 2454debug_to_get_current_exception_event (void) 2455{ 2456 struct exception_event_record *result; 2457 result = debug_target.to_get_current_exception_event (); 2458 fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n"); 2459 return result; 2460} 2461 2462static char * 2463debug_to_pid_to_exec_file (int pid) 2464{ 2465 char *exec_file; 2466 2467 exec_file = debug_target.to_pid_to_exec_file (pid); 2468 2469 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n", 2470 pid, exec_file); 2471 2472 return exec_file; 2473} 2474 2475static void 2476setup_target_debug (void) 2477{ 2478 memcpy (&debug_target, ¤t_target, sizeof debug_target); 2479 2480 current_target.to_open = debug_to_open; 2481 current_target.to_close = debug_to_close; 2482 current_target.to_attach = debug_to_attach; 2483 current_target.to_post_attach = debug_to_post_attach; 2484 current_target.to_detach = debug_to_detach; 2485 current_target.to_disconnect = debug_to_disconnect; 2486 current_target.to_resume = debug_to_resume; 2487 current_target.to_wait = debug_to_wait; 2488 current_target.to_fetch_registers = debug_to_fetch_registers; 2489 current_target.to_store_registers = debug_to_store_registers; 2490 current_target.to_prepare_to_store = debug_to_prepare_to_store; 2491 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory; 2492 current_target.to_files_info = debug_to_files_info; 2493 current_target.to_insert_breakpoint = debug_to_insert_breakpoint; 2494 current_target.to_remove_breakpoint = debug_to_remove_breakpoint; 2495 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint; 2496 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint; 2497 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint; 2498 current_target.to_insert_watchpoint = debug_to_insert_watchpoint; 2499 current_target.to_remove_watchpoint = debug_to_remove_watchpoint; 2500 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint; 2501 current_target.to_stopped_data_address = debug_to_stopped_data_address; 2502 current_target.to_region_size_ok_for_hw_watchpoint = debug_to_region_size_ok_for_hw_watchpoint; 2503 current_target.to_terminal_init = debug_to_terminal_init; 2504 current_target.to_terminal_inferior = debug_to_terminal_inferior; 2505 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output; 2506 current_target.to_terminal_ours = debug_to_terminal_ours; 2507 current_target.to_terminal_save_ours = debug_to_terminal_save_ours; 2508 current_target.to_terminal_info = debug_to_terminal_info; 2509 current_target.to_kill = debug_to_kill; 2510 current_target.to_load = debug_to_load; 2511 current_target.to_lookup_symbol = debug_to_lookup_symbol; 2512 current_target.to_create_inferior = debug_to_create_inferior; 2513 current_target.to_post_startup_inferior = debug_to_post_startup_inferior; 2514 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior; 2515 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint; 2516 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint; 2517 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint; 2518 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint; 2519 current_target.to_follow_fork = debug_to_follow_fork; 2520 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint; 2521 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint; 2522 current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call; 2523 current_target.to_has_exited = debug_to_has_exited; 2524 current_target.to_mourn_inferior = debug_to_mourn_inferior; 2525 current_target.to_can_run = debug_to_can_run; 2526 current_target.to_notice_signals = debug_to_notice_signals; 2527 current_target.to_thread_alive = debug_to_thread_alive; 2528 current_target.to_find_new_threads = debug_to_find_new_threads; 2529 current_target.to_stop = debug_to_stop; 2530 current_target.to_rcmd = debug_to_rcmd; 2531 current_target.to_enable_exception_callback = debug_to_enable_exception_callback; 2532 current_target.to_get_current_exception_event = debug_to_get_current_exception_event; 2533 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file; 2534 2535} 2536 2537 2538static char targ_desc[] = 2539"Names of targets and files being debugged.\n\ 2540Shows the entire stack of targets currently in use (including the exec-file,\n\ 2541core-file, and process, if any), as well as the symbol file name."; 2542 2543static void 2544do_monitor_command (char *cmd, 2545 int from_tty) 2546{ 2547 if ((current_target.to_rcmd 2548 == (void (*) (char *, struct ui_file *)) tcomplain) 2549 || (current_target.to_rcmd == debug_to_rcmd 2550 && (debug_target.to_rcmd 2551 == (void (*) (char *, struct ui_file *)) tcomplain))) 2552 { 2553 error ("\"monitor\" command not supported by this target.\n"); 2554 } 2555 target_rcmd (cmd, gdb_stdtarg); 2556} 2557 2558void 2559initialize_targets (void) 2560{ 2561 init_dummy_target (); 2562 push_target (&dummy_target); 2563 2564 add_info ("target", target_info, targ_desc); 2565 add_info ("files", target_info, targ_desc); 2566 2567 deprecated_add_show_from_set 2568 (add_set_cmd ("target", class_maintenance, var_zinteger, 2569 (char *) &targetdebug, 2570 "Set target debugging.\n\ 2571When non-zero, target debugging is enabled. Higher numbers are more\n\ 2572verbose. Changes do not take effect until the next \"run\" or \"target\"\n\ 2573command.", &setdebuglist), 2574 &showdebuglist); 2575 2576 add_setshow_boolean_cmd ("trust-readonly-sections", class_support, 2577 &trust_readonly, "\ 2578Set mode for reading from readonly sections.", "\ 2579Show mode for reading from readonly sections.", "\ 2580When this mode is on, memory reads from readonly sections (such as .text)\n\ 2581will be read from the object file instead of from the target. This will\n\ 2582result in significant performance improvement for remote targets.", "\ 2583Mode for reading from readonly sections is %s.", 2584 NULL, NULL, 2585 &setlist, &showlist); 2586 2587 add_com ("monitor", class_obscure, do_monitor_command, 2588 "Send a command to the remote monitor (remote targets only)."); 2589 2590 target_dcache = dcache_init (); 2591} 2592