1 /* Select target systems and architectures at runtime for GDB. 2 3 Copyright (C) 1990-2012 Free Software Foundation, Inc. 4 5 Contributed by Cygnus Support. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include <errno.h> 24 #include "gdb_string.h" 25 #include "target.h" 26 #include "gdbcmd.h" 27 #include "symtab.h" 28 #include "inferior.h" 29 #include "bfd.h" 30 #include "symfile.h" 31 #include "objfiles.h" 32 #include "gdb_wait.h" 33 #include "dcache.h" 34 #include <signal.h> 35 #include "regcache.h" 36 #include "gdb_assert.h" 37 #include "gdbcore.h" 38 #include "exceptions.h" 39 #include "target-descriptions.h" 40 #include "gdbthread.h" 41 #include "solib.h" 42 #include "exec.h" 43 #include "inline-frame.h" 44 #include "tracepoint.h" 45 46 static void target_info (char *, int); 47 48 static void default_terminal_info (char *, int); 49 50 static int default_watchpoint_addr_within_range (struct target_ops *, 51 CORE_ADDR, CORE_ADDR, int); 52 53 static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int); 54 55 static void tcomplain (void) ATTRIBUTE_NORETURN; 56 57 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *); 58 59 static int return_zero (void); 60 61 static int return_one (void); 62 63 static int return_minus_one (void); 64 65 void target_ignore (void); 66 67 static void target_command (char *, int); 68 69 static struct target_ops *find_default_run_target (char *); 70 71 static LONGEST default_xfer_partial (struct target_ops *ops, 72 enum target_object object, 73 const char *annex, gdb_byte *readbuf, 74 const gdb_byte *writebuf, 75 ULONGEST offset, LONGEST len); 76 77 static LONGEST current_xfer_partial (struct target_ops *ops, 78 enum target_object object, 79 const char *annex, gdb_byte *readbuf, 80 const gdb_byte *writebuf, 81 ULONGEST offset, LONGEST len); 82 83 static LONGEST target_xfer_partial (struct target_ops *ops, 84 enum target_object object, 85 const char *annex, 86 void *readbuf, const void *writebuf, 87 ULONGEST offset, LONGEST len); 88 89 static struct gdbarch *default_thread_architecture (struct target_ops *ops, 90 ptid_t ptid); 91 92 static void init_dummy_target (void); 93 94 static struct target_ops debug_target; 95 96 static void debug_to_open (char *, int); 97 98 static void debug_to_prepare_to_store (struct regcache *); 99 100 static void debug_to_files_info (struct target_ops *); 101 102 static int debug_to_insert_breakpoint (struct gdbarch *, 103 struct bp_target_info *); 104 105 static int debug_to_remove_breakpoint (struct gdbarch *, 106 struct bp_target_info *); 107 108 static int debug_to_can_use_hw_breakpoint (int, int, int); 109 110 static int debug_to_insert_hw_breakpoint (struct gdbarch *, 111 struct bp_target_info *); 112 113 static int debug_to_remove_hw_breakpoint (struct gdbarch *, 114 struct bp_target_info *); 115 116 static int debug_to_insert_watchpoint (CORE_ADDR, int, int, 117 struct expression *); 118 119 static int debug_to_remove_watchpoint (CORE_ADDR, int, int, 120 struct expression *); 121 122 static int debug_to_stopped_by_watchpoint (void); 123 124 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *); 125 126 static int debug_to_watchpoint_addr_within_range (struct target_ops *, 127 CORE_ADDR, CORE_ADDR, int); 128 129 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int); 130 131 static int debug_to_can_accel_watchpoint_condition (CORE_ADDR, int, int, 132 struct expression *); 133 134 static void debug_to_terminal_init (void); 135 136 static void debug_to_terminal_inferior (void); 137 138 static void debug_to_terminal_ours_for_output (void); 139 140 static void debug_to_terminal_save_ours (void); 141 142 static void debug_to_terminal_ours (void); 143 144 static void debug_to_terminal_info (char *, int); 145 146 static void debug_to_load (char *, int); 147 148 static int debug_to_can_run (void); 149 150 static void debug_to_stop (ptid_t); 151 152 /* Pointer to array of target architecture structures; the size of the 153 array; the current index into the array; the allocated size of the 154 array. */ 155 struct target_ops **target_structs; 156 unsigned target_struct_size; 157 unsigned target_struct_index; 158 unsigned target_struct_allocsize; 159 #define DEFAULT_ALLOCSIZE 10 160 161 /* The initial current target, so that there is always a semi-valid 162 current target. */ 163 164 static struct target_ops dummy_target; 165 166 /* Top of target stack. */ 167 168 static struct target_ops *target_stack; 169 170 /* The target structure we are currently using to talk to a process 171 or file or whatever "inferior" we have. */ 172 173 struct target_ops current_target; 174 175 /* Command list for target. */ 176 177 static struct cmd_list_element *targetlist = NULL; 178 179 /* Nonzero if we should trust readonly sections from the 180 executable when reading memory. */ 181 182 static int trust_readonly = 0; 183 184 /* Nonzero if we should show true memory content including 185 memory breakpoint inserted by gdb. */ 186 187 static int show_memory_breakpoints = 0; 188 189 /* These globals control whether GDB attempts to perform these 190 operations; they are useful for targets that need to prevent 191 inadvertant disruption, such as in non-stop mode. */ 192 193 int may_write_registers = 1; 194 195 int may_write_memory = 1; 196 197 int may_insert_breakpoints = 1; 198 199 int may_insert_tracepoints = 1; 200 201 int may_insert_fast_tracepoints = 1; 202 203 int may_stop = 1; 204 205 /* Non-zero if we want to see trace of target level stuff. */ 206 207 static int targetdebug = 0; 208 static void 209 show_targetdebug (struct ui_file *file, int from_tty, 210 struct cmd_list_element *c, const char *value) 211 { 212 fprintf_filtered (file, _("Target debugging is %s.\n"), value); 213 } 214 215 static void setup_target_debug (void); 216 217 /* The option sets this. */ 218 static int stack_cache_enabled_p_1 = 1; 219 /* And set_stack_cache_enabled_p updates this. 220 The reason for the separation is so that we don't flush the cache for 221 on->on transitions. */ 222 static int stack_cache_enabled_p = 1; 223 224 /* This is called *after* the stack-cache has been set. 225 Flush the cache for off->on and on->off transitions. 226 There's no real need to flush the cache for on->off transitions, 227 except cleanliness. */ 228 229 static void 230 set_stack_cache_enabled_p (char *args, int from_tty, 231 struct cmd_list_element *c) 232 { 233 if (stack_cache_enabled_p != stack_cache_enabled_p_1) 234 target_dcache_invalidate (); 235 236 stack_cache_enabled_p = stack_cache_enabled_p_1; 237 } 238 239 static void 240 show_stack_cache_enabled_p (struct ui_file *file, int from_tty, 241 struct cmd_list_element *c, const char *value) 242 { 243 fprintf_filtered (file, _("Cache use for stack accesses is %s.\n"), value); 244 } 245 246 /* Cache of memory operations, to speed up remote access. */ 247 static DCACHE *target_dcache; 248 249 /* Invalidate the target dcache. */ 250 251 void 252 target_dcache_invalidate (void) 253 { 254 dcache_invalidate (target_dcache); 255 } 256 257 /* The user just typed 'target' without the name of a target. */ 258 259 static void 260 target_command (char *arg, int from_tty) 261 { 262 fputs_filtered ("Argument required (target name). Try `help target'\n", 263 gdb_stdout); 264 } 265 266 /* Default target_has_* methods for process_stratum targets. */ 267 268 int 269 default_child_has_all_memory (struct target_ops *ops) 270 { 271 /* If no inferior selected, then we can't read memory here. */ 272 if (ptid_equal (inferior_ptid, null_ptid)) 273 return 0; 274 275 return 1; 276 } 277 278 int 279 default_child_has_memory (struct target_ops *ops) 280 { 281 /* If no inferior selected, then we can't read memory here. */ 282 if (ptid_equal (inferior_ptid, null_ptid)) 283 return 0; 284 285 return 1; 286 } 287 288 int 289 default_child_has_stack (struct target_ops *ops) 290 { 291 /* If no inferior selected, there's no stack. */ 292 if (ptid_equal (inferior_ptid, null_ptid)) 293 return 0; 294 295 return 1; 296 } 297 298 int 299 default_child_has_registers (struct target_ops *ops) 300 { 301 /* Can't read registers from no inferior. */ 302 if (ptid_equal (inferior_ptid, null_ptid)) 303 return 0; 304 305 return 1; 306 } 307 308 int 309 default_child_has_execution (struct target_ops *ops, ptid_t the_ptid) 310 { 311 /* If there's no thread selected, then we can't make it run through 312 hoops. */ 313 if (ptid_equal (the_ptid, null_ptid)) 314 return 0; 315 316 return 1; 317 } 318 319 320 int 321 target_has_all_memory_1 (void) 322 { 323 struct target_ops *t; 324 325 for (t = current_target.beneath; t != NULL; t = t->beneath) 326 if (t->to_has_all_memory (t)) 327 return 1; 328 329 return 0; 330 } 331 332 int 333 target_has_memory_1 (void) 334 { 335 struct target_ops *t; 336 337 for (t = current_target.beneath; t != NULL; t = t->beneath) 338 if (t->to_has_memory (t)) 339 return 1; 340 341 return 0; 342 } 343 344 int 345 target_has_stack_1 (void) 346 { 347 struct target_ops *t; 348 349 for (t = current_target.beneath; t != NULL; t = t->beneath) 350 if (t->to_has_stack (t)) 351 return 1; 352 353 return 0; 354 } 355 356 int 357 target_has_registers_1 (void) 358 { 359 struct target_ops *t; 360 361 for (t = current_target.beneath; t != NULL; t = t->beneath) 362 if (t->to_has_registers (t)) 363 return 1; 364 365 return 0; 366 } 367 368 int 369 target_has_execution_1 (ptid_t the_ptid) 370 { 371 struct target_ops *t; 372 373 for (t = current_target.beneath; t != NULL; t = t->beneath) 374 if (t->to_has_execution (t, the_ptid)) 375 return 1; 376 377 return 0; 378 } 379 380 int 381 target_has_execution_current (void) 382 { 383 return target_has_execution_1 (inferior_ptid); 384 } 385 386 /* Add a possible target architecture to the list. */ 387 388 void 389 add_target (struct target_ops *t) 390 { 391 /* Provide default values for all "must have" methods. */ 392 if (t->to_xfer_partial == NULL) 393 t->to_xfer_partial = default_xfer_partial; 394 395 if (t->to_has_all_memory == NULL) 396 t->to_has_all_memory = (int (*) (struct target_ops *)) return_zero; 397 398 if (t->to_has_memory == NULL) 399 t->to_has_memory = (int (*) (struct target_ops *)) return_zero; 400 401 if (t->to_has_stack == NULL) 402 t->to_has_stack = (int (*) (struct target_ops *)) return_zero; 403 404 if (t->to_has_registers == NULL) 405 t->to_has_registers = (int (*) (struct target_ops *)) return_zero; 406 407 if (t->to_has_execution == NULL) 408 t->to_has_execution = (int (*) (struct target_ops *, ptid_t)) return_zero; 409 410 if (!target_structs) 411 { 412 target_struct_allocsize = DEFAULT_ALLOCSIZE; 413 target_structs = (struct target_ops **) xmalloc 414 (target_struct_allocsize * sizeof (*target_structs)); 415 } 416 if (target_struct_size >= target_struct_allocsize) 417 { 418 target_struct_allocsize *= 2; 419 target_structs = (struct target_ops **) 420 xrealloc ((char *) target_structs, 421 target_struct_allocsize * sizeof (*target_structs)); 422 } 423 target_structs[target_struct_size++] = t; 424 425 if (targetlist == NULL) 426 add_prefix_cmd ("target", class_run, target_command, _("\ 427 Connect to a target machine or process.\n\ 428 The first argument is the type or protocol of the target machine.\n\ 429 Remaining arguments are interpreted by the target protocol. For more\n\ 430 information on the arguments for a particular protocol, type\n\ 431 `help target ' followed by the protocol name."), 432 &targetlist, "target ", 0, &cmdlist); 433 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist); 434 } 435 436 /* Stub functions */ 437 438 void 439 target_ignore (void) 440 { 441 } 442 443 void 444 target_kill (void) 445 { 446 struct target_ops *t; 447 448 for (t = current_target.beneath; t != NULL; t = t->beneath) 449 if (t->to_kill != NULL) 450 { 451 if (targetdebug) 452 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n"); 453 454 t->to_kill (t); 455 return; 456 } 457 458 noprocess (); 459 } 460 461 void 462 target_load (char *arg, int from_tty) 463 { 464 target_dcache_invalidate (); 465 (*current_target.to_load) (arg, from_tty); 466 } 467 468 void 469 target_create_inferior (char *exec_file, char *args, 470 char **env, int from_tty) 471 { 472 struct target_ops *t; 473 474 for (t = current_target.beneath; t != NULL; t = t->beneath) 475 { 476 if (t->to_create_inferior != NULL) 477 { 478 t->to_create_inferior (t, exec_file, args, env, from_tty); 479 if (targetdebug) 480 fprintf_unfiltered (gdb_stdlog, 481 "target_create_inferior (%s, %s, xxx, %d)\n", 482 exec_file, args, from_tty); 483 return; 484 } 485 } 486 487 internal_error (__FILE__, __LINE__, 488 _("could not find a target to create inferior")); 489 } 490 491 void 492 target_terminal_inferior (void) 493 { 494 /* A background resume (``run&'') should leave GDB in control of the 495 terminal. Use target_can_async_p, not target_is_async_p, since at 496 this point the target is not async yet. However, if sync_execution 497 is not set, we know it will become async prior to resume. */ 498 if (target_can_async_p () && !sync_execution) 499 return; 500 501 /* If GDB is resuming the inferior in the foreground, install 502 inferior's terminal modes. */ 503 (*current_target.to_terminal_inferior) (); 504 } 505 506 static int 507 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write, 508 struct target_ops *t) 509 { 510 errno = EIO; /* Can't read/write this location. */ 511 return 0; /* No bytes handled. */ 512 } 513 514 static void 515 tcomplain (void) 516 { 517 error (_("You can't do that when your target is `%s'"), 518 current_target.to_shortname); 519 } 520 521 void 522 noprocess (void) 523 { 524 error (_("You can't do that without a process to debug.")); 525 } 526 527 static void 528 default_terminal_info (char *args, int from_tty) 529 { 530 printf_unfiltered (_("No saved terminal information.\n")); 531 } 532 533 /* A default implementation for the to_get_ada_task_ptid target method. 534 535 This function builds the PTID by using both LWP and TID as part of 536 the PTID lwp and tid elements. The pid used is the pid of the 537 inferior_ptid. */ 538 539 static ptid_t 540 default_get_ada_task_ptid (long lwp, long tid) 541 { 542 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid); 543 } 544 545 static enum exec_direction_kind 546 default_execution_direction (void) 547 { 548 if (!target_can_execute_reverse) 549 return EXEC_FORWARD; 550 else if (!target_can_async_p ()) 551 return EXEC_FORWARD; 552 else 553 gdb_assert_not_reached ("\ 554 to_execution_direction must be implemented for reverse async"); 555 } 556 557 /* Go through the target stack from top to bottom, copying over zero 558 entries in current_target, then filling in still empty entries. In 559 effect, we are doing class inheritance through the pushed target 560 vectors. 561 562 NOTE: cagney/2003-10-17: The problem with this inheritance, as it 563 is currently implemented, is that it discards any knowledge of 564 which target an inherited method originally belonged to. 565 Consequently, new new target methods should instead explicitly and 566 locally search the target stack for the target that can handle the 567 request. */ 568 569 static void 570 update_current_target (void) 571 { 572 struct target_ops *t; 573 574 /* First, reset current's contents. */ 575 memset (¤t_target, 0, sizeof (current_target)); 576 577 #define INHERIT(FIELD, TARGET) \ 578 if (!current_target.FIELD) \ 579 current_target.FIELD = (TARGET)->FIELD 580 581 for (t = target_stack; t; t = t->beneath) 582 { 583 INHERIT (to_shortname, t); 584 INHERIT (to_longname, t); 585 INHERIT (to_doc, t); 586 /* Do not inherit to_open. */ 587 /* Do not inherit to_close. */ 588 /* Do not inherit to_attach. */ 589 INHERIT (to_post_attach, t); 590 INHERIT (to_attach_no_wait, t); 591 /* Do not inherit to_detach. */ 592 /* Do not inherit to_disconnect. */ 593 /* Do not inherit to_resume. */ 594 /* Do not inherit to_wait. */ 595 /* Do not inherit to_fetch_registers. */ 596 /* Do not inherit to_store_registers. */ 597 INHERIT (to_prepare_to_store, t); 598 INHERIT (deprecated_xfer_memory, t); 599 INHERIT (to_files_info, t); 600 INHERIT (to_insert_breakpoint, t); 601 INHERIT (to_remove_breakpoint, t); 602 INHERIT (to_can_use_hw_breakpoint, t); 603 INHERIT (to_insert_hw_breakpoint, t); 604 INHERIT (to_remove_hw_breakpoint, t); 605 /* Do not inherit to_ranged_break_num_registers. */ 606 INHERIT (to_insert_watchpoint, t); 607 INHERIT (to_remove_watchpoint, t); 608 /* Do not inherit to_insert_mask_watchpoint. */ 609 /* Do not inherit to_remove_mask_watchpoint. */ 610 INHERIT (to_stopped_data_address, t); 611 INHERIT (to_have_steppable_watchpoint, t); 612 INHERIT (to_have_continuable_watchpoint, t); 613 INHERIT (to_stopped_by_watchpoint, t); 614 INHERIT (to_watchpoint_addr_within_range, t); 615 INHERIT (to_region_ok_for_hw_watchpoint, t); 616 INHERIT (to_can_accel_watchpoint_condition, t); 617 /* Do not inherit to_masked_watch_num_registers. */ 618 INHERIT (to_terminal_init, t); 619 INHERIT (to_terminal_inferior, t); 620 INHERIT (to_terminal_ours_for_output, t); 621 INHERIT (to_terminal_ours, t); 622 INHERIT (to_terminal_save_ours, t); 623 INHERIT (to_terminal_info, t); 624 /* Do not inherit to_kill. */ 625 INHERIT (to_load, t); 626 /* Do no inherit to_create_inferior. */ 627 INHERIT (to_post_startup_inferior, t); 628 INHERIT (to_insert_fork_catchpoint, t); 629 INHERIT (to_remove_fork_catchpoint, t); 630 INHERIT (to_insert_vfork_catchpoint, t); 631 INHERIT (to_remove_vfork_catchpoint, t); 632 /* Do not inherit to_follow_fork. */ 633 INHERIT (to_insert_exec_catchpoint, t); 634 INHERIT (to_remove_exec_catchpoint, t); 635 INHERIT (to_set_syscall_catchpoint, t); 636 INHERIT (to_has_exited, t); 637 /* Do not inherit to_mourn_inferior. */ 638 INHERIT (to_can_run, t); 639 /* Do not inherit to_pass_signals. */ 640 /* Do not inherit to_thread_alive. */ 641 /* Do not inherit to_find_new_threads. */ 642 /* Do not inherit to_pid_to_str. */ 643 INHERIT (to_extra_thread_info, t); 644 INHERIT (to_thread_name, t); 645 INHERIT (to_stop, t); 646 /* Do not inherit to_xfer_partial. */ 647 INHERIT (to_rcmd, t); 648 INHERIT (to_pid_to_exec_file, t); 649 INHERIT (to_log_command, t); 650 INHERIT (to_stratum, t); 651 /* Do not inherit to_has_all_memory. */ 652 /* Do not inherit to_has_memory. */ 653 /* Do not inherit to_has_stack. */ 654 /* Do not inherit to_has_registers. */ 655 /* Do not inherit to_has_execution. */ 656 INHERIT (to_has_thread_control, t); 657 INHERIT (to_can_async_p, t); 658 INHERIT (to_is_async_p, t); 659 INHERIT (to_async, t); 660 INHERIT (to_find_memory_regions, t); 661 INHERIT (to_make_corefile_notes, t); 662 INHERIT (to_get_bookmark, t); 663 INHERIT (to_goto_bookmark, t); 664 /* Do not inherit to_get_thread_local_address. */ 665 INHERIT (to_can_execute_reverse, t); 666 INHERIT (to_execution_direction, t); 667 INHERIT (to_thread_architecture, t); 668 /* Do not inherit to_read_description. */ 669 INHERIT (to_get_ada_task_ptid, t); 670 /* Do not inherit to_search_memory. */ 671 INHERIT (to_supports_multi_process, t); 672 INHERIT (to_supports_enable_disable_tracepoint, t); 673 INHERIT (to_supports_string_tracing, t); 674 INHERIT (to_trace_init, t); 675 INHERIT (to_download_tracepoint, t); 676 INHERIT (to_can_download_tracepoint, t); 677 INHERIT (to_download_trace_state_variable, t); 678 INHERIT (to_enable_tracepoint, t); 679 INHERIT (to_disable_tracepoint, t); 680 INHERIT (to_trace_set_readonly_regions, t); 681 INHERIT (to_trace_start, t); 682 INHERIT (to_get_trace_status, t); 683 INHERIT (to_get_tracepoint_status, t); 684 INHERIT (to_trace_stop, t); 685 INHERIT (to_trace_find, t); 686 INHERIT (to_get_trace_state_variable_value, t); 687 INHERIT (to_save_trace_data, t); 688 INHERIT (to_upload_tracepoints, t); 689 INHERIT (to_upload_trace_state_variables, t); 690 INHERIT (to_get_raw_trace_data, t); 691 INHERIT (to_get_min_fast_tracepoint_insn_len, t); 692 INHERIT (to_set_disconnected_tracing, t); 693 INHERIT (to_set_circular_trace_buffer, t); 694 INHERIT (to_set_trace_notes, t); 695 INHERIT (to_get_tib_address, t); 696 INHERIT (to_set_permissions, t); 697 INHERIT (to_static_tracepoint_marker_at, t); 698 INHERIT (to_static_tracepoint_markers_by_strid, t); 699 INHERIT (to_traceframe_info, t); 700 INHERIT (to_magic, t); 701 /* Do not inherit to_memory_map. */ 702 /* Do not inherit to_flash_erase. */ 703 /* Do not inherit to_flash_done. */ 704 } 705 #undef INHERIT 706 707 /* Clean up a target struct so it no longer has any zero pointers in 708 it. Some entries are defaulted to a method that print an error, 709 others are hard-wired to a standard recursive default. */ 710 711 #define de_fault(field, value) \ 712 if (!current_target.field) \ 713 current_target.field = value 714 715 de_fault (to_open, 716 (void (*) (char *, int)) 717 tcomplain); 718 de_fault (to_close, 719 (void (*) (int)) 720 target_ignore); 721 de_fault (to_post_attach, 722 (void (*) (int)) 723 target_ignore); 724 de_fault (to_prepare_to_store, 725 (void (*) (struct regcache *)) 726 noprocess); 727 de_fault (deprecated_xfer_memory, 728 (int (*) (CORE_ADDR, gdb_byte *, int, int, 729 struct mem_attrib *, struct target_ops *)) 730 nomemory); 731 de_fault (to_files_info, 732 (void (*) (struct target_ops *)) 733 target_ignore); 734 de_fault (to_insert_breakpoint, 735 memory_insert_breakpoint); 736 de_fault (to_remove_breakpoint, 737 memory_remove_breakpoint); 738 de_fault (to_can_use_hw_breakpoint, 739 (int (*) (int, int, int)) 740 return_zero); 741 de_fault (to_insert_hw_breakpoint, 742 (int (*) (struct gdbarch *, struct bp_target_info *)) 743 return_minus_one); 744 de_fault (to_remove_hw_breakpoint, 745 (int (*) (struct gdbarch *, struct bp_target_info *)) 746 return_minus_one); 747 de_fault (to_insert_watchpoint, 748 (int (*) (CORE_ADDR, int, int, struct expression *)) 749 return_minus_one); 750 de_fault (to_remove_watchpoint, 751 (int (*) (CORE_ADDR, int, int, struct expression *)) 752 return_minus_one); 753 de_fault (to_stopped_by_watchpoint, 754 (int (*) (void)) 755 return_zero); 756 de_fault (to_stopped_data_address, 757 (int (*) (struct target_ops *, CORE_ADDR *)) 758 return_zero); 759 de_fault (to_watchpoint_addr_within_range, 760 default_watchpoint_addr_within_range); 761 de_fault (to_region_ok_for_hw_watchpoint, 762 default_region_ok_for_hw_watchpoint); 763 de_fault (to_can_accel_watchpoint_condition, 764 (int (*) (CORE_ADDR, int, int, struct expression *)) 765 return_zero); 766 de_fault (to_terminal_init, 767 (void (*) (void)) 768 target_ignore); 769 de_fault (to_terminal_inferior, 770 (void (*) (void)) 771 target_ignore); 772 de_fault (to_terminal_ours_for_output, 773 (void (*) (void)) 774 target_ignore); 775 de_fault (to_terminal_ours, 776 (void (*) (void)) 777 target_ignore); 778 de_fault (to_terminal_save_ours, 779 (void (*) (void)) 780 target_ignore); 781 de_fault (to_terminal_info, 782 default_terminal_info); 783 de_fault (to_load, 784 (void (*) (char *, int)) 785 tcomplain); 786 de_fault (to_post_startup_inferior, 787 (void (*) (ptid_t)) 788 target_ignore); 789 de_fault (to_insert_fork_catchpoint, 790 (int (*) (int)) 791 return_one); 792 de_fault (to_remove_fork_catchpoint, 793 (int (*) (int)) 794 return_one); 795 de_fault (to_insert_vfork_catchpoint, 796 (int (*) (int)) 797 return_one); 798 de_fault (to_remove_vfork_catchpoint, 799 (int (*) (int)) 800 return_one); 801 de_fault (to_insert_exec_catchpoint, 802 (int (*) (int)) 803 return_one); 804 de_fault (to_remove_exec_catchpoint, 805 (int (*) (int)) 806 return_one); 807 de_fault (to_set_syscall_catchpoint, 808 (int (*) (int, int, int, int, int *)) 809 return_one); 810 de_fault (to_has_exited, 811 (int (*) (int, int, int *)) 812 return_zero); 813 de_fault (to_can_run, 814 return_zero); 815 de_fault (to_extra_thread_info, 816 (char *(*) (struct thread_info *)) 817 return_zero); 818 de_fault (to_thread_name, 819 (char *(*) (struct thread_info *)) 820 return_zero); 821 de_fault (to_stop, 822 (void (*) (ptid_t)) 823 target_ignore); 824 current_target.to_xfer_partial = current_xfer_partial; 825 de_fault (to_rcmd, 826 (void (*) (char *, struct ui_file *)) 827 tcomplain); 828 de_fault (to_pid_to_exec_file, 829 (char *(*) (int)) 830 return_zero); 831 de_fault (to_async, 832 (void (*) (void (*) (enum inferior_event_type, void*), void*)) 833 tcomplain); 834 de_fault (to_thread_architecture, 835 default_thread_architecture); 836 current_target.to_read_description = NULL; 837 de_fault (to_get_ada_task_ptid, 838 (ptid_t (*) (long, long)) 839 default_get_ada_task_ptid); 840 de_fault (to_supports_multi_process, 841 (int (*) (void)) 842 return_zero); 843 de_fault (to_supports_enable_disable_tracepoint, 844 (int (*) (void)) 845 return_zero); 846 de_fault (to_supports_string_tracing, 847 (int (*) (void)) 848 return_zero); 849 de_fault (to_trace_init, 850 (void (*) (void)) 851 tcomplain); 852 de_fault (to_download_tracepoint, 853 (void (*) (struct bp_location *)) 854 tcomplain); 855 de_fault (to_can_download_tracepoint, 856 (int (*) (void)) 857 return_zero); 858 de_fault (to_download_trace_state_variable, 859 (void (*) (struct trace_state_variable *)) 860 tcomplain); 861 de_fault (to_enable_tracepoint, 862 (void (*) (struct bp_location *)) 863 tcomplain); 864 de_fault (to_disable_tracepoint, 865 (void (*) (struct bp_location *)) 866 tcomplain); 867 de_fault (to_trace_set_readonly_regions, 868 (void (*) (void)) 869 tcomplain); 870 de_fault (to_trace_start, 871 (void (*) (void)) 872 tcomplain); 873 de_fault (to_get_trace_status, 874 (int (*) (struct trace_status *)) 875 return_minus_one); 876 de_fault (to_get_tracepoint_status, 877 (void (*) (struct breakpoint *, struct uploaded_tp *)) 878 tcomplain); 879 de_fault (to_trace_stop, 880 (void (*) (void)) 881 tcomplain); 882 de_fault (to_trace_find, 883 (int (*) (enum trace_find_type, int, ULONGEST, ULONGEST, int *)) 884 return_minus_one); 885 de_fault (to_get_trace_state_variable_value, 886 (int (*) (int, LONGEST *)) 887 return_zero); 888 de_fault (to_save_trace_data, 889 (int (*) (const char *)) 890 tcomplain); 891 de_fault (to_upload_tracepoints, 892 (int (*) (struct uploaded_tp **)) 893 return_zero); 894 de_fault (to_upload_trace_state_variables, 895 (int (*) (struct uploaded_tsv **)) 896 return_zero); 897 de_fault (to_get_raw_trace_data, 898 (LONGEST (*) (gdb_byte *, ULONGEST, LONGEST)) 899 tcomplain); 900 de_fault (to_get_min_fast_tracepoint_insn_len, 901 (int (*) (void)) 902 return_minus_one); 903 de_fault (to_set_disconnected_tracing, 904 (void (*) (int)) 905 target_ignore); 906 de_fault (to_set_circular_trace_buffer, 907 (void (*) (int)) 908 target_ignore); 909 de_fault (to_set_trace_notes, 910 (int (*) (char *, char *, char *)) 911 return_zero); 912 de_fault (to_get_tib_address, 913 (int (*) (ptid_t, CORE_ADDR *)) 914 tcomplain); 915 de_fault (to_set_permissions, 916 (void (*) (void)) 917 target_ignore); 918 de_fault (to_static_tracepoint_marker_at, 919 (int (*) (CORE_ADDR, struct static_tracepoint_marker *)) 920 return_zero); 921 de_fault (to_static_tracepoint_markers_by_strid, 922 (VEC(static_tracepoint_marker_p) * (*) (const char *)) 923 tcomplain); 924 de_fault (to_traceframe_info, 925 (struct traceframe_info * (*) (void)) 926 tcomplain); 927 de_fault (to_execution_direction, default_execution_direction); 928 929 #undef de_fault 930 931 /* Finally, position the target-stack beneath the squashed 932 "current_target". That way code looking for a non-inherited 933 target method can quickly and simply find it. */ 934 current_target.beneath = target_stack; 935 936 if (targetdebug) 937 setup_target_debug (); 938 } 939 940 /* Push a new target type into the stack of the existing target accessors, 941 possibly superseding some of the existing accessors. 942 943 Rather than allow an empty stack, we always have the dummy target at 944 the bottom stratum, so we can call the function vectors without 945 checking them. */ 946 947 void 948 push_target (struct target_ops *t) 949 { 950 struct target_ops **cur; 951 952 /* Check magic number. If wrong, it probably means someone changed 953 the struct definition, but not all the places that initialize one. */ 954 if (t->to_magic != OPS_MAGIC) 955 { 956 fprintf_unfiltered (gdb_stderr, 957 "Magic number of %s target struct wrong\n", 958 t->to_shortname); 959 internal_error (__FILE__, __LINE__, 960 _("failed internal consistency check")); 961 } 962 963 /* Find the proper stratum to install this target in. */ 964 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath) 965 { 966 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum) 967 break; 968 } 969 970 /* If there's already targets at this stratum, remove them. */ 971 /* FIXME: cagney/2003-10-15: I think this should be popping all 972 targets to CUR, and not just those at this stratum level. */ 973 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum) 974 { 975 /* There's already something at this stratum level. Close it, 976 and un-hook it from the stack. */ 977 struct target_ops *tmp = (*cur); 978 979 (*cur) = (*cur)->beneath; 980 tmp->beneath = NULL; 981 target_close (tmp, 0); 982 } 983 984 /* We have removed all targets in our stratum, now add the new one. */ 985 t->beneath = (*cur); 986 (*cur) = t; 987 988 update_current_target (); 989 } 990 991 /* Remove a target_ops vector from the stack, wherever it may be. 992 Return how many times it was removed (0 or 1). */ 993 994 int 995 unpush_target (struct target_ops *t) 996 { 997 struct target_ops **cur; 998 struct target_ops *tmp; 999 1000 if (t->to_stratum == dummy_stratum) 1001 internal_error (__FILE__, __LINE__, 1002 _("Attempt to unpush the dummy target")); 1003 1004 /* Look for the specified target. Note that we assume that a target 1005 can only occur once in the target stack. */ 1006 1007 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath) 1008 { 1009 if ((*cur) == t) 1010 break; 1011 } 1012 1013 if ((*cur) == NULL) 1014 return 0; /* Didn't find target_ops, quit now. */ 1015 1016 /* NOTE: cagney/2003-12-06: In '94 the close call was made 1017 unconditional by moving it to before the above check that the 1018 target was in the target stack (something about "Change the way 1019 pushing and popping of targets work to support target overlays 1020 and inheritance"). This doesn't make much sense - only open 1021 targets should be closed. */ 1022 target_close (t, 0); 1023 1024 /* Unchain the target. */ 1025 tmp = (*cur); 1026 (*cur) = (*cur)->beneath; 1027 tmp->beneath = NULL; 1028 1029 update_current_target (); 1030 1031 return 1; 1032 } 1033 1034 void 1035 pop_target (void) 1036 { 1037 target_close (target_stack, 0); /* Let it clean up. */ 1038 if (unpush_target (target_stack) == 1) 1039 return; 1040 1041 fprintf_unfiltered (gdb_stderr, 1042 "pop_target couldn't find target %s\n", 1043 current_target.to_shortname); 1044 internal_error (__FILE__, __LINE__, 1045 _("failed internal consistency check")); 1046 } 1047 1048 void 1049 pop_all_targets_above (enum strata above_stratum, int quitting) 1050 { 1051 while ((int) (current_target.to_stratum) > (int) above_stratum) 1052 { 1053 target_close (target_stack, quitting); 1054 if (!unpush_target (target_stack)) 1055 { 1056 fprintf_unfiltered (gdb_stderr, 1057 "pop_all_targets couldn't find target %s\n", 1058 target_stack->to_shortname); 1059 internal_error (__FILE__, __LINE__, 1060 _("failed internal consistency check")); 1061 break; 1062 } 1063 } 1064 } 1065 1066 void 1067 pop_all_targets (int quitting) 1068 { 1069 pop_all_targets_above (dummy_stratum, quitting); 1070 } 1071 1072 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */ 1073 1074 int 1075 target_is_pushed (struct target_ops *t) 1076 { 1077 struct target_ops **cur; 1078 1079 /* Check magic number. If wrong, it probably means someone changed 1080 the struct definition, but not all the places that initialize one. */ 1081 if (t->to_magic != OPS_MAGIC) 1082 { 1083 fprintf_unfiltered (gdb_stderr, 1084 "Magic number of %s target struct wrong\n", 1085 t->to_shortname); 1086 internal_error (__FILE__, __LINE__, 1087 _("failed internal consistency check")); 1088 } 1089 1090 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath) 1091 if (*cur == t) 1092 return 1; 1093 1094 return 0; 1095 } 1096 1097 /* Using the objfile specified in OBJFILE, find the address for the 1098 current thread's thread-local storage with offset OFFSET. */ 1099 CORE_ADDR 1100 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset) 1101 { 1102 volatile CORE_ADDR addr = 0; 1103 struct target_ops *target; 1104 1105 for (target = current_target.beneath; 1106 target != NULL; 1107 target = target->beneath) 1108 { 1109 if (target->to_get_thread_local_address != NULL) 1110 break; 1111 } 1112 1113 if (target != NULL 1114 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch)) 1115 { 1116 ptid_t ptid = inferior_ptid; 1117 volatile struct gdb_exception ex; 1118 1119 TRY_CATCH (ex, RETURN_MASK_ALL) 1120 { 1121 CORE_ADDR lm_addr; 1122 1123 /* Fetch the load module address for this objfile. */ 1124 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch, 1125 objfile); 1126 /* If it's 0, throw the appropriate exception. */ 1127 if (lm_addr == 0) 1128 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR, 1129 _("TLS load module not found")); 1130 1131 addr = target->to_get_thread_local_address (target, ptid, 1132 lm_addr, offset); 1133 } 1134 /* If an error occurred, print TLS related messages here. Otherwise, 1135 throw the error to some higher catcher. */ 1136 if (ex.reason < 0) 1137 { 1138 int objfile_is_library = (objfile->flags & OBJF_SHARED); 1139 1140 switch (ex.error) 1141 { 1142 case TLS_NO_LIBRARY_SUPPORT_ERROR: 1143 error (_("Cannot find thread-local variables " 1144 "in this thread library.")); 1145 break; 1146 case TLS_LOAD_MODULE_NOT_FOUND_ERROR: 1147 if (objfile_is_library) 1148 error (_("Cannot find shared library `%s' in dynamic" 1149 " linker's load module list"), objfile->name); 1150 else 1151 error (_("Cannot find executable file `%s' in dynamic" 1152 " linker's load module list"), objfile->name); 1153 break; 1154 case TLS_NOT_ALLOCATED_YET_ERROR: 1155 if (objfile_is_library) 1156 error (_("The inferior has not yet allocated storage for" 1157 " thread-local variables in\n" 1158 "the shared library `%s'\n" 1159 "for %s"), 1160 objfile->name, target_pid_to_str (ptid)); 1161 else 1162 error (_("The inferior has not yet allocated storage for" 1163 " thread-local variables in\n" 1164 "the executable `%s'\n" 1165 "for %s"), 1166 objfile->name, target_pid_to_str (ptid)); 1167 break; 1168 case TLS_GENERIC_ERROR: 1169 if (objfile_is_library) 1170 error (_("Cannot find thread-local storage for %s, " 1171 "shared library %s:\n%s"), 1172 target_pid_to_str (ptid), 1173 objfile->name, ex.message); 1174 else 1175 error (_("Cannot find thread-local storage for %s, " 1176 "executable file %s:\n%s"), 1177 target_pid_to_str (ptid), 1178 objfile->name, ex.message); 1179 break; 1180 default: 1181 throw_exception (ex); 1182 break; 1183 } 1184 } 1185 } 1186 /* It wouldn't be wrong here to try a gdbarch method, too; finding 1187 TLS is an ABI-specific thing. But we don't do that yet. */ 1188 else 1189 error (_("Cannot find thread-local variables on this target")); 1190 1191 return addr; 1192 } 1193 1194 #undef MIN 1195 #define MIN(A, B) (((A) <= (B)) ? (A) : (B)) 1196 1197 /* target_read_string -- read a null terminated string, up to LEN bytes, 1198 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful. 1199 Set *STRING to a pointer to malloc'd memory containing the data; the caller 1200 is responsible for freeing it. Return the number of bytes successfully 1201 read. */ 1202 1203 int 1204 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop) 1205 { 1206 int tlen, origlen, offset, i; 1207 gdb_byte buf[4]; 1208 int errcode = 0; 1209 char *buffer; 1210 int buffer_allocated; 1211 char *bufptr; 1212 unsigned int nbytes_read = 0; 1213 1214 gdb_assert (string); 1215 1216 /* Small for testing. */ 1217 buffer_allocated = 4; 1218 buffer = xmalloc (buffer_allocated); 1219 bufptr = buffer; 1220 1221 origlen = len; 1222 1223 while (len > 0) 1224 { 1225 tlen = MIN (len, 4 - (memaddr & 3)); 1226 offset = memaddr & 3; 1227 1228 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf); 1229 if (errcode != 0) 1230 { 1231 /* The transfer request might have crossed the boundary to an 1232 unallocated region of memory. Retry the transfer, requesting 1233 a single byte. */ 1234 tlen = 1; 1235 offset = 0; 1236 errcode = target_read_memory (memaddr, buf, 1); 1237 if (errcode != 0) 1238 goto done; 1239 } 1240 1241 if (bufptr - buffer + tlen > buffer_allocated) 1242 { 1243 unsigned int bytes; 1244 1245 bytes = bufptr - buffer; 1246 buffer_allocated *= 2; 1247 buffer = xrealloc (buffer, buffer_allocated); 1248 bufptr = buffer + bytes; 1249 } 1250 1251 for (i = 0; i < tlen; i++) 1252 { 1253 *bufptr++ = buf[i + offset]; 1254 if (buf[i + offset] == '\000') 1255 { 1256 nbytes_read += i + 1; 1257 goto done; 1258 } 1259 } 1260 1261 memaddr += tlen; 1262 len -= tlen; 1263 nbytes_read += tlen; 1264 } 1265 done: 1266 *string = buffer; 1267 if (errnop != NULL) 1268 *errnop = errcode; 1269 return nbytes_read; 1270 } 1271 1272 struct target_section_table * 1273 target_get_section_table (struct target_ops *target) 1274 { 1275 struct target_ops *t; 1276 1277 if (targetdebug) 1278 fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n"); 1279 1280 for (t = target; t != NULL; t = t->beneath) 1281 if (t->to_get_section_table != NULL) 1282 return (*t->to_get_section_table) (t); 1283 1284 return NULL; 1285 } 1286 1287 /* Find a section containing ADDR. */ 1288 1289 struct target_section * 1290 target_section_by_addr (struct target_ops *target, CORE_ADDR addr) 1291 { 1292 struct target_section_table *table = target_get_section_table (target); 1293 struct target_section *secp; 1294 1295 if (table == NULL) 1296 return NULL; 1297 1298 for (secp = table->sections; secp < table->sections_end; secp++) 1299 { 1300 if (addr >= secp->addr && addr < secp->endaddr) 1301 return secp; 1302 } 1303 return NULL; 1304 } 1305 1306 /* Read memory from the live target, even if currently inspecting a 1307 traceframe. The return is the same as that of target_read. */ 1308 1309 static LONGEST 1310 target_read_live_memory (enum target_object object, 1311 ULONGEST memaddr, gdb_byte *myaddr, LONGEST len) 1312 { 1313 int ret; 1314 struct cleanup *cleanup; 1315 1316 /* Switch momentarily out of tfind mode so to access live memory. 1317 Note that this must not clear global state, such as the frame 1318 cache, which must still remain valid for the previous traceframe. 1319 We may be _building_ the frame cache at this point. */ 1320 cleanup = make_cleanup_restore_traceframe_number (); 1321 set_traceframe_number (-1); 1322 1323 ret = target_read (current_target.beneath, object, NULL, 1324 myaddr, memaddr, len); 1325 1326 do_cleanups (cleanup); 1327 return ret; 1328 } 1329 1330 /* Using the set of read-only target sections of OPS, read live 1331 read-only memory. Note that the actual reads start from the 1332 top-most target again. 1333 1334 For interface/parameters/return description see target.h, 1335 to_xfer_partial. */ 1336 1337 static LONGEST 1338 memory_xfer_live_readonly_partial (struct target_ops *ops, 1339 enum target_object object, 1340 gdb_byte *readbuf, ULONGEST memaddr, 1341 LONGEST len) 1342 { 1343 struct target_section *secp; 1344 struct target_section_table *table; 1345 1346 secp = target_section_by_addr (ops, memaddr); 1347 if (secp != NULL 1348 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section) 1349 & SEC_READONLY)) 1350 { 1351 struct target_section *p; 1352 ULONGEST memend = memaddr + len; 1353 1354 table = target_get_section_table (ops); 1355 1356 for (p = table->sections; p < table->sections_end; p++) 1357 { 1358 if (memaddr >= p->addr) 1359 { 1360 if (memend <= p->endaddr) 1361 { 1362 /* Entire transfer is within this section. */ 1363 return target_read_live_memory (object, memaddr, 1364 readbuf, len); 1365 } 1366 else if (memaddr >= p->endaddr) 1367 { 1368 /* This section ends before the transfer starts. */ 1369 continue; 1370 } 1371 else 1372 { 1373 /* This section overlaps the transfer. Just do half. */ 1374 len = p->endaddr - memaddr; 1375 return target_read_live_memory (object, memaddr, 1376 readbuf, len); 1377 } 1378 } 1379 } 1380 } 1381 1382 return 0; 1383 } 1384 1385 /* Perform a partial memory transfer. 1386 For docs see target.h, to_xfer_partial. */ 1387 1388 static LONGEST 1389 memory_xfer_partial_1 (struct target_ops *ops, enum target_object object, 1390 void *readbuf, const void *writebuf, ULONGEST memaddr, 1391 LONGEST len) 1392 { 1393 LONGEST res; 1394 int reg_len; 1395 struct mem_region *region; 1396 struct inferior *inf; 1397 1398 /* For accesses to unmapped overlay sections, read directly from 1399 files. Must do this first, as MEMADDR may need adjustment. */ 1400 if (readbuf != NULL && overlay_debugging) 1401 { 1402 struct obj_section *section = find_pc_overlay (memaddr); 1403 1404 if (pc_in_unmapped_range (memaddr, section)) 1405 { 1406 struct target_section_table *table 1407 = target_get_section_table (ops); 1408 const char *section_name = section->the_bfd_section->name; 1409 1410 memaddr = overlay_mapped_address (memaddr, section); 1411 return section_table_xfer_memory_partial (readbuf, writebuf, 1412 memaddr, len, 1413 table->sections, 1414 table->sections_end, 1415 section_name); 1416 } 1417 } 1418 1419 /* Try the executable files, if "trust-readonly-sections" is set. */ 1420 if (readbuf != NULL && trust_readonly) 1421 { 1422 struct target_section *secp; 1423 struct target_section_table *table; 1424 1425 secp = target_section_by_addr (ops, memaddr); 1426 if (secp != NULL 1427 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section) 1428 & SEC_READONLY)) 1429 { 1430 table = target_get_section_table (ops); 1431 return section_table_xfer_memory_partial (readbuf, writebuf, 1432 memaddr, len, 1433 table->sections, 1434 table->sections_end, 1435 NULL); 1436 } 1437 } 1438 1439 /* If reading unavailable memory in the context of traceframes, and 1440 this address falls within a read-only section, fallback to 1441 reading from live memory. */ 1442 if (readbuf != NULL && get_traceframe_number () != -1) 1443 { 1444 VEC(mem_range_s) *available; 1445 1446 /* If we fail to get the set of available memory, then the 1447 target does not support querying traceframe info, and so we 1448 attempt reading from the traceframe anyway (assuming the 1449 target implements the old QTro packet then). */ 1450 if (traceframe_available_memory (&available, memaddr, len)) 1451 { 1452 struct cleanup *old_chain; 1453 1454 old_chain = make_cleanup (VEC_cleanup(mem_range_s), &available); 1455 1456 if (VEC_empty (mem_range_s, available) 1457 || VEC_index (mem_range_s, available, 0)->start != memaddr) 1458 { 1459 /* Don't read into the traceframe's available 1460 memory. */ 1461 if (!VEC_empty (mem_range_s, available)) 1462 { 1463 LONGEST oldlen = len; 1464 1465 len = VEC_index (mem_range_s, available, 0)->start - memaddr; 1466 gdb_assert (len <= oldlen); 1467 } 1468 1469 do_cleanups (old_chain); 1470 1471 /* This goes through the topmost target again. */ 1472 res = memory_xfer_live_readonly_partial (ops, object, 1473 readbuf, memaddr, len); 1474 if (res > 0) 1475 return res; 1476 1477 /* No use trying further, we know some memory starting 1478 at MEMADDR isn't available. */ 1479 return -1; 1480 } 1481 1482 /* Don't try to read more than how much is available, in 1483 case the target implements the deprecated QTro packet to 1484 cater for older GDBs (the target's knowledge of read-only 1485 sections may be outdated by now). */ 1486 len = VEC_index (mem_range_s, available, 0)->length; 1487 1488 do_cleanups (old_chain); 1489 } 1490 } 1491 1492 /* Try GDB's internal data cache. */ 1493 region = lookup_mem_region (memaddr); 1494 /* region->hi == 0 means there's no upper bound. */ 1495 if (memaddr + len < region->hi || region->hi == 0) 1496 reg_len = len; 1497 else 1498 reg_len = region->hi - memaddr; 1499 1500 switch (region->attrib.mode) 1501 { 1502 case MEM_RO: 1503 if (writebuf != NULL) 1504 return -1; 1505 break; 1506 1507 case MEM_WO: 1508 if (readbuf != NULL) 1509 return -1; 1510 break; 1511 1512 case MEM_FLASH: 1513 /* We only support writing to flash during "load" for now. */ 1514 if (writebuf != NULL) 1515 error (_("Writing to flash memory forbidden in this context")); 1516 break; 1517 1518 case MEM_NONE: 1519 return -1; 1520 } 1521 1522 if (!ptid_equal (inferior_ptid, null_ptid)) 1523 inf = find_inferior_pid (ptid_get_pid (inferior_ptid)); 1524 else 1525 inf = NULL; 1526 1527 if (inf != NULL 1528 /* The dcache reads whole cache lines; that doesn't play well 1529 with reading from a trace buffer, because reading outside of 1530 the collected memory range fails. */ 1531 && get_traceframe_number () == -1 1532 && (region->attrib.cache 1533 || (stack_cache_enabled_p && object == TARGET_OBJECT_STACK_MEMORY))) 1534 { 1535 if (readbuf != NULL) 1536 res = dcache_xfer_memory (ops, target_dcache, memaddr, readbuf, 1537 reg_len, 0); 1538 else 1539 /* FIXME drow/2006-08-09: If we're going to preserve const 1540 correctness dcache_xfer_memory should take readbuf and 1541 writebuf. */ 1542 res = dcache_xfer_memory (ops, target_dcache, memaddr, 1543 (void *) writebuf, 1544 reg_len, 1); 1545 if (res <= 0) 1546 return -1; 1547 else 1548 return res; 1549 } 1550 1551 /* If none of those methods found the memory we wanted, fall back 1552 to a target partial transfer. Normally a single call to 1553 to_xfer_partial is enough; if it doesn't recognize an object 1554 it will call the to_xfer_partial of the next target down. 1555 But for memory this won't do. Memory is the only target 1556 object which can be read from more than one valid target. 1557 A core file, for instance, could have some of memory but 1558 delegate other bits to the target below it. So, we must 1559 manually try all targets. */ 1560 1561 do 1562 { 1563 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL, 1564 readbuf, writebuf, memaddr, reg_len); 1565 if (res > 0) 1566 break; 1567 1568 /* We want to continue past core files to executables, but not 1569 past a running target's memory. */ 1570 if (ops->to_has_all_memory (ops)) 1571 break; 1572 1573 ops = ops->beneath; 1574 } 1575 while (ops != NULL); 1576 1577 /* Make sure the cache gets updated no matter what - if we are writing 1578 to the stack. Even if this write is not tagged as such, we still need 1579 to update the cache. */ 1580 1581 if (res > 0 1582 && inf != NULL 1583 && writebuf != NULL 1584 && !region->attrib.cache 1585 && stack_cache_enabled_p 1586 && object != TARGET_OBJECT_STACK_MEMORY) 1587 { 1588 dcache_update (target_dcache, memaddr, (void *) writebuf, res); 1589 } 1590 1591 /* If we still haven't got anything, return the last error. We 1592 give up. */ 1593 return res; 1594 } 1595 1596 /* Perform a partial memory transfer. For docs see target.h, 1597 to_xfer_partial. */ 1598 1599 static LONGEST 1600 memory_xfer_partial (struct target_ops *ops, enum target_object object, 1601 void *readbuf, const void *writebuf, ULONGEST memaddr, 1602 LONGEST len) 1603 { 1604 int res; 1605 1606 /* Zero length requests are ok and require no work. */ 1607 if (len == 0) 1608 return 0; 1609 1610 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with 1611 breakpoint insns, thus hiding out from higher layers whether 1612 there are software breakpoints inserted in the code stream. */ 1613 if (readbuf != NULL) 1614 { 1615 res = memory_xfer_partial_1 (ops, object, readbuf, NULL, memaddr, len); 1616 1617 if (res > 0 && !show_memory_breakpoints) 1618 breakpoint_xfer_memory (readbuf, NULL, NULL, memaddr, res); 1619 } 1620 else 1621 { 1622 void *buf; 1623 struct cleanup *old_chain; 1624 1625 buf = xmalloc (len); 1626 old_chain = make_cleanup (xfree, buf); 1627 memcpy (buf, writebuf, len); 1628 1629 breakpoint_xfer_memory (NULL, buf, writebuf, memaddr, len); 1630 res = memory_xfer_partial_1 (ops, object, NULL, buf, memaddr, len); 1631 1632 do_cleanups (old_chain); 1633 } 1634 1635 return res; 1636 } 1637 1638 static void 1639 restore_show_memory_breakpoints (void *arg) 1640 { 1641 show_memory_breakpoints = (uintptr_t) arg; 1642 } 1643 1644 struct cleanup * 1645 make_show_memory_breakpoints_cleanup (int show) 1646 { 1647 int current = show_memory_breakpoints; 1648 1649 show_memory_breakpoints = show; 1650 return make_cleanup (restore_show_memory_breakpoints, 1651 (void *) (uintptr_t) current); 1652 } 1653 1654 /* For docs see target.h, to_xfer_partial. */ 1655 1656 static LONGEST 1657 target_xfer_partial (struct target_ops *ops, 1658 enum target_object object, const char *annex, 1659 void *readbuf, const void *writebuf, 1660 ULONGEST offset, LONGEST len) 1661 { 1662 LONGEST retval; 1663 1664 gdb_assert (ops->to_xfer_partial != NULL); 1665 1666 if (writebuf && !may_write_memory) 1667 error (_("Writing to memory is not allowed (addr %s, len %s)"), 1668 core_addr_to_string_nz (offset), plongest (len)); 1669 1670 /* If this is a memory transfer, let the memory-specific code 1671 have a look at it instead. Memory transfers are more 1672 complicated. */ 1673 if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY) 1674 retval = memory_xfer_partial (ops, object, readbuf, 1675 writebuf, offset, len); 1676 else 1677 { 1678 enum target_object raw_object = object; 1679 1680 /* If this is a raw memory transfer, request the normal 1681 memory object from other layers. */ 1682 if (raw_object == TARGET_OBJECT_RAW_MEMORY) 1683 raw_object = TARGET_OBJECT_MEMORY; 1684 1685 retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf, 1686 writebuf, offset, len); 1687 } 1688 1689 if (targetdebug) 1690 { 1691 const unsigned char *myaddr = NULL; 1692 1693 fprintf_unfiltered (gdb_stdlog, 1694 "%s:target_xfer_partial " 1695 "(%d, %s, %s, %s, %s, %s) = %s", 1696 ops->to_shortname, 1697 (int) object, 1698 (annex ? annex : "(null)"), 1699 host_address_to_string (readbuf), 1700 host_address_to_string (writebuf), 1701 core_addr_to_string_nz (offset), 1702 plongest (len), plongest (retval)); 1703 1704 if (readbuf) 1705 myaddr = readbuf; 1706 if (writebuf) 1707 myaddr = writebuf; 1708 if (retval > 0 && myaddr != NULL) 1709 { 1710 int i; 1711 1712 fputs_unfiltered (", bytes =", gdb_stdlog); 1713 for (i = 0; i < retval; i++) 1714 { 1715 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0) 1716 { 1717 if (targetdebug < 2 && i > 0) 1718 { 1719 fprintf_unfiltered (gdb_stdlog, " ..."); 1720 break; 1721 } 1722 fprintf_unfiltered (gdb_stdlog, "\n"); 1723 } 1724 1725 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff); 1726 } 1727 } 1728 1729 fputc_unfiltered ('\n', gdb_stdlog); 1730 } 1731 return retval; 1732 } 1733 1734 /* Read LEN bytes of target memory at address MEMADDR, placing the results in 1735 GDB's memory at MYADDR. Returns either 0 for success or an errno value 1736 if any error occurs. 1737 1738 If an error occurs, no guarantee is made about the contents of the data at 1739 MYADDR. In particular, the caller should not depend upon partial reads 1740 filling the buffer with good data. There is no way for the caller to know 1741 how much good data might have been transfered anyway. Callers that can 1742 deal with partial reads should call target_read (which will retry until 1743 it makes no progress, and then return how much was transferred). */ 1744 1745 int 1746 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len) 1747 { 1748 /* Dispatch to the topmost target, not the flattened current_target. 1749 Memory accesses check target->to_has_(all_)memory, and the 1750 flattened target doesn't inherit those. */ 1751 if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL, 1752 myaddr, memaddr, len) == len) 1753 return 0; 1754 else 1755 return EIO; 1756 } 1757 1758 /* Like target_read_memory, but specify explicitly that this is a read from 1759 the target's stack. This may trigger different cache behavior. */ 1760 1761 int 1762 target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len) 1763 { 1764 /* Dispatch to the topmost target, not the flattened current_target. 1765 Memory accesses check target->to_has_(all_)memory, and the 1766 flattened target doesn't inherit those. */ 1767 1768 if (target_read (current_target.beneath, TARGET_OBJECT_STACK_MEMORY, NULL, 1769 myaddr, memaddr, len) == len) 1770 return 0; 1771 else 1772 return EIO; 1773 } 1774 1775 /* Write LEN bytes from MYADDR to target memory at address MEMADDR. 1776 Returns either 0 for success or an errno value if any error occurs. 1777 If an error occurs, no guarantee is made about how much data got written. 1778 Callers that can deal with partial writes should call target_write. */ 1779 1780 int 1781 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len) 1782 { 1783 /* Dispatch to the topmost target, not the flattened current_target. 1784 Memory accesses check target->to_has_(all_)memory, and the 1785 flattened target doesn't inherit those. */ 1786 if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL, 1787 myaddr, memaddr, len) == len) 1788 return 0; 1789 else 1790 return EIO; 1791 } 1792 1793 /* Write LEN bytes from MYADDR to target raw memory at address 1794 MEMADDR. Returns either 0 for success or an errno value if any 1795 error occurs. If an error occurs, no guarantee is made about how 1796 much data got written. Callers that can deal with partial writes 1797 should call target_write. */ 1798 1799 int 1800 target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len) 1801 { 1802 /* Dispatch to the topmost target, not the flattened current_target. 1803 Memory accesses check target->to_has_(all_)memory, and the 1804 flattened target doesn't inherit those. */ 1805 if (target_write (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL, 1806 myaddr, memaddr, len) == len) 1807 return 0; 1808 else 1809 return EIO; 1810 } 1811 1812 /* Fetch the target's memory map. */ 1813 1814 VEC(mem_region_s) * 1815 target_memory_map (void) 1816 { 1817 VEC(mem_region_s) *result; 1818 struct mem_region *last_one, *this_one; 1819 int ix; 1820 struct target_ops *t; 1821 1822 if (targetdebug) 1823 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n"); 1824 1825 for (t = current_target.beneath; t != NULL; t = t->beneath) 1826 if (t->to_memory_map != NULL) 1827 break; 1828 1829 if (t == NULL) 1830 return NULL; 1831 1832 result = t->to_memory_map (t); 1833 if (result == NULL) 1834 return NULL; 1835 1836 qsort (VEC_address (mem_region_s, result), 1837 VEC_length (mem_region_s, result), 1838 sizeof (struct mem_region), mem_region_cmp); 1839 1840 /* Check that regions do not overlap. Simultaneously assign 1841 a numbering for the "mem" commands to use to refer to 1842 each region. */ 1843 last_one = NULL; 1844 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++) 1845 { 1846 this_one->number = ix; 1847 1848 if (last_one && last_one->hi > this_one->lo) 1849 { 1850 warning (_("Overlapping regions in memory map: ignoring")); 1851 VEC_free (mem_region_s, result); 1852 return NULL; 1853 } 1854 last_one = this_one; 1855 } 1856 1857 return result; 1858 } 1859 1860 void 1861 target_flash_erase (ULONGEST address, LONGEST length) 1862 { 1863 struct target_ops *t; 1864 1865 for (t = current_target.beneath; t != NULL; t = t->beneath) 1866 if (t->to_flash_erase != NULL) 1867 { 1868 if (targetdebug) 1869 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n", 1870 hex_string (address), phex (length, 0)); 1871 t->to_flash_erase (t, address, length); 1872 return; 1873 } 1874 1875 tcomplain (); 1876 } 1877 1878 void 1879 target_flash_done (void) 1880 { 1881 struct target_ops *t; 1882 1883 for (t = current_target.beneath; t != NULL; t = t->beneath) 1884 if (t->to_flash_done != NULL) 1885 { 1886 if (targetdebug) 1887 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n"); 1888 t->to_flash_done (t); 1889 return; 1890 } 1891 1892 tcomplain (); 1893 } 1894 1895 static void 1896 show_trust_readonly (struct ui_file *file, int from_tty, 1897 struct cmd_list_element *c, const char *value) 1898 { 1899 fprintf_filtered (file, 1900 _("Mode for reading from readonly sections is %s.\n"), 1901 value); 1902 } 1903 1904 /* More generic transfers. */ 1905 1906 static LONGEST 1907 default_xfer_partial (struct target_ops *ops, enum target_object object, 1908 const char *annex, gdb_byte *readbuf, 1909 const gdb_byte *writebuf, ULONGEST offset, LONGEST len) 1910 { 1911 if (object == TARGET_OBJECT_MEMORY 1912 && ops->deprecated_xfer_memory != NULL) 1913 /* If available, fall back to the target's 1914 "deprecated_xfer_memory" method. */ 1915 { 1916 int xfered = -1; 1917 1918 errno = 0; 1919 if (writebuf != NULL) 1920 { 1921 void *buffer = xmalloc (len); 1922 struct cleanup *cleanup = make_cleanup (xfree, buffer); 1923 1924 memcpy (buffer, writebuf, len); 1925 xfered = ops->deprecated_xfer_memory (offset, buffer, len, 1926 1/*write*/, NULL, ops); 1927 do_cleanups (cleanup); 1928 } 1929 if (readbuf != NULL) 1930 xfered = ops->deprecated_xfer_memory (offset, readbuf, len, 1931 0/*read*/, NULL, ops); 1932 if (xfered > 0) 1933 return xfered; 1934 else if (xfered == 0 && errno == 0) 1935 /* "deprecated_xfer_memory" uses 0, cross checked against 1936 ERRNO as one indication of an error. */ 1937 return 0; 1938 else 1939 return -1; 1940 } 1941 else if (ops->beneath != NULL) 1942 return ops->beneath->to_xfer_partial (ops->beneath, object, annex, 1943 readbuf, writebuf, offset, len); 1944 else 1945 return -1; 1946 } 1947 1948 /* The xfer_partial handler for the topmost target. Unlike the default, 1949 it does not need to handle memory specially; it just passes all 1950 requests down the stack. */ 1951 1952 static LONGEST 1953 current_xfer_partial (struct target_ops *ops, enum target_object object, 1954 const char *annex, gdb_byte *readbuf, 1955 const gdb_byte *writebuf, ULONGEST offset, LONGEST len) 1956 { 1957 if (ops->beneath != NULL) 1958 return ops->beneath->to_xfer_partial (ops->beneath, object, annex, 1959 readbuf, writebuf, offset, len); 1960 else 1961 return -1; 1962 } 1963 1964 /* Target vector read/write partial wrapper functions. */ 1965 1966 static LONGEST 1967 target_read_partial (struct target_ops *ops, 1968 enum target_object object, 1969 const char *annex, gdb_byte *buf, 1970 ULONGEST offset, LONGEST len) 1971 { 1972 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len); 1973 } 1974 1975 static LONGEST 1976 target_write_partial (struct target_ops *ops, 1977 enum target_object object, 1978 const char *annex, const gdb_byte *buf, 1979 ULONGEST offset, LONGEST len) 1980 { 1981 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len); 1982 } 1983 1984 /* Wrappers to perform the full transfer. */ 1985 1986 /* For docs on target_read see target.h. */ 1987 1988 LONGEST 1989 target_read (struct target_ops *ops, 1990 enum target_object object, 1991 const char *annex, gdb_byte *buf, 1992 ULONGEST offset, LONGEST len) 1993 { 1994 LONGEST xfered = 0; 1995 1996 while (xfered < len) 1997 { 1998 LONGEST xfer = target_read_partial (ops, object, annex, 1999 (gdb_byte *) buf + xfered, 2000 offset + xfered, len - xfered); 2001 2002 /* Call an observer, notifying them of the xfer progress? */ 2003 if (xfer == 0) 2004 return xfered; 2005 if (xfer < 0) 2006 return -1; 2007 xfered += xfer; 2008 QUIT; 2009 } 2010 return len; 2011 } 2012 2013 /* Assuming that the entire [begin, end) range of memory cannot be 2014 read, try to read whatever subrange is possible to read. 2015 2016 The function returns, in RESULT, either zero or one memory block. 2017 If there's a readable subrange at the beginning, it is completely 2018 read and returned. Any further readable subrange will not be read. 2019 Otherwise, if there's a readable subrange at the end, it will be 2020 completely read and returned. Any readable subranges before it 2021 (obviously, not starting at the beginning), will be ignored. In 2022 other cases -- either no readable subrange, or readable subrange(s) 2023 that is neither at the beginning, or end, nothing is returned. 2024 2025 The purpose of this function is to handle a read across a boundary 2026 of accessible memory in a case when memory map is not available. 2027 The above restrictions are fine for this case, but will give 2028 incorrect results if the memory is 'patchy'. However, supporting 2029 'patchy' memory would require trying to read every single byte, 2030 and it seems unacceptable solution. Explicit memory map is 2031 recommended for this case -- and target_read_memory_robust will 2032 take care of reading multiple ranges then. */ 2033 2034 static void 2035 read_whatever_is_readable (struct target_ops *ops, 2036 ULONGEST begin, ULONGEST end, 2037 VEC(memory_read_result_s) **result) 2038 { 2039 gdb_byte *buf = xmalloc (end - begin); 2040 ULONGEST current_begin = begin; 2041 ULONGEST current_end = end; 2042 int forward; 2043 memory_read_result_s r; 2044 2045 /* If we previously failed to read 1 byte, nothing can be done here. */ 2046 if (end - begin <= 1) 2047 { 2048 xfree (buf); 2049 return; 2050 } 2051 2052 /* Check that either first or the last byte is readable, and give up 2053 if not. This heuristic is meant to permit reading accessible memory 2054 at the boundary of accessible region. */ 2055 if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL, 2056 buf, begin, 1) == 1) 2057 { 2058 forward = 1; 2059 ++current_begin; 2060 } 2061 else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL, 2062 buf + (end-begin) - 1, end - 1, 1) == 1) 2063 { 2064 forward = 0; 2065 --current_end; 2066 } 2067 else 2068 { 2069 xfree (buf); 2070 return; 2071 } 2072 2073 /* Loop invariant is that the [current_begin, current_end) was previously 2074 found to be not readable as a whole. 2075 2076 Note loop condition -- if the range has 1 byte, we can't divide the range 2077 so there's no point trying further. */ 2078 while (current_end - current_begin > 1) 2079 { 2080 ULONGEST first_half_begin, first_half_end; 2081 ULONGEST second_half_begin, second_half_end; 2082 LONGEST xfer; 2083 ULONGEST middle = current_begin + (current_end - current_begin)/2; 2084 2085 if (forward) 2086 { 2087 first_half_begin = current_begin; 2088 first_half_end = middle; 2089 second_half_begin = middle; 2090 second_half_end = current_end; 2091 } 2092 else 2093 { 2094 first_half_begin = middle; 2095 first_half_end = current_end; 2096 second_half_begin = current_begin; 2097 second_half_end = middle; 2098 } 2099 2100 xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL, 2101 buf + (first_half_begin - begin), 2102 first_half_begin, 2103 first_half_end - first_half_begin); 2104 2105 if (xfer == first_half_end - first_half_begin) 2106 { 2107 /* This half reads up fine. So, the error must be in the 2108 other half. */ 2109 current_begin = second_half_begin; 2110 current_end = second_half_end; 2111 } 2112 else 2113 { 2114 /* This half is not readable. Because we've tried one byte, we 2115 know some part of this half if actually redable. Go to the next 2116 iteration to divide again and try to read. 2117 2118 We don't handle the other half, because this function only tries 2119 to read a single readable subrange. */ 2120 current_begin = first_half_begin; 2121 current_end = first_half_end; 2122 } 2123 } 2124 2125 if (forward) 2126 { 2127 /* The [begin, current_begin) range has been read. */ 2128 r.begin = begin; 2129 r.end = current_begin; 2130 r.data = buf; 2131 } 2132 else 2133 { 2134 /* The [current_end, end) range has been read. */ 2135 LONGEST rlen = end - current_end; 2136 2137 r.data = xmalloc (rlen); 2138 memcpy (r.data, buf + current_end - begin, rlen); 2139 r.begin = current_end; 2140 r.end = end; 2141 xfree (buf); 2142 } 2143 VEC_safe_push(memory_read_result_s, (*result), &r); 2144 } 2145 2146 void 2147 free_memory_read_result_vector (void *x) 2148 { 2149 VEC(memory_read_result_s) *v = x; 2150 memory_read_result_s *current; 2151 int ix; 2152 2153 for (ix = 0; VEC_iterate (memory_read_result_s, v, ix, current); ++ix) 2154 { 2155 xfree (current->data); 2156 } 2157 VEC_free (memory_read_result_s, v); 2158 } 2159 2160 VEC(memory_read_result_s) * 2161 read_memory_robust (struct target_ops *ops, ULONGEST offset, LONGEST len) 2162 { 2163 VEC(memory_read_result_s) *result = 0; 2164 2165 LONGEST xfered = 0; 2166 while (xfered < len) 2167 { 2168 struct mem_region *region = lookup_mem_region (offset + xfered); 2169 LONGEST rlen; 2170 2171 /* If there is no explicit region, a fake one should be created. */ 2172 gdb_assert (region); 2173 2174 if (region->hi == 0) 2175 rlen = len - xfered; 2176 else 2177 rlen = region->hi - offset; 2178 2179 if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO) 2180 { 2181 /* Cannot read this region. Note that we can end up here only 2182 if the region is explicitly marked inaccessible, or 2183 'inaccessible-by-default' is in effect. */ 2184 xfered += rlen; 2185 } 2186 else 2187 { 2188 LONGEST to_read = min (len - xfered, rlen); 2189 gdb_byte *buffer = (gdb_byte *)xmalloc (to_read); 2190 2191 LONGEST xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL, 2192 (gdb_byte *) buffer, 2193 offset + xfered, to_read); 2194 /* Call an observer, notifying them of the xfer progress? */ 2195 if (xfer <= 0) 2196 { 2197 /* Got an error reading full chunk. See if maybe we can read 2198 some subrange. */ 2199 xfree (buffer); 2200 read_whatever_is_readable (ops, offset + xfered, 2201 offset + xfered + to_read, &result); 2202 xfered += to_read; 2203 } 2204 else 2205 { 2206 struct memory_read_result r; 2207 r.data = buffer; 2208 r.begin = offset + xfered; 2209 r.end = r.begin + xfer; 2210 VEC_safe_push (memory_read_result_s, result, &r); 2211 xfered += xfer; 2212 } 2213 QUIT; 2214 } 2215 } 2216 return result; 2217 } 2218 2219 2220 /* An alternative to target_write with progress callbacks. */ 2221 2222 LONGEST 2223 target_write_with_progress (struct target_ops *ops, 2224 enum target_object object, 2225 const char *annex, const gdb_byte *buf, 2226 ULONGEST offset, LONGEST len, 2227 void (*progress) (ULONGEST, void *), void *baton) 2228 { 2229 LONGEST xfered = 0; 2230 2231 /* Give the progress callback a chance to set up. */ 2232 if (progress) 2233 (*progress) (0, baton); 2234 2235 while (xfered < len) 2236 { 2237 LONGEST xfer = target_write_partial (ops, object, annex, 2238 (gdb_byte *) buf + xfered, 2239 offset + xfered, len - xfered); 2240 2241 if (xfer == 0) 2242 return xfered; 2243 if (xfer < 0) 2244 return -1; 2245 2246 if (progress) 2247 (*progress) (xfer, baton); 2248 2249 xfered += xfer; 2250 QUIT; 2251 } 2252 return len; 2253 } 2254 2255 /* For docs on target_write see target.h. */ 2256 2257 LONGEST 2258 target_write (struct target_ops *ops, 2259 enum target_object object, 2260 const char *annex, const gdb_byte *buf, 2261 ULONGEST offset, LONGEST len) 2262 { 2263 return target_write_with_progress (ops, object, annex, buf, offset, len, 2264 NULL, NULL); 2265 } 2266 2267 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return 2268 the size of the transferred data. PADDING additional bytes are 2269 available in *BUF_P. This is a helper function for 2270 target_read_alloc; see the declaration of that function for more 2271 information. */ 2272 2273 static LONGEST 2274 target_read_alloc_1 (struct target_ops *ops, enum target_object object, 2275 const char *annex, gdb_byte **buf_p, int padding) 2276 { 2277 size_t buf_alloc, buf_pos; 2278 gdb_byte *buf; 2279 LONGEST n; 2280 2281 /* This function does not have a length parameter; it reads the 2282 entire OBJECT). Also, it doesn't support objects fetched partly 2283 from one target and partly from another (in a different stratum, 2284 e.g. a core file and an executable). Both reasons make it 2285 unsuitable for reading memory. */ 2286 gdb_assert (object != TARGET_OBJECT_MEMORY); 2287 2288 /* Start by reading up to 4K at a time. The target will throttle 2289 this number down if necessary. */ 2290 buf_alloc = 4096; 2291 buf = xmalloc (buf_alloc); 2292 buf_pos = 0; 2293 while (1) 2294 { 2295 n = target_read_partial (ops, object, annex, &buf[buf_pos], 2296 buf_pos, buf_alloc - buf_pos - padding); 2297 if (n < 0) 2298 { 2299 /* An error occurred. */ 2300 xfree (buf); 2301 return -1; 2302 } 2303 else if (n == 0) 2304 { 2305 /* Read all there was. */ 2306 if (buf_pos == 0) 2307 xfree (buf); 2308 else 2309 *buf_p = buf; 2310 return buf_pos; 2311 } 2312 2313 buf_pos += n; 2314 2315 /* If the buffer is filling up, expand it. */ 2316 if (buf_alloc < buf_pos * 2) 2317 { 2318 buf_alloc *= 2; 2319 buf = xrealloc (buf, buf_alloc); 2320 } 2321 2322 QUIT; 2323 } 2324 } 2325 2326 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return 2327 the size of the transferred data. See the declaration in "target.h" 2328 function for more information about the return value. */ 2329 2330 LONGEST 2331 target_read_alloc (struct target_ops *ops, enum target_object object, 2332 const char *annex, gdb_byte **buf_p) 2333 { 2334 return target_read_alloc_1 (ops, object, annex, buf_p, 0); 2335 } 2336 2337 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and 2338 returned as a string, allocated using xmalloc. If an error occurs 2339 or the transfer is unsupported, NULL is returned. Empty objects 2340 are returned as allocated but empty strings. A warning is issued 2341 if the result contains any embedded NUL bytes. */ 2342 2343 char * 2344 target_read_stralloc (struct target_ops *ops, enum target_object object, 2345 const char *annex) 2346 { 2347 gdb_byte *buffer; 2348 LONGEST transferred; 2349 2350 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1); 2351 2352 if (transferred < 0) 2353 return NULL; 2354 2355 if (transferred == 0) 2356 return xstrdup (""); 2357 2358 buffer[transferred] = 0; 2359 if (strlen (buffer) < transferred) 2360 warning (_("target object %d, annex %s, " 2361 "contained unexpected null characters"), 2362 (int) object, annex ? annex : "(none)"); 2363 2364 return (char *) buffer; 2365 } 2366 2367 /* Memory transfer methods. */ 2368 2369 void 2370 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf, 2371 LONGEST len) 2372 { 2373 /* This method is used to read from an alternate, non-current 2374 target. This read must bypass the overlay support (as symbols 2375 don't match this target), and GDB's internal cache (wrong cache 2376 for this target). */ 2377 if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len) 2378 != len) 2379 memory_error (EIO, addr); 2380 } 2381 2382 ULONGEST 2383 get_target_memory_unsigned (struct target_ops *ops, CORE_ADDR addr, 2384 int len, enum bfd_endian byte_order) 2385 { 2386 gdb_byte buf[sizeof (ULONGEST)]; 2387 2388 gdb_assert (len <= sizeof (buf)); 2389 get_target_memory (ops, addr, buf, len); 2390 return extract_unsigned_integer (buf, len, byte_order); 2391 } 2392 2393 int 2394 target_insert_breakpoint (struct gdbarch *gdbarch, 2395 struct bp_target_info *bp_tgt) 2396 { 2397 if (!may_insert_breakpoints) 2398 { 2399 warning (_("May not insert breakpoints")); 2400 return 1; 2401 } 2402 2403 return (*current_target.to_insert_breakpoint) (gdbarch, bp_tgt); 2404 } 2405 2406 int 2407 target_remove_breakpoint (struct gdbarch *gdbarch, 2408 struct bp_target_info *bp_tgt) 2409 { 2410 /* This is kind of a weird case to handle, but the permission might 2411 have been changed after breakpoints were inserted - in which case 2412 we should just take the user literally and assume that any 2413 breakpoints should be left in place. */ 2414 if (!may_insert_breakpoints) 2415 { 2416 warning (_("May not remove breakpoints")); 2417 return 1; 2418 } 2419 2420 return (*current_target.to_remove_breakpoint) (gdbarch, bp_tgt); 2421 } 2422 2423 static void 2424 target_info (char *args, int from_tty) 2425 { 2426 struct target_ops *t; 2427 int has_all_mem = 0; 2428 2429 if (symfile_objfile != NULL) 2430 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name); 2431 2432 for (t = target_stack; t != NULL; t = t->beneath) 2433 { 2434 if (!(*t->to_has_memory) (t)) 2435 continue; 2436 2437 if ((int) (t->to_stratum) <= (int) dummy_stratum) 2438 continue; 2439 if (has_all_mem) 2440 printf_unfiltered (_("\tWhile running this, " 2441 "GDB does not access memory from...\n")); 2442 printf_unfiltered ("%s:\n", t->to_longname); 2443 (t->to_files_info) (t); 2444 has_all_mem = (*t->to_has_all_memory) (t); 2445 } 2446 } 2447 2448 /* This function is called before any new inferior is created, e.g. 2449 by running a program, attaching, or connecting to a target. 2450 It cleans up any state from previous invocations which might 2451 change between runs. This is a subset of what target_preopen 2452 resets (things which might change between targets). */ 2453 2454 void 2455 target_pre_inferior (int from_tty) 2456 { 2457 /* Clear out solib state. Otherwise the solib state of the previous 2458 inferior might have survived and is entirely wrong for the new 2459 target. This has been observed on GNU/Linux using glibc 2.3. How 2460 to reproduce: 2461 2462 bash$ ./foo& 2463 [1] 4711 2464 bash$ ./foo& 2465 [1] 4712 2466 bash$ gdb ./foo 2467 [...] 2468 (gdb) attach 4711 2469 (gdb) detach 2470 (gdb) attach 4712 2471 Cannot access memory at address 0xdeadbeef 2472 */ 2473 2474 /* In some OSs, the shared library list is the same/global/shared 2475 across inferiors. If code is shared between processes, so are 2476 memory regions and features. */ 2477 if (!gdbarch_has_global_solist (target_gdbarch)) 2478 { 2479 no_shared_libraries (NULL, from_tty); 2480 2481 invalidate_target_mem_regions (); 2482 2483 target_clear_description (); 2484 } 2485 } 2486 2487 /* Callback for iterate_over_inferiors. Gets rid of the given 2488 inferior. */ 2489 2490 static int 2491 dispose_inferior (struct inferior *inf, void *args) 2492 { 2493 struct thread_info *thread; 2494 2495 thread = any_thread_of_process (inf->pid); 2496 if (thread) 2497 { 2498 switch_to_thread (thread->ptid); 2499 2500 /* Core inferiors actually should be detached, not killed. */ 2501 if (target_has_execution) 2502 target_kill (); 2503 else 2504 target_detach (NULL, 0); 2505 } 2506 2507 return 0; 2508 } 2509 2510 /* This is to be called by the open routine before it does 2511 anything. */ 2512 2513 void 2514 target_preopen (int from_tty) 2515 { 2516 dont_repeat (); 2517 2518 if (have_inferiors ()) 2519 { 2520 if (!from_tty 2521 || !have_live_inferiors () 2522 || query (_("A program is being debugged already. Kill it? "))) 2523 iterate_over_inferiors (dispose_inferior, NULL); 2524 else 2525 error (_("Program not killed.")); 2526 } 2527 2528 /* Calling target_kill may remove the target from the stack. But if 2529 it doesn't (which seems like a win for UDI), remove it now. */ 2530 /* Leave the exec target, though. The user may be switching from a 2531 live process to a core of the same program. */ 2532 pop_all_targets_above (file_stratum, 0); 2533 2534 target_pre_inferior (from_tty); 2535 } 2536 2537 /* Detach a target after doing deferred register stores. */ 2538 2539 void 2540 target_detach (char *args, int from_tty) 2541 { 2542 struct target_ops* t; 2543 2544 if (gdbarch_has_global_breakpoints (target_gdbarch)) 2545 /* Don't remove global breakpoints here. They're removed on 2546 disconnection from the target. */ 2547 ; 2548 else 2549 /* If we're in breakpoints-always-inserted mode, have to remove 2550 them before detaching. */ 2551 remove_breakpoints_pid (PIDGET (inferior_ptid)); 2552 2553 prepare_for_detach (); 2554 2555 for (t = current_target.beneath; t != NULL; t = t->beneath) 2556 { 2557 if (t->to_detach != NULL) 2558 { 2559 t->to_detach (t, args, from_tty); 2560 if (targetdebug) 2561 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", 2562 args, from_tty); 2563 return; 2564 } 2565 } 2566 2567 internal_error (__FILE__, __LINE__, _("could not find a target to detach")); 2568 } 2569 2570 void 2571 target_disconnect (char *args, int from_tty) 2572 { 2573 struct target_ops *t; 2574 2575 /* If we're in breakpoints-always-inserted mode or if breakpoints 2576 are global across processes, we have to remove them before 2577 disconnecting. */ 2578 remove_breakpoints (); 2579 2580 for (t = current_target.beneath; t != NULL; t = t->beneath) 2581 if (t->to_disconnect != NULL) 2582 { 2583 if (targetdebug) 2584 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n", 2585 args, from_tty); 2586 t->to_disconnect (t, args, from_tty); 2587 return; 2588 } 2589 2590 tcomplain (); 2591 } 2592 2593 ptid_t 2594 target_wait (ptid_t ptid, struct target_waitstatus *status, int options) 2595 { 2596 struct target_ops *t; 2597 2598 for (t = current_target.beneath; t != NULL; t = t->beneath) 2599 { 2600 if (t->to_wait != NULL) 2601 { 2602 ptid_t retval = (*t->to_wait) (t, ptid, status, options); 2603 2604 if (targetdebug) 2605 { 2606 char *status_string; 2607 2608 status_string = target_waitstatus_to_string (status); 2609 fprintf_unfiltered (gdb_stdlog, 2610 "target_wait (%d, status) = %d, %s\n", 2611 PIDGET (ptid), PIDGET (retval), 2612 status_string); 2613 xfree (status_string); 2614 } 2615 2616 return retval; 2617 } 2618 } 2619 2620 noprocess (); 2621 } 2622 2623 char * 2624 target_pid_to_str (ptid_t ptid) 2625 { 2626 struct target_ops *t; 2627 2628 for (t = current_target.beneath; t != NULL; t = t->beneath) 2629 { 2630 if (t->to_pid_to_str != NULL) 2631 return (*t->to_pid_to_str) (t, ptid); 2632 } 2633 2634 return normal_pid_to_str (ptid); 2635 } 2636 2637 char * 2638 target_thread_name (struct thread_info *info) 2639 { 2640 struct target_ops *t; 2641 2642 for (t = current_target.beneath; t != NULL; t = t->beneath) 2643 { 2644 if (t->to_thread_name != NULL) 2645 return (*t->to_thread_name) (info); 2646 } 2647 2648 return NULL; 2649 } 2650 2651 void 2652 target_resume (ptid_t ptid, int step, enum target_signal signal) 2653 { 2654 struct target_ops *t; 2655 2656 target_dcache_invalidate (); 2657 2658 for (t = current_target.beneath; t != NULL; t = t->beneath) 2659 { 2660 if (t->to_resume != NULL) 2661 { 2662 t->to_resume (t, ptid, step, signal); 2663 if (targetdebug) 2664 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", 2665 PIDGET (ptid), 2666 step ? "step" : "continue", 2667 target_signal_to_name (signal)); 2668 2669 registers_changed_ptid (ptid); 2670 set_executing (ptid, 1); 2671 set_running (ptid, 1); 2672 clear_inline_frame_state (ptid); 2673 return; 2674 } 2675 } 2676 2677 noprocess (); 2678 } 2679 2680 void 2681 target_pass_signals (int numsigs, unsigned char *pass_signals) 2682 { 2683 struct target_ops *t; 2684 2685 for (t = current_target.beneath; t != NULL; t = t->beneath) 2686 { 2687 if (t->to_pass_signals != NULL) 2688 { 2689 if (targetdebug) 2690 { 2691 int i; 2692 2693 fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {", 2694 numsigs); 2695 2696 for (i = 0; i < numsigs; i++) 2697 if (pass_signals[i]) 2698 fprintf_unfiltered (gdb_stdlog, " %s", 2699 target_signal_to_name (i)); 2700 2701 fprintf_unfiltered (gdb_stdlog, " })\n"); 2702 } 2703 2704 (*t->to_pass_signals) (numsigs, pass_signals); 2705 return; 2706 } 2707 } 2708 } 2709 2710 /* Look through the list of possible targets for a target that can 2711 follow forks. */ 2712 2713 int 2714 target_follow_fork (int follow_child) 2715 { 2716 struct target_ops *t; 2717 2718 for (t = current_target.beneath; t != NULL; t = t->beneath) 2719 { 2720 if (t->to_follow_fork != NULL) 2721 { 2722 int retval = t->to_follow_fork (t, follow_child); 2723 2724 if (targetdebug) 2725 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n", 2726 follow_child, retval); 2727 return retval; 2728 } 2729 } 2730 2731 /* Some target returned a fork event, but did not know how to follow it. */ 2732 internal_error (__FILE__, __LINE__, 2733 _("could not find a target to follow fork")); 2734 } 2735 2736 void 2737 target_mourn_inferior (void) 2738 { 2739 struct target_ops *t; 2740 2741 for (t = current_target.beneath; t != NULL; t = t->beneath) 2742 { 2743 if (t->to_mourn_inferior != NULL) 2744 { 2745 t->to_mourn_inferior (t); 2746 if (targetdebug) 2747 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n"); 2748 2749 /* We no longer need to keep handles on any of the object files. 2750 Make sure to release them to avoid unnecessarily locking any 2751 of them while we're not actually debugging. */ 2752 bfd_cache_close_all (); 2753 2754 return; 2755 } 2756 } 2757 2758 internal_error (__FILE__, __LINE__, 2759 _("could not find a target to follow mourn inferior")); 2760 } 2761 2762 /* Look for a target which can describe architectural features, starting 2763 from TARGET. If we find one, return its description. */ 2764 2765 const struct target_desc * 2766 target_read_description (struct target_ops *target) 2767 { 2768 struct target_ops *t; 2769 2770 for (t = target; t != NULL; t = t->beneath) 2771 if (t->to_read_description != NULL) 2772 { 2773 const struct target_desc *tdesc; 2774 2775 tdesc = t->to_read_description (t); 2776 if (tdesc) 2777 return tdesc; 2778 } 2779 2780 return NULL; 2781 } 2782 2783 /* The default implementation of to_search_memory. 2784 This implements a basic search of memory, reading target memory and 2785 performing the search here (as opposed to performing the search in on the 2786 target side with, for example, gdbserver). */ 2787 2788 int 2789 simple_search_memory (struct target_ops *ops, 2790 CORE_ADDR start_addr, ULONGEST search_space_len, 2791 const gdb_byte *pattern, ULONGEST pattern_len, 2792 CORE_ADDR *found_addrp) 2793 { 2794 /* NOTE: also defined in find.c testcase. */ 2795 #define SEARCH_CHUNK_SIZE 16000 2796 const unsigned chunk_size = SEARCH_CHUNK_SIZE; 2797 /* Buffer to hold memory contents for searching. */ 2798 gdb_byte *search_buf; 2799 unsigned search_buf_size; 2800 struct cleanup *old_cleanups; 2801 2802 search_buf_size = chunk_size + pattern_len - 1; 2803 2804 /* No point in trying to allocate a buffer larger than the search space. */ 2805 if (search_space_len < search_buf_size) 2806 search_buf_size = search_space_len; 2807 2808 search_buf = malloc (search_buf_size); 2809 if (search_buf == NULL) 2810 error (_("Unable to allocate memory to perform the search.")); 2811 old_cleanups = make_cleanup (free_current_contents, &search_buf); 2812 2813 /* Prime the search buffer. */ 2814 2815 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, 2816 search_buf, start_addr, search_buf_size) != search_buf_size) 2817 { 2818 warning (_("Unable to access target memory at %s, halting search."), 2819 hex_string (start_addr)); 2820 do_cleanups (old_cleanups); 2821 return -1; 2822 } 2823 2824 /* Perform the search. 2825 2826 The loop is kept simple by allocating [N + pattern-length - 1] bytes. 2827 When we've scanned N bytes we copy the trailing bytes to the start and 2828 read in another N bytes. */ 2829 2830 while (search_space_len >= pattern_len) 2831 { 2832 gdb_byte *found_ptr; 2833 unsigned nr_search_bytes = min (search_space_len, search_buf_size); 2834 2835 found_ptr = memmem (search_buf, nr_search_bytes, 2836 pattern, pattern_len); 2837 2838 if (found_ptr != NULL) 2839 { 2840 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf); 2841 2842 *found_addrp = found_addr; 2843 do_cleanups (old_cleanups); 2844 return 1; 2845 } 2846 2847 /* Not found in this chunk, skip to next chunk. */ 2848 2849 /* Don't let search_space_len wrap here, it's unsigned. */ 2850 if (search_space_len >= chunk_size) 2851 search_space_len -= chunk_size; 2852 else 2853 search_space_len = 0; 2854 2855 if (search_space_len >= pattern_len) 2856 { 2857 unsigned keep_len = search_buf_size - chunk_size; 2858 CORE_ADDR read_addr = start_addr + chunk_size + keep_len; 2859 int nr_to_read; 2860 2861 /* Copy the trailing part of the previous iteration to the front 2862 of the buffer for the next iteration. */ 2863 gdb_assert (keep_len == pattern_len - 1); 2864 memcpy (search_buf, search_buf + chunk_size, keep_len); 2865 2866 nr_to_read = min (search_space_len - keep_len, chunk_size); 2867 2868 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, 2869 search_buf + keep_len, read_addr, 2870 nr_to_read) != nr_to_read) 2871 { 2872 warning (_("Unable to access target " 2873 "memory at %s, halting search."), 2874 hex_string (read_addr)); 2875 do_cleanups (old_cleanups); 2876 return -1; 2877 } 2878 2879 start_addr += chunk_size; 2880 } 2881 } 2882 2883 /* Not found. */ 2884 2885 do_cleanups (old_cleanups); 2886 return 0; 2887 } 2888 2889 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the 2890 sequence of bytes in PATTERN with length PATTERN_LEN. 2891 2892 The result is 1 if found, 0 if not found, and -1 if there was an error 2893 requiring halting of the search (e.g. memory read error). 2894 If the pattern is found the address is recorded in FOUND_ADDRP. */ 2895 2896 int 2897 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len, 2898 const gdb_byte *pattern, ULONGEST pattern_len, 2899 CORE_ADDR *found_addrp) 2900 { 2901 struct target_ops *t; 2902 int found; 2903 2904 /* We don't use INHERIT to set current_target.to_search_memory, 2905 so we have to scan the target stack and handle targetdebug 2906 ourselves. */ 2907 2908 if (targetdebug) 2909 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n", 2910 hex_string (start_addr)); 2911 2912 for (t = current_target.beneath; t != NULL; t = t->beneath) 2913 if (t->to_search_memory != NULL) 2914 break; 2915 2916 if (t != NULL) 2917 { 2918 found = t->to_search_memory (t, start_addr, search_space_len, 2919 pattern, pattern_len, found_addrp); 2920 } 2921 else 2922 { 2923 /* If a special version of to_search_memory isn't available, use the 2924 simple version. */ 2925 found = simple_search_memory (current_target.beneath, 2926 start_addr, search_space_len, 2927 pattern, pattern_len, found_addrp); 2928 } 2929 2930 if (targetdebug) 2931 fprintf_unfiltered (gdb_stdlog, " = %d\n", found); 2932 2933 return found; 2934 } 2935 2936 /* Look through the currently pushed targets. If none of them will 2937 be able to restart the currently running process, issue an error 2938 message. */ 2939 2940 void 2941 target_require_runnable (void) 2942 { 2943 struct target_ops *t; 2944 2945 for (t = target_stack; t != NULL; t = t->beneath) 2946 { 2947 /* If this target knows how to create a new program, then 2948 assume we will still be able to after killing the current 2949 one. Either killing and mourning will not pop T, or else 2950 find_default_run_target will find it again. */ 2951 if (t->to_create_inferior != NULL) 2952 return; 2953 2954 /* Do not worry about thread_stratum targets that can not 2955 create inferiors. Assume they will be pushed again if 2956 necessary, and continue to the process_stratum. */ 2957 if (t->to_stratum == thread_stratum 2958 || t->to_stratum == arch_stratum) 2959 continue; 2960 2961 error (_("The \"%s\" target does not support \"run\". " 2962 "Try \"help target\" or \"continue\"."), 2963 t->to_shortname); 2964 } 2965 2966 /* This function is only called if the target is running. In that 2967 case there should have been a process_stratum target and it 2968 should either know how to create inferiors, or not... */ 2969 internal_error (__FILE__, __LINE__, _("No targets found")); 2970 } 2971 2972 /* Look through the list of possible targets for a target that can 2973 execute a run or attach command without any other data. This is 2974 used to locate the default process stratum. 2975 2976 If DO_MESG is not NULL, the result is always valid (error() is 2977 called for errors); else, return NULL on error. */ 2978 2979 static struct target_ops * 2980 find_default_run_target (char *do_mesg) 2981 { 2982 struct target_ops **t; 2983 struct target_ops *runable = NULL; 2984 int count; 2985 2986 count = 0; 2987 2988 for (t = target_structs; t < target_structs + target_struct_size; 2989 ++t) 2990 { 2991 if ((*t)->to_can_run && target_can_run (*t)) 2992 { 2993 runable = *t; 2994 ++count; 2995 } 2996 } 2997 2998 if (count != 1) 2999 { 3000 if (do_mesg) 3001 error (_("Don't know how to %s. Try \"help target\"."), do_mesg); 3002 else 3003 return NULL; 3004 } 3005 3006 return runable; 3007 } 3008 3009 void 3010 find_default_attach (struct target_ops *ops, char *args, int from_tty) 3011 { 3012 struct target_ops *t; 3013 3014 t = find_default_run_target ("attach"); 3015 (t->to_attach) (t, args, from_tty); 3016 return; 3017 } 3018 3019 void 3020 find_default_create_inferior (struct target_ops *ops, 3021 char *exec_file, char *allargs, char **env, 3022 int from_tty) 3023 { 3024 struct target_ops *t; 3025 3026 t = find_default_run_target ("run"); 3027 (t->to_create_inferior) (t, exec_file, allargs, env, from_tty); 3028 return; 3029 } 3030 3031 static int 3032 find_default_can_async_p (void) 3033 { 3034 struct target_ops *t; 3035 3036 /* This may be called before the target is pushed on the stack; 3037 look for the default process stratum. If there's none, gdb isn't 3038 configured with a native debugger, and target remote isn't 3039 connected yet. */ 3040 t = find_default_run_target (NULL); 3041 if (t && t->to_can_async_p) 3042 return (t->to_can_async_p) (); 3043 return 0; 3044 } 3045 3046 static int 3047 find_default_is_async_p (void) 3048 { 3049 struct target_ops *t; 3050 3051 /* This may be called before the target is pushed on the stack; 3052 look for the default process stratum. If there's none, gdb isn't 3053 configured with a native debugger, and target remote isn't 3054 connected yet. */ 3055 t = find_default_run_target (NULL); 3056 if (t && t->to_is_async_p) 3057 return (t->to_is_async_p) (); 3058 return 0; 3059 } 3060 3061 static int 3062 find_default_supports_non_stop (void) 3063 { 3064 struct target_ops *t; 3065 3066 t = find_default_run_target (NULL); 3067 if (t && t->to_supports_non_stop) 3068 return (t->to_supports_non_stop) (); 3069 return 0; 3070 } 3071 3072 int 3073 target_supports_non_stop (void) 3074 { 3075 struct target_ops *t; 3076 3077 for (t = ¤t_target; t != NULL; t = t->beneath) 3078 if (t->to_supports_non_stop) 3079 return t->to_supports_non_stop (); 3080 3081 return 0; 3082 } 3083 3084 static int 3085 find_default_supports_disable_randomization (void) 3086 { 3087 struct target_ops *t; 3088 3089 t = find_default_run_target (NULL); 3090 if (t && t->to_supports_disable_randomization) 3091 return (t->to_supports_disable_randomization) (); 3092 return 0; 3093 } 3094 3095 int 3096 target_supports_disable_randomization (void) 3097 { 3098 struct target_ops *t; 3099 3100 for (t = ¤t_target; t != NULL; t = t->beneath) 3101 if (t->to_supports_disable_randomization) 3102 return t->to_supports_disable_randomization (); 3103 3104 return 0; 3105 } 3106 3107 char * 3108 target_get_osdata (const char *type) 3109 { 3110 struct target_ops *t; 3111 3112 /* If we're already connected to something that can get us OS 3113 related data, use it. Otherwise, try using the native 3114 target. */ 3115 if (current_target.to_stratum >= process_stratum) 3116 t = current_target.beneath; 3117 else 3118 t = find_default_run_target ("get OS data"); 3119 3120 if (!t) 3121 return NULL; 3122 3123 return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type); 3124 } 3125 3126 /* Determine the current address space of thread PTID. */ 3127 3128 struct address_space * 3129 target_thread_address_space (ptid_t ptid) 3130 { 3131 struct address_space *aspace; 3132 struct inferior *inf; 3133 struct target_ops *t; 3134 3135 for (t = current_target.beneath; t != NULL; t = t->beneath) 3136 { 3137 if (t->to_thread_address_space != NULL) 3138 { 3139 aspace = t->to_thread_address_space (t, ptid); 3140 gdb_assert (aspace); 3141 3142 if (targetdebug) 3143 fprintf_unfiltered (gdb_stdlog, 3144 "target_thread_address_space (%s) = %d\n", 3145 target_pid_to_str (ptid), 3146 address_space_num (aspace)); 3147 return aspace; 3148 } 3149 } 3150 3151 /* Fall-back to the "main" address space of the inferior. */ 3152 inf = find_inferior_pid (ptid_get_pid (ptid)); 3153 3154 if (inf == NULL || inf->aspace == NULL) 3155 internal_error (__FILE__, __LINE__, 3156 _("Can't determine the current " 3157 "address space of thread %s\n"), 3158 target_pid_to_str (ptid)); 3159 3160 return inf->aspace; 3161 } 3162 3163 static int 3164 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) 3165 { 3166 return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT); 3167 } 3168 3169 static int 3170 default_watchpoint_addr_within_range (struct target_ops *target, 3171 CORE_ADDR addr, 3172 CORE_ADDR start, int length) 3173 { 3174 return addr >= start && addr < start + length; 3175 } 3176 3177 static struct gdbarch * 3178 default_thread_architecture (struct target_ops *ops, ptid_t ptid) 3179 { 3180 return target_gdbarch; 3181 } 3182 3183 static int 3184 return_zero (void) 3185 { 3186 return 0; 3187 } 3188 3189 static int 3190 return_one (void) 3191 { 3192 return 1; 3193 } 3194 3195 static int 3196 return_minus_one (void) 3197 { 3198 return -1; 3199 } 3200 3201 /* Find a single runnable target in the stack and return it. If for 3202 some reason there is more than one, return NULL. */ 3203 3204 struct target_ops * 3205 find_run_target (void) 3206 { 3207 struct target_ops **t; 3208 struct target_ops *runable = NULL; 3209 int count; 3210 3211 count = 0; 3212 3213 for (t = target_structs; t < target_structs + target_struct_size; ++t) 3214 { 3215 if ((*t)->to_can_run && target_can_run (*t)) 3216 { 3217 runable = *t; 3218 ++count; 3219 } 3220 } 3221 3222 return (count == 1 ? runable : NULL); 3223 } 3224 3225 /* 3226 * Find the next target down the stack from the specified target. 3227 */ 3228 3229 struct target_ops * 3230 find_target_beneath (struct target_ops *t) 3231 { 3232 return t->beneath; 3233 } 3234 3235 3236 /* The inferior process has died. Long live the inferior! */ 3237 3238 void 3239 generic_mourn_inferior (void) 3240 { 3241 ptid_t ptid; 3242 3243 ptid = inferior_ptid; 3244 inferior_ptid = null_ptid; 3245 3246 if (!ptid_equal (ptid, null_ptid)) 3247 { 3248 int pid = ptid_get_pid (ptid); 3249 exit_inferior (pid); 3250 } 3251 3252 breakpoint_init_inferior (inf_exited); 3253 registers_changed (); 3254 3255 reopen_exec_file (); 3256 reinit_frame_cache (); 3257 3258 if (deprecated_detach_hook) 3259 deprecated_detach_hook (); 3260 } 3261 3262 /* Helper function for child_wait and the derivatives of child_wait. 3263 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our 3264 translation of that in OURSTATUS. */ 3265 void 3266 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus) 3267 { 3268 if (WIFEXITED (hoststatus)) 3269 { 3270 ourstatus->kind = TARGET_WAITKIND_EXITED; 3271 ourstatus->value.integer = WEXITSTATUS (hoststatus); 3272 } 3273 else if (!WIFSTOPPED (hoststatus)) 3274 { 3275 ourstatus->kind = TARGET_WAITKIND_SIGNALLED; 3276 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus)); 3277 } 3278 else 3279 { 3280 ourstatus->kind = TARGET_WAITKIND_STOPPED; 3281 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus)); 3282 } 3283 } 3284 3285 /* Convert a normal process ID to a string. Returns the string in a 3286 static buffer. */ 3287 3288 char * 3289 normal_pid_to_str (ptid_t ptid) 3290 { 3291 static char buf[32]; 3292 3293 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid)); 3294 return buf; 3295 } 3296 3297 static char * 3298 dummy_pid_to_str (struct target_ops *ops, ptid_t ptid) 3299 { 3300 return normal_pid_to_str (ptid); 3301 } 3302 3303 /* Error-catcher for target_find_memory_regions. */ 3304 static int 3305 dummy_find_memory_regions (find_memory_region_ftype ignore1, void *ignore2) 3306 { 3307 error (_("Command not implemented for this target.")); 3308 return 0; 3309 } 3310 3311 /* Error-catcher for target_make_corefile_notes. */ 3312 static char * 3313 dummy_make_corefile_notes (bfd *ignore1, int *ignore2) 3314 { 3315 error (_("Command not implemented for this target.")); 3316 return NULL; 3317 } 3318 3319 /* Error-catcher for target_get_bookmark. */ 3320 static gdb_byte * 3321 dummy_get_bookmark (char *ignore1, int ignore2) 3322 { 3323 tcomplain (); 3324 return NULL; 3325 } 3326 3327 /* Error-catcher for target_goto_bookmark. */ 3328 static void 3329 dummy_goto_bookmark (gdb_byte *ignore, int from_tty) 3330 { 3331 tcomplain (); 3332 } 3333 3334 /* Set up the handful of non-empty slots needed by the dummy target 3335 vector. */ 3336 3337 static void 3338 init_dummy_target (void) 3339 { 3340 dummy_target.to_shortname = "None"; 3341 dummy_target.to_longname = "None"; 3342 dummy_target.to_doc = ""; 3343 dummy_target.to_attach = find_default_attach; 3344 dummy_target.to_detach = 3345 (void (*)(struct target_ops *, char *, int))target_ignore; 3346 dummy_target.to_create_inferior = find_default_create_inferior; 3347 dummy_target.to_can_async_p = find_default_can_async_p; 3348 dummy_target.to_is_async_p = find_default_is_async_p; 3349 dummy_target.to_supports_non_stop = find_default_supports_non_stop; 3350 dummy_target.to_supports_disable_randomization 3351 = find_default_supports_disable_randomization; 3352 dummy_target.to_pid_to_str = dummy_pid_to_str; 3353 dummy_target.to_stratum = dummy_stratum; 3354 dummy_target.to_find_memory_regions = dummy_find_memory_regions; 3355 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes; 3356 dummy_target.to_get_bookmark = dummy_get_bookmark; 3357 dummy_target.to_goto_bookmark = dummy_goto_bookmark; 3358 dummy_target.to_xfer_partial = default_xfer_partial; 3359 dummy_target.to_has_all_memory = (int (*) (struct target_ops *)) return_zero; 3360 dummy_target.to_has_memory = (int (*) (struct target_ops *)) return_zero; 3361 dummy_target.to_has_stack = (int (*) (struct target_ops *)) return_zero; 3362 dummy_target.to_has_registers = (int (*) (struct target_ops *)) return_zero; 3363 dummy_target.to_has_execution 3364 = (int (*) (struct target_ops *, ptid_t)) return_zero; 3365 dummy_target.to_stopped_by_watchpoint = return_zero; 3366 dummy_target.to_stopped_data_address = 3367 (int (*) (struct target_ops *, CORE_ADDR *)) return_zero; 3368 dummy_target.to_magic = OPS_MAGIC; 3369 } 3370 3371 static void 3372 debug_to_open (char *args, int from_tty) 3373 { 3374 debug_target.to_open (args, from_tty); 3375 3376 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty); 3377 } 3378 3379 void 3380 target_close (struct target_ops *targ, int quitting) 3381 { 3382 if (targ->to_xclose != NULL) 3383 targ->to_xclose (targ, quitting); 3384 else if (targ->to_close != NULL) 3385 targ->to_close (quitting); 3386 3387 if (targetdebug) 3388 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting); 3389 } 3390 3391 void 3392 target_attach (char *args, int from_tty) 3393 { 3394 struct target_ops *t; 3395 3396 for (t = current_target.beneath; t != NULL; t = t->beneath) 3397 { 3398 if (t->to_attach != NULL) 3399 { 3400 t->to_attach (t, args, from_tty); 3401 if (targetdebug) 3402 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", 3403 args, from_tty); 3404 return; 3405 } 3406 } 3407 3408 internal_error (__FILE__, __LINE__, 3409 _("could not find a target to attach")); 3410 } 3411 3412 int 3413 target_thread_alive (ptid_t ptid) 3414 { 3415 struct target_ops *t; 3416 3417 for (t = current_target.beneath; t != NULL; t = t->beneath) 3418 { 3419 if (t->to_thread_alive != NULL) 3420 { 3421 int retval; 3422 3423 retval = t->to_thread_alive (t, ptid); 3424 if (targetdebug) 3425 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n", 3426 PIDGET (ptid), retval); 3427 3428 return retval; 3429 } 3430 } 3431 3432 return 0; 3433 } 3434 3435 void 3436 target_find_new_threads (void) 3437 { 3438 struct target_ops *t; 3439 3440 for (t = current_target.beneath; t != NULL; t = t->beneath) 3441 { 3442 if (t->to_find_new_threads != NULL) 3443 { 3444 t->to_find_new_threads (t); 3445 if (targetdebug) 3446 fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n"); 3447 3448 return; 3449 } 3450 } 3451 } 3452 3453 void 3454 target_stop (ptid_t ptid) 3455 { 3456 if (!may_stop) 3457 { 3458 warning (_("May not interrupt or stop the target, ignoring attempt")); 3459 return; 3460 } 3461 3462 (*current_target.to_stop) (ptid); 3463 } 3464 3465 static void 3466 debug_to_post_attach (int pid) 3467 { 3468 debug_target.to_post_attach (pid); 3469 3470 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid); 3471 } 3472 3473 /* Return a pretty printed form of target_waitstatus. 3474 Space for the result is malloc'd, caller must free. */ 3475 3476 char * 3477 target_waitstatus_to_string (const struct target_waitstatus *ws) 3478 { 3479 const char *kind_str = "status->kind = "; 3480 3481 switch (ws->kind) 3482 { 3483 case TARGET_WAITKIND_EXITED: 3484 return xstrprintf ("%sexited, status = %d", 3485 kind_str, ws->value.integer); 3486 case TARGET_WAITKIND_STOPPED: 3487 return xstrprintf ("%sstopped, signal = %s", 3488 kind_str, target_signal_to_name (ws->value.sig)); 3489 case TARGET_WAITKIND_SIGNALLED: 3490 return xstrprintf ("%ssignalled, signal = %s", 3491 kind_str, target_signal_to_name (ws->value.sig)); 3492 case TARGET_WAITKIND_LOADED: 3493 return xstrprintf ("%sloaded", kind_str); 3494 case TARGET_WAITKIND_FORKED: 3495 return xstrprintf ("%sforked", kind_str); 3496 case TARGET_WAITKIND_VFORKED: 3497 return xstrprintf ("%svforked", kind_str); 3498 case TARGET_WAITKIND_EXECD: 3499 return xstrprintf ("%sexecd", kind_str); 3500 case TARGET_WAITKIND_SYSCALL_ENTRY: 3501 return xstrprintf ("%sentered syscall", kind_str); 3502 case TARGET_WAITKIND_SYSCALL_RETURN: 3503 return xstrprintf ("%sexited syscall", kind_str); 3504 case TARGET_WAITKIND_SPURIOUS: 3505 return xstrprintf ("%sspurious", kind_str); 3506 case TARGET_WAITKIND_IGNORE: 3507 return xstrprintf ("%signore", kind_str); 3508 case TARGET_WAITKIND_NO_HISTORY: 3509 return xstrprintf ("%sno-history", kind_str); 3510 case TARGET_WAITKIND_NO_RESUMED: 3511 return xstrprintf ("%sno-resumed", kind_str); 3512 default: 3513 return xstrprintf ("%sunknown???", kind_str); 3514 } 3515 } 3516 3517 static void 3518 debug_print_register (const char * func, 3519 struct regcache *regcache, int regno) 3520 { 3521 struct gdbarch *gdbarch = get_regcache_arch (regcache); 3522 3523 fprintf_unfiltered (gdb_stdlog, "%s ", func); 3524 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch) 3525 && gdbarch_register_name (gdbarch, regno) != NULL 3526 && gdbarch_register_name (gdbarch, regno)[0] != '\0') 3527 fprintf_unfiltered (gdb_stdlog, "(%s)", 3528 gdbarch_register_name (gdbarch, regno)); 3529 else 3530 fprintf_unfiltered (gdb_stdlog, "(%d)", regno); 3531 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)) 3532 { 3533 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 3534 int i, size = register_size (gdbarch, regno); 3535 unsigned char buf[MAX_REGISTER_SIZE]; 3536 3537 regcache_raw_collect (regcache, regno, buf); 3538 fprintf_unfiltered (gdb_stdlog, " = "); 3539 for (i = 0; i < size; i++) 3540 { 3541 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]); 3542 } 3543 if (size <= sizeof (LONGEST)) 3544 { 3545 ULONGEST val = extract_unsigned_integer (buf, size, byte_order); 3546 3547 fprintf_unfiltered (gdb_stdlog, " %s %s", 3548 core_addr_to_string_nz (val), plongest (val)); 3549 } 3550 } 3551 fprintf_unfiltered (gdb_stdlog, "\n"); 3552 } 3553 3554 void 3555 target_fetch_registers (struct regcache *regcache, int regno) 3556 { 3557 struct target_ops *t; 3558 3559 for (t = current_target.beneath; t != NULL; t = t->beneath) 3560 { 3561 if (t->to_fetch_registers != NULL) 3562 { 3563 t->to_fetch_registers (t, regcache, regno); 3564 if (targetdebug) 3565 debug_print_register ("target_fetch_registers", regcache, regno); 3566 return; 3567 } 3568 } 3569 } 3570 3571 void 3572 target_store_registers (struct regcache *regcache, int regno) 3573 { 3574 struct target_ops *t; 3575 3576 if (!may_write_registers) 3577 error (_("Writing to registers is not allowed (regno %d)"), regno); 3578 3579 for (t = current_target.beneath; t != NULL; t = t->beneath) 3580 { 3581 if (t->to_store_registers != NULL) 3582 { 3583 t->to_store_registers (t, regcache, regno); 3584 if (targetdebug) 3585 { 3586 debug_print_register ("target_store_registers", regcache, regno); 3587 } 3588 return; 3589 } 3590 } 3591 3592 noprocess (); 3593 } 3594 3595 int 3596 target_core_of_thread (ptid_t ptid) 3597 { 3598 struct target_ops *t; 3599 3600 for (t = current_target.beneath; t != NULL; t = t->beneath) 3601 { 3602 if (t->to_core_of_thread != NULL) 3603 { 3604 int retval = t->to_core_of_thread (t, ptid); 3605 3606 if (targetdebug) 3607 fprintf_unfiltered (gdb_stdlog, 3608 "target_core_of_thread (%d) = %d\n", 3609 PIDGET (ptid), retval); 3610 return retval; 3611 } 3612 } 3613 3614 return -1; 3615 } 3616 3617 int 3618 target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size) 3619 { 3620 struct target_ops *t; 3621 3622 for (t = current_target.beneath; t != NULL; t = t->beneath) 3623 { 3624 if (t->to_verify_memory != NULL) 3625 { 3626 int retval = t->to_verify_memory (t, data, memaddr, size); 3627 3628 if (targetdebug) 3629 fprintf_unfiltered (gdb_stdlog, 3630 "target_verify_memory (%s, %s) = %d\n", 3631 paddress (target_gdbarch, memaddr), 3632 pulongest (size), 3633 retval); 3634 return retval; 3635 } 3636 } 3637 3638 tcomplain (); 3639 } 3640 3641 /* The documentation for this function is in its prototype declaration in 3642 target.h. */ 3643 3644 int 3645 target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw) 3646 { 3647 struct target_ops *t; 3648 3649 for (t = current_target.beneath; t != NULL; t = t->beneath) 3650 if (t->to_insert_mask_watchpoint != NULL) 3651 { 3652 int ret; 3653 3654 ret = t->to_insert_mask_watchpoint (t, addr, mask, rw); 3655 3656 if (targetdebug) 3657 fprintf_unfiltered (gdb_stdlog, "\ 3658 target_insert_mask_watchpoint (%s, %s, %d) = %d\n", 3659 core_addr_to_string (addr), 3660 core_addr_to_string (mask), rw, ret); 3661 3662 return ret; 3663 } 3664 3665 return 1; 3666 } 3667 3668 /* The documentation for this function is in its prototype declaration in 3669 target.h. */ 3670 3671 int 3672 target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw) 3673 { 3674 struct target_ops *t; 3675 3676 for (t = current_target.beneath; t != NULL; t = t->beneath) 3677 if (t->to_remove_mask_watchpoint != NULL) 3678 { 3679 int ret; 3680 3681 ret = t->to_remove_mask_watchpoint (t, addr, mask, rw); 3682 3683 if (targetdebug) 3684 fprintf_unfiltered (gdb_stdlog, "\ 3685 target_remove_mask_watchpoint (%s, %s, %d) = %d\n", 3686 core_addr_to_string (addr), 3687 core_addr_to_string (mask), rw, ret); 3688 3689 return ret; 3690 } 3691 3692 return 1; 3693 } 3694 3695 /* The documentation for this function is in its prototype declaration 3696 in target.h. */ 3697 3698 int 3699 target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask) 3700 { 3701 struct target_ops *t; 3702 3703 for (t = current_target.beneath; t != NULL; t = t->beneath) 3704 if (t->to_masked_watch_num_registers != NULL) 3705 return t->to_masked_watch_num_registers (t, addr, mask); 3706 3707 return -1; 3708 } 3709 3710 /* The documentation for this function is in its prototype declaration 3711 in target.h. */ 3712 3713 int 3714 target_ranged_break_num_registers (void) 3715 { 3716 struct target_ops *t; 3717 3718 for (t = current_target.beneath; t != NULL; t = t->beneath) 3719 if (t->to_ranged_break_num_registers != NULL) 3720 return t->to_ranged_break_num_registers (t); 3721 3722 return -1; 3723 } 3724 3725 static void 3726 debug_to_prepare_to_store (struct regcache *regcache) 3727 { 3728 debug_target.to_prepare_to_store (regcache); 3729 3730 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n"); 3731 } 3732 3733 static int 3734 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len, 3735 int write, struct mem_attrib *attrib, 3736 struct target_ops *target) 3737 { 3738 int retval; 3739 3740 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write, 3741 attrib, target); 3742 3743 fprintf_unfiltered (gdb_stdlog, 3744 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d", 3745 paddress (target_gdbarch, memaddr), len, 3746 write ? "write" : "read", retval); 3747 3748 if (retval > 0) 3749 { 3750 int i; 3751 3752 fputs_unfiltered (", bytes =", gdb_stdlog); 3753 for (i = 0; i < retval; i++) 3754 { 3755 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0) 3756 { 3757 if (targetdebug < 2 && i > 0) 3758 { 3759 fprintf_unfiltered (gdb_stdlog, " ..."); 3760 break; 3761 } 3762 fprintf_unfiltered (gdb_stdlog, "\n"); 3763 } 3764 3765 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff); 3766 } 3767 } 3768 3769 fputc_unfiltered ('\n', gdb_stdlog); 3770 3771 return retval; 3772 } 3773 3774 static void 3775 debug_to_files_info (struct target_ops *target) 3776 { 3777 debug_target.to_files_info (target); 3778 3779 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n"); 3780 } 3781 3782 static int 3783 debug_to_insert_breakpoint (struct gdbarch *gdbarch, 3784 struct bp_target_info *bp_tgt) 3785 { 3786 int retval; 3787 3788 retval = debug_target.to_insert_breakpoint (gdbarch, bp_tgt); 3789 3790 fprintf_unfiltered (gdb_stdlog, 3791 "target_insert_breakpoint (%s, xxx) = %ld\n", 3792 core_addr_to_string (bp_tgt->placed_address), 3793 (unsigned long) retval); 3794 return retval; 3795 } 3796 3797 static int 3798 debug_to_remove_breakpoint (struct gdbarch *gdbarch, 3799 struct bp_target_info *bp_tgt) 3800 { 3801 int retval; 3802 3803 retval = debug_target.to_remove_breakpoint (gdbarch, bp_tgt); 3804 3805 fprintf_unfiltered (gdb_stdlog, 3806 "target_remove_breakpoint (%s, xxx) = %ld\n", 3807 core_addr_to_string (bp_tgt->placed_address), 3808 (unsigned long) retval); 3809 return retval; 3810 } 3811 3812 static int 3813 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty) 3814 { 3815 int retval; 3816 3817 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty); 3818 3819 fprintf_unfiltered (gdb_stdlog, 3820 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n", 3821 (unsigned long) type, 3822 (unsigned long) cnt, 3823 (unsigned long) from_tty, 3824 (unsigned long) retval); 3825 return retval; 3826 } 3827 3828 static int 3829 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) 3830 { 3831 CORE_ADDR retval; 3832 3833 retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len); 3834 3835 fprintf_unfiltered (gdb_stdlog, 3836 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n", 3837 core_addr_to_string (addr), (unsigned long) len, 3838 core_addr_to_string (retval)); 3839 return retval; 3840 } 3841 3842 static int 3843 debug_to_can_accel_watchpoint_condition (CORE_ADDR addr, int len, int rw, 3844 struct expression *cond) 3845 { 3846 int retval; 3847 3848 retval = debug_target.to_can_accel_watchpoint_condition (addr, len, 3849 rw, cond); 3850 3851 fprintf_unfiltered (gdb_stdlog, 3852 "target_can_accel_watchpoint_condition " 3853 "(%s, %d, %d, %s) = %ld\n", 3854 core_addr_to_string (addr), len, rw, 3855 host_address_to_string (cond), (unsigned long) retval); 3856 return retval; 3857 } 3858 3859 static int 3860 debug_to_stopped_by_watchpoint (void) 3861 { 3862 int retval; 3863 3864 retval = debug_target.to_stopped_by_watchpoint (); 3865 3866 fprintf_unfiltered (gdb_stdlog, 3867 "target_stopped_by_watchpoint () = %ld\n", 3868 (unsigned long) retval); 3869 return retval; 3870 } 3871 3872 static int 3873 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr) 3874 { 3875 int retval; 3876 3877 retval = debug_target.to_stopped_data_address (target, addr); 3878 3879 fprintf_unfiltered (gdb_stdlog, 3880 "target_stopped_data_address ([%s]) = %ld\n", 3881 core_addr_to_string (*addr), 3882 (unsigned long)retval); 3883 return retval; 3884 } 3885 3886 static int 3887 debug_to_watchpoint_addr_within_range (struct target_ops *target, 3888 CORE_ADDR addr, 3889 CORE_ADDR start, int length) 3890 { 3891 int retval; 3892 3893 retval = debug_target.to_watchpoint_addr_within_range (target, addr, 3894 start, length); 3895 3896 fprintf_filtered (gdb_stdlog, 3897 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n", 3898 core_addr_to_string (addr), core_addr_to_string (start), 3899 length, retval); 3900 return retval; 3901 } 3902 3903 static int 3904 debug_to_insert_hw_breakpoint (struct gdbarch *gdbarch, 3905 struct bp_target_info *bp_tgt) 3906 { 3907 int retval; 3908 3909 retval = debug_target.to_insert_hw_breakpoint (gdbarch, bp_tgt); 3910 3911 fprintf_unfiltered (gdb_stdlog, 3912 "target_insert_hw_breakpoint (%s, xxx) = %ld\n", 3913 core_addr_to_string (bp_tgt->placed_address), 3914 (unsigned long) retval); 3915 return retval; 3916 } 3917 3918 static int 3919 debug_to_remove_hw_breakpoint (struct gdbarch *gdbarch, 3920 struct bp_target_info *bp_tgt) 3921 { 3922 int retval; 3923 3924 retval = debug_target.to_remove_hw_breakpoint (gdbarch, bp_tgt); 3925 3926 fprintf_unfiltered (gdb_stdlog, 3927 "target_remove_hw_breakpoint (%s, xxx) = %ld\n", 3928 core_addr_to_string (bp_tgt->placed_address), 3929 (unsigned long) retval); 3930 return retval; 3931 } 3932 3933 static int 3934 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type, 3935 struct expression *cond) 3936 { 3937 int retval; 3938 3939 retval = debug_target.to_insert_watchpoint (addr, len, type, cond); 3940 3941 fprintf_unfiltered (gdb_stdlog, 3942 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n", 3943 core_addr_to_string (addr), len, type, 3944 host_address_to_string (cond), (unsigned long) retval); 3945 return retval; 3946 } 3947 3948 static int 3949 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type, 3950 struct expression *cond) 3951 { 3952 int retval; 3953 3954 retval = debug_target.to_remove_watchpoint (addr, len, type, cond); 3955 3956 fprintf_unfiltered (gdb_stdlog, 3957 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n", 3958 core_addr_to_string (addr), len, type, 3959 host_address_to_string (cond), (unsigned long) retval); 3960 return retval; 3961 } 3962 3963 static void 3964 debug_to_terminal_init (void) 3965 { 3966 debug_target.to_terminal_init (); 3967 3968 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n"); 3969 } 3970 3971 static void 3972 debug_to_terminal_inferior (void) 3973 { 3974 debug_target.to_terminal_inferior (); 3975 3976 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n"); 3977 } 3978 3979 static void 3980 debug_to_terminal_ours_for_output (void) 3981 { 3982 debug_target.to_terminal_ours_for_output (); 3983 3984 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n"); 3985 } 3986 3987 static void 3988 debug_to_terminal_ours (void) 3989 { 3990 debug_target.to_terminal_ours (); 3991 3992 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n"); 3993 } 3994 3995 static void 3996 debug_to_terminal_save_ours (void) 3997 { 3998 debug_target.to_terminal_save_ours (); 3999 4000 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n"); 4001 } 4002 4003 static void 4004 debug_to_terminal_info (char *arg, int from_tty) 4005 { 4006 debug_target.to_terminal_info (arg, from_tty); 4007 4008 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg, 4009 from_tty); 4010 } 4011 4012 static void 4013 debug_to_load (char *args, int from_tty) 4014 { 4015 debug_target.to_load (args, from_tty); 4016 4017 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty); 4018 } 4019 4020 static void 4021 debug_to_post_startup_inferior (ptid_t ptid) 4022 { 4023 debug_target.to_post_startup_inferior (ptid); 4024 4025 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n", 4026 PIDGET (ptid)); 4027 } 4028 4029 static int 4030 debug_to_insert_fork_catchpoint (int pid) 4031 { 4032 int retval; 4033 4034 retval = debug_target.to_insert_fork_catchpoint (pid); 4035 4036 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n", 4037 pid, retval); 4038 4039 return retval; 4040 } 4041 4042 static int 4043 debug_to_remove_fork_catchpoint (int pid) 4044 { 4045 int retval; 4046 4047 retval = debug_target.to_remove_fork_catchpoint (pid); 4048 4049 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n", 4050 pid, retval); 4051 4052 return retval; 4053 } 4054 4055 static int 4056 debug_to_insert_vfork_catchpoint (int pid) 4057 { 4058 int retval; 4059 4060 retval = debug_target.to_insert_vfork_catchpoint (pid); 4061 4062 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n", 4063 pid, retval); 4064 4065 return retval; 4066 } 4067 4068 static int 4069 debug_to_remove_vfork_catchpoint (int pid) 4070 { 4071 int retval; 4072 4073 retval = debug_target.to_remove_vfork_catchpoint (pid); 4074 4075 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n", 4076 pid, retval); 4077 4078 return retval; 4079 } 4080 4081 static int 4082 debug_to_insert_exec_catchpoint (int pid) 4083 { 4084 int retval; 4085 4086 retval = debug_target.to_insert_exec_catchpoint (pid); 4087 4088 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n", 4089 pid, retval); 4090 4091 return retval; 4092 } 4093 4094 static int 4095 debug_to_remove_exec_catchpoint (int pid) 4096 { 4097 int retval; 4098 4099 retval = debug_target.to_remove_exec_catchpoint (pid); 4100 4101 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n", 4102 pid, retval); 4103 4104 return retval; 4105 } 4106 4107 static int 4108 debug_to_has_exited (int pid, int wait_status, int *exit_status) 4109 { 4110 int has_exited; 4111 4112 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status); 4113 4114 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n", 4115 pid, wait_status, *exit_status, has_exited); 4116 4117 return has_exited; 4118 } 4119 4120 static int 4121 debug_to_can_run (void) 4122 { 4123 int retval; 4124 4125 retval = debug_target.to_can_run (); 4126 4127 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval); 4128 4129 return retval; 4130 } 4131 4132 static struct gdbarch * 4133 debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid) 4134 { 4135 struct gdbarch *retval; 4136 4137 retval = debug_target.to_thread_architecture (ops, ptid); 4138 4139 fprintf_unfiltered (gdb_stdlog, 4140 "target_thread_architecture (%s) = %s [%s]\n", 4141 target_pid_to_str (ptid), 4142 host_address_to_string (retval), 4143 gdbarch_bfd_arch_info (retval)->printable_name); 4144 return retval; 4145 } 4146 4147 static void 4148 debug_to_stop (ptid_t ptid) 4149 { 4150 debug_target.to_stop (ptid); 4151 4152 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n", 4153 target_pid_to_str (ptid)); 4154 } 4155 4156 static void 4157 debug_to_rcmd (char *command, 4158 struct ui_file *outbuf) 4159 { 4160 debug_target.to_rcmd (command, outbuf); 4161 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command); 4162 } 4163 4164 static char * 4165 debug_to_pid_to_exec_file (int pid) 4166 { 4167 char *exec_file; 4168 4169 exec_file = debug_target.to_pid_to_exec_file (pid); 4170 4171 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n", 4172 pid, exec_file); 4173 4174 return exec_file; 4175 } 4176 4177 static void 4178 setup_target_debug (void) 4179 { 4180 memcpy (&debug_target, ¤t_target, sizeof debug_target); 4181 4182 current_target.to_open = debug_to_open; 4183 current_target.to_post_attach = debug_to_post_attach; 4184 current_target.to_prepare_to_store = debug_to_prepare_to_store; 4185 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory; 4186 current_target.to_files_info = debug_to_files_info; 4187 current_target.to_insert_breakpoint = debug_to_insert_breakpoint; 4188 current_target.to_remove_breakpoint = debug_to_remove_breakpoint; 4189 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint; 4190 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint; 4191 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint; 4192 current_target.to_insert_watchpoint = debug_to_insert_watchpoint; 4193 current_target.to_remove_watchpoint = debug_to_remove_watchpoint; 4194 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint; 4195 current_target.to_stopped_data_address = debug_to_stopped_data_address; 4196 current_target.to_watchpoint_addr_within_range 4197 = debug_to_watchpoint_addr_within_range; 4198 current_target.to_region_ok_for_hw_watchpoint 4199 = debug_to_region_ok_for_hw_watchpoint; 4200 current_target.to_can_accel_watchpoint_condition 4201 = debug_to_can_accel_watchpoint_condition; 4202 current_target.to_terminal_init = debug_to_terminal_init; 4203 current_target.to_terminal_inferior = debug_to_terminal_inferior; 4204 current_target.to_terminal_ours_for_output 4205 = debug_to_terminal_ours_for_output; 4206 current_target.to_terminal_ours = debug_to_terminal_ours; 4207 current_target.to_terminal_save_ours = debug_to_terminal_save_ours; 4208 current_target.to_terminal_info = debug_to_terminal_info; 4209 current_target.to_load = debug_to_load; 4210 current_target.to_post_startup_inferior = debug_to_post_startup_inferior; 4211 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint; 4212 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint; 4213 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint; 4214 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint; 4215 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint; 4216 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint; 4217 current_target.to_has_exited = debug_to_has_exited; 4218 current_target.to_can_run = debug_to_can_run; 4219 current_target.to_stop = debug_to_stop; 4220 current_target.to_rcmd = debug_to_rcmd; 4221 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file; 4222 current_target.to_thread_architecture = debug_to_thread_architecture; 4223 } 4224 4225 4226 static char targ_desc[] = 4227 "Names of targets and files being debugged.\nShows the entire \ 4228 stack of targets currently in use (including the exec-file,\n\ 4229 core-file, and process, if any), as well as the symbol file name."; 4230 4231 static void 4232 do_monitor_command (char *cmd, 4233 int from_tty) 4234 { 4235 if ((current_target.to_rcmd 4236 == (void (*) (char *, struct ui_file *)) tcomplain) 4237 || (current_target.to_rcmd == debug_to_rcmd 4238 && (debug_target.to_rcmd 4239 == (void (*) (char *, struct ui_file *)) tcomplain))) 4240 error (_("\"monitor\" command not supported by this target.")); 4241 target_rcmd (cmd, gdb_stdtarg); 4242 } 4243 4244 /* Print the name of each layers of our target stack. */ 4245 4246 static void 4247 maintenance_print_target_stack (char *cmd, int from_tty) 4248 { 4249 struct target_ops *t; 4250 4251 printf_filtered (_("The current target stack is:\n")); 4252 4253 for (t = target_stack; t != NULL; t = t->beneath) 4254 { 4255 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname); 4256 } 4257 } 4258 4259 /* Controls if async mode is permitted. */ 4260 int target_async_permitted = 0; 4261 4262 /* The set command writes to this variable. If the inferior is 4263 executing, linux_nat_async_permitted is *not* updated. */ 4264 static int target_async_permitted_1 = 0; 4265 4266 static void 4267 set_maintenance_target_async_permitted (char *args, int from_tty, 4268 struct cmd_list_element *c) 4269 { 4270 if (have_live_inferiors ()) 4271 { 4272 target_async_permitted_1 = target_async_permitted; 4273 error (_("Cannot change this setting while the inferior is running.")); 4274 } 4275 4276 target_async_permitted = target_async_permitted_1; 4277 } 4278 4279 static void 4280 show_maintenance_target_async_permitted (struct ui_file *file, int from_tty, 4281 struct cmd_list_element *c, 4282 const char *value) 4283 { 4284 fprintf_filtered (file, 4285 _("Controlling the inferior in " 4286 "asynchronous mode is %s.\n"), value); 4287 } 4288 4289 /* Temporary copies of permission settings. */ 4290 4291 static int may_write_registers_1 = 1; 4292 static int may_write_memory_1 = 1; 4293 static int may_insert_breakpoints_1 = 1; 4294 static int may_insert_tracepoints_1 = 1; 4295 static int may_insert_fast_tracepoints_1 = 1; 4296 static int may_stop_1 = 1; 4297 4298 /* Make the user-set values match the real values again. */ 4299 4300 void 4301 update_target_permissions (void) 4302 { 4303 may_write_registers_1 = may_write_registers; 4304 may_write_memory_1 = may_write_memory; 4305 may_insert_breakpoints_1 = may_insert_breakpoints; 4306 may_insert_tracepoints_1 = may_insert_tracepoints; 4307 may_insert_fast_tracepoints_1 = may_insert_fast_tracepoints; 4308 may_stop_1 = may_stop; 4309 } 4310 4311 /* The one function handles (most of) the permission flags in the same 4312 way. */ 4313 4314 static void 4315 set_target_permissions (char *args, int from_tty, 4316 struct cmd_list_element *c) 4317 { 4318 if (target_has_execution) 4319 { 4320 update_target_permissions (); 4321 error (_("Cannot change this setting while the inferior is running.")); 4322 } 4323 4324 /* Make the real values match the user-changed values. */ 4325 may_write_registers = may_write_registers_1; 4326 may_insert_breakpoints = may_insert_breakpoints_1; 4327 may_insert_tracepoints = may_insert_tracepoints_1; 4328 may_insert_fast_tracepoints = may_insert_fast_tracepoints_1; 4329 may_stop = may_stop_1; 4330 update_observer_mode (); 4331 } 4332 4333 /* Set memory write permission independently of observer mode. */ 4334 4335 static void 4336 set_write_memory_permission (char *args, int from_tty, 4337 struct cmd_list_element *c) 4338 { 4339 /* Make the real values match the user-changed values. */ 4340 may_write_memory = may_write_memory_1; 4341 update_observer_mode (); 4342 } 4343 4344 4345 void 4346 initialize_targets (void) 4347 { 4348 init_dummy_target (); 4349 push_target (&dummy_target); 4350 4351 add_info ("target", target_info, targ_desc); 4352 add_info ("files", target_info, targ_desc); 4353 4354 add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\ 4355 Set target debugging."), _("\ 4356 Show target debugging."), _("\ 4357 When non-zero, target debugging is enabled. Higher numbers are more\n\ 4358 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\ 4359 command."), 4360 NULL, 4361 show_targetdebug, 4362 &setdebuglist, &showdebuglist); 4363 4364 add_setshow_boolean_cmd ("trust-readonly-sections", class_support, 4365 &trust_readonly, _("\ 4366 Set mode for reading from readonly sections."), _("\ 4367 Show mode for reading from readonly sections."), _("\ 4368 When this mode is on, memory reads from readonly sections (such as .text)\n\ 4369 will be read from the object file instead of from the target. This will\n\ 4370 result in significant performance improvement for remote targets."), 4371 NULL, 4372 show_trust_readonly, 4373 &setlist, &showlist); 4374 4375 add_com ("monitor", class_obscure, do_monitor_command, 4376 _("Send a command to the remote monitor (remote targets only).")); 4377 4378 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack, 4379 _("Print the name of each layer of the internal target stack."), 4380 &maintenanceprintlist); 4381 4382 add_setshow_boolean_cmd ("target-async", no_class, 4383 &target_async_permitted_1, _("\ 4384 Set whether gdb controls the inferior in asynchronous mode."), _("\ 4385 Show whether gdb controls the inferior in asynchronous mode."), _("\ 4386 Tells gdb whether to control the inferior in asynchronous mode."), 4387 set_maintenance_target_async_permitted, 4388 show_maintenance_target_async_permitted, 4389 &setlist, 4390 &showlist); 4391 4392 add_setshow_boolean_cmd ("stack-cache", class_support, 4393 &stack_cache_enabled_p_1, _("\ 4394 Set cache use for stack access."), _("\ 4395 Show cache use for stack access."), _("\ 4396 When on, use the data cache for all stack access, regardless of any\n\ 4397 configured memory regions. This improves remote performance significantly.\n\ 4398 By default, caching for stack access is on."), 4399 set_stack_cache_enabled_p, 4400 show_stack_cache_enabled_p, 4401 &setlist, &showlist); 4402 4403 add_setshow_boolean_cmd ("may-write-registers", class_support, 4404 &may_write_registers_1, _("\ 4405 Set permission to write into registers."), _("\ 4406 Show permission to write into registers."), _("\ 4407 When this permission is on, GDB may write into the target's registers.\n\ 4408 Otherwise, any sort of write attempt will result in an error."), 4409 set_target_permissions, NULL, 4410 &setlist, &showlist); 4411 4412 add_setshow_boolean_cmd ("may-write-memory", class_support, 4413 &may_write_memory_1, _("\ 4414 Set permission to write into target memory."), _("\ 4415 Show permission to write into target memory."), _("\ 4416 When this permission is on, GDB may write into the target's memory.\n\ 4417 Otherwise, any sort of write attempt will result in an error."), 4418 set_write_memory_permission, NULL, 4419 &setlist, &showlist); 4420 4421 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support, 4422 &may_insert_breakpoints_1, _("\ 4423 Set permission to insert breakpoints in the target."), _("\ 4424 Show permission to insert breakpoints in the target."), _("\ 4425 When this permission is on, GDB may insert breakpoints in the program.\n\ 4426 Otherwise, any sort of insertion attempt will result in an error."), 4427 set_target_permissions, NULL, 4428 &setlist, &showlist); 4429 4430 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support, 4431 &may_insert_tracepoints_1, _("\ 4432 Set permission to insert tracepoints in the target."), _("\ 4433 Show permission to insert tracepoints in the target."), _("\ 4434 When this permission is on, GDB may insert tracepoints in the program.\n\ 4435 Otherwise, any sort of insertion attempt will result in an error."), 4436 set_target_permissions, NULL, 4437 &setlist, &showlist); 4438 4439 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support, 4440 &may_insert_fast_tracepoints_1, _("\ 4441 Set permission to insert fast tracepoints in the target."), _("\ 4442 Show permission to insert fast tracepoints in the target."), _("\ 4443 When this permission is on, GDB may insert fast tracepoints.\n\ 4444 Otherwise, any sort of insertion attempt will result in an error."), 4445 set_target_permissions, NULL, 4446 &setlist, &showlist); 4447 4448 add_setshow_boolean_cmd ("may-interrupt", class_support, 4449 &may_stop_1, _("\ 4450 Set permission to interrupt or signal the target."), _("\ 4451 Show permission to interrupt or signal the target."), _("\ 4452 When this permission is on, GDB may interrupt/stop the target's execution.\n\ 4453 Otherwise, any attempt to interrupt or stop will be ignored."), 4454 set_target_permissions, NULL, 4455 &setlist, &showlist); 4456 4457 4458 target_dcache = dcache_init (); 4459 } 4460