1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
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.
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.
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/>. */
26 #include "target-dcache.h"
36 #include "gdb_assert.h"
38 #include "exceptions.h"
39 #include "target-descriptions.h"
40 #include "gdbthread.h"
43 #include "inline-frame.h"
44 #include "tracepoint.h"
45 #include "gdb/fileio.h"
48 static void target_info (char *, int);
50 static void default_terminal_info (const char *, int);
52 static int default_watchpoint_addr_within_range (struct target_ops
*,
53 CORE_ADDR
, CORE_ADDR
, int);
55 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
57 static void tcomplain (void) ATTRIBUTE_NORETURN
;
59 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
61 static int return_zero (void);
63 static int return_one (void);
65 static int return_minus_one (void);
67 static void *return_null (void);
69 void target_ignore (void);
71 static void target_command (char *, int);
73 static struct target_ops
*find_default_run_target (char *);
75 static target_xfer_partial_ftype default_xfer_partial
;
77 static target_xfer_partial_ftype current_xfer_partial
;
79 static struct gdbarch
*default_thread_architecture (struct target_ops
*ops
,
82 static void init_dummy_target (void);
84 static struct target_ops debug_target
;
86 static void debug_to_open (char *, int);
88 static void debug_to_prepare_to_store (struct target_ops
*self
,
91 static void debug_to_files_info (struct target_ops
*);
93 static int debug_to_insert_breakpoint (struct target_ops
*, struct gdbarch
*,
94 struct bp_target_info
*);
96 static int debug_to_remove_breakpoint (struct target_ops
*, struct gdbarch
*,
97 struct bp_target_info
*);
99 static int debug_to_can_use_hw_breakpoint (int, int, int);
101 static int debug_to_insert_hw_breakpoint (struct gdbarch
*,
102 struct bp_target_info
*);
104 static int debug_to_remove_hw_breakpoint (struct gdbarch
*,
105 struct bp_target_info
*);
107 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int,
108 struct expression
*);
110 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int,
111 struct expression
*);
113 static int debug_to_stopped_by_watchpoint (void);
115 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
117 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
118 CORE_ADDR
, CORE_ADDR
, int);
120 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
122 static int debug_to_can_accel_watchpoint_condition (CORE_ADDR
, int, int,
123 struct expression
*);
125 static void debug_to_terminal_init (void);
127 static void debug_to_terminal_inferior (void);
129 static void debug_to_terminal_ours_for_output (void);
131 static void debug_to_terminal_save_ours (void);
133 static void debug_to_terminal_ours (void);
135 static void debug_to_load (char *, int);
137 static int debug_to_can_run (void);
139 static void debug_to_stop (ptid_t
);
141 /* Pointer to array of target architecture structures; the size of the
142 array; the current index into the array; the allocated size of the
144 struct target_ops
**target_structs
;
145 unsigned target_struct_size
;
146 unsigned target_struct_allocsize
;
147 #define DEFAULT_ALLOCSIZE 10
149 /* The initial current target, so that there is always a semi-valid
152 static struct target_ops dummy_target
;
154 /* Top of target stack. */
156 static struct target_ops
*target_stack
;
158 /* The target structure we are currently using to talk to a process
159 or file or whatever "inferior" we have. */
161 struct target_ops current_target
;
163 /* Command list for target. */
165 static struct cmd_list_element
*targetlist
= NULL
;
167 /* Nonzero if we should trust readonly sections from the
168 executable when reading memory. */
170 static int trust_readonly
= 0;
172 /* Nonzero if we should show true memory content including
173 memory breakpoint inserted by gdb. */
175 static int show_memory_breakpoints
= 0;
177 /* These globals control whether GDB attempts to perform these
178 operations; they are useful for targets that need to prevent
179 inadvertant disruption, such as in non-stop mode. */
181 int may_write_registers
= 1;
183 int may_write_memory
= 1;
185 int may_insert_breakpoints
= 1;
187 int may_insert_tracepoints
= 1;
189 int may_insert_fast_tracepoints
= 1;
193 /* Non-zero if we want to see trace of target level stuff. */
195 static unsigned int targetdebug
= 0;
197 show_targetdebug (struct ui_file
*file
, int from_tty
,
198 struct cmd_list_element
*c
, const char *value
)
200 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
203 static void setup_target_debug (void);
205 /* The user just typed 'target' without the name of a target. */
208 target_command (char *arg
, int from_tty
)
210 fputs_filtered ("Argument required (target name). Try `help target'\n",
214 /* Default target_has_* methods for process_stratum targets. */
217 default_child_has_all_memory (struct target_ops
*ops
)
219 /* If no inferior selected, then we can't read memory here. */
220 if (ptid_equal (inferior_ptid
, null_ptid
))
227 default_child_has_memory (struct target_ops
*ops
)
229 /* If no inferior selected, then we can't read memory here. */
230 if (ptid_equal (inferior_ptid
, null_ptid
))
237 default_child_has_stack (struct target_ops
*ops
)
239 /* If no inferior selected, there's no stack. */
240 if (ptid_equal (inferior_ptid
, null_ptid
))
247 default_child_has_registers (struct target_ops
*ops
)
249 /* Can't read registers from no inferior. */
250 if (ptid_equal (inferior_ptid
, null_ptid
))
257 default_child_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
259 /* If there's no thread selected, then we can't make it run through
261 if (ptid_equal (the_ptid
, null_ptid
))
269 target_has_all_memory_1 (void)
271 struct target_ops
*t
;
273 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
274 if (t
->to_has_all_memory (t
))
281 target_has_memory_1 (void)
283 struct target_ops
*t
;
285 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
286 if (t
->to_has_memory (t
))
293 target_has_stack_1 (void)
295 struct target_ops
*t
;
297 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
298 if (t
->to_has_stack (t
))
305 target_has_registers_1 (void)
307 struct target_ops
*t
;
309 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
310 if (t
->to_has_registers (t
))
317 target_has_execution_1 (ptid_t the_ptid
)
319 struct target_ops
*t
;
321 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
322 if (t
->to_has_execution (t
, the_ptid
))
329 target_has_execution_current (void)
331 return target_has_execution_1 (inferior_ptid
);
334 /* Complete initialization of T. This ensures that various fields in
335 T are set, if needed by the target implementation. */
338 complete_target_initialization (struct target_ops
*t
)
340 /* Provide default values for all "must have" methods. */
341 if (t
->to_xfer_partial
== NULL
)
342 t
->to_xfer_partial
= default_xfer_partial
;
344 if (t
->to_has_all_memory
== NULL
)
345 t
->to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
347 if (t
->to_has_memory
== NULL
)
348 t
->to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
350 if (t
->to_has_stack
== NULL
)
351 t
->to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
353 if (t
->to_has_registers
== NULL
)
354 t
->to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
356 if (t
->to_has_execution
== NULL
)
357 t
->to_has_execution
= (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
360 /* Add possible target architecture T to the list and add a new
361 command 'target T->to_shortname'. Set COMPLETER as the command's
362 completer if not NULL. */
365 add_target_with_completer (struct target_ops
*t
,
366 completer_ftype
*completer
)
368 struct cmd_list_element
*c
;
370 complete_target_initialization (t
);
374 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
375 target_structs
= (struct target_ops
**) xmalloc
376 (target_struct_allocsize
* sizeof (*target_structs
));
378 if (target_struct_size
>= target_struct_allocsize
)
380 target_struct_allocsize
*= 2;
381 target_structs
= (struct target_ops
**)
382 xrealloc ((char *) target_structs
,
383 target_struct_allocsize
* sizeof (*target_structs
));
385 target_structs
[target_struct_size
++] = t
;
387 if (targetlist
== NULL
)
388 add_prefix_cmd ("target", class_run
, target_command
, _("\
389 Connect to a target machine or process.\n\
390 The first argument is the type or protocol of the target machine.\n\
391 Remaining arguments are interpreted by the target protocol. For more\n\
392 information on the arguments for a particular protocol, type\n\
393 `help target ' followed by the protocol name."),
394 &targetlist
, "target ", 0, &cmdlist
);
395 c
= add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
,
397 if (completer
!= NULL
)
398 set_cmd_completer (c
, completer
);
401 /* Add a possible target architecture to the list. */
404 add_target (struct target_ops
*t
)
406 add_target_with_completer (t
, NULL
);
412 add_deprecated_target_alias (struct target_ops
*t
, char *alias
)
414 struct cmd_list_element
*c
;
417 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
419 c
= add_cmd (alias
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
420 alt
= xstrprintf ("target %s", t
->to_shortname
);
421 deprecate_cmd (c
, alt
);
434 struct target_ops
*t
;
436 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
437 if (t
->to_kill
!= NULL
)
440 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
450 target_load (char *arg
, int from_tty
)
452 target_dcache_invalidate ();
453 (*current_target
.to_load
) (arg
, from_tty
);
457 target_create_inferior (char *exec_file
, char *args
,
458 char **env
, int from_tty
)
460 struct target_ops
*t
;
462 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
464 if (t
->to_create_inferior
!= NULL
)
466 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
468 fprintf_unfiltered (gdb_stdlog
,
469 "target_create_inferior (%s, %s, xxx, %d)\n",
470 exec_file
, args
, from_tty
);
475 internal_error (__FILE__
, __LINE__
,
476 _("could not find a target to create inferior"));
480 target_terminal_inferior (void)
482 /* A background resume (``run&'') should leave GDB in control of the
483 terminal. Use target_can_async_p, not target_is_async_p, since at
484 this point the target is not async yet. However, if sync_execution
485 is not set, we know it will become async prior to resume. */
486 if (target_can_async_p () && !sync_execution
)
489 /* If GDB is resuming the inferior in the foreground, install
490 inferior's terminal modes. */
491 (*current_target
.to_terminal_inferior
) ();
495 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
496 struct target_ops
*t
)
498 errno
= EIO
; /* Can't read/write this location. */
499 return 0; /* No bytes handled. */
505 error (_("You can't do that when your target is `%s'"),
506 current_target
.to_shortname
);
512 error (_("You can't do that without a process to debug."));
516 default_terminal_info (const char *args
, int from_tty
)
518 printf_unfiltered (_("No saved terminal information.\n"));
521 /* A default implementation for the to_get_ada_task_ptid target method.
523 This function builds the PTID by using both LWP and TID as part of
524 the PTID lwp and tid elements. The pid used is the pid of the
528 default_get_ada_task_ptid (long lwp
, long tid
)
530 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
533 static enum exec_direction_kind
534 default_execution_direction (void)
536 if (!target_can_execute_reverse
)
538 else if (!target_can_async_p ())
541 gdb_assert_not_reached ("\
542 to_execution_direction must be implemented for reverse async");
545 /* Go through the target stack from top to bottom, copying over zero
546 entries in current_target, then filling in still empty entries. In
547 effect, we are doing class inheritance through the pushed target
550 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
551 is currently implemented, is that it discards any knowledge of
552 which target an inherited method originally belonged to.
553 Consequently, new new target methods should instead explicitly and
554 locally search the target stack for the target that can handle the
558 update_current_target (void)
560 struct target_ops
*t
;
562 /* First, reset current's contents. */
563 memset (¤t_target
, 0, sizeof (current_target
));
565 #define INHERIT(FIELD, TARGET) \
566 if (!current_target.FIELD) \
567 current_target.FIELD = (TARGET)->FIELD
569 for (t
= target_stack
; t
; t
= t
->beneath
)
571 INHERIT (to_shortname
, t
);
572 INHERIT (to_longname
, t
);
574 /* Do not inherit to_open. */
575 /* Do not inherit to_close. */
576 /* Do not inherit to_attach. */
577 INHERIT (to_post_attach
, t
);
578 INHERIT (to_attach_no_wait
, t
);
579 /* Do not inherit to_detach. */
580 /* Do not inherit to_disconnect. */
581 /* Do not inherit to_resume. */
582 /* Do not inherit to_wait. */
583 /* Do not inherit to_fetch_registers. */
584 /* Do not inherit to_store_registers. */
585 INHERIT (to_prepare_to_store
, t
);
586 INHERIT (deprecated_xfer_memory
, t
);
587 INHERIT (to_files_info
, t
);
588 /* Do not inherit to_insert_breakpoint. */
589 /* Do not inherit to_remove_breakpoint. */
590 INHERIT (to_can_use_hw_breakpoint
, t
);
591 INHERIT (to_insert_hw_breakpoint
, t
);
592 INHERIT (to_remove_hw_breakpoint
, t
);
593 /* Do not inherit to_ranged_break_num_registers. */
594 INHERIT (to_insert_watchpoint
, t
);
595 INHERIT (to_remove_watchpoint
, t
);
596 /* Do not inherit to_insert_mask_watchpoint. */
597 /* Do not inherit to_remove_mask_watchpoint. */
598 INHERIT (to_stopped_data_address
, t
);
599 INHERIT (to_have_steppable_watchpoint
, t
);
600 INHERIT (to_have_continuable_watchpoint
, t
);
601 INHERIT (to_stopped_by_watchpoint
, t
);
602 INHERIT (to_watchpoint_addr_within_range
, t
);
603 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
604 INHERIT (to_can_accel_watchpoint_condition
, t
);
605 /* Do not inherit to_masked_watch_num_registers. */
606 INHERIT (to_terminal_init
, t
);
607 INHERIT (to_terminal_inferior
, t
);
608 INHERIT (to_terminal_ours_for_output
, t
);
609 INHERIT (to_terminal_ours
, t
);
610 INHERIT (to_terminal_save_ours
, t
);
611 INHERIT (to_terminal_info
, t
);
612 /* Do not inherit to_kill. */
613 INHERIT (to_load
, t
);
614 /* Do no inherit to_create_inferior. */
615 INHERIT (to_post_startup_inferior
, t
);
616 INHERIT (to_insert_fork_catchpoint
, t
);
617 INHERIT (to_remove_fork_catchpoint
, t
);
618 INHERIT (to_insert_vfork_catchpoint
, t
);
619 INHERIT (to_remove_vfork_catchpoint
, t
);
620 /* Do not inherit to_follow_fork. */
621 INHERIT (to_insert_exec_catchpoint
, t
);
622 INHERIT (to_remove_exec_catchpoint
, t
);
623 INHERIT (to_set_syscall_catchpoint
, t
);
624 INHERIT (to_has_exited
, t
);
625 /* Do not inherit to_mourn_inferior. */
626 INHERIT (to_can_run
, t
);
627 /* Do not inherit to_pass_signals. */
628 /* Do not inherit to_program_signals. */
629 /* Do not inherit to_thread_alive. */
630 /* Do not inherit to_find_new_threads. */
631 /* Do not inherit to_pid_to_str. */
632 INHERIT (to_extra_thread_info
, t
);
633 INHERIT (to_thread_name
, t
);
634 INHERIT (to_stop
, t
);
635 /* Do not inherit to_xfer_partial. */
636 INHERIT (to_rcmd
, t
);
637 INHERIT (to_pid_to_exec_file
, t
);
638 INHERIT (to_log_command
, t
);
639 INHERIT (to_stratum
, t
);
640 /* Do not inherit to_has_all_memory. */
641 /* Do not inherit to_has_memory. */
642 /* Do not inherit to_has_stack. */
643 /* Do not inherit to_has_registers. */
644 /* Do not inherit to_has_execution. */
645 INHERIT (to_has_thread_control
, t
);
646 INHERIT (to_can_async_p
, t
);
647 INHERIT (to_is_async_p
, t
);
648 INHERIT (to_async
, t
);
649 INHERIT (to_find_memory_regions
, t
);
650 INHERIT (to_make_corefile_notes
, t
);
651 INHERIT (to_get_bookmark
, t
);
652 INHERIT (to_goto_bookmark
, t
);
653 /* Do not inherit to_get_thread_local_address. */
654 INHERIT (to_can_execute_reverse
, t
);
655 INHERIT (to_execution_direction
, t
);
656 INHERIT (to_thread_architecture
, t
);
657 /* Do not inherit to_read_description. */
658 INHERIT (to_get_ada_task_ptid
, t
);
659 /* Do not inherit to_search_memory. */
660 INHERIT (to_supports_multi_process
, t
);
661 INHERIT (to_supports_enable_disable_tracepoint
, t
);
662 INHERIT (to_supports_string_tracing
, t
);
663 INHERIT (to_trace_init
, t
);
664 INHERIT (to_download_tracepoint
, t
);
665 INHERIT (to_can_download_tracepoint
, t
);
666 INHERIT (to_download_trace_state_variable
, t
);
667 INHERIT (to_enable_tracepoint
, t
);
668 INHERIT (to_disable_tracepoint
, t
);
669 INHERIT (to_trace_set_readonly_regions
, t
);
670 INHERIT (to_trace_start
, t
);
671 INHERIT (to_get_trace_status
, t
);
672 INHERIT (to_get_tracepoint_status
, t
);
673 INHERIT (to_trace_stop
, t
);
674 INHERIT (to_trace_find
, t
);
675 INHERIT (to_get_trace_state_variable_value
, t
);
676 INHERIT (to_save_trace_data
, t
);
677 INHERIT (to_upload_tracepoints
, t
);
678 INHERIT (to_upload_trace_state_variables
, t
);
679 INHERIT (to_get_raw_trace_data
, t
);
680 INHERIT (to_get_min_fast_tracepoint_insn_len
, t
);
681 INHERIT (to_set_disconnected_tracing
, t
);
682 INHERIT (to_set_circular_trace_buffer
, t
);
683 INHERIT (to_set_trace_buffer_size
, t
);
684 INHERIT (to_set_trace_notes
, t
);
685 INHERIT (to_get_tib_address
, t
);
686 INHERIT (to_set_permissions
, t
);
687 INHERIT (to_static_tracepoint_marker_at
, t
);
688 INHERIT (to_static_tracepoint_markers_by_strid
, t
);
689 INHERIT (to_traceframe_info
, t
);
690 INHERIT (to_use_agent
, t
);
691 INHERIT (to_can_use_agent
, t
);
692 INHERIT (to_augmented_libraries_svr4_read
, t
);
693 INHERIT (to_magic
, t
);
694 INHERIT (to_supports_evaluation_of_breakpoint_conditions
, t
);
695 INHERIT (to_can_run_breakpoint_commands
, t
);
696 /* Do not inherit to_memory_map. */
697 /* Do not inherit to_flash_erase. */
698 /* Do not inherit to_flash_done. */
702 /* Clean up a target struct so it no longer has any zero pointers in
703 it. Some entries are defaulted to a method that print an error,
704 others are hard-wired to a standard recursive default. */
706 #define de_fault(field, value) \
707 if (!current_target.field) \
708 current_target.field = value
711 (void (*) (char *, int))
716 de_fault (to_post_attach
,
719 de_fault (to_prepare_to_store
,
720 (void (*) (struct target_ops
*, struct regcache
*))
722 de_fault (deprecated_xfer_memory
,
723 (int (*) (CORE_ADDR
, gdb_byte
*, int, int,
724 struct mem_attrib
*, struct target_ops
*))
726 de_fault (to_files_info
,
727 (void (*) (struct target_ops
*))
729 de_fault (to_can_use_hw_breakpoint
,
730 (int (*) (int, int, int))
732 de_fault (to_insert_hw_breakpoint
,
733 (int (*) (struct gdbarch
*, struct bp_target_info
*))
735 de_fault (to_remove_hw_breakpoint
,
736 (int (*) (struct gdbarch
*, struct bp_target_info
*))
738 de_fault (to_insert_watchpoint
,
739 (int (*) (CORE_ADDR
, int, int, struct expression
*))
741 de_fault (to_remove_watchpoint
,
742 (int (*) (CORE_ADDR
, int, int, struct expression
*))
744 de_fault (to_stopped_by_watchpoint
,
747 de_fault (to_stopped_data_address
,
748 (int (*) (struct target_ops
*, CORE_ADDR
*))
750 de_fault (to_watchpoint_addr_within_range
,
751 default_watchpoint_addr_within_range
);
752 de_fault (to_region_ok_for_hw_watchpoint
,
753 default_region_ok_for_hw_watchpoint
);
754 de_fault (to_can_accel_watchpoint_condition
,
755 (int (*) (CORE_ADDR
, int, int, struct expression
*))
757 de_fault (to_terminal_init
,
760 de_fault (to_terminal_inferior
,
763 de_fault (to_terminal_ours_for_output
,
766 de_fault (to_terminal_ours
,
769 de_fault (to_terminal_save_ours
,
772 de_fault (to_terminal_info
,
773 default_terminal_info
);
775 (void (*) (char *, int))
777 de_fault (to_post_startup_inferior
,
780 de_fault (to_insert_fork_catchpoint
,
783 de_fault (to_remove_fork_catchpoint
,
786 de_fault (to_insert_vfork_catchpoint
,
789 de_fault (to_remove_vfork_catchpoint
,
792 de_fault (to_insert_exec_catchpoint
,
795 de_fault (to_remove_exec_catchpoint
,
798 de_fault (to_set_syscall_catchpoint
,
799 (int (*) (int, int, int, int, int *))
801 de_fault (to_has_exited
,
802 (int (*) (int, int, int *))
804 de_fault (to_can_run
,
806 de_fault (to_extra_thread_info
,
807 (char *(*) (struct thread_info
*))
809 de_fault (to_thread_name
,
810 (char *(*) (struct thread_info
*))
815 current_target
.to_xfer_partial
= current_xfer_partial
;
817 (void (*) (char *, struct ui_file
*))
819 de_fault (to_pid_to_exec_file
,
823 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
825 de_fault (to_thread_architecture
,
826 default_thread_architecture
);
827 current_target
.to_read_description
= NULL
;
828 de_fault (to_get_ada_task_ptid
,
829 (ptid_t (*) (long, long))
830 default_get_ada_task_ptid
);
831 de_fault (to_supports_multi_process
,
834 de_fault (to_supports_enable_disable_tracepoint
,
837 de_fault (to_supports_string_tracing
,
840 de_fault (to_trace_init
,
843 de_fault (to_download_tracepoint
,
844 (void (*) (struct bp_location
*))
846 de_fault (to_can_download_tracepoint
,
849 de_fault (to_download_trace_state_variable
,
850 (void (*) (struct trace_state_variable
*))
852 de_fault (to_enable_tracepoint
,
853 (void (*) (struct bp_location
*))
855 de_fault (to_disable_tracepoint
,
856 (void (*) (struct bp_location
*))
858 de_fault (to_trace_set_readonly_regions
,
861 de_fault (to_trace_start
,
864 de_fault (to_get_trace_status
,
865 (int (*) (struct trace_status
*))
867 de_fault (to_get_tracepoint_status
,
868 (void (*) (struct breakpoint
*, struct uploaded_tp
*))
870 de_fault (to_trace_stop
,
873 de_fault (to_trace_find
,
874 (int (*) (enum trace_find_type
, int, CORE_ADDR
, CORE_ADDR
, int *))
876 de_fault (to_get_trace_state_variable_value
,
877 (int (*) (int, LONGEST
*))
879 de_fault (to_save_trace_data
,
880 (int (*) (const char *))
882 de_fault (to_upload_tracepoints
,
883 (int (*) (struct uploaded_tp
**))
885 de_fault (to_upload_trace_state_variables
,
886 (int (*) (struct uploaded_tsv
**))
888 de_fault (to_get_raw_trace_data
,
889 (LONGEST (*) (gdb_byte
*, ULONGEST
, LONGEST
))
891 de_fault (to_get_min_fast_tracepoint_insn_len
,
894 de_fault (to_set_disconnected_tracing
,
897 de_fault (to_set_circular_trace_buffer
,
900 de_fault (to_set_trace_buffer_size
,
903 de_fault (to_set_trace_notes
,
904 (int (*) (const char *, const char *, const char *))
906 de_fault (to_get_tib_address
,
907 (int (*) (ptid_t
, CORE_ADDR
*))
909 de_fault (to_set_permissions
,
912 de_fault (to_static_tracepoint_marker_at
,
913 (int (*) (CORE_ADDR
, struct static_tracepoint_marker
*))
915 de_fault (to_static_tracepoint_markers_by_strid
,
916 (VEC(static_tracepoint_marker_p
) * (*) (const char *))
918 de_fault (to_traceframe_info
,
919 (struct traceframe_info
* (*) (void))
921 de_fault (to_supports_evaluation_of_breakpoint_conditions
,
924 de_fault (to_can_run_breakpoint_commands
,
927 de_fault (to_use_agent
,
930 de_fault (to_can_use_agent
,
933 de_fault (to_augmented_libraries_svr4_read
,
936 de_fault (to_execution_direction
, default_execution_direction
);
940 /* Finally, position the target-stack beneath the squashed
941 "current_target". That way code looking for a non-inherited
942 target method can quickly and simply find it. */
943 current_target
.beneath
= target_stack
;
946 setup_target_debug ();
949 /* Push a new target type into the stack of the existing target accessors,
950 possibly superseding some of the existing accessors.
952 Rather than allow an empty stack, we always have the dummy target at
953 the bottom stratum, so we can call the function vectors without
957 push_target (struct target_ops
*t
)
959 struct target_ops
**cur
;
961 /* Check magic number. If wrong, it probably means someone changed
962 the struct definition, but not all the places that initialize one. */
963 if (t
->to_magic
!= OPS_MAGIC
)
965 fprintf_unfiltered (gdb_stderr
,
966 "Magic number of %s target struct wrong\n",
968 internal_error (__FILE__
, __LINE__
,
969 _("failed internal consistency check"));
972 /* Find the proper stratum to install this target in. */
973 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
975 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
979 /* If there's already targets at this stratum, remove them. */
980 /* FIXME: cagney/2003-10-15: I think this should be popping all
981 targets to CUR, and not just those at this stratum level. */
982 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
984 /* There's already something at this stratum level. Close it,
985 and un-hook it from the stack. */
986 struct target_ops
*tmp
= (*cur
);
988 (*cur
) = (*cur
)->beneath
;
993 /* We have removed all targets in our stratum, now add the new one. */
997 update_current_target ();
1000 /* Remove a target_ops vector from the stack, wherever it may be.
1001 Return how many times it was removed (0 or 1). */
1004 unpush_target (struct target_ops
*t
)
1006 struct target_ops
**cur
;
1007 struct target_ops
*tmp
;
1009 if (t
->to_stratum
== dummy_stratum
)
1010 internal_error (__FILE__
, __LINE__
,
1011 _("Attempt to unpush the dummy target"));
1013 /* Look for the specified target. Note that we assume that a target
1014 can only occur once in the target stack. */
1016 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1022 /* If we don't find target_ops, quit. Only open targets should be
1027 /* Unchain the target. */
1029 (*cur
) = (*cur
)->beneath
;
1030 tmp
->beneath
= NULL
;
1032 update_current_target ();
1034 /* Finally close the target. Note we do this after unchaining, so
1035 any target method calls from within the target_close
1036 implementation don't end up in T anymore. */
1043 pop_all_targets_above (enum strata above_stratum
)
1045 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
1047 if (!unpush_target (target_stack
))
1049 fprintf_unfiltered (gdb_stderr
,
1050 "pop_all_targets couldn't find target %s\n",
1051 target_stack
->to_shortname
);
1052 internal_error (__FILE__
, __LINE__
,
1053 _("failed internal consistency check"));
1060 pop_all_targets (void)
1062 pop_all_targets_above (dummy_stratum
);
1065 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
1068 target_is_pushed (struct target_ops
*t
)
1070 struct target_ops
**cur
;
1072 /* Check magic number. If wrong, it probably means someone changed
1073 the struct definition, but not all the places that initialize one. */
1074 if (t
->to_magic
!= OPS_MAGIC
)
1076 fprintf_unfiltered (gdb_stderr
,
1077 "Magic number of %s target struct wrong\n",
1079 internal_error (__FILE__
, __LINE__
,
1080 _("failed internal consistency check"));
1083 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1090 /* Using the objfile specified in OBJFILE, find the address for the
1091 current thread's thread-local storage with offset OFFSET. */
1093 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
1095 volatile CORE_ADDR addr
= 0;
1096 struct target_ops
*target
;
1098 for (target
= current_target
.beneath
;
1100 target
= target
->beneath
)
1102 if (target
->to_get_thread_local_address
!= NULL
)
1107 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
1109 ptid_t ptid
= inferior_ptid
;
1110 volatile struct gdb_exception ex
;
1112 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1116 /* Fetch the load module address for this objfile. */
1117 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch (),
1119 /* If it's 0, throw the appropriate exception. */
1121 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
1122 _("TLS load module not found"));
1124 addr
= target
->to_get_thread_local_address (target
, ptid
,
1127 /* If an error occurred, print TLS related messages here. Otherwise,
1128 throw the error to some higher catcher. */
1131 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1135 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
1136 error (_("Cannot find thread-local variables "
1137 "in this thread library."));
1139 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
1140 if (objfile_is_library
)
1141 error (_("Cannot find shared library `%s' in dynamic"
1142 " linker's load module list"), objfile_name (objfile
));
1144 error (_("Cannot find executable file `%s' in dynamic"
1145 " linker's load module list"), objfile_name (objfile
));
1147 case TLS_NOT_ALLOCATED_YET_ERROR
:
1148 if (objfile_is_library
)
1149 error (_("The inferior has not yet allocated storage for"
1150 " thread-local variables in\n"
1151 "the shared library `%s'\n"
1153 objfile_name (objfile
), target_pid_to_str (ptid
));
1155 error (_("The inferior has not yet allocated storage for"
1156 " thread-local variables in\n"
1157 "the executable `%s'\n"
1159 objfile_name (objfile
), target_pid_to_str (ptid
));
1161 case TLS_GENERIC_ERROR
:
1162 if (objfile_is_library
)
1163 error (_("Cannot find thread-local storage for %s, "
1164 "shared library %s:\n%s"),
1165 target_pid_to_str (ptid
),
1166 objfile_name (objfile
), ex
.message
);
1168 error (_("Cannot find thread-local storage for %s, "
1169 "executable file %s:\n%s"),
1170 target_pid_to_str (ptid
),
1171 objfile_name (objfile
), ex
.message
);
1174 throw_exception (ex
);
1179 /* It wouldn't be wrong here to try a gdbarch method, too; finding
1180 TLS is an ABI-specific thing. But we don't do that yet. */
1182 error (_("Cannot find thread-local variables on this target"));
1188 target_xfer_error_to_string (enum target_xfer_error err
)
1190 #define CASE(X) case X: return #X
1193 CASE(TARGET_XFER_E_IO
);
1194 CASE(TARGET_XFER_E_UNAVAILABLE
);
1203 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1205 /* target_read_string -- read a null terminated string, up to LEN bytes,
1206 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1207 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1208 is responsible for freeing it. Return the number of bytes successfully
1212 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
1214 int tlen
, offset
, i
;
1218 int buffer_allocated
;
1220 unsigned int nbytes_read
= 0;
1222 gdb_assert (string
);
1224 /* Small for testing. */
1225 buffer_allocated
= 4;
1226 buffer
= xmalloc (buffer_allocated
);
1231 tlen
= MIN (len
, 4 - (memaddr
& 3));
1232 offset
= memaddr
& 3;
1234 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
1237 /* The transfer request might have crossed the boundary to an
1238 unallocated region of memory. Retry the transfer, requesting
1242 errcode
= target_read_memory (memaddr
, buf
, 1);
1247 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
1251 bytes
= bufptr
- buffer
;
1252 buffer_allocated
*= 2;
1253 buffer
= xrealloc (buffer
, buffer_allocated
);
1254 bufptr
= buffer
+ bytes
;
1257 for (i
= 0; i
< tlen
; i
++)
1259 *bufptr
++ = buf
[i
+ offset
];
1260 if (buf
[i
+ offset
] == '\000')
1262 nbytes_read
+= i
+ 1;
1269 nbytes_read
+= tlen
;
1278 struct target_section_table
*
1279 target_get_section_table (struct target_ops
*target
)
1281 struct target_ops
*t
;
1284 fprintf_unfiltered (gdb_stdlog
, "target_get_section_table ()\n");
1286 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1287 if (t
->to_get_section_table
!= NULL
)
1288 return (*t
->to_get_section_table
) (t
);
1293 /* Find a section containing ADDR. */
1295 struct target_section
*
1296 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1298 struct target_section_table
*table
= target_get_section_table (target
);
1299 struct target_section
*secp
;
1304 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
1306 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1312 /* Read memory from the live target, even if currently inspecting a
1313 traceframe. The return is the same as that of target_read. */
1316 target_read_live_memory (enum target_object object
,
1317 ULONGEST memaddr
, gdb_byte
*myaddr
, ULONGEST len
)
1320 struct cleanup
*cleanup
;
1322 /* Switch momentarily out of tfind mode so to access live memory.
1323 Note that this must not clear global state, such as the frame
1324 cache, which must still remain valid for the previous traceframe.
1325 We may be _building_ the frame cache at this point. */
1326 cleanup
= make_cleanup_restore_traceframe_number ();
1327 set_traceframe_number (-1);
1329 ret
= target_read (current_target
.beneath
, object
, NULL
,
1330 myaddr
, memaddr
, len
);
1332 do_cleanups (cleanup
);
1336 /* Using the set of read-only target sections of OPS, read live
1337 read-only memory. Note that the actual reads start from the
1338 top-most target again.
1340 For interface/parameters/return description see target.h,
1344 memory_xfer_live_readonly_partial (struct target_ops
*ops
,
1345 enum target_object object
,
1346 gdb_byte
*readbuf
, ULONGEST memaddr
,
1349 struct target_section
*secp
;
1350 struct target_section_table
*table
;
1352 secp
= target_section_by_addr (ops
, memaddr
);
1354 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1355 secp
->the_bfd_section
)
1358 struct target_section
*p
;
1359 ULONGEST memend
= memaddr
+ len
;
1361 table
= target_get_section_table (ops
);
1363 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1365 if (memaddr
>= p
->addr
)
1367 if (memend
<= p
->endaddr
)
1369 /* Entire transfer is within this section. */
1370 return target_read_live_memory (object
, memaddr
,
1373 else if (memaddr
>= p
->endaddr
)
1375 /* This section ends before the transfer starts. */
1380 /* This section overlaps the transfer. Just do half. */
1381 len
= p
->endaddr
- memaddr
;
1382 return target_read_live_memory (object
, memaddr
,
1392 /* Read memory from more than one valid target. A core file, for
1393 instance, could have some of memory but delegate other bits to
1394 the target below it. So, we must manually try all targets. */
1397 raw_memory_xfer_partial (struct target_ops
*ops
, void *readbuf
,
1398 const void *writebuf
, ULONGEST memaddr
, LONGEST len
)
1404 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1405 readbuf
, writebuf
, memaddr
, len
);
1409 /* We want to continue past core files to executables, but not
1410 past a running target's memory. */
1411 if (ops
->to_has_all_memory (ops
))
1416 while (ops
!= NULL
);
1421 /* Perform a partial memory transfer.
1422 For docs see target.h, to_xfer_partial. */
1425 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
1426 void *readbuf
, const void *writebuf
, ULONGEST memaddr
,
1431 struct mem_region
*region
;
1432 struct inferior
*inf
;
1434 /* For accesses to unmapped overlay sections, read directly from
1435 files. Must do this first, as MEMADDR may need adjustment. */
1436 if (readbuf
!= NULL
&& overlay_debugging
)
1438 struct obj_section
*section
= find_pc_overlay (memaddr
);
1440 if (pc_in_unmapped_range (memaddr
, section
))
1442 struct target_section_table
*table
1443 = target_get_section_table (ops
);
1444 const char *section_name
= section
->the_bfd_section
->name
;
1446 memaddr
= overlay_mapped_address (memaddr
, section
);
1447 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1450 table
->sections_end
,
1455 /* Try the executable files, if "trust-readonly-sections" is set. */
1456 if (readbuf
!= NULL
&& trust_readonly
)
1458 struct target_section
*secp
;
1459 struct target_section_table
*table
;
1461 secp
= target_section_by_addr (ops
, memaddr
);
1463 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1464 secp
->the_bfd_section
)
1467 table
= target_get_section_table (ops
);
1468 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1471 table
->sections_end
,
1476 /* If reading unavailable memory in the context of traceframes, and
1477 this address falls within a read-only section, fallback to
1478 reading from live memory. */
1479 if (readbuf
!= NULL
&& get_traceframe_number () != -1)
1481 VEC(mem_range_s
) *available
;
1483 /* If we fail to get the set of available memory, then the
1484 target does not support querying traceframe info, and so we
1485 attempt reading from the traceframe anyway (assuming the
1486 target implements the old QTro packet then). */
1487 if (traceframe_available_memory (&available
, memaddr
, len
))
1489 struct cleanup
*old_chain
;
1491 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
1493 if (VEC_empty (mem_range_s
, available
)
1494 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
1496 /* Don't read into the traceframe's available
1498 if (!VEC_empty (mem_range_s
, available
))
1500 LONGEST oldlen
= len
;
1502 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
1503 gdb_assert (len
<= oldlen
);
1506 do_cleanups (old_chain
);
1508 /* This goes through the topmost target again. */
1509 res
= memory_xfer_live_readonly_partial (ops
, object
,
1510 readbuf
, memaddr
, len
);
1514 /* No use trying further, we know some memory starting
1515 at MEMADDR isn't available. */
1516 return TARGET_XFER_E_UNAVAILABLE
;
1519 /* Don't try to read more than how much is available, in
1520 case the target implements the deprecated QTro packet to
1521 cater for older GDBs (the target's knowledge of read-only
1522 sections may be outdated by now). */
1523 len
= VEC_index (mem_range_s
, available
, 0)->length
;
1525 do_cleanups (old_chain
);
1529 /* Try GDB's internal data cache. */
1530 region
= lookup_mem_region (memaddr
);
1531 /* region->hi == 0 means there's no upper bound. */
1532 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1535 reg_len
= region
->hi
- memaddr
;
1537 switch (region
->attrib
.mode
)
1540 if (writebuf
!= NULL
)
1545 if (readbuf
!= NULL
)
1550 /* We only support writing to flash during "load" for now. */
1551 if (writebuf
!= NULL
)
1552 error (_("Writing to flash memory forbidden in this context"));
1559 if (!ptid_equal (inferior_ptid
, null_ptid
))
1560 inf
= find_inferior_pid (ptid_get_pid (inferior_ptid
));
1565 /* The dcache reads whole cache lines; that doesn't play well
1566 with reading from a trace buffer, because reading outside of
1567 the collected memory range fails. */
1568 && get_traceframe_number () == -1
1569 && (region
->attrib
.cache
1570 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1571 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1573 DCACHE
*dcache
= target_dcache_get_or_init ();
1575 if (readbuf
!= NULL
)
1576 res
= dcache_xfer_memory (ops
, dcache
, memaddr
, readbuf
, reg_len
, 0);
1578 /* FIXME drow/2006-08-09: If we're going to preserve const
1579 correctness dcache_xfer_memory should take readbuf and
1581 res
= dcache_xfer_memory (ops
, dcache
, memaddr
, (void *) writebuf
,
1589 /* If none of those methods found the memory we wanted, fall back
1590 to a target partial transfer. Normally a single call to
1591 to_xfer_partial is enough; if it doesn't recognize an object
1592 it will call the to_xfer_partial of the next target down.
1593 But for memory this won't do. Memory is the only target
1594 object which can be read from more than one valid target. */
1595 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
);
1597 /* Make sure the cache gets updated no matter what - if we are writing
1598 to the stack. Even if this write is not tagged as such, we still need
1599 to update the cache. */
1604 && target_dcache_init_p ()
1605 && !region
->attrib
.cache
1606 && ((stack_cache_enabled_p () && object
!= TARGET_OBJECT_STACK_MEMORY
)
1607 || (code_cache_enabled_p () && object
!= TARGET_OBJECT_CODE_MEMORY
)))
1609 DCACHE
*dcache
= target_dcache_get ();
1611 dcache_update (dcache
, memaddr
, (void *) writebuf
, res
);
1614 /* If we still haven't got anything, return the last error. We
1619 /* Perform a partial memory transfer. For docs see target.h,
1623 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1624 void *readbuf
, const void *writebuf
, ULONGEST memaddr
,
1629 /* Zero length requests are ok and require no work. */
1633 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1634 breakpoint insns, thus hiding out from higher layers whether
1635 there are software breakpoints inserted in the code stream. */
1636 if (readbuf
!= NULL
)
1638 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
);
1640 if (res
> 0 && !show_memory_breakpoints
)
1641 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, res
);
1646 struct cleanup
*old_chain
;
1648 /* A large write request is likely to be partially satisfied
1649 by memory_xfer_partial_1. We will continually malloc
1650 and free a copy of the entire write request for breakpoint
1651 shadow handling even though we only end up writing a small
1652 subset of it. Cap writes to 4KB to mitigate this. */
1653 len
= min (4096, len
);
1655 buf
= xmalloc (len
);
1656 old_chain
= make_cleanup (xfree
, buf
);
1657 memcpy (buf
, writebuf
, len
);
1659 breakpoint_xfer_memory (NULL
, buf
, writebuf
, memaddr
, len
);
1660 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
, memaddr
, len
);
1662 do_cleanups (old_chain
);
1669 restore_show_memory_breakpoints (void *arg
)
1671 show_memory_breakpoints
= (uintptr_t) arg
;
1675 make_show_memory_breakpoints_cleanup (int show
)
1677 int current
= show_memory_breakpoints
;
1679 show_memory_breakpoints
= show
;
1680 return make_cleanup (restore_show_memory_breakpoints
,
1681 (void *) (uintptr_t) current
);
1684 /* For docs see target.h, to_xfer_partial. */
1687 target_xfer_partial (struct target_ops
*ops
,
1688 enum target_object object
, const char *annex
,
1689 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1690 ULONGEST offset
, ULONGEST len
)
1694 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1696 if (writebuf
&& !may_write_memory
)
1697 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1698 core_addr_to_string_nz (offset
), plongest (len
));
1700 /* If this is a memory transfer, let the memory-specific code
1701 have a look at it instead. Memory transfers are more
1703 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1704 || object
== TARGET_OBJECT_CODE_MEMORY
)
1705 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1706 writebuf
, offset
, len
);
1707 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1709 /* Request the normal memory object from other layers. */
1710 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1713 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
,
1714 writebuf
, offset
, len
);
1718 const unsigned char *myaddr
= NULL
;
1720 fprintf_unfiltered (gdb_stdlog
,
1721 "%s:target_xfer_partial "
1722 "(%d, %s, %s, %s, %s, %s) = %s",
1725 (annex
? annex
: "(null)"),
1726 host_address_to_string (readbuf
),
1727 host_address_to_string (writebuf
),
1728 core_addr_to_string_nz (offset
),
1729 pulongest (len
), plongest (retval
));
1735 if (retval
> 0 && myaddr
!= NULL
)
1739 fputs_unfiltered (", bytes =", gdb_stdlog
);
1740 for (i
= 0; i
< retval
; i
++)
1742 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1744 if (targetdebug
< 2 && i
> 0)
1746 fprintf_unfiltered (gdb_stdlog
, " ...");
1749 fprintf_unfiltered (gdb_stdlog
, "\n");
1752 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1756 fputc_unfiltered ('\n', gdb_stdlog
);
1761 /* Read LEN bytes of target memory at address MEMADDR, placing the
1762 results in GDB's memory at MYADDR. Returns either 0 for success or
1763 a target_xfer_error value if any error occurs.
1765 If an error occurs, no guarantee is made about the contents of the data at
1766 MYADDR. In particular, the caller should not depend upon partial reads
1767 filling the buffer with good data. There is no way for the caller to know
1768 how much good data might have been transfered anyway. Callers that can
1769 deal with partial reads should call target_read (which will retry until
1770 it makes no progress, and then return how much was transferred). */
1773 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1775 /* Dispatch to the topmost target, not the flattened current_target.
1776 Memory accesses check target->to_has_(all_)memory, and the
1777 flattened target doesn't inherit those. */
1778 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1779 myaddr
, memaddr
, len
) == len
)
1782 return TARGET_XFER_E_IO
;
1785 /* Like target_read_memory, but specify explicitly that this is a read
1786 from the target's raw memory. That is, this read bypasses the
1787 dcache, breakpoint shadowing, etc. */
1790 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1792 /* See comment in target_read_memory about why the request starts at
1793 current_target.beneath. */
1794 if (target_read (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1795 myaddr
, memaddr
, len
) == len
)
1798 return TARGET_XFER_E_IO
;
1801 /* Like target_read_memory, but specify explicitly that this is a read from
1802 the target's stack. This may trigger different cache behavior. */
1805 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1807 /* See comment in target_read_memory about why the request starts at
1808 current_target.beneath. */
1809 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1810 myaddr
, memaddr
, len
) == len
)
1813 return TARGET_XFER_E_IO
;
1816 /* Like target_read_memory, but specify explicitly that this is a read from
1817 the target's code. This may trigger different cache behavior. */
1820 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1822 /* See comment in target_read_memory about why the request starts at
1823 current_target.beneath. */
1824 if (target_read (current_target
.beneath
, TARGET_OBJECT_CODE_MEMORY
, NULL
,
1825 myaddr
, memaddr
, len
) == len
)
1828 return TARGET_XFER_E_IO
;
1831 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1832 Returns either 0 for success or a target_xfer_error value if any
1833 error occurs. If an error occurs, no guarantee is made about how
1834 much data got written. Callers that can deal with partial writes
1835 should call target_write. */
1838 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1840 /* See comment in target_read_memory about why the request starts at
1841 current_target.beneath. */
1842 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1843 myaddr
, memaddr
, len
) == len
)
1846 return TARGET_XFER_E_IO
;
1849 /* Write LEN bytes from MYADDR to target raw memory at address
1850 MEMADDR. Returns either 0 for success or a target_xfer_error value
1851 if any error occurs. If an error occurs, no guarantee is made
1852 about how much data got written. Callers that can deal with
1853 partial writes should call target_write. */
1856 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1858 /* See comment in target_read_memory about why the request starts at
1859 current_target.beneath. */
1860 if (target_write (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1861 myaddr
, memaddr
, len
) == len
)
1864 return TARGET_XFER_E_IO
;
1867 /* Fetch the target's memory map. */
1870 target_memory_map (void)
1872 VEC(mem_region_s
) *result
;
1873 struct mem_region
*last_one
, *this_one
;
1875 struct target_ops
*t
;
1878 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1880 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1881 if (t
->to_memory_map
!= NULL
)
1887 result
= t
->to_memory_map (t
);
1891 qsort (VEC_address (mem_region_s
, result
),
1892 VEC_length (mem_region_s
, result
),
1893 sizeof (struct mem_region
), mem_region_cmp
);
1895 /* Check that regions do not overlap. Simultaneously assign
1896 a numbering for the "mem" commands to use to refer to
1899 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1901 this_one
->number
= ix
;
1903 if (last_one
&& last_one
->hi
> this_one
->lo
)
1905 warning (_("Overlapping regions in memory map: ignoring"));
1906 VEC_free (mem_region_s
, result
);
1909 last_one
= this_one
;
1916 target_flash_erase (ULONGEST address
, LONGEST length
)
1918 struct target_ops
*t
;
1920 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1921 if (t
->to_flash_erase
!= NULL
)
1924 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1925 hex_string (address
), phex (length
, 0));
1926 t
->to_flash_erase (t
, address
, length
);
1934 target_flash_done (void)
1936 struct target_ops
*t
;
1938 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1939 if (t
->to_flash_done
!= NULL
)
1942 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1943 t
->to_flash_done (t
);
1951 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1952 struct cmd_list_element
*c
, const char *value
)
1954 fprintf_filtered (file
,
1955 _("Mode for reading from readonly sections is %s.\n"),
1959 /* More generic transfers. */
1962 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1963 const char *annex
, gdb_byte
*readbuf
,
1964 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
)
1966 if (object
== TARGET_OBJECT_MEMORY
1967 && ops
->deprecated_xfer_memory
!= NULL
)
1968 /* If available, fall back to the target's
1969 "deprecated_xfer_memory" method. */
1974 if (writebuf
!= NULL
)
1976 void *buffer
= xmalloc (len
);
1977 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1979 memcpy (buffer
, writebuf
, len
);
1980 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1981 1/*write*/, NULL
, ops
);
1982 do_cleanups (cleanup
);
1984 if (readbuf
!= NULL
)
1985 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1986 0/*read*/, NULL
, ops
);
1989 else if (xfered
== 0 && errno
== 0)
1990 /* "deprecated_xfer_memory" uses 0, cross checked against
1991 ERRNO as one indication of an error. */
1996 else if (ops
->beneath
!= NULL
)
1997 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1998 readbuf
, writebuf
, offset
, len
);
2003 /* The xfer_partial handler for the topmost target. Unlike the default,
2004 it does not need to handle memory specially; it just passes all
2005 requests down the stack. */
2008 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2009 const char *annex
, gdb_byte
*readbuf
,
2010 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
)
2012 if (ops
->beneath
!= NULL
)
2013 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2014 readbuf
, writebuf
, offset
, len
);
2019 /* Target vector read/write partial wrapper functions. */
2022 target_read_partial (struct target_ops
*ops
,
2023 enum target_object object
,
2024 const char *annex
, gdb_byte
*buf
,
2025 ULONGEST offset
, LONGEST len
)
2027 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
2031 target_write_partial (struct target_ops
*ops
,
2032 enum target_object object
,
2033 const char *annex
, const gdb_byte
*buf
,
2034 ULONGEST offset
, LONGEST len
)
2036 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
2039 /* Wrappers to perform the full transfer. */
2041 /* For docs on target_read see target.h. */
2044 target_read (struct target_ops
*ops
,
2045 enum target_object object
,
2046 const char *annex
, gdb_byte
*buf
,
2047 ULONGEST offset
, LONGEST len
)
2051 while (xfered
< len
)
2053 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
2054 (gdb_byte
*) buf
+ xfered
,
2055 offset
+ xfered
, len
- xfered
);
2057 /* Call an observer, notifying them of the xfer progress? */
2068 /* Assuming that the entire [begin, end) range of memory cannot be
2069 read, try to read whatever subrange is possible to read.
2071 The function returns, in RESULT, either zero or one memory block.
2072 If there's a readable subrange at the beginning, it is completely
2073 read and returned. Any further readable subrange will not be read.
2074 Otherwise, if there's a readable subrange at the end, it will be
2075 completely read and returned. Any readable subranges before it
2076 (obviously, not starting at the beginning), will be ignored. In
2077 other cases -- either no readable subrange, or readable subrange(s)
2078 that is neither at the beginning, or end, nothing is returned.
2080 The purpose of this function is to handle a read across a boundary
2081 of accessible memory in a case when memory map is not available.
2082 The above restrictions are fine for this case, but will give
2083 incorrect results if the memory is 'patchy'. However, supporting
2084 'patchy' memory would require trying to read every single byte,
2085 and it seems unacceptable solution. Explicit memory map is
2086 recommended for this case -- and target_read_memory_robust will
2087 take care of reading multiple ranges then. */
2090 read_whatever_is_readable (struct target_ops
*ops
,
2091 ULONGEST begin
, ULONGEST end
,
2092 VEC(memory_read_result_s
) **result
)
2094 gdb_byte
*buf
= xmalloc (end
- begin
);
2095 ULONGEST current_begin
= begin
;
2096 ULONGEST current_end
= end
;
2098 memory_read_result_s r
;
2100 /* If we previously failed to read 1 byte, nothing can be done here. */
2101 if (end
- begin
<= 1)
2107 /* Check that either first or the last byte is readable, and give up
2108 if not. This heuristic is meant to permit reading accessible memory
2109 at the boundary of accessible region. */
2110 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2111 buf
, begin
, 1) == 1)
2116 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2117 buf
+ (end
-begin
) - 1, end
- 1, 1) == 1)
2128 /* Loop invariant is that the [current_begin, current_end) was previously
2129 found to be not readable as a whole.
2131 Note loop condition -- if the range has 1 byte, we can't divide the range
2132 so there's no point trying further. */
2133 while (current_end
- current_begin
> 1)
2135 ULONGEST first_half_begin
, first_half_end
;
2136 ULONGEST second_half_begin
, second_half_end
;
2138 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
2142 first_half_begin
= current_begin
;
2143 first_half_end
= middle
;
2144 second_half_begin
= middle
;
2145 second_half_end
= current_end
;
2149 first_half_begin
= middle
;
2150 first_half_end
= current_end
;
2151 second_half_begin
= current_begin
;
2152 second_half_end
= middle
;
2155 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2156 buf
+ (first_half_begin
- begin
),
2158 first_half_end
- first_half_begin
);
2160 if (xfer
== first_half_end
- first_half_begin
)
2162 /* This half reads up fine. So, the error must be in the
2164 current_begin
= second_half_begin
;
2165 current_end
= second_half_end
;
2169 /* This half is not readable. Because we've tried one byte, we
2170 know some part of this half if actually redable. Go to the next
2171 iteration to divide again and try to read.
2173 We don't handle the other half, because this function only tries
2174 to read a single readable subrange. */
2175 current_begin
= first_half_begin
;
2176 current_end
= first_half_end
;
2182 /* The [begin, current_begin) range has been read. */
2184 r
.end
= current_begin
;
2189 /* The [current_end, end) range has been read. */
2190 LONGEST rlen
= end
- current_end
;
2192 r
.data
= xmalloc (rlen
);
2193 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
2194 r
.begin
= current_end
;
2198 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
2202 free_memory_read_result_vector (void *x
)
2204 VEC(memory_read_result_s
) *v
= x
;
2205 memory_read_result_s
*current
;
2208 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
2210 xfree (current
->data
);
2212 VEC_free (memory_read_result_s
, v
);
2215 VEC(memory_read_result_s
) *
2216 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
2218 VEC(memory_read_result_s
) *result
= 0;
2221 while (xfered
< len
)
2223 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
2226 /* If there is no explicit region, a fake one should be created. */
2227 gdb_assert (region
);
2229 if (region
->hi
== 0)
2230 rlen
= len
- xfered
;
2232 rlen
= region
->hi
- offset
;
2234 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
2236 /* Cannot read this region. Note that we can end up here only
2237 if the region is explicitly marked inaccessible, or
2238 'inaccessible-by-default' is in effect. */
2243 LONGEST to_read
= min (len
- xfered
, rlen
);
2244 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
2246 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2247 (gdb_byte
*) buffer
,
2248 offset
+ xfered
, to_read
);
2249 /* Call an observer, notifying them of the xfer progress? */
2252 /* Got an error reading full chunk. See if maybe we can read
2255 read_whatever_is_readable (ops
, offset
+ xfered
,
2256 offset
+ xfered
+ to_read
, &result
);
2261 struct memory_read_result r
;
2263 r
.begin
= offset
+ xfered
;
2264 r
.end
= r
.begin
+ xfer
;
2265 VEC_safe_push (memory_read_result_s
, result
, &r
);
2275 /* An alternative to target_write with progress callbacks. */
2278 target_write_with_progress (struct target_ops
*ops
,
2279 enum target_object object
,
2280 const char *annex
, const gdb_byte
*buf
,
2281 ULONGEST offset
, LONGEST len
,
2282 void (*progress
) (ULONGEST
, void *), void *baton
)
2286 /* Give the progress callback a chance to set up. */
2288 (*progress
) (0, baton
);
2290 while (xfered
< len
)
2292 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
2293 (gdb_byte
*) buf
+ xfered
,
2294 offset
+ xfered
, len
- xfered
);
2302 (*progress
) (xfer
, baton
);
2310 /* For docs on target_write see target.h. */
2313 target_write (struct target_ops
*ops
,
2314 enum target_object object
,
2315 const char *annex
, const gdb_byte
*buf
,
2316 ULONGEST offset
, LONGEST len
)
2318 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2322 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2323 the size of the transferred data. PADDING additional bytes are
2324 available in *BUF_P. This is a helper function for
2325 target_read_alloc; see the declaration of that function for more
2329 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2330 const char *annex
, gdb_byte
**buf_p
, int padding
)
2332 size_t buf_alloc
, buf_pos
;
2336 /* This function does not have a length parameter; it reads the
2337 entire OBJECT). Also, it doesn't support objects fetched partly
2338 from one target and partly from another (in a different stratum,
2339 e.g. a core file and an executable). Both reasons make it
2340 unsuitable for reading memory. */
2341 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2343 /* Start by reading up to 4K at a time. The target will throttle
2344 this number down if necessary. */
2346 buf
= xmalloc (buf_alloc
);
2350 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2351 buf_pos
, buf_alloc
- buf_pos
- padding
);
2354 /* An error occurred. */
2360 /* Read all there was. */
2370 /* If the buffer is filling up, expand it. */
2371 if (buf_alloc
< buf_pos
* 2)
2374 buf
= xrealloc (buf
, buf_alloc
);
2381 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2382 the size of the transferred data. See the declaration in "target.h"
2383 function for more information about the return value. */
2386 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2387 const char *annex
, gdb_byte
**buf_p
)
2389 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2392 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2393 returned as a string, allocated using xmalloc. If an error occurs
2394 or the transfer is unsupported, NULL is returned. Empty objects
2395 are returned as allocated but empty strings. A warning is issued
2396 if the result contains any embedded NUL bytes. */
2399 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2404 LONGEST i
, transferred
;
2406 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2407 bufstr
= (char *) buffer
;
2409 if (transferred
< 0)
2412 if (transferred
== 0)
2413 return xstrdup ("");
2415 bufstr
[transferred
] = 0;
2417 /* Check for embedded NUL bytes; but allow trailing NULs. */
2418 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2421 warning (_("target object %d, annex %s, "
2422 "contained unexpected null characters"),
2423 (int) object
, annex
? annex
: "(none)");
2430 /* Memory transfer methods. */
2433 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2436 /* This method is used to read from an alternate, non-current
2437 target. This read must bypass the overlay support (as symbols
2438 don't match this target), and GDB's internal cache (wrong cache
2439 for this target). */
2440 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2442 memory_error (TARGET_XFER_E_IO
, addr
);
2446 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2447 int len
, enum bfd_endian byte_order
)
2449 gdb_byte buf
[sizeof (ULONGEST
)];
2451 gdb_assert (len
<= sizeof (buf
));
2452 get_target_memory (ops
, addr
, buf
, len
);
2453 return extract_unsigned_integer (buf
, len
, byte_order
);
2459 forward_target_insert_breakpoint (struct target_ops
*ops
,
2460 struct gdbarch
*gdbarch
,
2461 struct bp_target_info
*bp_tgt
)
2463 for (; ops
!= NULL
; ops
= ops
->beneath
)
2464 if (ops
->to_insert_breakpoint
!= NULL
)
2465 return ops
->to_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
2467 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
2473 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2474 struct bp_target_info
*bp_tgt
)
2476 if (!may_insert_breakpoints
)
2478 warning (_("May not insert breakpoints"));
2482 return forward_target_insert_breakpoint (¤t_target
, gdbarch
, bp_tgt
);
2488 forward_target_remove_breakpoint (struct target_ops
*ops
,
2489 struct gdbarch
*gdbarch
,
2490 struct bp_target_info
*bp_tgt
)
2492 /* This is kind of a weird case to handle, but the permission might
2493 have been changed after breakpoints were inserted - in which case
2494 we should just take the user literally and assume that any
2495 breakpoints should be left in place. */
2496 if (!may_insert_breakpoints
)
2498 warning (_("May not remove breakpoints"));
2502 for (; ops
!= NULL
; ops
= ops
->beneath
)
2503 if (ops
->to_remove_breakpoint
!= NULL
)
2504 return ops
->to_remove_breakpoint (ops
, gdbarch
, bp_tgt
);
2506 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
);
2512 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2513 struct bp_target_info
*bp_tgt
)
2515 return forward_target_remove_breakpoint (¤t_target
, gdbarch
, bp_tgt
);
2519 target_info (char *args
, int from_tty
)
2521 struct target_ops
*t
;
2522 int has_all_mem
= 0;
2524 if (symfile_objfile
!= NULL
)
2525 printf_unfiltered (_("Symbols from \"%s\".\n"),
2526 objfile_name (symfile_objfile
));
2528 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2530 if (!(*t
->to_has_memory
) (t
))
2533 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2536 printf_unfiltered (_("\tWhile running this, "
2537 "GDB does not access memory from...\n"));
2538 printf_unfiltered ("%s:\n", t
->to_longname
);
2539 (t
->to_files_info
) (t
);
2540 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2544 /* This function is called before any new inferior is created, e.g.
2545 by running a program, attaching, or connecting to a target.
2546 It cleans up any state from previous invocations which might
2547 change between runs. This is a subset of what target_preopen
2548 resets (things which might change between targets). */
2551 target_pre_inferior (int from_tty
)
2553 /* Clear out solib state. Otherwise the solib state of the previous
2554 inferior might have survived and is entirely wrong for the new
2555 target. This has been observed on GNU/Linux using glibc 2.3. How
2567 Cannot access memory at address 0xdeadbeef
2570 /* In some OSs, the shared library list is the same/global/shared
2571 across inferiors. If code is shared between processes, so are
2572 memory regions and features. */
2573 if (!gdbarch_has_global_solist (target_gdbarch ()))
2575 no_shared_libraries (NULL
, from_tty
);
2577 invalidate_target_mem_regions ();
2579 target_clear_description ();
2582 agent_capability_invalidate ();
2585 /* Callback for iterate_over_inferiors. Gets rid of the given
2589 dispose_inferior (struct inferior
*inf
, void *args
)
2591 struct thread_info
*thread
;
2593 thread
= any_thread_of_process (inf
->pid
);
2596 switch_to_thread (thread
->ptid
);
2598 /* Core inferiors actually should be detached, not killed. */
2599 if (target_has_execution
)
2602 target_detach (NULL
, 0);
2608 /* This is to be called by the open routine before it does
2612 target_preopen (int from_tty
)
2616 if (have_inferiors ())
2619 || !have_live_inferiors ()
2620 || query (_("A program is being debugged already. Kill it? ")))
2621 iterate_over_inferiors (dispose_inferior
, NULL
);
2623 error (_("Program not killed."));
2626 /* Calling target_kill may remove the target from the stack. But if
2627 it doesn't (which seems like a win for UDI), remove it now. */
2628 /* Leave the exec target, though. The user may be switching from a
2629 live process to a core of the same program. */
2630 pop_all_targets_above (file_stratum
);
2632 target_pre_inferior (from_tty
);
2635 /* Detach a target after doing deferred register stores. */
2638 target_detach (const char *args
, int from_tty
)
2640 struct target_ops
* t
;
2642 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2643 /* Don't remove global breakpoints here. They're removed on
2644 disconnection from the target. */
2647 /* If we're in breakpoints-always-inserted mode, have to remove
2648 them before detaching. */
2649 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2651 prepare_for_detach ();
2653 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2655 if (t
->to_detach
!= NULL
)
2657 t
->to_detach (t
, args
, from_tty
);
2659 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2665 internal_error (__FILE__
, __LINE__
, _("could not find a target to detach"));
2669 target_disconnect (char *args
, int from_tty
)
2671 struct target_ops
*t
;
2673 /* If we're in breakpoints-always-inserted mode or if breakpoints
2674 are global across processes, we have to remove them before
2676 remove_breakpoints ();
2678 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2679 if (t
->to_disconnect
!= NULL
)
2682 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2684 t
->to_disconnect (t
, args
, from_tty
);
2692 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2694 struct target_ops
*t
;
2696 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2698 if (t
->to_wait
!= NULL
)
2700 ptid_t retval
= (*t
->to_wait
) (t
, ptid
, status
, options
);
2704 char *status_string
;
2705 char *options_string
;
2707 status_string
= target_waitstatus_to_string (status
);
2708 options_string
= target_options_to_string (options
);
2709 fprintf_unfiltered (gdb_stdlog
,
2710 "target_wait (%d, status, options={%s})"
2712 ptid_get_pid (ptid
), options_string
,
2713 ptid_get_pid (retval
), status_string
);
2714 xfree (status_string
);
2715 xfree (options_string
);
2726 target_pid_to_str (ptid_t ptid
)
2728 struct target_ops
*t
;
2730 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2732 if (t
->to_pid_to_str
!= NULL
)
2733 return (*t
->to_pid_to_str
) (t
, ptid
);
2736 return normal_pid_to_str (ptid
);
2740 target_thread_name (struct thread_info
*info
)
2742 struct target_ops
*t
;
2744 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2746 if (t
->to_thread_name
!= NULL
)
2747 return (*t
->to_thread_name
) (info
);
2754 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2756 struct target_ops
*t
;
2758 target_dcache_invalidate ();
2760 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2762 if (t
->to_resume
!= NULL
)
2764 t
->to_resume (t
, ptid
, step
, signal
);
2766 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2767 ptid_get_pid (ptid
),
2768 step
? "step" : "continue",
2769 gdb_signal_to_name (signal
));
2771 registers_changed_ptid (ptid
);
2772 set_executing (ptid
, 1);
2773 set_running (ptid
, 1);
2774 clear_inline_frame_state (ptid
);
2783 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2785 struct target_ops
*t
;
2787 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2789 if (t
->to_pass_signals
!= NULL
)
2795 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2798 for (i
= 0; i
< numsigs
; i
++)
2799 if (pass_signals
[i
])
2800 fprintf_unfiltered (gdb_stdlog
, " %s",
2801 gdb_signal_to_name (i
));
2803 fprintf_unfiltered (gdb_stdlog
, " })\n");
2806 (*t
->to_pass_signals
) (numsigs
, pass_signals
);
2813 target_program_signals (int numsigs
, unsigned char *program_signals
)
2815 struct target_ops
*t
;
2817 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2819 if (t
->to_program_signals
!= NULL
)
2825 fprintf_unfiltered (gdb_stdlog
, "target_program_signals (%d, {",
2828 for (i
= 0; i
< numsigs
; i
++)
2829 if (program_signals
[i
])
2830 fprintf_unfiltered (gdb_stdlog
, " %s",
2831 gdb_signal_to_name (i
));
2833 fprintf_unfiltered (gdb_stdlog
, " })\n");
2836 (*t
->to_program_signals
) (numsigs
, program_signals
);
2842 /* Look through the list of possible targets for a target that can
2846 target_follow_fork (int follow_child
, int detach_fork
)
2848 struct target_ops
*t
;
2850 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2852 if (t
->to_follow_fork
!= NULL
)
2854 int retval
= t
->to_follow_fork (t
, follow_child
, detach_fork
);
2857 fprintf_unfiltered (gdb_stdlog
,
2858 "target_follow_fork (%d, %d) = %d\n",
2859 follow_child
, detach_fork
, retval
);
2864 /* Some target returned a fork event, but did not know how to follow it. */
2865 internal_error (__FILE__
, __LINE__
,
2866 _("could not find a target to follow fork"));
2870 target_mourn_inferior (void)
2872 struct target_ops
*t
;
2874 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2876 if (t
->to_mourn_inferior
!= NULL
)
2878 t
->to_mourn_inferior (t
);
2880 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2882 /* We no longer need to keep handles on any of the object files.
2883 Make sure to release them to avoid unnecessarily locking any
2884 of them while we're not actually debugging. */
2885 bfd_cache_close_all ();
2891 internal_error (__FILE__
, __LINE__
,
2892 _("could not find a target to follow mourn inferior"));
2895 /* Look for a target which can describe architectural features, starting
2896 from TARGET. If we find one, return its description. */
2898 const struct target_desc
*
2899 target_read_description (struct target_ops
*target
)
2901 struct target_ops
*t
;
2903 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
2904 if (t
->to_read_description
!= NULL
)
2906 const struct target_desc
*tdesc
;
2908 tdesc
= t
->to_read_description (t
);
2916 /* The default implementation of to_search_memory.
2917 This implements a basic search of memory, reading target memory and
2918 performing the search here (as opposed to performing the search in on the
2919 target side with, for example, gdbserver). */
2922 simple_search_memory (struct target_ops
*ops
,
2923 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2924 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2925 CORE_ADDR
*found_addrp
)
2927 /* NOTE: also defined in find.c testcase. */
2928 #define SEARCH_CHUNK_SIZE 16000
2929 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2930 /* Buffer to hold memory contents for searching. */
2931 gdb_byte
*search_buf
;
2932 unsigned search_buf_size
;
2933 struct cleanup
*old_cleanups
;
2935 search_buf_size
= chunk_size
+ pattern_len
- 1;
2937 /* No point in trying to allocate a buffer larger than the search space. */
2938 if (search_space_len
< search_buf_size
)
2939 search_buf_size
= search_space_len
;
2941 search_buf
= malloc (search_buf_size
);
2942 if (search_buf
== NULL
)
2943 error (_("Unable to allocate memory to perform the search."));
2944 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2946 /* Prime the search buffer. */
2948 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2949 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2951 warning (_("Unable to access %s bytes of target "
2952 "memory at %s, halting search."),
2953 pulongest (search_buf_size
), hex_string (start_addr
));
2954 do_cleanups (old_cleanups
);
2958 /* Perform the search.
2960 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2961 When we've scanned N bytes we copy the trailing bytes to the start and
2962 read in another N bytes. */
2964 while (search_space_len
>= pattern_len
)
2966 gdb_byte
*found_ptr
;
2967 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2969 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2970 pattern
, pattern_len
);
2972 if (found_ptr
!= NULL
)
2974 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2976 *found_addrp
= found_addr
;
2977 do_cleanups (old_cleanups
);
2981 /* Not found in this chunk, skip to next chunk. */
2983 /* Don't let search_space_len wrap here, it's unsigned. */
2984 if (search_space_len
>= chunk_size
)
2985 search_space_len
-= chunk_size
;
2987 search_space_len
= 0;
2989 if (search_space_len
>= pattern_len
)
2991 unsigned keep_len
= search_buf_size
- chunk_size
;
2992 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2995 /* Copy the trailing part of the previous iteration to the front
2996 of the buffer for the next iteration. */
2997 gdb_assert (keep_len
== pattern_len
- 1);
2998 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
3000 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
3002 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
3003 search_buf
+ keep_len
, read_addr
,
3004 nr_to_read
) != nr_to_read
)
3006 warning (_("Unable to access %s bytes of target "
3007 "memory at %s, halting search."),
3008 plongest (nr_to_read
),
3009 hex_string (read_addr
));
3010 do_cleanups (old_cleanups
);
3014 start_addr
+= chunk_size
;
3020 do_cleanups (old_cleanups
);
3024 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
3025 sequence of bytes in PATTERN with length PATTERN_LEN.
3027 The result is 1 if found, 0 if not found, and -1 if there was an error
3028 requiring halting of the search (e.g. memory read error).
3029 If the pattern is found the address is recorded in FOUND_ADDRP. */
3032 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
3033 const gdb_byte
*pattern
, ULONGEST pattern_len
,
3034 CORE_ADDR
*found_addrp
)
3036 struct target_ops
*t
;
3039 /* We don't use INHERIT to set current_target.to_search_memory,
3040 so we have to scan the target stack and handle targetdebug
3044 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
3045 hex_string (start_addr
));
3047 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3048 if (t
->to_search_memory
!= NULL
)
3053 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
3054 pattern
, pattern_len
, found_addrp
);
3058 /* If a special version of to_search_memory isn't available, use the
3060 found
= simple_search_memory (current_target
.beneath
,
3061 start_addr
, search_space_len
,
3062 pattern
, pattern_len
, found_addrp
);
3066 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
3071 /* Look through the currently pushed targets. If none of them will
3072 be able to restart the currently running process, issue an error
3076 target_require_runnable (void)
3078 struct target_ops
*t
;
3080 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3082 /* If this target knows how to create a new program, then
3083 assume we will still be able to after killing the current
3084 one. Either killing and mourning will not pop T, or else
3085 find_default_run_target will find it again. */
3086 if (t
->to_create_inferior
!= NULL
)
3089 /* Do not worry about thread_stratum targets that can not
3090 create inferiors. Assume they will be pushed again if
3091 necessary, and continue to the process_stratum. */
3092 if (t
->to_stratum
== thread_stratum
3093 || t
->to_stratum
== arch_stratum
)
3096 error (_("The \"%s\" target does not support \"run\". "
3097 "Try \"help target\" or \"continue\"."),
3101 /* This function is only called if the target is running. In that
3102 case there should have been a process_stratum target and it
3103 should either know how to create inferiors, or not... */
3104 internal_error (__FILE__
, __LINE__
, _("No targets found"));
3107 /* Look through the list of possible targets for a target that can
3108 execute a run or attach command without any other data. This is
3109 used to locate the default process stratum.
3111 If DO_MESG is not NULL, the result is always valid (error() is
3112 called for errors); else, return NULL on error. */
3114 static struct target_ops
*
3115 find_default_run_target (char *do_mesg
)
3117 struct target_ops
**t
;
3118 struct target_ops
*runable
= NULL
;
3123 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
3126 if ((*t
)->to_can_run
&& target_can_run (*t
))
3136 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
3145 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3147 struct target_ops
*t
;
3149 t
= find_default_run_target ("attach");
3150 (t
->to_attach
) (t
, args
, from_tty
);
3155 find_default_create_inferior (struct target_ops
*ops
,
3156 char *exec_file
, char *allargs
, char **env
,
3159 struct target_ops
*t
;
3161 t
= find_default_run_target ("run");
3162 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
3167 find_default_can_async_p (void)
3169 struct target_ops
*t
;
3171 /* This may be called before the target is pushed on the stack;
3172 look for the default process stratum. If there's none, gdb isn't
3173 configured with a native debugger, and target remote isn't
3175 t
= find_default_run_target (NULL
);
3176 if (t
&& t
->to_can_async_p
)
3177 return (t
->to_can_async_p
) ();
3182 find_default_is_async_p (void)
3184 struct target_ops
*t
;
3186 /* This may be called before the target is pushed on the stack;
3187 look for the default process stratum. If there's none, gdb isn't
3188 configured with a native debugger, and target remote isn't
3190 t
= find_default_run_target (NULL
);
3191 if (t
&& t
->to_is_async_p
)
3192 return (t
->to_is_async_p
) ();
3197 find_default_supports_non_stop (void)
3199 struct target_ops
*t
;
3201 t
= find_default_run_target (NULL
);
3202 if (t
&& t
->to_supports_non_stop
)
3203 return (t
->to_supports_non_stop
) ();
3208 target_supports_non_stop (void)
3210 struct target_ops
*t
;
3212 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3213 if (t
->to_supports_non_stop
)
3214 return t
->to_supports_non_stop ();
3219 /* Implement the "info proc" command. */
3222 target_info_proc (char *args
, enum info_proc_what what
)
3224 struct target_ops
*t
;
3226 /* If we're already connected to something that can get us OS
3227 related data, use it. Otherwise, try using the native
3229 if (current_target
.to_stratum
>= process_stratum
)
3230 t
= current_target
.beneath
;
3232 t
= find_default_run_target (NULL
);
3234 for (; t
!= NULL
; t
= t
->beneath
)
3236 if (t
->to_info_proc
!= NULL
)
3238 t
->to_info_proc (t
, args
, what
);
3241 fprintf_unfiltered (gdb_stdlog
,
3242 "target_info_proc (\"%s\", %d)\n", args
, what
);
3252 find_default_supports_disable_randomization (void)
3254 struct target_ops
*t
;
3256 t
= find_default_run_target (NULL
);
3257 if (t
&& t
->to_supports_disable_randomization
)
3258 return (t
->to_supports_disable_randomization
) ();
3263 target_supports_disable_randomization (void)
3265 struct target_ops
*t
;
3267 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3268 if (t
->to_supports_disable_randomization
)
3269 return t
->to_supports_disable_randomization ();
3275 target_get_osdata (const char *type
)
3277 struct target_ops
*t
;
3279 /* If we're already connected to something that can get us OS
3280 related data, use it. Otherwise, try using the native
3282 if (current_target
.to_stratum
>= process_stratum
)
3283 t
= current_target
.beneath
;
3285 t
= find_default_run_target ("get OS data");
3290 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
3293 /* Determine the current address space of thread PTID. */
3295 struct address_space
*
3296 target_thread_address_space (ptid_t ptid
)
3298 struct address_space
*aspace
;
3299 struct inferior
*inf
;
3300 struct target_ops
*t
;
3302 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3304 if (t
->to_thread_address_space
!= NULL
)
3306 aspace
= t
->to_thread_address_space (t
, ptid
);
3307 gdb_assert (aspace
);
3310 fprintf_unfiltered (gdb_stdlog
,
3311 "target_thread_address_space (%s) = %d\n",
3312 target_pid_to_str (ptid
),
3313 address_space_num (aspace
));
3318 /* Fall-back to the "main" address space of the inferior. */
3319 inf
= find_inferior_pid (ptid_get_pid (ptid
));
3321 if (inf
== NULL
|| inf
->aspace
== NULL
)
3322 internal_error (__FILE__
, __LINE__
,
3323 _("Can't determine the current "
3324 "address space of thread %s\n"),
3325 target_pid_to_str (ptid
));
3331 /* Target file operations. */
3333 static struct target_ops
*
3334 default_fileio_target (void)
3336 /* If we're already connected to something that can perform
3337 file I/O, use it. Otherwise, try using the native target. */
3338 if (current_target
.to_stratum
>= process_stratum
)
3339 return current_target
.beneath
;
3341 return find_default_run_target ("file I/O");
3344 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3345 target file descriptor, or -1 if an error occurs (and set
3348 target_fileio_open (const char *filename
, int flags
, int mode
,
3351 struct target_ops
*t
;
3353 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3355 if (t
->to_fileio_open
!= NULL
)
3357 int fd
= t
->to_fileio_open (filename
, flags
, mode
, target_errno
);
3360 fprintf_unfiltered (gdb_stdlog
,
3361 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3362 filename
, flags
, mode
,
3363 fd
, fd
!= -1 ? 0 : *target_errno
);
3368 *target_errno
= FILEIO_ENOSYS
;
3372 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3373 Return the number of bytes written, or -1 if an error occurs
3374 (and set *TARGET_ERRNO). */
3376 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
3377 ULONGEST offset
, int *target_errno
)
3379 struct target_ops
*t
;
3381 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3383 if (t
->to_fileio_pwrite
!= NULL
)
3385 int ret
= t
->to_fileio_pwrite (fd
, write_buf
, len
, offset
,
3389 fprintf_unfiltered (gdb_stdlog
,
3390 "target_fileio_pwrite (%d,...,%d,%s) "
3392 fd
, len
, pulongest (offset
),
3393 ret
, ret
!= -1 ? 0 : *target_errno
);
3398 *target_errno
= FILEIO_ENOSYS
;
3402 /* Read up to LEN bytes FD on the target into READ_BUF.
3403 Return the number of bytes read, or -1 if an error occurs
3404 (and set *TARGET_ERRNO). */
3406 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
3407 ULONGEST offset
, int *target_errno
)
3409 struct target_ops
*t
;
3411 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3413 if (t
->to_fileio_pread
!= NULL
)
3415 int ret
= t
->to_fileio_pread (fd
, read_buf
, len
, offset
,
3419 fprintf_unfiltered (gdb_stdlog
,
3420 "target_fileio_pread (%d,...,%d,%s) "
3422 fd
, len
, pulongest (offset
),
3423 ret
, ret
!= -1 ? 0 : *target_errno
);
3428 *target_errno
= FILEIO_ENOSYS
;
3432 /* Close FD on the target. Return 0, or -1 if an error occurs
3433 (and set *TARGET_ERRNO). */
3435 target_fileio_close (int fd
, int *target_errno
)
3437 struct target_ops
*t
;
3439 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3441 if (t
->to_fileio_close
!= NULL
)
3443 int ret
= t
->to_fileio_close (fd
, target_errno
);
3446 fprintf_unfiltered (gdb_stdlog
,
3447 "target_fileio_close (%d) = %d (%d)\n",
3448 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
3453 *target_errno
= FILEIO_ENOSYS
;
3457 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3458 occurs (and set *TARGET_ERRNO). */
3460 target_fileio_unlink (const char *filename
, int *target_errno
)
3462 struct target_ops
*t
;
3464 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3466 if (t
->to_fileio_unlink
!= NULL
)
3468 int ret
= t
->to_fileio_unlink (filename
, target_errno
);
3471 fprintf_unfiltered (gdb_stdlog
,
3472 "target_fileio_unlink (%s) = %d (%d)\n",
3473 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
3478 *target_errno
= FILEIO_ENOSYS
;
3482 /* Read value of symbolic link FILENAME on the target. Return a
3483 null-terminated string allocated via xmalloc, or NULL if an error
3484 occurs (and set *TARGET_ERRNO). */
3486 target_fileio_readlink (const char *filename
, int *target_errno
)
3488 struct target_ops
*t
;
3490 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3492 if (t
->to_fileio_readlink
!= NULL
)
3494 char *ret
= t
->to_fileio_readlink (filename
, target_errno
);
3497 fprintf_unfiltered (gdb_stdlog
,
3498 "target_fileio_readlink (%s) = %s (%d)\n",
3499 filename
, ret
? ret
: "(nil)",
3500 ret
? 0 : *target_errno
);
3505 *target_errno
= FILEIO_ENOSYS
;
3510 target_fileio_close_cleanup (void *opaque
)
3512 int fd
= *(int *) opaque
;
3515 target_fileio_close (fd
, &target_errno
);
3518 /* Read target file FILENAME. Store the result in *BUF_P and
3519 return the size of the transferred data. PADDING additional bytes are
3520 available in *BUF_P. This is a helper function for
3521 target_fileio_read_alloc; see the declaration of that function for more
3525 target_fileio_read_alloc_1 (const char *filename
,
3526 gdb_byte
**buf_p
, int padding
)
3528 struct cleanup
*close_cleanup
;
3529 size_t buf_alloc
, buf_pos
;
3535 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
3539 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
3541 /* Start by reading up to 4K at a time. The target will throttle
3542 this number down if necessary. */
3544 buf
= xmalloc (buf_alloc
);
3548 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
3549 buf_alloc
- buf_pos
- padding
, buf_pos
,
3553 /* An error occurred. */
3554 do_cleanups (close_cleanup
);
3560 /* Read all there was. */
3561 do_cleanups (close_cleanup
);
3571 /* If the buffer is filling up, expand it. */
3572 if (buf_alloc
< buf_pos
* 2)
3575 buf
= xrealloc (buf
, buf_alloc
);
3582 /* Read target file FILENAME. Store the result in *BUF_P and return
3583 the size of the transferred data. See the declaration in "target.h"
3584 function for more information about the return value. */
3587 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
3589 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
3592 /* Read target file FILENAME. The result is NUL-terminated and
3593 returned as a string, allocated using xmalloc. If an error occurs
3594 or the transfer is unsupported, NULL is returned. Empty objects
3595 are returned as allocated but empty strings. A warning is issued
3596 if the result contains any embedded NUL bytes. */
3599 target_fileio_read_stralloc (const char *filename
)
3603 LONGEST i
, transferred
;
3605 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
3606 bufstr
= (char *) buffer
;
3608 if (transferred
< 0)
3611 if (transferred
== 0)
3612 return xstrdup ("");
3614 bufstr
[transferred
] = 0;
3616 /* Check for embedded NUL bytes; but allow trailing NULs. */
3617 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3620 warning (_("target file %s "
3621 "contained unexpected null characters"),
3631 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3633 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3637 default_watchpoint_addr_within_range (struct target_ops
*target
,
3639 CORE_ADDR start
, int length
)
3641 return addr
>= start
&& addr
< start
+ length
;
3644 static struct gdbarch
*
3645 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3647 return target_gdbarch ();
3663 return_minus_one (void)
3675 * Find the next target down the stack from the specified target.
3679 find_target_beneath (struct target_ops
*t
)
3685 /* The inferior process has died. Long live the inferior! */
3688 generic_mourn_inferior (void)
3692 ptid
= inferior_ptid
;
3693 inferior_ptid
= null_ptid
;
3695 /* Mark breakpoints uninserted in case something tries to delete a
3696 breakpoint while we delete the inferior's threads (which would
3697 fail, since the inferior is long gone). */
3698 mark_breakpoints_out ();
3700 if (!ptid_equal (ptid
, null_ptid
))
3702 int pid
= ptid_get_pid (ptid
);
3703 exit_inferior (pid
);
3706 /* Note this wipes step-resume breakpoints, so needs to be done
3707 after exit_inferior, which ends up referencing the step-resume
3708 breakpoints through clear_thread_inferior_resources. */
3709 breakpoint_init_inferior (inf_exited
);
3711 registers_changed ();
3713 reopen_exec_file ();
3714 reinit_frame_cache ();
3716 if (deprecated_detach_hook
)
3717 deprecated_detach_hook ();
3720 /* Convert a normal process ID to a string. Returns the string in a
3724 normal_pid_to_str (ptid_t ptid
)
3726 static char buf
[32];
3728 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3733 dummy_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3735 return normal_pid_to_str (ptid
);
3738 /* Error-catcher for target_find_memory_regions. */
3740 dummy_find_memory_regions (find_memory_region_ftype ignore1
, void *ignore2
)
3742 error (_("Command not implemented for this target."));
3746 /* Error-catcher for target_make_corefile_notes. */
3748 dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
3750 error (_("Command not implemented for this target."));
3754 /* Error-catcher for target_get_bookmark. */
3756 dummy_get_bookmark (char *ignore1
, int ignore2
)
3762 /* Error-catcher for target_goto_bookmark. */
3764 dummy_goto_bookmark (gdb_byte
*ignore
, int from_tty
)
3769 /* Set up the handful of non-empty slots needed by the dummy target
3773 init_dummy_target (void)
3775 dummy_target
.to_shortname
= "None";
3776 dummy_target
.to_longname
= "None";
3777 dummy_target
.to_doc
= "";
3778 dummy_target
.to_attach
= find_default_attach
;
3779 dummy_target
.to_detach
=
3780 (void (*)(struct target_ops
*, const char *, int))target_ignore
;
3781 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3782 dummy_target
.to_can_async_p
= find_default_can_async_p
;
3783 dummy_target
.to_is_async_p
= find_default_is_async_p
;
3784 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3785 dummy_target
.to_supports_disable_randomization
3786 = find_default_supports_disable_randomization
;
3787 dummy_target
.to_pid_to_str
= dummy_pid_to_str
;
3788 dummy_target
.to_stratum
= dummy_stratum
;
3789 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
3790 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
3791 dummy_target
.to_get_bookmark
= dummy_get_bookmark
;
3792 dummy_target
.to_goto_bookmark
= dummy_goto_bookmark
;
3793 dummy_target
.to_xfer_partial
= default_xfer_partial
;
3794 dummy_target
.to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
3795 dummy_target
.to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
3796 dummy_target
.to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
3797 dummy_target
.to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
3798 dummy_target
.to_has_execution
3799 = (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
3800 dummy_target
.to_stopped_by_watchpoint
= return_zero
;
3801 dummy_target
.to_stopped_data_address
=
3802 (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
;
3803 dummy_target
.to_magic
= OPS_MAGIC
;
3807 debug_to_open (char *args
, int from_tty
)
3809 debug_target
.to_open (args
, from_tty
);
3811 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3815 target_close (struct target_ops
*targ
)
3817 gdb_assert (!target_is_pushed (targ
));
3819 if (targ
->to_xclose
!= NULL
)
3820 targ
->to_xclose (targ
);
3821 else if (targ
->to_close
!= NULL
)
3825 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3829 target_attach (char *args
, int from_tty
)
3831 struct target_ops
*t
;
3833 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3835 if (t
->to_attach
!= NULL
)
3837 t
->to_attach (t
, args
, from_tty
);
3839 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3845 internal_error (__FILE__
, __LINE__
,
3846 _("could not find a target to attach"));
3850 target_thread_alive (ptid_t ptid
)
3852 struct target_ops
*t
;
3854 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3856 if (t
->to_thread_alive
!= NULL
)
3860 retval
= t
->to_thread_alive (t
, ptid
);
3862 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3863 ptid_get_pid (ptid
), retval
);
3873 target_find_new_threads (void)
3875 struct target_ops
*t
;
3877 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3879 if (t
->to_find_new_threads
!= NULL
)
3881 t
->to_find_new_threads (t
);
3883 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3891 target_stop (ptid_t ptid
)
3895 warning (_("May not interrupt or stop the target, ignoring attempt"));
3899 (*current_target
.to_stop
) (ptid
);
3903 debug_to_post_attach (int pid
)
3905 debug_target
.to_post_attach (pid
);
3907 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3910 /* Concatenate ELEM to LIST, a comma separate list, and return the
3911 result. The LIST incoming argument is released. */
3914 str_comma_list_concat_elem (char *list
, const char *elem
)
3917 return xstrdup (elem
);
3919 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3922 /* Helper for target_options_to_string. If OPT is present in
3923 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3924 Returns the new resulting string. OPT is removed from
3928 do_option (int *target_options
, char *ret
,
3929 int opt
, char *opt_str
)
3931 if ((*target_options
& opt
) != 0)
3933 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3934 *target_options
&= ~opt
;
3941 target_options_to_string (int target_options
)
3945 #define DO_TARG_OPTION(OPT) \
3946 ret = do_option (&target_options, ret, OPT, #OPT)
3948 DO_TARG_OPTION (TARGET_WNOHANG
);
3950 if (target_options
!= 0)
3951 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3959 debug_print_register (const char * func
,
3960 struct regcache
*regcache
, int regno
)
3962 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3964 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3965 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3966 && gdbarch_register_name (gdbarch
, regno
) != NULL
3967 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3968 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3969 gdbarch_register_name (gdbarch
, regno
));
3971 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3972 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3974 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3975 int i
, size
= register_size (gdbarch
, regno
);
3976 gdb_byte buf
[MAX_REGISTER_SIZE
];
3978 regcache_raw_collect (regcache
, regno
, buf
);
3979 fprintf_unfiltered (gdb_stdlog
, " = ");
3980 for (i
= 0; i
< size
; i
++)
3982 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3984 if (size
<= sizeof (LONGEST
))
3986 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
3988 fprintf_unfiltered (gdb_stdlog
, " %s %s",
3989 core_addr_to_string_nz (val
), plongest (val
));
3992 fprintf_unfiltered (gdb_stdlog
, "\n");
3996 target_fetch_registers (struct regcache
*regcache
, int regno
)
3998 struct target_ops
*t
;
4000 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4002 if (t
->to_fetch_registers
!= NULL
)
4004 t
->to_fetch_registers (t
, regcache
, regno
);
4006 debug_print_register ("target_fetch_registers", regcache
, regno
);
4013 target_store_registers (struct regcache
*regcache
, int regno
)
4015 struct target_ops
*t
;
4017 if (!may_write_registers
)
4018 error (_("Writing to registers is not allowed (regno %d)"), regno
);
4020 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4022 if (t
->to_store_registers
!= NULL
)
4024 t
->to_store_registers (t
, regcache
, regno
);
4027 debug_print_register ("target_store_registers", regcache
, regno
);
4037 target_core_of_thread (ptid_t ptid
)
4039 struct target_ops
*t
;
4041 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4043 if (t
->to_core_of_thread
!= NULL
)
4045 int retval
= t
->to_core_of_thread (t
, ptid
);
4048 fprintf_unfiltered (gdb_stdlog
,
4049 "target_core_of_thread (%d) = %d\n",
4050 ptid_get_pid (ptid
), retval
);
4059 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
4061 struct target_ops
*t
;
4063 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4065 if (t
->to_verify_memory
!= NULL
)
4067 int retval
= t
->to_verify_memory (t
, data
, memaddr
, size
);
4070 fprintf_unfiltered (gdb_stdlog
,
4071 "target_verify_memory (%s, %s) = %d\n",
4072 paddress (target_gdbarch (), memaddr
),
4082 /* The documentation for this function is in its prototype declaration in
4086 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4088 struct target_ops
*t
;
4090 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4091 if (t
->to_insert_mask_watchpoint
!= NULL
)
4095 ret
= t
->to_insert_mask_watchpoint (t
, addr
, mask
, rw
);
4098 fprintf_unfiltered (gdb_stdlog
, "\
4099 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
4100 core_addr_to_string (addr
),
4101 core_addr_to_string (mask
), rw
, ret
);
4109 /* The documentation for this function is in its prototype declaration in
4113 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4115 struct target_ops
*t
;
4117 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4118 if (t
->to_remove_mask_watchpoint
!= NULL
)
4122 ret
= t
->to_remove_mask_watchpoint (t
, addr
, mask
, rw
);
4125 fprintf_unfiltered (gdb_stdlog
, "\
4126 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
4127 core_addr_to_string (addr
),
4128 core_addr_to_string (mask
), rw
, ret
);
4136 /* The documentation for this function is in its prototype declaration
4140 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
4142 struct target_ops
*t
;
4144 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4145 if (t
->to_masked_watch_num_registers
!= NULL
)
4146 return t
->to_masked_watch_num_registers (t
, addr
, mask
);
4151 /* The documentation for this function is in its prototype declaration
4155 target_ranged_break_num_registers (void)
4157 struct target_ops
*t
;
4159 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4160 if (t
->to_ranged_break_num_registers
!= NULL
)
4161 return t
->to_ranged_break_num_registers (t
);
4169 target_supports_btrace (void)
4171 struct target_ops
*t
;
4173 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4174 if (t
->to_supports_btrace
!= NULL
)
4175 return t
->to_supports_btrace ();
4182 struct btrace_target_info
*
4183 target_enable_btrace (ptid_t ptid
)
4185 struct target_ops
*t
;
4187 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4188 if (t
->to_enable_btrace
!= NULL
)
4189 return t
->to_enable_btrace (ptid
);
4198 target_disable_btrace (struct btrace_target_info
*btinfo
)
4200 struct target_ops
*t
;
4202 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4203 if (t
->to_disable_btrace
!= NULL
)
4205 t
->to_disable_btrace (btinfo
);
4215 target_teardown_btrace (struct btrace_target_info
*btinfo
)
4217 struct target_ops
*t
;
4219 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4220 if (t
->to_teardown_btrace
!= NULL
)
4222 t
->to_teardown_btrace (btinfo
);
4231 VEC (btrace_block_s
) *
4232 target_read_btrace (struct btrace_target_info
*btinfo
,
4233 enum btrace_read_type type
)
4235 struct target_ops
*t
;
4237 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4238 if (t
->to_read_btrace
!= NULL
)
4239 return t
->to_read_btrace (btinfo
, type
);
4248 target_stop_recording (void)
4250 struct target_ops
*t
;
4252 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4253 if (t
->to_stop_recording
!= NULL
)
4255 t
->to_stop_recording ();
4259 /* This is optional. */
4265 target_info_record (void)
4267 struct target_ops
*t
;
4269 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4270 if (t
->to_info_record
!= NULL
)
4272 t
->to_info_record ();
4282 target_save_record (const char *filename
)
4284 struct target_ops
*t
;
4286 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4287 if (t
->to_save_record
!= NULL
)
4289 t
->to_save_record (filename
);
4299 target_supports_delete_record (void)
4301 struct target_ops
*t
;
4303 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4304 if (t
->to_delete_record
!= NULL
)
4313 target_delete_record (void)
4315 struct target_ops
*t
;
4317 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4318 if (t
->to_delete_record
!= NULL
)
4320 t
->to_delete_record ();
4330 target_record_is_replaying (void)
4332 struct target_ops
*t
;
4334 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4335 if (t
->to_record_is_replaying
!= NULL
)
4336 return t
->to_record_is_replaying ();
4344 target_goto_record_begin (void)
4346 struct target_ops
*t
;
4348 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4349 if (t
->to_goto_record_begin
!= NULL
)
4351 t
->to_goto_record_begin ();
4361 target_goto_record_end (void)
4363 struct target_ops
*t
;
4365 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4366 if (t
->to_goto_record_end
!= NULL
)
4368 t
->to_goto_record_end ();
4378 target_goto_record (ULONGEST insn
)
4380 struct target_ops
*t
;
4382 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4383 if (t
->to_goto_record
!= NULL
)
4385 t
->to_goto_record (insn
);
4395 target_insn_history (int size
, int flags
)
4397 struct target_ops
*t
;
4399 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4400 if (t
->to_insn_history
!= NULL
)
4402 t
->to_insn_history (size
, flags
);
4412 target_insn_history_from (ULONGEST from
, int size
, int flags
)
4414 struct target_ops
*t
;
4416 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4417 if (t
->to_insn_history_from
!= NULL
)
4419 t
->to_insn_history_from (from
, size
, flags
);
4429 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4431 struct target_ops
*t
;
4433 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4434 if (t
->to_insn_history_range
!= NULL
)
4436 t
->to_insn_history_range (begin
, end
, flags
);
4446 target_call_history (int size
, int flags
)
4448 struct target_ops
*t
;
4450 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4451 if (t
->to_call_history
!= NULL
)
4453 t
->to_call_history (size
, flags
);
4463 target_call_history_from (ULONGEST begin
, int size
, int flags
)
4465 struct target_ops
*t
;
4467 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4468 if (t
->to_call_history_from
!= NULL
)
4470 t
->to_call_history_from (begin
, size
, flags
);
4480 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4482 struct target_ops
*t
;
4484 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4485 if (t
->to_call_history_range
!= NULL
)
4487 t
->to_call_history_range (begin
, end
, flags
);
4495 debug_to_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
4497 debug_target
.to_prepare_to_store (&debug_target
, regcache
);
4499 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
4504 const struct frame_unwind
*
4505 target_get_unwinder (void)
4507 struct target_ops
*t
;
4509 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4510 if (t
->to_get_unwinder
!= NULL
)
4511 return t
->to_get_unwinder
;
4518 const struct frame_unwind
*
4519 target_get_tailcall_unwinder (void)
4521 struct target_ops
*t
;
4523 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4524 if (t
->to_get_tailcall_unwinder
!= NULL
)
4525 return t
->to_get_tailcall_unwinder
;
4531 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
4532 int write
, struct mem_attrib
*attrib
,
4533 struct target_ops
*target
)
4537 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
4540 fprintf_unfiltered (gdb_stdlog
,
4541 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4542 paddress (target_gdbarch (), memaddr
), len
,
4543 write
? "write" : "read", retval
);
4549 fputs_unfiltered (", bytes =", gdb_stdlog
);
4550 for (i
= 0; i
< retval
; i
++)
4552 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
4554 if (targetdebug
< 2 && i
> 0)
4556 fprintf_unfiltered (gdb_stdlog
, " ...");
4559 fprintf_unfiltered (gdb_stdlog
, "\n");
4562 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
4566 fputc_unfiltered ('\n', gdb_stdlog
);
4572 debug_to_files_info (struct target_ops
*target
)
4574 debug_target
.to_files_info (target
);
4576 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
4580 debug_to_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4581 struct bp_target_info
*bp_tgt
)
4585 retval
= forward_target_insert_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4587 fprintf_unfiltered (gdb_stdlog
,
4588 "target_insert_breakpoint (%s, xxx) = %ld\n",
4589 core_addr_to_string (bp_tgt
->placed_address
),
4590 (unsigned long) retval
);
4595 debug_to_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4596 struct bp_target_info
*bp_tgt
)
4600 retval
= forward_target_remove_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4602 fprintf_unfiltered (gdb_stdlog
,
4603 "target_remove_breakpoint (%s, xxx) = %ld\n",
4604 core_addr_to_string (bp_tgt
->placed_address
),
4605 (unsigned long) retval
);
4610 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
4614 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
4616 fprintf_unfiltered (gdb_stdlog
,
4617 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4618 (unsigned long) type
,
4619 (unsigned long) cnt
,
4620 (unsigned long) from_tty
,
4621 (unsigned long) retval
);
4626 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
4630 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
4632 fprintf_unfiltered (gdb_stdlog
,
4633 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4634 core_addr_to_string (addr
), (unsigned long) len
,
4635 core_addr_to_string (retval
));
4640 debug_to_can_accel_watchpoint_condition (CORE_ADDR addr
, int len
, int rw
,
4641 struct expression
*cond
)
4645 retval
= debug_target
.to_can_accel_watchpoint_condition (addr
, len
,
4648 fprintf_unfiltered (gdb_stdlog
,
4649 "target_can_accel_watchpoint_condition "
4650 "(%s, %d, %d, %s) = %ld\n",
4651 core_addr_to_string (addr
), len
, rw
,
4652 host_address_to_string (cond
), (unsigned long) retval
);
4657 debug_to_stopped_by_watchpoint (void)
4661 retval
= debug_target
.to_stopped_by_watchpoint ();
4663 fprintf_unfiltered (gdb_stdlog
,
4664 "target_stopped_by_watchpoint () = %ld\n",
4665 (unsigned long) retval
);
4670 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
4674 retval
= debug_target
.to_stopped_data_address (target
, addr
);
4676 fprintf_unfiltered (gdb_stdlog
,
4677 "target_stopped_data_address ([%s]) = %ld\n",
4678 core_addr_to_string (*addr
),
4679 (unsigned long)retval
);
4684 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
4686 CORE_ADDR start
, int length
)
4690 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
4693 fprintf_filtered (gdb_stdlog
,
4694 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4695 core_addr_to_string (addr
), core_addr_to_string (start
),
4701 debug_to_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
4702 struct bp_target_info
*bp_tgt
)
4706 retval
= debug_target
.to_insert_hw_breakpoint (gdbarch
, bp_tgt
);
4708 fprintf_unfiltered (gdb_stdlog
,
4709 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4710 core_addr_to_string (bp_tgt
->placed_address
),
4711 (unsigned long) retval
);
4716 debug_to_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
4717 struct bp_target_info
*bp_tgt
)
4721 retval
= debug_target
.to_remove_hw_breakpoint (gdbarch
, bp_tgt
);
4723 fprintf_unfiltered (gdb_stdlog
,
4724 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4725 core_addr_to_string (bp_tgt
->placed_address
),
4726 (unsigned long) retval
);
4731 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
4732 struct expression
*cond
)
4736 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
, cond
);
4738 fprintf_unfiltered (gdb_stdlog
,
4739 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4740 core_addr_to_string (addr
), len
, type
,
4741 host_address_to_string (cond
), (unsigned long) retval
);
4746 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
4747 struct expression
*cond
)
4751 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
, cond
);
4753 fprintf_unfiltered (gdb_stdlog
,
4754 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4755 core_addr_to_string (addr
), len
, type
,
4756 host_address_to_string (cond
), (unsigned long) retval
);
4761 debug_to_terminal_init (void)
4763 debug_target
.to_terminal_init ();
4765 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
4769 debug_to_terminal_inferior (void)
4771 debug_target
.to_terminal_inferior ();
4773 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
4777 debug_to_terminal_ours_for_output (void)
4779 debug_target
.to_terminal_ours_for_output ();
4781 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
4785 debug_to_terminal_ours (void)
4787 debug_target
.to_terminal_ours ();
4789 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
4793 debug_to_terminal_save_ours (void)
4795 debug_target
.to_terminal_save_ours ();
4797 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
4801 debug_to_terminal_info (const char *arg
, int from_tty
)
4803 debug_target
.to_terminal_info (arg
, from_tty
);
4805 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
4810 debug_to_load (char *args
, int from_tty
)
4812 debug_target
.to_load (args
, from_tty
);
4814 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
4818 debug_to_post_startup_inferior (ptid_t ptid
)
4820 debug_target
.to_post_startup_inferior (ptid
);
4822 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
4823 ptid_get_pid (ptid
));
4827 debug_to_insert_fork_catchpoint (int pid
)
4831 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
4833 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
4840 debug_to_remove_fork_catchpoint (int pid
)
4844 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
4846 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
4853 debug_to_insert_vfork_catchpoint (int pid
)
4857 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
4859 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
4866 debug_to_remove_vfork_catchpoint (int pid
)
4870 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
4872 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
4879 debug_to_insert_exec_catchpoint (int pid
)
4883 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
4885 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
4892 debug_to_remove_exec_catchpoint (int pid
)
4896 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
4898 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
4905 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
4909 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
4911 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
4912 pid
, wait_status
, *exit_status
, has_exited
);
4918 debug_to_can_run (void)
4922 retval
= debug_target
.to_can_run ();
4924 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4929 static struct gdbarch
*
4930 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4932 struct gdbarch
*retval
;
4934 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4936 fprintf_unfiltered (gdb_stdlog
,
4937 "target_thread_architecture (%s) = %s [%s]\n",
4938 target_pid_to_str (ptid
),
4939 host_address_to_string (retval
),
4940 gdbarch_bfd_arch_info (retval
)->printable_name
);
4945 debug_to_stop (ptid_t ptid
)
4947 debug_target
.to_stop (ptid
);
4949 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4950 target_pid_to_str (ptid
));
4954 debug_to_rcmd (char *command
,
4955 struct ui_file
*outbuf
)
4957 debug_target
.to_rcmd (command
, outbuf
);
4958 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4962 debug_to_pid_to_exec_file (int pid
)
4966 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
4968 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
4975 setup_target_debug (void)
4977 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
4979 current_target
.to_open
= debug_to_open
;
4980 current_target
.to_post_attach
= debug_to_post_attach
;
4981 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
4982 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
4983 current_target
.to_files_info
= debug_to_files_info
;
4984 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
4985 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
4986 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
4987 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
4988 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
4989 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
4990 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
4991 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
4992 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
4993 current_target
.to_watchpoint_addr_within_range
4994 = debug_to_watchpoint_addr_within_range
;
4995 current_target
.to_region_ok_for_hw_watchpoint
4996 = debug_to_region_ok_for_hw_watchpoint
;
4997 current_target
.to_can_accel_watchpoint_condition
4998 = debug_to_can_accel_watchpoint_condition
;
4999 current_target
.to_terminal_init
= debug_to_terminal_init
;
5000 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
5001 current_target
.to_terminal_ours_for_output
5002 = debug_to_terminal_ours_for_output
;
5003 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
5004 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
5005 current_target
.to_terminal_info
= debug_to_terminal_info
;
5006 current_target
.to_load
= debug_to_load
;
5007 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
5008 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
5009 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
5010 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
5011 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
5012 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
5013 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
5014 current_target
.to_has_exited
= debug_to_has_exited
;
5015 current_target
.to_can_run
= debug_to_can_run
;
5016 current_target
.to_stop
= debug_to_stop
;
5017 current_target
.to_rcmd
= debug_to_rcmd
;
5018 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
5019 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
5023 static char targ_desc
[] =
5024 "Names of targets and files being debugged.\nShows the entire \
5025 stack of targets currently in use (including the exec-file,\n\
5026 core-file, and process, if any), as well as the symbol file name.";
5029 do_monitor_command (char *cmd
,
5032 if ((current_target
.to_rcmd
5033 == (void (*) (char *, struct ui_file
*)) tcomplain
)
5034 || (current_target
.to_rcmd
== debug_to_rcmd
5035 && (debug_target
.to_rcmd
5036 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
5037 error (_("\"monitor\" command not supported by this target."));
5038 target_rcmd (cmd
, gdb_stdtarg
);
5041 /* Print the name of each layers of our target stack. */
5044 maintenance_print_target_stack (char *cmd
, int from_tty
)
5046 struct target_ops
*t
;
5048 printf_filtered (_("The current target stack is:\n"));
5050 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
5052 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
5056 /* Controls if async mode is permitted. */
5057 int target_async_permitted
= 0;
5059 /* The set command writes to this variable. If the inferior is
5060 executing, target_async_permitted is *not* updated. */
5061 static int target_async_permitted_1
= 0;
5064 set_target_async_command (char *args
, int from_tty
,
5065 struct cmd_list_element
*c
)
5067 if (have_live_inferiors ())
5069 target_async_permitted_1
= target_async_permitted
;
5070 error (_("Cannot change this setting while the inferior is running."));
5073 target_async_permitted
= target_async_permitted_1
;
5077 show_target_async_command (struct ui_file
*file
, int from_tty
,
5078 struct cmd_list_element
*c
,
5081 fprintf_filtered (file
,
5082 _("Controlling the inferior in "
5083 "asynchronous mode is %s.\n"), value
);
5086 /* Temporary copies of permission settings. */
5088 static int may_write_registers_1
= 1;
5089 static int may_write_memory_1
= 1;
5090 static int may_insert_breakpoints_1
= 1;
5091 static int may_insert_tracepoints_1
= 1;
5092 static int may_insert_fast_tracepoints_1
= 1;
5093 static int may_stop_1
= 1;
5095 /* Make the user-set values match the real values again. */
5098 update_target_permissions (void)
5100 may_write_registers_1
= may_write_registers
;
5101 may_write_memory_1
= may_write_memory
;
5102 may_insert_breakpoints_1
= may_insert_breakpoints
;
5103 may_insert_tracepoints_1
= may_insert_tracepoints
;
5104 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
5105 may_stop_1
= may_stop
;
5108 /* The one function handles (most of) the permission flags in the same
5112 set_target_permissions (char *args
, int from_tty
,
5113 struct cmd_list_element
*c
)
5115 if (target_has_execution
)
5117 update_target_permissions ();
5118 error (_("Cannot change this setting while the inferior is running."));
5121 /* Make the real values match the user-changed values. */
5122 may_write_registers
= may_write_registers_1
;
5123 may_insert_breakpoints
= may_insert_breakpoints_1
;
5124 may_insert_tracepoints
= may_insert_tracepoints_1
;
5125 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
5126 may_stop
= may_stop_1
;
5127 update_observer_mode ();
5130 /* Set memory write permission independently of observer mode. */
5133 set_write_memory_permission (char *args
, int from_tty
,
5134 struct cmd_list_element
*c
)
5136 /* Make the real values match the user-changed values. */
5137 may_write_memory
= may_write_memory_1
;
5138 update_observer_mode ();
5143 initialize_targets (void)
5145 init_dummy_target ();
5146 push_target (&dummy_target
);
5148 add_info ("target", target_info
, targ_desc
);
5149 add_info ("files", target_info
, targ_desc
);
5151 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
5152 Set target debugging."), _("\
5153 Show target debugging."), _("\
5154 When non-zero, target debugging is enabled. Higher numbers are more\n\
5155 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
5159 &setdebuglist
, &showdebuglist
);
5161 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
5162 &trust_readonly
, _("\
5163 Set mode for reading from readonly sections."), _("\
5164 Show mode for reading from readonly sections."), _("\
5165 When this mode is on, memory reads from readonly sections (such as .text)\n\
5166 will be read from the object file instead of from the target. This will\n\
5167 result in significant performance improvement for remote targets."),
5169 show_trust_readonly
,
5170 &setlist
, &showlist
);
5172 add_com ("monitor", class_obscure
, do_monitor_command
,
5173 _("Send a command to the remote monitor (remote targets only)."));
5175 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
5176 _("Print the name of each layer of the internal target stack."),
5177 &maintenanceprintlist
);
5179 add_setshow_boolean_cmd ("target-async", no_class
,
5180 &target_async_permitted_1
, _("\
5181 Set whether gdb controls the inferior in asynchronous mode."), _("\
5182 Show whether gdb controls the inferior in asynchronous mode."), _("\
5183 Tells gdb whether to control the inferior in asynchronous mode."),
5184 set_target_async_command
,
5185 show_target_async_command
,
5189 add_setshow_boolean_cmd ("may-write-registers", class_support
,
5190 &may_write_registers_1
, _("\
5191 Set permission to write into registers."), _("\
5192 Show permission to write into registers."), _("\
5193 When this permission is on, GDB may write into the target's registers.\n\
5194 Otherwise, any sort of write attempt will result in an error."),
5195 set_target_permissions
, NULL
,
5196 &setlist
, &showlist
);
5198 add_setshow_boolean_cmd ("may-write-memory", class_support
,
5199 &may_write_memory_1
, _("\
5200 Set permission to write into target memory."), _("\
5201 Show permission to write into target memory."), _("\
5202 When this permission is on, GDB may write into the target's memory.\n\
5203 Otherwise, any sort of write attempt will result in an error."),
5204 set_write_memory_permission
, NULL
,
5205 &setlist
, &showlist
);
5207 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
5208 &may_insert_breakpoints_1
, _("\
5209 Set permission to insert breakpoints in the target."), _("\
5210 Show permission to insert breakpoints in the target."), _("\
5211 When this permission is on, GDB may insert breakpoints in the program.\n\
5212 Otherwise, any sort of insertion attempt will result in an error."),
5213 set_target_permissions
, NULL
,
5214 &setlist
, &showlist
);
5216 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
5217 &may_insert_tracepoints_1
, _("\
5218 Set permission to insert tracepoints in the target."), _("\
5219 Show permission to insert tracepoints in the target."), _("\
5220 When this permission is on, GDB may insert tracepoints in the program.\n\
5221 Otherwise, any sort of insertion attempt will result in an error."),
5222 set_target_permissions
, NULL
,
5223 &setlist
, &showlist
);
5225 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
5226 &may_insert_fast_tracepoints_1
, _("\
5227 Set permission to insert fast tracepoints in the target."), _("\
5228 Show permission to insert fast tracepoints in the target."), _("\
5229 When this permission is on, GDB may insert fast tracepoints.\n\
5230 Otherwise, any sort of insertion attempt will result in an error."),
5231 set_target_permissions
, NULL
,
5232 &setlist
, &showlist
);
5234 add_setshow_boolean_cmd ("may-interrupt", class_support
,
5236 Set permission to interrupt or signal the target."), _("\
5237 Show permission to interrupt or signal the target."), _("\
5238 When this permission is on, GDB may interrupt/stop the target's execution.\n\
5239 Otherwise, any attempt to interrupt or stop will be ignored."),
5240 set_target_permissions
, NULL
,
5241 &setlist
, &showlist
);