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