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 /* There is a flattened view of the target stack in current_target, 1429 so its to_sections pointer might also need updating. */ 1430 if (current_target.to_sections == old_value) 1431 { 1432 current_target.to_sections = target->to_sections; 1433 current_target.to_sections_end = target->to_sections_end; 1434 } 1435 } 1436 1437 return old_count; 1438 1439} 1440 1441/* Remove all target sections taken from ABFD. 1442 1443 Scan the current target stack for targets whose section tables 1444 refer to sections from BFD, and remove those sections. We use this 1445 when we notice that the inferior has unloaded a shared object, for 1446 example. */ 1447void 1448remove_target_sections (bfd *abfd) 1449{ 1450 struct target_ops **t; 1451 1452 for (t = target_structs; t < target_structs + target_struct_size; t++) 1453 { 1454 struct section_table *src, *dest; 1455 1456 dest = (*t)->to_sections; 1457 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++) 1458 if (src->bfd != abfd) 1459 { 1460 /* Keep this section. */ 1461 if (dest < src) *dest = *src; 1462 dest++; 1463 } 1464 1465 /* If we've dropped any sections, resize the section table. */ 1466 if (dest < src) 1467 target_resize_to_sections (*t, dest - src); 1468 } 1469} 1470 1471 1472 1473 1474/* Find a single runnable target in the stack and return it. If for 1475 some reason there is more than one, return NULL. */ 1476 1477struct target_ops * 1478find_run_target (void) 1479{ 1480 struct target_ops **t; 1481 struct target_ops *runable = NULL; 1482 int count; 1483 1484 count = 0; 1485 1486 for (t = target_structs; t < target_structs + target_struct_size; ++t) 1487 { 1488 if ((*t)->to_can_run && target_can_run (*t)) 1489 { 1490 runable = *t; 1491 ++count; 1492 } 1493 } 1494 1495 return (count == 1 ? runable : NULL); 1496} 1497 1498/* Find a single core_stratum target in the list of targets and return it. 1499 If for some reason there is more than one, return NULL. */ 1500 1501struct target_ops * 1502find_core_target (void) 1503{ 1504 struct target_ops **t; 1505 struct target_ops *runable = NULL; 1506 int count; 1507 1508 count = 0; 1509 1510 for (t = target_structs; t < target_structs + target_struct_size; 1511 ++t) 1512 { 1513 if ((*t)->to_stratum == core_stratum) 1514 { 1515 runable = *t; 1516 ++count; 1517 } 1518 } 1519 1520 return (count == 1 ? runable : NULL); 1521} 1522 1523/* 1524 * Find the next target down the stack from the specified target. 1525 */ 1526 1527struct target_ops * 1528find_target_beneath (struct target_ops *t) 1529{ 1530 return t->beneath; 1531} 1532 1533 1534/* The inferior process has died. Long live the inferior! */ 1535 1536void 1537generic_mourn_inferior (void) 1538{ 1539 extern int show_breakpoint_hit_counts; 1540 1541 inferior_ptid = null_ptid; 1542 attach_flag = 0; 1543 breakpoint_init_inferior (inf_exited); 1544 registers_changed (); 1545 1546#ifdef CLEAR_DEFERRED_STORES 1547 /* Delete any pending stores to the inferior... */ 1548 CLEAR_DEFERRED_STORES; 1549#endif 1550 1551 reopen_exec_file (); 1552 reinit_frame_cache (); 1553 1554 /* It is confusing to the user for ignore counts to stick around 1555 from previous runs of the inferior. So clear them. */ 1556 /* However, it is more confusing for the ignore counts to disappear when 1557 using hit counts. So don't clear them if we're counting hits. */ 1558 if (!show_breakpoint_hit_counts) 1559 breakpoint_clear_ignore_counts (); 1560 1561 if (detach_hook) 1562 detach_hook (); 1563} 1564 1565/* Helper function for child_wait and the Lynx derivatives of child_wait. 1566 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our 1567 translation of that in OURSTATUS. */ 1568void 1569store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus) 1570{ 1571#ifdef CHILD_SPECIAL_WAITSTATUS 1572 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS 1573 if it wants to deal with hoststatus. */ 1574 if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus)) 1575 return; 1576#endif 1577 1578 if (WIFEXITED (hoststatus)) 1579 { 1580 ourstatus->kind = TARGET_WAITKIND_EXITED; 1581 ourstatus->value.integer = WEXITSTATUS (hoststatus); 1582 } 1583 else if (!WIFSTOPPED (hoststatus)) 1584 { 1585 ourstatus->kind = TARGET_WAITKIND_SIGNALLED; 1586 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus)); 1587 } 1588 else 1589 { 1590 ourstatus->kind = TARGET_WAITKIND_STOPPED; 1591 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus)); 1592 } 1593} 1594 1595/* Returns zero to leave the inferior alone, one to interrupt it. */ 1596int (*target_activity_function) (void); 1597int target_activity_fd; 1598 1599/* Convert a normal process ID to a string. Returns the string in a static 1600 buffer. */ 1601 1602char * 1603normal_pid_to_str (ptid_t ptid) 1604{ 1605 static char buf[30]; 1606 1607 sprintf (buf, "process %d", PIDGET (ptid)); 1608 return buf; 1609} 1610 1611/* Error-catcher for target_find_memory_regions */ 1612static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2) 1613{ 1614 error ("No target."); 1615 return 0; 1616} 1617 1618/* Error-catcher for target_make_corefile_notes */ 1619static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2) 1620{ 1621 error ("No target."); 1622 return NULL; 1623} 1624 1625/* Set up the handful of non-empty slots needed by the dummy target 1626 vector. */ 1627 1628static void 1629init_dummy_target (void) 1630{ 1631 dummy_target.to_shortname = "None"; 1632 dummy_target.to_longname = "None"; 1633 dummy_target.to_doc = ""; 1634 dummy_target.to_attach = find_default_attach; 1635 dummy_target.to_create_inferior = find_default_create_inferior; 1636 dummy_target.to_pid_to_str = normal_pid_to_str; 1637 dummy_target.to_stratum = dummy_stratum; 1638 dummy_target.to_find_memory_regions = dummy_find_memory_regions; 1639 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes; 1640 dummy_target.to_xfer_partial = default_xfer_partial; 1641 dummy_target.to_magic = OPS_MAGIC; 1642} 1643 1644 1645static struct target_ops debug_target; 1646 1647static void 1648debug_to_open (char *args, int from_tty) 1649{ 1650 debug_target.to_open (args, from_tty); 1651 1652 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty); 1653} 1654 1655static void 1656debug_to_close (int quitting) 1657{ 1658 target_close (&debug_target, quitting); 1659 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting); 1660} 1661 1662void 1663target_close (struct target_ops *targ, int quitting) 1664{ 1665 if (targ->to_xclose != NULL) 1666 targ->to_xclose (targ, quitting); 1667 else if (targ->to_close != NULL) 1668 targ->to_close (quitting); 1669} 1670 1671static void 1672debug_to_attach (char *args, int from_tty) 1673{ 1674 debug_target.to_attach (args, from_tty); 1675 1676 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty); 1677} 1678 1679 1680static void 1681debug_to_post_attach (int pid) 1682{ 1683 debug_target.to_post_attach (pid); 1684 1685 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid); 1686} 1687 1688static void 1689debug_to_detach (char *args, int from_tty) 1690{ 1691 debug_target.to_detach (args, from_tty); 1692 1693 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty); 1694} 1695 1696static void 1697debug_to_disconnect (char *args, int from_tty) 1698{ 1699 debug_target.to_disconnect (args, from_tty); 1700 1701 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n", 1702 args, from_tty); 1703} 1704 1705static void 1706debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal) 1707{ 1708 debug_target.to_resume (ptid, step, siggnal); 1709 1710 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid), 1711 step ? "step" : "continue", 1712 target_signal_to_name (siggnal)); 1713} 1714 1715static ptid_t 1716debug_to_wait (ptid_t ptid, struct target_waitstatus *status) 1717{ 1718 ptid_t retval; 1719 1720 retval = debug_target.to_wait (ptid, status); 1721 1722 fprintf_unfiltered (gdb_stdlog, 1723 "target_wait (%d, status) = %d, ", PIDGET (ptid), 1724 PIDGET (retval)); 1725 fprintf_unfiltered (gdb_stdlog, "status->kind = "); 1726 switch (status->kind) 1727 { 1728 case TARGET_WAITKIND_EXITED: 1729 fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n", 1730 status->value.integer); 1731 break; 1732 case TARGET_WAITKIND_STOPPED: 1733 fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n", 1734 target_signal_to_name (status->value.sig)); 1735 break; 1736 case TARGET_WAITKIND_SIGNALLED: 1737 fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n", 1738 target_signal_to_name (status->value.sig)); 1739 break; 1740 case TARGET_WAITKIND_LOADED: 1741 fprintf_unfiltered (gdb_stdlog, "loaded\n"); 1742 break; 1743 case TARGET_WAITKIND_FORKED: 1744 fprintf_unfiltered (gdb_stdlog, "forked\n"); 1745 break; 1746 case TARGET_WAITKIND_VFORKED: 1747 fprintf_unfiltered (gdb_stdlog, "vforked\n"); 1748 break; 1749 case TARGET_WAITKIND_EXECD: 1750 fprintf_unfiltered (gdb_stdlog, "execd\n"); 1751 break; 1752 case TARGET_WAITKIND_SPURIOUS: 1753 fprintf_unfiltered (gdb_stdlog, "spurious\n"); 1754 break; 1755 default: 1756 fprintf_unfiltered (gdb_stdlog, "unknown???\n"); 1757 break; 1758 } 1759 1760 return retval; 1761} 1762 1763static void 1764debug_to_post_wait (ptid_t ptid, int status) 1765{ 1766 debug_target.to_post_wait (ptid, status); 1767 1768 fprintf_unfiltered (gdb_stdlog, "target_post_wait (%d, %d)\n", 1769 PIDGET (ptid), status); 1770} 1771 1772static void 1773debug_print_register (const char * func, int regno) 1774{ 1775 fprintf_unfiltered (gdb_stdlog, "%s ", func); 1776 if (regno >= 0 && regno < NUM_REGS + NUM_PSEUDO_REGS 1777 && REGISTER_NAME (regno) != NULL && REGISTER_NAME (regno)[0] != '\0') 1778 fprintf_unfiltered (gdb_stdlog, "(%s)", REGISTER_NAME (regno)); 1779 else 1780 fprintf_unfiltered (gdb_stdlog, "(%d)", regno); 1781 if (regno >= 0) 1782 { 1783 int i; 1784 unsigned char buf[MAX_REGISTER_SIZE]; 1785 deprecated_read_register_gen (regno, buf); 1786 fprintf_unfiltered (gdb_stdlog, " = "); 1787 for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i++) 1788 { 1789 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]); 1790 } 1791 if (DEPRECATED_REGISTER_RAW_SIZE (regno) <= sizeof (LONGEST)) 1792 { 1793 fprintf_unfiltered (gdb_stdlog, " 0x%s %s", 1794 paddr_nz (read_register (regno)), 1795 paddr_d (read_register (regno))); 1796 } 1797 } 1798 fprintf_unfiltered (gdb_stdlog, "\n"); 1799} 1800 1801static void 1802debug_to_fetch_registers (int regno) 1803{ 1804 debug_target.to_fetch_registers (regno); 1805 debug_print_register ("target_fetch_registers", regno); 1806} 1807 1808static void 1809debug_to_store_registers (int regno) 1810{ 1811 debug_target.to_store_registers (regno); 1812 debug_print_register ("target_store_registers", regno); 1813 fprintf_unfiltered (gdb_stdlog, "\n"); 1814} 1815 1816static void 1817debug_to_prepare_to_store (void) 1818{ 1819 debug_target.to_prepare_to_store (); 1820 1821 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n"); 1822} 1823 1824static int 1825debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, 1826 struct mem_attrib *attrib, 1827 struct target_ops *target) 1828{ 1829 int retval; 1830 1831 retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, 1832 attrib, target); 1833 1834 fprintf_unfiltered (gdb_stdlog, 1835 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d", 1836 (unsigned int) memaddr, /* possable truncate long long */ 1837 len, write ? "write" : "read", retval); 1838 1839 1840 1841 if (retval > 0) 1842 { 1843 int i; 1844 1845 fputs_unfiltered (", bytes =", gdb_stdlog); 1846 for (i = 0; i < retval; i++) 1847 { 1848 if ((((long) &(myaddr[i])) & 0xf) == 0) 1849 fprintf_unfiltered (gdb_stdlog, "\n"); 1850 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff); 1851 } 1852 } 1853 1854 fputc_unfiltered ('\n', gdb_stdlog); 1855 1856 return retval; 1857} 1858 1859static void 1860debug_to_files_info (struct target_ops *target) 1861{ 1862 debug_target.to_files_info (target); 1863 1864 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n"); 1865} 1866 1867static int 1868debug_to_insert_breakpoint (CORE_ADDR addr, char *save) 1869{ 1870 int retval; 1871 1872 retval = debug_target.to_insert_breakpoint (addr, save); 1873 1874 fprintf_unfiltered (gdb_stdlog, 1875 "target_insert_breakpoint (0x%lx, xxx) = %ld\n", 1876 (unsigned long) addr, 1877 (unsigned long) retval); 1878 return retval; 1879} 1880 1881static int 1882debug_to_remove_breakpoint (CORE_ADDR addr, char *save) 1883{ 1884 int retval; 1885 1886 retval = debug_target.to_remove_breakpoint (addr, save); 1887 1888 fprintf_unfiltered (gdb_stdlog, 1889 "target_remove_breakpoint (0x%lx, xxx) = %ld\n", 1890 (unsigned long) addr, 1891 (unsigned long) retval); 1892 return retval; 1893} 1894 1895static int 1896debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty) 1897{ 1898 int retval; 1899 1900 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty); 1901 1902 fprintf_unfiltered (gdb_stdlog, 1903 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n", 1904 (unsigned long) type, 1905 (unsigned long) cnt, 1906 (unsigned long) from_tty, 1907 (unsigned long) retval); 1908 return retval; 1909} 1910 1911static int 1912debug_to_region_size_ok_for_hw_watchpoint (int byte_count) 1913{ 1914 CORE_ADDR retval; 1915 1916 retval = debug_target.to_region_size_ok_for_hw_watchpoint (byte_count); 1917 1918 fprintf_unfiltered (gdb_stdlog, 1919 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n", 1920 (unsigned long) byte_count, 1921 (unsigned long) retval); 1922 return retval; 1923} 1924 1925static int 1926debug_to_stopped_by_watchpoint (void) 1927{ 1928 int retval; 1929 1930 retval = debug_target.to_stopped_by_watchpoint (); 1931 1932 fprintf_unfiltered (gdb_stdlog, 1933 "STOPPED_BY_WATCHPOINT () = %ld\n", 1934 (unsigned long) retval); 1935 return retval; 1936} 1937 1938static CORE_ADDR 1939debug_to_stopped_data_address (void) 1940{ 1941 CORE_ADDR retval; 1942 1943 retval = debug_target.to_stopped_data_address (); 1944 1945 fprintf_unfiltered (gdb_stdlog, 1946 "target_stopped_data_address () = 0x%lx\n", 1947 (unsigned long) retval); 1948 return retval; 1949} 1950 1951static int 1952debug_to_insert_hw_breakpoint (CORE_ADDR addr, char *save) 1953{ 1954 int retval; 1955 1956 retval = debug_target.to_insert_hw_breakpoint (addr, save); 1957 1958 fprintf_unfiltered (gdb_stdlog, 1959 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n", 1960 (unsigned long) addr, 1961 (unsigned long) retval); 1962 return retval; 1963} 1964 1965static int 1966debug_to_remove_hw_breakpoint (CORE_ADDR addr, char *save) 1967{ 1968 int retval; 1969 1970 retval = debug_target.to_remove_hw_breakpoint (addr, save); 1971 1972 fprintf_unfiltered (gdb_stdlog, 1973 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n", 1974 (unsigned long) addr, 1975 (unsigned long) retval); 1976 return retval; 1977} 1978 1979static int 1980debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type) 1981{ 1982 int retval; 1983 1984 retval = debug_target.to_insert_watchpoint (addr, len, type); 1985 1986 fprintf_unfiltered (gdb_stdlog, 1987 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n", 1988 (unsigned long) addr, len, type, (unsigned long) retval); 1989 return retval; 1990} 1991 1992static int 1993debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type) 1994{ 1995 int retval; 1996 1997 retval = debug_target.to_insert_watchpoint (addr, len, type); 1998 1999 fprintf_unfiltered (gdb_stdlog, 2000 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n", 2001 (unsigned long) addr, len, type, (unsigned long) retval); 2002 return retval; 2003} 2004 2005static void 2006debug_to_terminal_init (void) 2007{ 2008 debug_target.to_terminal_init (); 2009 2010 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n"); 2011} 2012 2013static void 2014debug_to_terminal_inferior (void) 2015{ 2016 debug_target.to_terminal_inferior (); 2017 2018 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n"); 2019} 2020 2021static void 2022debug_to_terminal_ours_for_output (void) 2023{ 2024 debug_target.to_terminal_ours_for_output (); 2025 2026 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n"); 2027} 2028 2029static void 2030debug_to_terminal_ours (void) 2031{ 2032 debug_target.to_terminal_ours (); 2033 2034 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n"); 2035} 2036 2037static void 2038debug_to_terminal_save_ours (void) 2039{ 2040 debug_target.to_terminal_save_ours (); 2041 2042 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n"); 2043} 2044 2045static void 2046debug_to_terminal_info (char *arg, int from_tty) 2047{ 2048 debug_target.to_terminal_info (arg, from_tty); 2049 2050 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg, 2051 from_tty); 2052} 2053 2054static void 2055debug_to_kill (void) 2056{ 2057 debug_target.to_kill (); 2058 2059 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n"); 2060} 2061 2062static void 2063debug_to_load (char *args, int from_tty) 2064{ 2065 debug_target.to_load (args, from_tty); 2066 2067 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty); 2068} 2069 2070static int 2071debug_to_lookup_symbol (char *name, CORE_ADDR *addrp) 2072{ 2073 int retval; 2074 2075 retval = debug_target.to_lookup_symbol (name, addrp); 2076 2077 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name); 2078 2079 return retval; 2080} 2081 2082static void 2083debug_to_create_inferior (char *exec_file, char *args, char **env) 2084{ 2085 debug_target.to_create_inferior (exec_file, args, env); 2086 2087 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx)\n", 2088 exec_file, args); 2089} 2090 2091static void 2092debug_to_post_startup_inferior (ptid_t ptid) 2093{ 2094 debug_target.to_post_startup_inferior (ptid); 2095 2096 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n", 2097 PIDGET (ptid)); 2098} 2099 2100static void 2101debug_to_acknowledge_created_inferior (int pid) 2102{ 2103 debug_target.to_acknowledge_created_inferior (pid); 2104 2105 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n", 2106 pid); 2107} 2108 2109static int 2110debug_to_insert_fork_catchpoint (int pid) 2111{ 2112 int retval; 2113 2114 retval = debug_target.to_insert_fork_catchpoint (pid); 2115 2116 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n", 2117 pid, retval); 2118 2119 return retval; 2120} 2121 2122static int 2123debug_to_remove_fork_catchpoint (int pid) 2124{ 2125 int retval; 2126 2127 retval = debug_target.to_remove_fork_catchpoint (pid); 2128 2129 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n", 2130 pid, retval); 2131 2132 return retval; 2133} 2134 2135static int 2136debug_to_insert_vfork_catchpoint (int pid) 2137{ 2138 int retval; 2139 2140 retval = debug_target.to_insert_vfork_catchpoint (pid); 2141 2142 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n", 2143 pid, retval); 2144 2145 return retval; 2146} 2147 2148static int 2149debug_to_remove_vfork_catchpoint (int pid) 2150{ 2151 int retval; 2152 2153 retval = debug_target.to_remove_vfork_catchpoint (pid); 2154 2155 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n", 2156 pid, retval); 2157 2158 return retval; 2159} 2160 2161static int 2162debug_to_follow_fork (int follow_child) 2163{ 2164 int retval = debug_target.to_follow_fork (follow_child); 2165 2166 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n", 2167 follow_child, retval); 2168 2169 return retval; 2170} 2171 2172static int 2173debug_to_insert_exec_catchpoint (int pid) 2174{ 2175 int retval; 2176 2177 retval = debug_target.to_insert_exec_catchpoint (pid); 2178 2179 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n", 2180 pid, retval); 2181 2182 return retval; 2183} 2184 2185static int 2186debug_to_remove_exec_catchpoint (int pid) 2187{ 2188 int retval; 2189 2190 retval = debug_target.to_remove_exec_catchpoint (pid); 2191 2192 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n", 2193 pid, retval); 2194 2195 return retval; 2196} 2197 2198static int 2199debug_to_reported_exec_events_per_exec_call (void) 2200{ 2201 int reported_exec_events; 2202 2203 reported_exec_events = debug_target.to_reported_exec_events_per_exec_call (); 2204 2205 fprintf_unfiltered (gdb_stdlog, 2206 "target_reported_exec_events_per_exec_call () = %d\n", 2207 reported_exec_events); 2208 2209 return reported_exec_events; 2210} 2211 2212static int 2213debug_to_has_exited (int pid, int wait_status, int *exit_status) 2214{ 2215 int has_exited; 2216 2217 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status); 2218 2219 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n", 2220 pid, wait_status, *exit_status, has_exited); 2221 2222 return has_exited; 2223} 2224 2225static void 2226debug_to_mourn_inferior (void) 2227{ 2228 debug_target.to_mourn_inferior (); 2229 2230 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n"); 2231} 2232 2233static int 2234debug_to_can_run (void) 2235{ 2236 int retval; 2237 2238 retval = debug_target.to_can_run (); 2239 2240 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval); 2241 2242 return retval; 2243} 2244 2245static void 2246debug_to_notice_signals (ptid_t ptid) 2247{ 2248 debug_target.to_notice_signals (ptid); 2249 2250 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n", 2251 PIDGET (ptid)); 2252} 2253 2254static int 2255debug_to_thread_alive (ptid_t ptid) 2256{ 2257 int retval; 2258 2259 retval = debug_target.to_thread_alive (ptid); 2260 2261 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n", 2262 PIDGET (ptid), retval); 2263 2264 return retval; 2265} 2266 2267static void 2268debug_to_find_new_threads (void) 2269{ 2270 debug_target.to_find_new_threads (); 2271 2272 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog); 2273} 2274 2275static void 2276debug_to_stop (void) 2277{ 2278 debug_target.to_stop (); 2279 2280 fprintf_unfiltered (gdb_stdlog, "target_stop ()\n"); 2281} 2282 2283static LONGEST 2284debug_to_xfer_partial (struct target_ops *ops, enum target_object object, 2285 const char *annex, void *readbuf, const void *writebuf, 2286 ULONGEST offset, LONGEST len) 2287{ 2288 LONGEST retval; 2289 2290 retval = debug_target.to_xfer_partial (&debug_target, object, annex, 2291 readbuf, writebuf, offset, len); 2292 2293 fprintf_unfiltered (gdb_stdlog, 2294 "target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s\n", 2295 (int) object, (annex ? annex : "(null)"), 2296 (long) readbuf, (long) writebuf, paddr_nz (offset), 2297 paddr_d (len), paddr_d (retval)); 2298 2299 return retval; 2300} 2301 2302static void 2303debug_to_rcmd (char *command, 2304 struct ui_file *outbuf) 2305{ 2306 debug_target.to_rcmd (command, outbuf); 2307 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command); 2308} 2309 2310static struct symtab_and_line * 2311debug_to_enable_exception_callback (enum exception_event_kind kind, int enable) 2312{ 2313 struct symtab_and_line *result; 2314 result = debug_target.to_enable_exception_callback (kind, enable); 2315 fprintf_unfiltered (gdb_stdlog, 2316 "target get_exception_callback_sal (%d, %d)\n", 2317 kind, enable); 2318 return result; 2319} 2320 2321static struct exception_event_record * 2322debug_to_get_current_exception_event (void) 2323{ 2324 struct exception_event_record *result; 2325 result = debug_target.to_get_current_exception_event (); 2326 fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n"); 2327 return result; 2328} 2329 2330static char * 2331debug_to_pid_to_exec_file (int pid) 2332{ 2333 char *exec_file; 2334 2335 exec_file = debug_target.to_pid_to_exec_file (pid); 2336 2337 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n", 2338 pid, exec_file); 2339 2340 return exec_file; 2341} 2342 2343static void 2344setup_target_debug (void) 2345{ 2346 memcpy (&debug_target, ¤t_target, sizeof debug_target); 2347 2348 current_target.to_open = debug_to_open; 2349 current_target.to_close = debug_to_close; 2350 current_target.to_attach = debug_to_attach; 2351 current_target.to_post_attach = debug_to_post_attach; 2352 current_target.to_detach = debug_to_detach; 2353 current_target.to_disconnect = debug_to_disconnect; 2354 current_target.to_resume = debug_to_resume; 2355 current_target.to_wait = debug_to_wait; 2356 current_target.to_post_wait = debug_to_post_wait; 2357 current_target.to_fetch_registers = debug_to_fetch_registers; 2358 current_target.to_store_registers = debug_to_store_registers; 2359 current_target.to_prepare_to_store = debug_to_prepare_to_store; 2360 current_target.to_xfer_memory = debug_to_xfer_memory; 2361 current_target.to_files_info = debug_to_files_info; 2362 current_target.to_insert_breakpoint = debug_to_insert_breakpoint; 2363 current_target.to_remove_breakpoint = debug_to_remove_breakpoint; 2364 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint; 2365 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint; 2366 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint; 2367 current_target.to_insert_watchpoint = debug_to_insert_watchpoint; 2368 current_target.to_remove_watchpoint = debug_to_remove_watchpoint; 2369 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint; 2370 current_target.to_stopped_data_address = debug_to_stopped_data_address; 2371 current_target.to_region_size_ok_for_hw_watchpoint = debug_to_region_size_ok_for_hw_watchpoint; 2372 current_target.to_terminal_init = debug_to_terminal_init; 2373 current_target.to_terminal_inferior = debug_to_terminal_inferior; 2374 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output; 2375 current_target.to_terminal_ours = debug_to_terminal_ours; 2376 current_target.to_terminal_save_ours = debug_to_terminal_save_ours; 2377 current_target.to_terminal_info = debug_to_terminal_info; 2378 current_target.to_kill = debug_to_kill; 2379 current_target.to_load = debug_to_load; 2380 current_target.to_lookup_symbol = debug_to_lookup_symbol; 2381 current_target.to_create_inferior = debug_to_create_inferior; 2382 current_target.to_post_startup_inferior = debug_to_post_startup_inferior; 2383 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior; 2384 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint; 2385 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint; 2386 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint; 2387 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint; 2388 current_target.to_follow_fork = debug_to_follow_fork; 2389 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint; 2390 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint; 2391 current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call; 2392 current_target.to_has_exited = debug_to_has_exited; 2393 current_target.to_mourn_inferior = debug_to_mourn_inferior; 2394 current_target.to_can_run = debug_to_can_run; 2395 current_target.to_notice_signals = debug_to_notice_signals; 2396 current_target.to_thread_alive = debug_to_thread_alive; 2397 current_target.to_find_new_threads = debug_to_find_new_threads; 2398 current_target.to_stop = debug_to_stop; 2399 current_target.to_xfer_partial = debug_to_xfer_partial; 2400 current_target.to_rcmd = debug_to_rcmd; 2401 current_target.to_enable_exception_callback = debug_to_enable_exception_callback; 2402 current_target.to_get_current_exception_event = debug_to_get_current_exception_event; 2403 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file; 2404 2405} 2406 2407 2408static char targ_desc[] = 2409"Names of targets and files being debugged.\n\ 2410Shows the entire stack of targets currently in use (including the exec-file,\n\ 2411core-file, and process, if any), as well as the symbol file name."; 2412 2413static void 2414do_monitor_command (char *cmd, 2415 int from_tty) 2416{ 2417 if ((current_target.to_rcmd 2418 == (void (*) (char *, struct ui_file *)) tcomplain) 2419 || (current_target.to_rcmd == debug_to_rcmd 2420 && (debug_target.to_rcmd 2421 == (void (*) (char *, struct ui_file *)) tcomplain))) 2422 { 2423 error ("\"monitor\" command not supported by this target.\n"); 2424 } 2425 target_rcmd (cmd, gdb_stdtarg); 2426} 2427 2428void 2429initialize_targets (void) 2430{ 2431 init_dummy_target (); 2432 push_target (&dummy_target); 2433 2434 add_info ("target", target_info, targ_desc); 2435 add_info ("files", target_info, targ_desc); 2436 2437 add_show_from_set 2438 (add_set_cmd ("target", class_maintenance, var_zinteger, 2439 (char *) &targetdebug, 2440 "Set target debugging.\n\ 2441When non-zero, target debugging is enabled.", &setdebuglist), 2442 &showdebuglist); 2443 2444 add_setshow_boolean_cmd ("trust-readonly-sections", class_support, 2445 &trust_readonly, "\ 2446Set mode for reading from readonly sections.\n\ 2447When this mode is on, memory reads from readonly sections (such as .text)\n\ 2448will be read from the object file instead of from the target. This will\n\ 2449result in significant performance improvement for remote targets.", "\ 2450Show mode for reading from readonly sections.\n", 2451 NULL, NULL, 2452 &setlist, &showlist); 2453 2454 add_com ("monitor", class_obscure, do_monitor_command, 2455 "Send a command to the remote monitor (remote targets only)."); 2456 2457 target_dcache = dcache_init (); 2458} 2459