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