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 struct gdbarch
*default_thread_architecture (struct target_ops
*ops
,
80 static int find_default_can_async_p (struct target_ops
*ignore
);
82 static int find_default_is_async_p (struct target_ops
*ignore
);
84 #include "target-delegates.c"
86 static void init_dummy_target (void);
88 static struct target_ops debug_target
;
90 static void debug_to_open (char *, int);
92 static void debug_to_prepare_to_store (struct target_ops
*self
,
95 static void debug_to_files_info (struct target_ops
*);
97 static int debug_to_insert_breakpoint (struct target_ops
*, struct gdbarch
*,
98 struct bp_target_info
*);
100 static int debug_to_remove_breakpoint (struct target_ops
*, struct gdbarch
*,
101 struct bp_target_info
*);
103 static int debug_to_can_use_hw_breakpoint (struct target_ops
*self
,
106 static int debug_to_insert_hw_breakpoint (struct gdbarch
*,
107 struct bp_target_info
*);
109 static int debug_to_remove_hw_breakpoint (struct gdbarch
*,
110 struct bp_target_info
*);
112 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int,
113 struct expression
*);
115 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int,
116 struct expression
*);
118 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
120 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
121 CORE_ADDR
, CORE_ADDR
, int);
123 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
125 static int debug_to_can_accel_watchpoint_condition (CORE_ADDR
, int, int,
126 struct expression
*);
128 static void debug_to_terminal_init (void);
130 static void debug_to_terminal_inferior (void);
132 static void debug_to_terminal_ours_for_output (void);
134 static void debug_to_terminal_save_ours (void);
136 static void debug_to_terminal_ours (void);
138 static void debug_to_load (char *, int);
140 static int debug_to_can_run (void);
142 static void debug_to_stop (ptid_t
);
144 /* Pointer to array of target architecture structures; the size of the
145 array; the current index into the array; the allocated size of the
147 struct target_ops
**target_structs
;
148 unsigned target_struct_size
;
149 unsigned target_struct_allocsize
;
150 #define DEFAULT_ALLOCSIZE 10
152 /* The initial current target, so that there is always a semi-valid
155 static struct target_ops dummy_target
;
157 /* Top of target stack. */
159 static struct target_ops
*target_stack
;
161 /* The target structure we are currently using to talk to a process
162 or file or whatever "inferior" we have. */
164 struct target_ops current_target
;
166 /* Command list for target. */
168 static struct cmd_list_element
*targetlist
= NULL
;
170 /* Nonzero if we should trust readonly sections from the
171 executable when reading memory. */
173 static int trust_readonly
= 0;
175 /* Nonzero if we should show true memory content including
176 memory breakpoint inserted by gdb. */
178 static int show_memory_breakpoints
= 0;
180 /* These globals control whether GDB attempts to perform these
181 operations; they are useful for targets that need to prevent
182 inadvertant disruption, such as in non-stop mode. */
184 int may_write_registers
= 1;
186 int may_write_memory
= 1;
188 int may_insert_breakpoints
= 1;
190 int may_insert_tracepoints
= 1;
192 int may_insert_fast_tracepoints
= 1;
196 /* Non-zero if we want to see trace of target level stuff. */
198 static unsigned int targetdebug
= 0;
200 show_targetdebug (struct ui_file
*file
, int from_tty
,
201 struct cmd_list_element
*c
, const char *value
)
203 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
206 static void setup_target_debug (void);
208 /* The user just typed 'target' without the name of a target. */
211 target_command (char *arg
, int from_tty
)
213 fputs_filtered ("Argument required (target name). Try `help target'\n",
217 /* Default target_has_* methods for process_stratum targets. */
220 default_child_has_all_memory (struct target_ops
*ops
)
222 /* If no inferior selected, then we can't read memory here. */
223 if (ptid_equal (inferior_ptid
, null_ptid
))
230 default_child_has_memory (struct target_ops
*ops
)
232 /* If no inferior selected, then we can't read memory here. */
233 if (ptid_equal (inferior_ptid
, null_ptid
))
240 default_child_has_stack (struct target_ops
*ops
)
242 /* If no inferior selected, there's no stack. */
243 if (ptid_equal (inferior_ptid
, null_ptid
))
250 default_child_has_registers (struct target_ops
*ops
)
252 /* Can't read registers from no inferior. */
253 if (ptid_equal (inferior_ptid
, null_ptid
))
260 default_child_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
262 /* If there's no thread selected, then we can't make it run through
264 if (ptid_equal (the_ptid
, null_ptid
))
272 target_has_all_memory_1 (void)
274 struct target_ops
*t
;
276 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
277 if (t
->to_has_all_memory (t
))
284 target_has_memory_1 (void)
286 struct target_ops
*t
;
288 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
289 if (t
->to_has_memory (t
))
296 target_has_stack_1 (void)
298 struct target_ops
*t
;
300 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
301 if (t
->to_has_stack (t
))
308 target_has_registers_1 (void)
310 struct target_ops
*t
;
312 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
313 if (t
->to_has_registers (t
))
320 target_has_execution_1 (ptid_t the_ptid
)
322 struct target_ops
*t
;
324 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
325 if (t
->to_has_execution (t
, the_ptid
))
332 target_has_execution_current (void)
334 return target_has_execution_1 (inferior_ptid
);
337 /* Complete initialization of T. This ensures that various fields in
338 T are set, if needed by the target implementation. */
341 complete_target_initialization (struct target_ops
*t
)
343 /* Provide default values for all "must have" methods. */
344 if (t
->to_xfer_partial
== NULL
)
345 t
->to_xfer_partial
= default_xfer_partial
;
347 if (t
->to_has_all_memory
== NULL
)
348 t
->to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
350 if (t
->to_has_memory
== NULL
)
351 t
->to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
353 if (t
->to_has_stack
== NULL
)
354 t
->to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
356 if (t
->to_has_registers
== NULL
)
357 t
->to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
359 if (t
->to_has_execution
== NULL
)
360 t
->to_has_execution
= (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
362 install_delegators (t
);
365 /* Add possible target architecture T to the list and add a new
366 command 'target T->to_shortname'. Set COMPLETER as the command's
367 completer if not NULL. */
370 add_target_with_completer (struct target_ops
*t
,
371 completer_ftype
*completer
)
373 struct cmd_list_element
*c
;
375 complete_target_initialization (t
);
379 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
380 target_structs
= (struct target_ops
**) xmalloc
381 (target_struct_allocsize
* sizeof (*target_structs
));
383 if (target_struct_size
>= target_struct_allocsize
)
385 target_struct_allocsize
*= 2;
386 target_structs
= (struct target_ops
**)
387 xrealloc ((char *) target_structs
,
388 target_struct_allocsize
* sizeof (*target_structs
));
390 target_structs
[target_struct_size
++] = t
;
392 if (targetlist
== NULL
)
393 add_prefix_cmd ("target", class_run
, target_command
, _("\
394 Connect to a target machine or process.\n\
395 The first argument is the type or protocol of the target machine.\n\
396 Remaining arguments are interpreted by the target protocol. For more\n\
397 information on the arguments for a particular protocol, type\n\
398 `help target ' followed by the protocol name."),
399 &targetlist
, "target ", 0, &cmdlist
);
400 c
= add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
,
402 if (completer
!= NULL
)
403 set_cmd_completer (c
, completer
);
406 /* Add a possible target architecture to the list. */
409 add_target (struct target_ops
*t
)
411 add_target_with_completer (t
, NULL
);
417 add_deprecated_target_alias (struct target_ops
*t
, char *alias
)
419 struct cmd_list_element
*c
;
422 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
424 c
= add_cmd (alias
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
425 alt
= xstrprintf ("target %s", t
->to_shortname
);
426 deprecate_cmd (c
, alt
);
439 struct target_ops
*t
;
441 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
442 if (t
->to_kill
!= NULL
)
445 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
455 target_load (char *arg
, int from_tty
)
457 target_dcache_invalidate ();
458 (*current_target
.to_load
) (arg
, from_tty
);
462 target_create_inferior (char *exec_file
, char *args
,
463 char **env
, int from_tty
)
465 struct target_ops
*t
;
467 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
469 if (t
->to_create_inferior
!= NULL
)
471 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
473 fprintf_unfiltered (gdb_stdlog
,
474 "target_create_inferior (%s, %s, xxx, %d)\n",
475 exec_file
, args
, from_tty
);
480 internal_error (__FILE__
, __LINE__
,
481 _("could not find a target to create inferior"));
485 target_terminal_inferior (void)
487 /* A background resume (``run&'') should leave GDB in control of the
488 terminal. Use target_can_async_p, not target_is_async_p, since at
489 this point the target is not async yet. However, if sync_execution
490 is not set, we know it will become async prior to resume. */
491 if (target_can_async_p () && !sync_execution
)
494 /* If GDB is resuming the inferior in the foreground, install
495 inferior's terminal modes. */
496 (*current_target
.to_terminal_inferior
) ();
500 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
501 struct target_ops
*t
)
503 errno
= EIO
; /* Can't read/write this location. */
504 return 0; /* No bytes handled. */
510 error (_("You can't do that when your target is `%s'"),
511 current_target
.to_shortname
);
517 error (_("You can't do that without a process to debug."));
521 default_terminal_info (const char *args
, int from_tty
)
523 printf_unfiltered (_("No saved terminal information.\n"));
526 /* A default implementation for the to_get_ada_task_ptid target method.
528 This function builds the PTID by using both LWP and TID as part of
529 the PTID lwp and tid elements. The pid used is the pid of the
533 default_get_ada_task_ptid (long lwp
, long tid
)
535 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
538 static enum exec_direction_kind
539 default_execution_direction (void)
541 if (!target_can_execute_reverse
)
543 else if (!target_can_async_p ())
546 gdb_assert_not_reached ("\
547 to_execution_direction must be implemented for reverse async");
550 /* Go through the target stack from top to bottom, copying over zero
551 entries in current_target, then filling in still empty entries. In
552 effect, we are doing class inheritance through the pushed target
555 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
556 is currently implemented, is that it discards any knowledge of
557 which target an inherited method originally belonged to.
558 Consequently, new new target methods should instead explicitly and
559 locally search the target stack for the target that can handle the
563 update_current_target (void)
565 struct target_ops
*t
;
567 /* First, reset current's contents. */
568 memset (¤t_target
, 0, sizeof (current_target
));
570 /* Install the delegators. */
571 install_delegators (¤t_target
);
573 #define INHERIT(FIELD, TARGET) \
574 if (!current_target.FIELD) \
575 current_target.FIELD = (TARGET)->FIELD
577 for (t
= target_stack
; t
; t
= t
->beneath
)
579 INHERIT (to_shortname
, t
);
580 INHERIT (to_longname
, t
);
582 /* Do not inherit to_open. */
583 /* Do not inherit to_close. */
584 /* Do not inherit to_attach. */
585 INHERIT (to_post_attach
, t
);
586 INHERIT (to_attach_no_wait
, t
);
587 /* Do not inherit to_detach. */
588 /* Do not inherit to_disconnect. */
589 /* Do not inherit to_resume. */
590 /* Do not inherit to_wait. */
591 /* Do not inherit to_fetch_registers. */
592 /* Do not inherit to_store_registers. */
593 INHERIT (to_prepare_to_store
, t
);
594 INHERIT (deprecated_xfer_memory
, t
);
595 INHERIT (to_files_info
, t
);
596 /* Do not inherit to_insert_breakpoint. */
597 /* Do not inherit to_remove_breakpoint. */
598 INHERIT (to_can_use_hw_breakpoint
, t
);
599 INHERIT (to_insert_hw_breakpoint
, t
);
600 INHERIT (to_remove_hw_breakpoint
, t
);
601 /* Do not inherit to_ranged_break_num_registers. */
602 INHERIT (to_insert_watchpoint
, t
);
603 INHERIT (to_remove_watchpoint
, t
);
604 /* Do not inherit to_insert_mask_watchpoint. */
605 /* Do not inherit to_remove_mask_watchpoint. */
606 /* Do not inherit to_stopped_data_address. */
607 INHERIT (to_have_steppable_watchpoint
, t
);
608 INHERIT (to_have_continuable_watchpoint
, t
);
609 /* Do not inherit to_stopped_by_watchpoint. */
610 INHERIT (to_watchpoint_addr_within_range
, t
);
611 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
612 INHERIT (to_can_accel_watchpoint_condition
, t
);
613 /* Do not inherit to_masked_watch_num_registers. */
614 INHERIT (to_terminal_init
, t
);
615 INHERIT (to_terminal_inferior
, t
);
616 INHERIT (to_terminal_ours_for_output
, t
);
617 INHERIT (to_terminal_ours
, t
);
618 INHERIT (to_terminal_save_ours
, t
);
619 INHERIT (to_terminal_info
, t
);
620 /* Do not inherit to_kill. */
621 INHERIT (to_load
, t
);
622 /* Do no inherit to_create_inferior. */
623 INHERIT (to_post_startup_inferior
, t
);
624 INHERIT (to_insert_fork_catchpoint
, t
);
625 INHERIT (to_remove_fork_catchpoint
, t
);
626 INHERIT (to_insert_vfork_catchpoint
, t
);
627 INHERIT (to_remove_vfork_catchpoint
, t
);
628 /* Do not inherit to_follow_fork. */
629 INHERIT (to_insert_exec_catchpoint
, t
);
630 INHERIT (to_remove_exec_catchpoint
, t
);
631 INHERIT (to_set_syscall_catchpoint
, t
);
632 INHERIT (to_has_exited
, t
);
633 /* Do not inherit to_mourn_inferior. */
634 INHERIT (to_can_run
, t
);
635 /* Do not inherit to_pass_signals. */
636 /* Do not inherit to_program_signals. */
637 /* Do not inherit to_thread_alive. */
638 /* Do not inherit to_find_new_threads. */
639 /* Do not inherit to_pid_to_str. */
640 INHERIT (to_extra_thread_info
, t
);
641 INHERIT (to_thread_name
, t
);
642 INHERIT (to_stop
, t
);
643 /* Do not inherit to_xfer_partial. */
644 INHERIT (to_rcmd
, t
);
645 INHERIT (to_pid_to_exec_file
, t
);
646 INHERIT (to_log_command
, t
);
647 INHERIT (to_stratum
, t
);
648 /* Do not inherit to_has_all_memory. */
649 /* Do not inherit to_has_memory. */
650 /* Do not inherit to_has_stack. */
651 /* Do not inherit to_has_registers. */
652 /* Do not inherit to_has_execution. */
653 INHERIT (to_has_thread_control
, t
);
654 /* Do not inherit to_can_async_p. */
655 /* Do not inherit to_is_async_p. */
656 /* Do not inherit to_async. */
657 INHERIT (to_find_memory_regions
, t
);
658 INHERIT (to_make_corefile_notes
, t
);
659 INHERIT (to_get_bookmark
, t
);
660 INHERIT (to_goto_bookmark
, t
);
661 /* Do not inherit to_get_thread_local_address. */
662 INHERIT (to_can_execute_reverse
, t
);
663 INHERIT (to_execution_direction
, t
);
664 INHERIT (to_thread_architecture
, t
);
665 /* Do not inherit to_read_description. */
666 INHERIT (to_get_ada_task_ptid
, t
);
667 /* Do not inherit to_search_memory. */
668 INHERIT (to_supports_multi_process
, t
);
669 INHERIT (to_supports_enable_disable_tracepoint
, t
);
670 INHERIT (to_supports_string_tracing
, t
);
671 INHERIT (to_trace_init
, t
);
672 INHERIT (to_download_tracepoint
, t
);
673 INHERIT (to_can_download_tracepoint
, t
);
674 INHERIT (to_download_trace_state_variable
, t
);
675 INHERIT (to_enable_tracepoint
, t
);
676 INHERIT (to_disable_tracepoint
, t
);
677 INHERIT (to_trace_set_readonly_regions
, t
);
678 INHERIT (to_trace_start
, t
);
679 INHERIT (to_get_trace_status
, t
);
680 INHERIT (to_get_tracepoint_status
, t
);
681 INHERIT (to_trace_stop
, t
);
682 INHERIT (to_trace_find
, t
);
683 INHERIT (to_get_trace_state_variable_value
, t
);
684 INHERIT (to_save_trace_data
, t
);
685 INHERIT (to_upload_tracepoints
, t
);
686 INHERIT (to_upload_trace_state_variables
, t
);
687 INHERIT (to_get_raw_trace_data
, t
);
688 INHERIT (to_get_min_fast_tracepoint_insn_len
, t
);
689 INHERIT (to_set_disconnected_tracing
, t
);
690 INHERIT (to_set_circular_trace_buffer
, t
);
691 INHERIT (to_set_trace_buffer_size
, t
);
692 INHERIT (to_set_trace_notes
, t
);
693 INHERIT (to_get_tib_address
, t
);
694 INHERIT (to_set_permissions
, t
);
695 INHERIT (to_static_tracepoint_marker_at
, t
);
696 INHERIT (to_static_tracepoint_markers_by_strid
, t
);
697 INHERIT (to_traceframe_info
, t
);
698 INHERIT (to_use_agent
, t
);
699 INHERIT (to_can_use_agent
, t
);
700 INHERIT (to_augmented_libraries_svr4_read
, t
);
701 INHERIT (to_magic
, t
);
702 INHERIT (to_supports_evaluation_of_breakpoint_conditions
, t
);
703 INHERIT (to_can_run_breakpoint_commands
, t
);
704 /* Do not inherit to_memory_map. */
705 /* Do not inherit to_flash_erase. */
706 /* Do not inherit to_flash_done. */
710 /* Clean up a target struct so it no longer has any zero pointers in
711 it. Some entries are defaulted to a method that print an error,
712 others are hard-wired to a standard recursive default. */
714 #define de_fault(field, value) \
715 if (!current_target.field) \
716 current_target.field = value
719 (void (*) (char *, int))
722 (void (*) (struct target_ops
*))
724 de_fault (to_post_attach
,
725 (void (*) (struct target_ops
*, int))
727 de_fault (to_prepare_to_store
,
728 (void (*) (struct target_ops
*, struct regcache
*))
730 de_fault (deprecated_xfer_memory
,
731 (int (*) (CORE_ADDR
, gdb_byte
*, int, int,
732 struct mem_attrib
*, struct target_ops
*))
734 de_fault (to_files_info
,
735 (void (*) (struct target_ops
*))
737 de_fault (to_can_use_hw_breakpoint
,
738 (int (*) (struct target_ops
*, int, int, int))
740 de_fault (to_insert_hw_breakpoint
,
741 (int (*) (struct gdbarch
*, struct bp_target_info
*))
743 de_fault (to_remove_hw_breakpoint
,
744 (int (*) (struct gdbarch
*, struct bp_target_info
*))
746 de_fault (to_insert_watchpoint
,
747 (int (*) (CORE_ADDR
, int, int, struct expression
*))
749 de_fault (to_remove_watchpoint
,
750 (int (*) (CORE_ADDR
, int, int, struct expression
*))
752 de_fault (to_watchpoint_addr_within_range
,
753 default_watchpoint_addr_within_range
);
754 de_fault (to_region_ok_for_hw_watchpoint
,
755 default_region_ok_for_hw_watchpoint
);
756 de_fault (to_can_accel_watchpoint_condition
,
757 (int (*) (CORE_ADDR
, int, int, struct expression
*))
759 de_fault (to_terminal_init
,
762 de_fault (to_terminal_inferior
,
765 de_fault (to_terminal_ours_for_output
,
768 de_fault (to_terminal_ours
,
771 de_fault (to_terminal_save_ours
,
774 de_fault (to_terminal_info
,
775 default_terminal_info
);
777 (void (*) (char *, int))
779 de_fault (to_post_startup_inferior
,
782 de_fault (to_insert_fork_catchpoint
,
785 de_fault (to_remove_fork_catchpoint
,
788 de_fault (to_insert_vfork_catchpoint
,
791 de_fault (to_remove_vfork_catchpoint
,
794 de_fault (to_insert_exec_catchpoint
,
797 de_fault (to_remove_exec_catchpoint
,
800 de_fault (to_set_syscall_catchpoint
,
801 (int (*) (int, int, int, int, int *))
803 de_fault (to_has_exited
,
804 (int (*) (int, int, int *))
806 de_fault (to_can_run
,
808 de_fault (to_extra_thread_info
,
809 (char *(*) (struct thread_info
*))
811 de_fault (to_thread_name
,
812 (char *(*) (struct thread_info
*))
818 (void (*) (char *, struct ui_file
*))
820 de_fault (to_pid_to_exec_file
,
823 de_fault (to_thread_architecture
,
824 default_thread_architecture
);
825 current_target
.to_read_description
= NULL
;
826 de_fault (to_get_ada_task_ptid
,
827 (ptid_t (*) (long, long))
828 default_get_ada_task_ptid
);
829 de_fault (to_supports_multi_process
,
832 de_fault (to_supports_enable_disable_tracepoint
,
835 de_fault (to_supports_string_tracing
,
838 de_fault (to_trace_init
,
841 de_fault (to_download_tracepoint
,
842 (void (*) (struct bp_location
*))
844 de_fault (to_can_download_tracepoint
,
847 de_fault (to_download_trace_state_variable
,
848 (void (*) (struct trace_state_variable
*))
850 de_fault (to_enable_tracepoint
,
851 (void (*) (struct bp_location
*))
853 de_fault (to_disable_tracepoint
,
854 (void (*) (struct bp_location
*))
856 de_fault (to_trace_set_readonly_regions
,
859 de_fault (to_trace_start
,
862 de_fault (to_get_trace_status
,
863 (int (*) (struct trace_status
*))
865 de_fault (to_get_tracepoint_status
,
866 (void (*) (struct breakpoint
*, struct uploaded_tp
*))
868 de_fault (to_trace_stop
,
871 de_fault (to_trace_find
,
872 (int (*) (enum trace_find_type
, int, CORE_ADDR
, CORE_ADDR
, int *))
874 de_fault (to_get_trace_state_variable_value
,
875 (int (*) (int, LONGEST
*))
877 de_fault (to_save_trace_data
,
878 (int (*) (const char *))
880 de_fault (to_upload_tracepoints
,
881 (int (*) (struct uploaded_tp
**))
883 de_fault (to_upload_trace_state_variables
,
884 (int (*) (struct uploaded_tsv
**))
886 de_fault (to_get_raw_trace_data
,
887 (LONGEST (*) (gdb_byte
*, ULONGEST
, LONGEST
))
889 de_fault (to_get_min_fast_tracepoint_insn_len
,
892 de_fault (to_set_disconnected_tracing
,
895 de_fault (to_set_circular_trace_buffer
,
898 de_fault (to_set_trace_buffer_size
,
901 de_fault (to_set_trace_notes
,
902 (int (*) (const char *, const char *, const char *))
904 de_fault (to_get_tib_address
,
905 (int (*) (ptid_t
, CORE_ADDR
*))
907 de_fault (to_set_permissions
,
910 de_fault (to_static_tracepoint_marker_at
,
911 (int (*) (CORE_ADDR
, struct static_tracepoint_marker
*))
913 de_fault (to_static_tracepoint_markers_by_strid
,
914 (VEC(static_tracepoint_marker_p
) * (*) (const char *))
916 de_fault (to_traceframe_info
,
917 (struct traceframe_info
* (*) (void))
919 de_fault (to_supports_evaluation_of_breakpoint_conditions
,
922 de_fault (to_can_run_breakpoint_commands
,
925 de_fault (to_use_agent
,
928 de_fault (to_can_use_agent
,
931 de_fault (to_augmented_libraries_svr4_read
,
934 de_fault (to_execution_direction
, default_execution_direction
);
938 /* Finally, position the target-stack beneath the squashed
939 "current_target". That way code looking for a non-inherited
940 target method can quickly and simply find it. */
941 current_target
.beneath
= target_stack
;
944 setup_target_debug ();
947 /* Push a new target type into the stack of the existing target accessors,
948 possibly superseding some of the existing accessors.
950 Rather than allow an empty stack, we always have the dummy target at
951 the bottom stratum, so we can call the function vectors without
955 push_target (struct target_ops
*t
)
957 struct target_ops
**cur
;
959 /* Check magic number. If wrong, it probably means someone changed
960 the struct definition, but not all the places that initialize one. */
961 if (t
->to_magic
!= OPS_MAGIC
)
963 fprintf_unfiltered (gdb_stderr
,
964 "Magic number of %s target struct wrong\n",
966 internal_error (__FILE__
, __LINE__
,
967 _("failed internal consistency check"));
970 /* Find the proper stratum to install this target in. */
971 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
973 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
977 /* If there's already targets at this stratum, remove them. */
978 /* FIXME: cagney/2003-10-15: I think this should be popping all
979 targets to CUR, and not just those at this stratum level. */
980 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
982 /* There's already something at this stratum level. Close it,
983 and un-hook it from the stack. */
984 struct target_ops
*tmp
= (*cur
);
986 (*cur
) = (*cur
)->beneath
;
991 /* We have removed all targets in our stratum, now add the new one. */
995 update_current_target ();
998 /* Remove a target_ops vector from the stack, wherever it may be.
999 Return how many times it was removed (0 or 1). */
1002 unpush_target (struct target_ops
*t
)
1004 struct target_ops
**cur
;
1005 struct target_ops
*tmp
;
1007 if (t
->to_stratum
== dummy_stratum
)
1008 internal_error (__FILE__
, __LINE__
,
1009 _("Attempt to unpush the dummy target"));
1011 /* Look for the specified target. Note that we assume that a target
1012 can only occur once in the target stack. */
1014 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1020 /* If we don't find target_ops, quit. Only open targets should be
1025 /* Unchain the target. */
1027 (*cur
) = (*cur
)->beneath
;
1028 tmp
->beneath
= NULL
;
1030 update_current_target ();
1032 /* Finally close the target. Note we do this after unchaining, so
1033 any target method calls from within the target_close
1034 implementation don't end up in T anymore. */
1041 pop_all_targets_above (enum strata above_stratum
)
1043 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
1045 if (!unpush_target (target_stack
))
1047 fprintf_unfiltered (gdb_stderr
,
1048 "pop_all_targets couldn't find target %s\n",
1049 target_stack
->to_shortname
);
1050 internal_error (__FILE__
, __LINE__
,
1051 _("failed internal consistency check"));
1058 pop_all_targets (void)
1060 pop_all_targets_above (dummy_stratum
);
1063 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
1066 target_is_pushed (struct target_ops
*t
)
1068 struct target_ops
**cur
;
1070 /* Check magic number. If wrong, it probably means someone changed
1071 the struct definition, but not all the places that initialize one. */
1072 if (t
->to_magic
!= OPS_MAGIC
)
1074 fprintf_unfiltered (gdb_stderr
,
1075 "Magic number of %s target struct wrong\n",
1077 internal_error (__FILE__
, __LINE__
,
1078 _("failed internal consistency check"));
1081 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1088 /* Using the objfile specified in OBJFILE, find the address for the
1089 current thread's thread-local storage with offset OFFSET. */
1091 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
1093 volatile CORE_ADDR addr
= 0;
1094 struct target_ops
*target
;
1096 for (target
= current_target
.beneath
;
1098 target
= target
->beneath
)
1100 if (target
->to_get_thread_local_address
!= NULL
)
1105 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
1107 ptid_t ptid
= inferior_ptid
;
1108 volatile struct gdb_exception ex
;
1110 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1114 /* Fetch the load module address for this objfile. */
1115 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch (),
1117 /* If it's 0, throw the appropriate exception. */
1119 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
1120 _("TLS load module not found"));
1122 addr
= target
->to_get_thread_local_address (target
, ptid
,
1125 /* If an error occurred, print TLS related messages here. Otherwise,
1126 throw the error to some higher catcher. */
1129 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1133 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
1134 error (_("Cannot find thread-local variables "
1135 "in this thread library."));
1137 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
1138 if (objfile_is_library
)
1139 error (_("Cannot find shared library `%s' in dynamic"
1140 " linker's load module list"), objfile_name (objfile
));
1142 error (_("Cannot find executable file `%s' in dynamic"
1143 " linker's load module list"), objfile_name (objfile
));
1145 case TLS_NOT_ALLOCATED_YET_ERROR
:
1146 if (objfile_is_library
)
1147 error (_("The inferior has not yet allocated storage for"
1148 " thread-local variables in\n"
1149 "the shared library `%s'\n"
1151 objfile_name (objfile
), target_pid_to_str (ptid
));
1153 error (_("The inferior has not yet allocated storage for"
1154 " thread-local variables in\n"
1155 "the executable `%s'\n"
1157 objfile_name (objfile
), target_pid_to_str (ptid
));
1159 case TLS_GENERIC_ERROR
:
1160 if (objfile_is_library
)
1161 error (_("Cannot find thread-local storage for %s, "
1162 "shared library %s:\n%s"),
1163 target_pid_to_str (ptid
),
1164 objfile_name (objfile
), ex
.message
);
1166 error (_("Cannot find thread-local storage for %s, "
1167 "executable file %s:\n%s"),
1168 target_pid_to_str (ptid
),
1169 objfile_name (objfile
), ex
.message
);
1172 throw_exception (ex
);
1177 /* It wouldn't be wrong here to try a gdbarch method, too; finding
1178 TLS is an ABI-specific thing. But we don't do that yet. */
1180 error (_("Cannot find thread-local variables on this target"));
1186 target_xfer_status_to_string (enum target_xfer_status err
)
1188 #define CASE(X) case X: return #X
1191 CASE(TARGET_XFER_E_IO
);
1192 CASE(TARGET_XFER_E_UNAVAILABLE
);
1201 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1203 /* target_read_string -- read a null terminated string, up to LEN bytes,
1204 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1205 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1206 is responsible for freeing it. Return the number of bytes successfully
1210 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
1212 int tlen
, offset
, i
;
1216 int buffer_allocated
;
1218 unsigned int nbytes_read
= 0;
1220 gdb_assert (string
);
1222 /* Small for testing. */
1223 buffer_allocated
= 4;
1224 buffer
= xmalloc (buffer_allocated
);
1229 tlen
= MIN (len
, 4 - (memaddr
& 3));
1230 offset
= memaddr
& 3;
1232 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
1235 /* The transfer request might have crossed the boundary to an
1236 unallocated region of memory. Retry the transfer, requesting
1240 errcode
= target_read_memory (memaddr
, buf
, 1);
1245 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
1249 bytes
= bufptr
- buffer
;
1250 buffer_allocated
*= 2;
1251 buffer
= xrealloc (buffer
, buffer_allocated
);
1252 bufptr
= buffer
+ bytes
;
1255 for (i
= 0; i
< tlen
; i
++)
1257 *bufptr
++ = buf
[i
+ offset
];
1258 if (buf
[i
+ offset
] == '\000')
1260 nbytes_read
+= i
+ 1;
1267 nbytes_read
+= tlen
;
1276 struct target_section_table
*
1277 target_get_section_table (struct target_ops
*target
)
1279 struct target_ops
*t
;
1282 fprintf_unfiltered (gdb_stdlog
, "target_get_section_table ()\n");
1284 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1285 if (t
->to_get_section_table
!= NULL
)
1286 return (*t
->to_get_section_table
) (t
);
1291 /* Find a section containing ADDR. */
1293 struct target_section
*
1294 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1296 struct target_section_table
*table
= target_get_section_table (target
);
1297 struct target_section
*secp
;
1302 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
1304 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1310 /* Read memory from the live target, even if currently inspecting a
1311 traceframe. The return is the same as that of target_read. */
1313 static enum target_xfer_status
1314 target_read_live_memory (enum target_object object
,
1315 ULONGEST memaddr
, gdb_byte
*myaddr
, ULONGEST len
,
1316 ULONGEST
*xfered_len
)
1318 enum target_xfer_status ret
;
1319 struct cleanup
*cleanup
;
1321 /* Switch momentarily out of tfind mode so to access live memory.
1322 Note that this must not clear global state, such as the frame
1323 cache, which must still remain valid for the previous traceframe.
1324 We may be _building_ the frame cache at this point. */
1325 cleanup
= make_cleanup_restore_traceframe_number ();
1326 set_traceframe_number (-1);
1328 ret
= target_xfer_partial (current_target
.beneath
, object
, NULL
,
1329 myaddr
, NULL
, memaddr
, len
, xfered_len
);
1331 do_cleanups (cleanup
);
1335 /* Using the set of read-only target sections of OPS, read live
1336 read-only memory. Note that the actual reads start from the
1337 top-most target again.
1339 For interface/parameters/return description see target.h,
1342 static enum target_xfer_status
1343 memory_xfer_live_readonly_partial (struct target_ops
*ops
,
1344 enum target_object object
,
1345 gdb_byte
*readbuf
, ULONGEST memaddr
,
1346 ULONGEST len
, ULONGEST
*xfered_len
)
1348 struct target_section
*secp
;
1349 struct target_section_table
*table
;
1351 secp
= target_section_by_addr (ops
, memaddr
);
1353 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1354 secp
->the_bfd_section
)
1357 struct target_section
*p
;
1358 ULONGEST memend
= memaddr
+ len
;
1360 table
= target_get_section_table (ops
);
1362 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1364 if (memaddr
>= p
->addr
)
1366 if (memend
<= p
->endaddr
)
1368 /* Entire transfer is within this section. */
1369 return target_read_live_memory (object
, memaddr
,
1370 readbuf
, len
, xfered_len
);
1372 else if (memaddr
>= p
->endaddr
)
1374 /* This section ends before the transfer starts. */
1379 /* This section overlaps the transfer. Just do half. */
1380 len
= p
->endaddr
- memaddr
;
1381 return target_read_live_memory (object
, memaddr
,
1382 readbuf
, len
, xfered_len
);
1388 return TARGET_XFER_EOF
;
1391 /* Read memory from more than one valid target. A core file, for
1392 instance, could have some of memory but delegate other bits to
1393 the target below it. So, we must manually try all targets. */
1395 static enum target_xfer_status
1396 raw_memory_xfer_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
1397 const gdb_byte
*writebuf
, ULONGEST memaddr
, LONGEST len
,
1398 ULONGEST
*xfered_len
)
1400 enum target_xfer_status res
;
1404 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1405 readbuf
, writebuf
, memaddr
, len
,
1407 if (res
== TARGET_XFER_OK
)
1410 /* Stop if the target reports that the memory is not available. */
1411 if (res
== TARGET_XFER_E_UNAVAILABLE
)
1414 /* We want to continue past core files to executables, but not
1415 past a running target's memory. */
1416 if (ops
->to_has_all_memory (ops
))
1421 while (ops
!= NULL
);
1426 /* Perform a partial memory transfer.
1427 For docs see target.h, to_xfer_partial. */
1429 static enum target_xfer_status
1430 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
1431 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
1432 ULONGEST len
, ULONGEST
*xfered_len
)
1434 enum target_xfer_status res
;
1436 struct mem_region
*region
;
1437 struct inferior
*inf
;
1439 /* For accesses to unmapped overlay sections, read directly from
1440 files. Must do this first, as MEMADDR may need adjustment. */
1441 if (readbuf
!= NULL
&& overlay_debugging
)
1443 struct obj_section
*section
= find_pc_overlay (memaddr
);
1445 if (pc_in_unmapped_range (memaddr
, section
))
1447 struct target_section_table
*table
1448 = target_get_section_table (ops
);
1449 const char *section_name
= section
->the_bfd_section
->name
;
1451 memaddr
= overlay_mapped_address (memaddr
, section
);
1452 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1453 memaddr
, len
, xfered_len
,
1455 table
->sections_end
,
1460 /* Try the executable files, if "trust-readonly-sections" is set. */
1461 if (readbuf
!= NULL
&& trust_readonly
)
1463 struct target_section
*secp
;
1464 struct target_section_table
*table
;
1466 secp
= target_section_by_addr (ops
, memaddr
);
1468 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1469 secp
->the_bfd_section
)
1472 table
= target_get_section_table (ops
);
1473 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1474 memaddr
, len
, xfered_len
,
1476 table
->sections_end
,
1481 /* If reading unavailable memory in the context of traceframes, and
1482 this address falls within a read-only section, fallback to
1483 reading from live memory. */
1484 if (readbuf
!= NULL
&& get_traceframe_number () != -1)
1486 VEC(mem_range_s
) *available
;
1488 /* If we fail to get the set of available memory, then the
1489 target does not support querying traceframe info, and so we
1490 attempt reading from the traceframe anyway (assuming the
1491 target implements the old QTro packet then). */
1492 if (traceframe_available_memory (&available
, memaddr
, len
))
1494 struct cleanup
*old_chain
;
1496 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
1498 if (VEC_empty (mem_range_s
, available
)
1499 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
1501 /* Don't read into the traceframe's available
1503 if (!VEC_empty (mem_range_s
, available
))
1505 LONGEST oldlen
= len
;
1507 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
1508 gdb_assert (len
<= oldlen
);
1511 do_cleanups (old_chain
);
1513 /* This goes through the topmost target again. */
1514 res
= memory_xfer_live_readonly_partial (ops
, object
,
1517 if (res
== TARGET_XFER_OK
)
1518 return TARGET_XFER_OK
;
1521 /* No use trying further, we know some memory starting
1522 at MEMADDR isn't available. */
1524 return TARGET_XFER_E_UNAVAILABLE
;
1528 /* Don't try to read more than how much is available, in
1529 case the target implements the deprecated QTro packet to
1530 cater for older GDBs (the target's knowledge of read-only
1531 sections may be outdated by now). */
1532 len
= VEC_index (mem_range_s
, available
, 0)->length
;
1534 do_cleanups (old_chain
);
1538 /* Try GDB's internal data cache. */
1539 region
= lookup_mem_region (memaddr
);
1540 /* region->hi == 0 means there's no upper bound. */
1541 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1544 reg_len
= region
->hi
- memaddr
;
1546 switch (region
->attrib
.mode
)
1549 if (writebuf
!= NULL
)
1550 return TARGET_XFER_E_IO
;
1554 if (readbuf
!= NULL
)
1555 return TARGET_XFER_E_IO
;
1559 /* We only support writing to flash during "load" for now. */
1560 if (writebuf
!= NULL
)
1561 error (_("Writing to flash memory forbidden in this context"));
1565 return TARGET_XFER_E_IO
;
1568 if (!ptid_equal (inferior_ptid
, null_ptid
))
1569 inf
= find_inferior_pid (ptid_get_pid (inferior_ptid
));
1574 /* The dcache reads whole cache lines; that doesn't play well
1575 with reading from a trace buffer, because reading outside of
1576 the collected memory range fails. */
1577 && get_traceframe_number () == -1
1578 && (region
->attrib
.cache
1579 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1580 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1582 DCACHE
*dcache
= target_dcache_get_or_init ();
1585 if (readbuf
!= NULL
)
1586 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, readbuf
, reg_len
, 0);
1588 /* FIXME drow/2006-08-09: If we're going to preserve const
1589 correctness dcache_xfer_memory should take readbuf and
1591 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, (void *) writebuf
,
1594 return TARGET_XFER_E_IO
;
1597 *xfered_len
= (ULONGEST
) l
;
1598 return TARGET_XFER_OK
;
1602 /* If none of those methods found the memory we wanted, fall back
1603 to a target partial transfer. Normally a single call to
1604 to_xfer_partial is enough; if it doesn't recognize an object
1605 it will call the to_xfer_partial of the next target down.
1606 But for memory this won't do. Memory is the only target
1607 object which can be read from more than one valid target.
1608 A core file, for instance, could have some of memory but
1609 delegate other bits to the target below it. So, we must
1610 manually try all targets. */
1612 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
,
1615 /* Make sure the cache gets updated no matter what - if we are writing
1616 to the stack. Even if this write is not tagged as such, we still need
1617 to update the cache. */
1619 if (res
== TARGET_XFER_OK
1622 && target_dcache_init_p ()
1623 && !region
->attrib
.cache
1624 && ((stack_cache_enabled_p () && object
!= TARGET_OBJECT_STACK_MEMORY
)
1625 || (code_cache_enabled_p () && object
!= TARGET_OBJECT_CODE_MEMORY
)))
1627 DCACHE
*dcache
= target_dcache_get ();
1629 dcache_update (dcache
, memaddr
, (void *) writebuf
, reg_len
);
1632 /* If we still haven't got anything, return the last error. We
1637 /* Perform a partial memory transfer. For docs see target.h,
1640 static enum target_xfer_status
1641 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1642 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1643 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1645 enum target_xfer_status res
;
1647 /* Zero length requests are ok and require no work. */
1649 return TARGET_XFER_EOF
;
1651 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1652 breakpoint insns, thus hiding out from higher layers whether
1653 there are software breakpoints inserted in the code stream. */
1654 if (readbuf
!= NULL
)
1656 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
,
1659 if (res
== TARGET_XFER_OK
&& !show_memory_breakpoints
)
1660 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, res
);
1665 struct cleanup
*old_chain
;
1667 /* A large write request is likely to be partially satisfied
1668 by memory_xfer_partial_1. We will continually malloc
1669 and free a copy of the entire write request for breakpoint
1670 shadow handling even though we only end up writing a small
1671 subset of it. Cap writes to 4KB to mitigate this. */
1672 len
= min (4096, len
);
1674 buf
= xmalloc (len
);
1675 old_chain
= make_cleanup (xfree
, buf
);
1676 memcpy (buf
, writebuf
, len
);
1678 breakpoint_xfer_memory (NULL
, buf
, writebuf
, memaddr
, len
);
1679 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
, memaddr
, len
,
1682 do_cleanups (old_chain
);
1689 restore_show_memory_breakpoints (void *arg
)
1691 show_memory_breakpoints
= (uintptr_t) arg
;
1695 make_show_memory_breakpoints_cleanup (int show
)
1697 int current
= show_memory_breakpoints
;
1699 show_memory_breakpoints
= show
;
1700 return make_cleanup (restore_show_memory_breakpoints
,
1701 (void *) (uintptr_t) current
);
1704 /* For docs see target.h, to_xfer_partial. */
1706 enum target_xfer_status
1707 target_xfer_partial (struct target_ops
*ops
,
1708 enum target_object object
, const char *annex
,
1709 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1710 ULONGEST offset
, ULONGEST len
,
1711 ULONGEST
*xfered_len
)
1713 enum target_xfer_status retval
;
1715 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1717 /* Transfer is done when LEN is zero. */
1719 return TARGET_XFER_EOF
;
1721 if (writebuf
&& !may_write_memory
)
1722 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1723 core_addr_to_string_nz (offset
), plongest (len
));
1727 /* If this is a memory transfer, let the memory-specific code
1728 have a look at it instead. Memory transfers are more
1730 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1731 || object
== TARGET_OBJECT_CODE_MEMORY
)
1732 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1733 writebuf
, offset
, len
, xfered_len
);
1734 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1736 /* Request the normal memory object from other layers. */
1737 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
,
1741 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
,
1742 writebuf
, offset
, len
, xfered_len
);
1746 const unsigned char *myaddr
= NULL
;
1748 fprintf_unfiltered (gdb_stdlog
,
1749 "%s:target_xfer_partial "
1750 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1753 (annex
? annex
: "(null)"),
1754 host_address_to_string (readbuf
),
1755 host_address_to_string (writebuf
),
1756 core_addr_to_string_nz (offset
),
1757 pulongest (len
), retval
,
1758 pulongest (*xfered_len
));
1764 if (retval
== TARGET_XFER_OK
&& myaddr
!= NULL
)
1768 fputs_unfiltered (", bytes =", gdb_stdlog
);
1769 for (i
= 0; i
< *xfered_len
; i
++)
1771 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1773 if (targetdebug
< 2 && i
> 0)
1775 fprintf_unfiltered (gdb_stdlog
, " ...");
1778 fprintf_unfiltered (gdb_stdlog
, "\n");
1781 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1785 fputc_unfiltered ('\n', gdb_stdlog
);
1788 /* Check implementations of to_xfer_partial update *XFERED_LEN
1789 properly. Do assertion after printing debug messages, so that we
1790 can find more clues on assertion failure from debugging messages. */
1791 if (retval
== TARGET_XFER_OK
|| retval
== TARGET_XFER_E_UNAVAILABLE
)
1792 gdb_assert (*xfered_len
> 0);
1797 /* Read LEN bytes of target memory at address MEMADDR, placing the
1798 results in GDB's memory at MYADDR. Returns either 0 for success or
1799 TARGET_XFER_E_IO if any error occurs.
1801 If an error occurs, no guarantee is made about the contents of the data at
1802 MYADDR. In particular, the caller should not depend upon partial reads
1803 filling the buffer with good data. There is no way for the caller to know
1804 how much good data might have been transfered anyway. Callers that can
1805 deal with partial reads should call target_read (which will retry until
1806 it makes no progress, and then return how much was transferred). */
1809 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1811 /* Dispatch to the topmost target, not the flattened current_target.
1812 Memory accesses check target->to_has_(all_)memory, and the
1813 flattened target doesn't inherit those. */
1814 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1815 myaddr
, memaddr
, len
) == len
)
1818 return TARGET_XFER_E_IO
;
1821 /* Like target_read_memory, but specify explicitly that this is a read
1822 from the target's raw memory. That is, this read bypasses the
1823 dcache, breakpoint shadowing, etc. */
1826 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1828 /* See comment in target_read_memory about why the request starts at
1829 current_target.beneath. */
1830 if (target_read (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1831 myaddr
, memaddr
, len
) == len
)
1834 return TARGET_XFER_E_IO
;
1837 /* Like target_read_memory, but specify explicitly that this is a read from
1838 the target's stack. This may trigger different cache behavior. */
1841 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1843 /* See comment in target_read_memory about why the request starts at
1844 current_target.beneath. */
1845 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1846 myaddr
, memaddr
, len
) == len
)
1849 return TARGET_XFER_E_IO
;
1852 /* Like target_read_memory, but specify explicitly that this is a read from
1853 the target's code. This may trigger different cache behavior. */
1856 target_read_code (CORE_ADDR memaddr
, 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_read (current_target
.beneath
, TARGET_OBJECT_CODE_MEMORY
, NULL
,
1861 myaddr
, memaddr
, len
) == len
)
1864 return TARGET_XFER_E_IO
;
1867 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1868 Returns either 0 for success or TARGET_XFER_E_IO if any
1869 error occurs. If an error occurs, no guarantee is made about how
1870 much data got written. Callers that can deal with partial writes
1871 should call target_write. */
1874 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1876 /* See comment in target_read_memory about why the request starts at
1877 current_target.beneath. */
1878 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1879 myaddr
, memaddr
, len
) == len
)
1882 return TARGET_XFER_E_IO
;
1885 /* Write LEN bytes from MYADDR to target raw memory at address
1886 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1887 if any error occurs. If an error occurs, no guarantee is made
1888 about how much data got written. Callers that can deal with
1889 partial writes should call target_write. */
1892 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1894 /* See comment in target_read_memory about why the request starts at
1895 current_target.beneath. */
1896 if (target_write (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1897 myaddr
, memaddr
, len
) == len
)
1900 return TARGET_XFER_E_IO
;
1903 /* Fetch the target's memory map. */
1906 target_memory_map (void)
1908 VEC(mem_region_s
) *result
;
1909 struct mem_region
*last_one
, *this_one
;
1911 struct target_ops
*t
;
1914 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1916 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1917 if (t
->to_memory_map
!= NULL
)
1923 result
= t
->to_memory_map (t
);
1927 qsort (VEC_address (mem_region_s
, result
),
1928 VEC_length (mem_region_s
, result
),
1929 sizeof (struct mem_region
), mem_region_cmp
);
1931 /* Check that regions do not overlap. Simultaneously assign
1932 a numbering for the "mem" commands to use to refer to
1935 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1937 this_one
->number
= ix
;
1939 if (last_one
&& last_one
->hi
> this_one
->lo
)
1941 warning (_("Overlapping regions in memory map: ignoring"));
1942 VEC_free (mem_region_s
, result
);
1945 last_one
= this_one
;
1952 target_flash_erase (ULONGEST address
, LONGEST length
)
1954 struct target_ops
*t
;
1956 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1957 if (t
->to_flash_erase
!= NULL
)
1960 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1961 hex_string (address
), phex (length
, 0));
1962 t
->to_flash_erase (t
, address
, length
);
1970 target_flash_done (void)
1972 struct target_ops
*t
;
1974 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1975 if (t
->to_flash_done
!= NULL
)
1978 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1979 t
->to_flash_done (t
);
1987 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1988 struct cmd_list_element
*c
, const char *value
)
1990 fprintf_filtered (file
,
1991 _("Mode for reading from readonly sections is %s.\n"),
1995 /* More generic transfers. */
1997 static enum target_xfer_status
1998 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1999 const char *annex
, gdb_byte
*readbuf
,
2000 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2001 ULONGEST
*xfered_len
)
2003 if (object
== TARGET_OBJECT_MEMORY
2004 && ops
->deprecated_xfer_memory
!= NULL
)
2005 /* If available, fall back to the target's
2006 "deprecated_xfer_memory" method. */
2011 if (writebuf
!= NULL
)
2013 void *buffer
= xmalloc (len
);
2014 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
2016 memcpy (buffer
, writebuf
, len
);
2017 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
2018 1/*write*/, NULL
, ops
);
2019 do_cleanups (cleanup
);
2021 if (readbuf
!= NULL
)
2022 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
2023 0/*read*/, NULL
, ops
);
2026 *xfered_len
= (ULONGEST
) xfered
;
2027 return TARGET_XFER_E_IO
;
2029 else if (xfered
== 0 && errno
== 0)
2030 /* "deprecated_xfer_memory" uses 0, cross checked against
2031 ERRNO as one indication of an error. */
2032 return TARGET_XFER_EOF
;
2034 return TARGET_XFER_E_IO
;
2038 gdb_assert (ops
->beneath
!= NULL
);
2039 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2040 readbuf
, writebuf
, offset
, len
,
2045 /* Target vector read/write partial wrapper functions. */
2047 static enum target_xfer_status
2048 target_read_partial (struct target_ops
*ops
,
2049 enum target_object object
,
2050 const char *annex
, gdb_byte
*buf
,
2051 ULONGEST offset
, ULONGEST len
,
2052 ULONGEST
*xfered_len
)
2054 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
,
2058 static enum target_xfer_status
2059 target_write_partial (struct target_ops
*ops
,
2060 enum target_object object
,
2061 const char *annex
, const gdb_byte
*buf
,
2062 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
2064 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
,
2068 /* Wrappers to perform the full transfer. */
2070 /* For docs on target_read see target.h. */
2073 target_read (struct target_ops
*ops
,
2074 enum target_object object
,
2075 const char *annex
, gdb_byte
*buf
,
2076 ULONGEST offset
, LONGEST len
)
2080 while (xfered
< len
)
2082 ULONGEST xfered_len
;
2083 enum target_xfer_status status
;
2085 status
= target_read_partial (ops
, object
, annex
,
2086 (gdb_byte
*) buf
+ xfered
,
2087 offset
+ xfered
, len
- xfered
,
2090 /* Call an observer, notifying them of the xfer progress? */
2091 if (status
== TARGET_XFER_EOF
)
2093 else if (status
== TARGET_XFER_OK
)
2095 xfered
+= xfered_len
;
2105 /* Assuming that the entire [begin, end) range of memory cannot be
2106 read, try to read whatever subrange is possible to read.
2108 The function returns, in RESULT, either zero or one memory block.
2109 If there's a readable subrange at the beginning, it is completely
2110 read and returned. Any further readable subrange will not be read.
2111 Otherwise, if there's a readable subrange at the end, it will be
2112 completely read and returned. Any readable subranges before it
2113 (obviously, not starting at the beginning), will be ignored. In
2114 other cases -- either no readable subrange, or readable subrange(s)
2115 that is neither at the beginning, or end, nothing is returned.
2117 The purpose of this function is to handle a read across a boundary
2118 of accessible memory in a case when memory map is not available.
2119 The above restrictions are fine for this case, but will give
2120 incorrect results if the memory is 'patchy'. However, supporting
2121 'patchy' memory would require trying to read every single byte,
2122 and it seems unacceptable solution. Explicit memory map is
2123 recommended for this case -- and target_read_memory_robust will
2124 take care of reading multiple ranges then. */
2127 read_whatever_is_readable (struct target_ops
*ops
,
2128 ULONGEST begin
, ULONGEST end
,
2129 VEC(memory_read_result_s
) **result
)
2131 gdb_byte
*buf
= xmalloc (end
- begin
);
2132 ULONGEST current_begin
= begin
;
2133 ULONGEST current_end
= end
;
2135 memory_read_result_s r
;
2136 ULONGEST xfered_len
;
2138 /* If we previously failed to read 1 byte, nothing can be done here. */
2139 if (end
- begin
<= 1)
2145 /* Check that either first or the last byte is readable, and give up
2146 if not. This heuristic is meant to permit reading accessible memory
2147 at the boundary of accessible region. */
2148 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2149 buf
, begin
, 1, &xfered_len
) == TARGET_XFER_OK
)
2154 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2155 buf
+ (end
-begin
) - 1, end
- 1, 1,
2156 &xfered_len
) == TARGET_XFER_OK
)
2167 /* Loop invariant is that the [current_begin, current_end) was previously
2168 found to be not readable as a whole.
2170 Note loop condition -- if the range has 1 byte, we can't divide the range
2171 so there's no point trying further. */
2172 while (current_end
- current_begin
> 1)
2174 ULONGEST first_half_begin
, first_half_end
;
2175 ULONGEST second_half_begin
, second_half_end
;
2177 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
2181 first_half_begin
= current_begin
;
2182 first_half_end
= middle
;
2183 second_half_begin
= middle
;
2184 second_half_end
= current_end
;
2188 first_half_begin
= middle
;
2189 first_half_end
= current_end
;
2190 second_half_begin
= current_begin
;
2191 second_half_end
= middle
;
2194 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2195 buf
+ (first_half_begin
- begin
),
2197 first_half_end
- first_half_begin
);
2199 if (xfer
== first_half_end
- first_half_begin
)
2201 /* This half reads up fine. So, the error must be in the
2203 current_begin
= second_half_begin
;
2204 current_end
= second_half_end
;
2208 /* This half is not readable. Because we've tried one byte, we
2209 know some part of this half if actually redable. Go to the next
2210 iteration to divide again and try to read.
2212 We don't handle the other half, because this function only tries
2213 to read a single readable subrange. */
2214 current_begin
= first_half_begin
;
2215 current_end
= first_half_end
;
2221 /* The [begin, current_begin) range has been read. */
2223 r
.end
= current_begin
;
2228 /* The [current_end, end) range has been read. */
2229 LONGEST rlen
= end
- current_end
;
2231 r
.data
= xmalloc (rlen
);
2232 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
2233 r
.begin
= current_end
;
2237 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
2241 free_memory_read_result_vector (void *x
)
2243 VEC(memory_read_result_s
) *v
= x
;
2244 memory_read_result_s
*current
;
2247 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
2249 xfree (current
->data
);
2251 VEC_free (memory_read_result_s
, v
);
2254 VEC(memory_read_result_s
) *
2255 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
2257 VEC(memory_read_result_s
) *result
= 0;
2260 while (xfered
< len
)
2262 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
2265 /* If there is no explicit region, a fake one should be created. */
2266 gdb_assert (region
);
2268 if (region
->hi
== 0)
2269 rlen
= len
- xfered
;
2271 rlen
= region
->hi
- offset
;
2273 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
2275 /* Cannot read this region. Note that we can end up here only
2276 if the region is explicitly marked inaccessible, or
2277 'inaccessible-by-default' is in effect. */
2282 LONGEST to_read
= min (len
- xfered
, rlen
);
2283 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
2285 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2286 (gdb_byte
*) buffer
,
2287 offset
+ xfered
, to_read
);
2288 /* Call an observer, notifying them of the xfer progress? */
2291 /* Got an error reading full chunk. See if maybe we can read
2294 read_whatever_is_readable (ops
, offset
+ xfered
,
2295 offset
+ xfered
+ to_read
, &result
);
2300 struct memory_read_result r
;
2302 r
.begin
= offset
+ xfered
;
2303 r
.end
= r
.begin
+ xfer
;
2304 VEC_safe_push (memory_read_result_s
, result
, &r
);
2314 /* An alternative to target_write with progress callbacks. */
2317 target_write_with_progress (struct target_ops
*ops
,
2318 enum target_object object
,
2319 const char *annex
, const gdb_byte
*buf
,
2320 ULONGEST offset
, LONGEST len
,
2321 void (*progress
) (ULONGEST
, void *), void *baton
)
2325 /* Give the progress callback a chance to set up. */
2327 (*progress
) (0, baton
);
2329 while (xfered
< len
)
2331 ULONGEST xfered_len
;
2332 enum target_xfer_status status
;
2334 status
= target_write_partial (ops
, object
, annex
,
2335 (gdb_byte
*) buf
+ xfered
,
2336 offset
+ xfered
, len
- xfered
,
2339 if (status
== TARGET_XFER_EOF
)
2341 if (TARGET_XFER_STATUS_ERROR_P (status
))
2344 gdb_assert (status
== TARGET_XFER_OK
);
2346 (*progress
) (xfered_len
, baton
);
2348 xfered
+= xfered_len
;
2354 /* For docs on target_write see target.h. */
2357 target_write (struct target_ops
*ops
,
2358 enum target_object object
,
2359 const char *annex
, const gdb_byte
*buf
,
2360 ULONGEST offset
, LONGEST len
)
2362 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2366 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2367 the size of the transferred data. PADDING additional bytes are
2368 available in *BUF_P. This is a helper function for
2369 target_read_alloc; see the declaration of that function for more
2373 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2374 const char *annex
, gdb_byte
**buf_p
, int padding
)
2376 size_t buf_alloc
, buf_pos
;
2379 /* This function does not have a length parameter; it reads the
2380 entire OBJECT). Also, it doesn't support objects fetched partly
2381 from one target and partly from another (in a different stratum,
2382 e.g. a core file and an executable). Both reasons make it
2383 unsuitable for reading memory. */
2384 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2386 /* Start by reading up to 4K at a time. The target will throttle
2387 this number down if necessary. */
2389 buf
= xmalloc (buf_alloc
);
2393 ULONGEST xfered_len
;
2394 enum target_xfer_status status
;
2396 status
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2397 buf_pos
, buf_alloc
- buf_pos
- padding
,
2400 if (status
== TARGET_XFER_EOF
)
2402 /* Read all there was. */
2409 else if (status
!= TARGET_XFER_OK
)
2411 /* An error occurred. */
2413 return TARGET_XFER_E_IO
;
2416 buf_pos
+= xfered_len
;
2418 /* If the buffer is filling up, expand it. */
2419 if (buf_alloc
< buf_pos
* 2)
2422 buf
= xrealloc (buf
, buf_alloc
);
2429 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2430 the size of the transferred data. See the declaration in "target.h"
2431 function for more information about the return value. */
2434 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2435 const char *annex
, gdb_byte
**buf_p
)
2437 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2440 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2441 returned as a string, allocated using xmalloc. If an error occurs
2442 or the transfer is unsupported, NULL is returned. Empty objects
2443 are returned as allocated but empty strings. A warning is issued
2444 if the result contains any embedded NUL bytes. */
2447 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2452 LONGEST i
, transferred
;
2454 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2455 bufstr
= (char *) buffer
;
2457 if (transferred
< 0)
2460 if (transferred
== 0)
2461 return xstrdup ("");
2463 bufstr
[transferred
] = 0;
2465 /* Check for embedded NUL bytes; but allow trailing NULs. */
2466 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2469 warning (_("target object %d, annex %s, "
2470 "contained unexpected null characters"),
2471 (int) object
, annex
? annex
: "(none)");
2478 /* Memory transfer methods. */
2481 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2484 /* This method is used to read from an alternate, non-current
2485 target. This read must bypass the overlay support (as symbols
2486 don't match this target), and GDB's internal cache (wrong cache
2487 for this target). */
2488 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2490 memory_error (TARGET_XFER_E_IO
, addr
);
2494 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2495 int len
, enum bfd_endian byte_order
)
2497 gdb_byte buf
[sizeof (ULONGEST
)];
2499 gdb_assert (len
<= sizeof (buf
));
2500 get_target_memory (ops
, addr
, buf
, len
);
2501 return extract_unsigned_integer (buf
, len
, byte_order
);
2507 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2508 struct bp_target_info
*bp_tgt
)
2510 if (!may_insert_breakpoints
)
2512 warning (_("May not insert breakpoints"));
2516 return current_target
.to_insert_breakpoint (¤t_target
,
2523 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2524 struct bp_target_info
*bp_tgt
)
2526 /* This is kind of a weird case to handle, but the permission might
2527 have been changed after breakpoints were inserted - in which case
2528 we should just take the user literally and assume that any
2529 breakpoints should be left in place. */
2530 if (!may_insert_breakpoints
)
2532 warning (_("May not remove breakpoints"));
2536 return current_target
.to_remove_breakpoint (¤t_target
,
2541 target_info (char *args
, int from_tty
)
2543 struct target_ops
*t
;
2544 int has_all_mem
= 0;
2546 if (symfile_objfile
!= NULL
)
2547 printf_unfiltered (_("Symbols from \"%s\".\n"),
2548 objfile_name (symfile_objfile
));
2550 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2552 if (!(*t
->to_has_memory
) (t
))
2555 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2558 printf_unfiltered (_("\tWhile running this, "
2559 "GDB does not access memory from...\n"));
2560 printf_unfiltered ("%s:\n", t
->to_longname
);
2561 (t
->to_files_info
) (t
);
2562 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2566 /* This function is called before any new inferior is created, e.g.
2567 by running a program, attaching, or connecting to a target.
2568 It cleans up any state from previous invocations which might
2569 change between runs. This is a subset of what target_preopen
2570 resets (things which might change between targets). */
2573 target_pre_inferior (int from_tty
)
2575 /* Clear out solib state. Otherwise the solib state of the previous
2576 inferior might have survived and is entirely wrong for the new
2577 target. This has been observed on GNU/Linux using glibc 2.3. How
2589 Cannot access memory at address 0xdeadbeef
2592 /* In some OSs, the shared library list is the same/global/shared
2593 across inferiors. If code is shared between processes, so are
2594 memory regions and features. */
2595 if (!gdbarch_has_global_solist (target_gdbarch ()))
2597 no_shared_libraries (NULL
, from_tty
);
2599 invalidate_target_mem_regions ();
2601 target_clear_description ();
2604 agent_capability_invalidate ();
2607 /* Callback for iterate_over_inferiors. Gets rid of the given
2611 dispose_inferior (struct inferior
*inf
, void *args
)
2613 struct thread_info
*thread
;
2615 thread
= any_thread_of_process (inf
->pid
);
2618 switch_to_thread (thread
->ptid
);
2620 /* Core inferiors actually should be detached, not killed. */
2621 if (target_has_execution
)
2624 target_detach (NULL
, 0);
2630 /* This is to be called by the open routine before it does
2634 target_preopen (int from_tty
)
2638 if (have_inferiors ())
2641 || !have_live_inferiors ()
2642 || query (_("A program is being debugged already. Kill it? ")))
2643 iterate_over_inferiors (dispose_inferior
, NULL
);
2645 error (_("Program not killed."));
2648 /* Calling target_kill may remove the target from the stack. But if
2649 it doesn't (which seems like a win for UDI), remove it now. */
2650 /* Leave the exec target, though. The user may be switching from a
2651 live process to a core of the same program. */
2652 pop_all_targets_above (file_stratum
);
2654 target_pre_inferior (from_tty
);
2657 /* Detach a target after doing deferred register stores. */
2660 target_detach (const char *args
, int from_tty
)
2662 struct target_ops
* t
;
2664 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2665 /* Don't remove global breakpoints here. They're removed on
2666 disconnection from the target. */
2669 /* If we're in breakpoints-always-inserted mode, have to remove
2670 them before detaching. */
2671 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2673 prepare_for_detach ();
2675 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2677 if (t
->to_detach
!= NULL
)
2679 t
->to_detach (t
, args
, from_tty
);
2681 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2687 internal_error (__FILE__
, __LINE__
, _("could not find a target to detach"));
2691 target_disconnect (char *args
, int from_tty
)
2693 struct target_ops
*t
;
2695 /* If we're in breakpoints-always-inserted mode or if breakpoints
2696 are global across processes, we have to remove them before
2698 remove_breakpoints ();
2700 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2701 if (t
->to_disconnect
!= NULL
)
2704 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2706 t
->to_disconnect (t
, args
, from_tty
);
2714 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2716 struct target_ops
*t
;
2717 ptid_t retval
= (current_target
.to_wait
) (¤t_target
, ptid
,
2722 char *status_string
;
2723 char *options_string
;
2725 status_string
= target_waitstatus_to_string (status
);
2726 options_string
= target_options_to_string (options
);
2727 fprintf_unfiltered (gdb_stdlog
,
2728 "target_wait (%d, status, options={%s})"
2730 ptid_get_pid (ptid
), options_string
,
2731 ptid_get_pid (retval
), status_string
);
2732 xfree (status_string
);
2733 xfree (options_string
);
2740 target_pid_to_str (ptid_t ptid
)
2742 struct target_ops
*t
;
2744 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2746 if (t
->to_pid_to_str
!= NULL
)
2747 return (*t
->to_pid_to_str
) (t
, ptid
);
2750 return normal_pid_to_str (ptid
);
2754 target_thread_name (struct thread_info
*info
)
2756 struct target_ops
*t
;
2758 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2760 if (t
->to_thread_name
!= NULL
)
2761 return (*t
->to_thread_name
) (info
);
2768 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2770 struct target_ops
*t
;
2772 target_dcache_invalidate ();
2774 current_target
.to_resume (¤t_target
, ptid
, step
, signal
);
2776 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2777 ptid_get_pid (ptid
),
2778 step
? "step" : "continue",
2779 gdb_signal_to_name (signal
));
2781 registers_changed_ptid (ptid
);
2782 set_executing (ptid
, 1);
2783 set_running (ptid
, 1);
2784 clear_inline_frame_state (ptid
);
2788 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2790 struct target_ops
*t
;
2792 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2794 if (t
->to_pass_signals
!= NULL
)
2800 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2803 for (i
= 0; i
< numsigs
; i
++)
2804 if (pass_signals
[i
])
2805 fprintf_unfiltered (gdb_stdlog
, " %s",
2806 gdb_signal_to_name (i
));
2808 fprintf_unfiltered (gdb_stdlog
, " })\n");
2811 (*t
->to_pass_signals
) (numsigs
, pass_signals
);
2818 target_program_signals (int numsigs
, unsigned char *program_signals
)
2820 struct target_ops
*t
;
2822 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2824 if (t
->to_program_signals
!= NULL
)
2830 fprintf_unfiltered (gdb_stdlog
, "target_program_signals (%d, {",
2833 for (i
= 0; i
< numsigs
; i
++)
2834 if (program_signals
[i
])
2835 fprintf_unfiltered (gdb_stdlog
, " %s",
2836 gdb_signal_to_name (i
));
2838 fprintf_unfiltered (gdb_stdlog
, " })\n");
2841 (*t
->to_program_signals
) (numsigs
, program_signals
);
2847 /* Look through the list of possible targets for a target that can
2851 target_follow_fork (int follow_child
, int detach_fork
)
2853 struct target_ops
*t
;
2855 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2857 if (t
->to_follow_fork
!= NULL
)
2859 int retval
= t
->to_follow_fork (t
, follow_child
, detach_fork
);
2862 fprintf_unfiltered (gdb_stdlog
,
2863 "target_follow_fork (%d, %d) = %d\n",
2864 follow_child
, detach_fork
, retval
);
2869 /* Some target returned a fork event, but did not know how to follow it. */
2870 internal_error (__FILE__
, __LINE__
,
2871 _("could not find a target to follow fork"));
2875 target_mourn_inferior (void)
2877 struct target_ops
*t
;
2879 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2881 if (t
->to_mourn_inferior
!= NULL
)
2883 t
->to_mourn_inferior (t
);
2885 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2887 /* We no longer need to keep handles on any of the object files.
2888 Make sure to release them to avoid unnecessarily locking any
2889 of them while we're not actually debugging. */
2890 bfd_cache_close_all ();
2896 internal_error (__FILE__
, __LINE__
,
2897 _("could not find a target to follow mourn inferior"));
2900 /* Look for a target which can describe architectural features, starting
2901 from TARGET. If we find one, return its description. */
2903 const struct target_desc
*
2904 target_read_description (struct target_ops
*target
)
2906 struct target_ops
*t
;
2908 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
2909 if (t
->to_read_description
!= NULL
)
2911 const struct target_desc
*tdesc
;
2913 tdesc
= t
->to_read_description (t
);
2921 /* The default implementation of to_search_memory.
2922 This implements a basic search of memory, reading target memory and
2923 performing the search here (as opposed to performing the search in on the
2924 target side with, for example, gdbserver). */
2927 simple_search_memory (struct target_ops
*ops
,
2928 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2929 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2930 CORE_ADDR
*found_addrp
)
2932 /* NOTE: also defined in find.c testcase. */
2933 #define SEARCH_CHUNK_SIZE 16000
2934 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2935 /* Buffer to hold memory contents for searching. */
2936 gdb_byte
*search_buf
;
2937 unsigned search_buf_size
;
2938 struct cleanup
*old_cleanups
;
2940 search_buf_size
= chunk_size
+ pattern_len
- 1;
2942 /* No point in trying to allocate a buffer larger than the search space. */
2943 if (search_space_len
< search_buf_size
)
2944 search_buf_size
= search_space_len
;
2946 search_buf
= malloc (search_buf_size
);
2947 if (search_buf
== NULL
)
2948 error (_("Unable to allocate memory to perform the search."));
2949 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2951 /* Prime the search buffer. */
2953 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2954 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2956 warning (_("Unable to access %s bytes of target "
2957 "memory at %s, halting search."),
2958 pulongest (search_buf_size
), hex_string (start_addr
));
2959 do_cleanups (old_cleanups
);
2963 /* Perform the search.
2965 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2966 When we've scanned N bytes we copy the trailing bytes to the start and
2967 read in another N bytes. */
2969 while (search_space_len
>= pattern_len
)
2971 gdb_byte
*found_ptr
;
2972 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2974 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2975 pattern
, pattern_len
);
2977 if (found_ptr
!= NULL
)
2979 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2981 *found_addrp
= found_addr
;
2982 do_cleanups (old_cleanups
);
2986 /* Not found in this chunk, skip to next chunk. */
2988 /* Don't let search_space_len wrap here, it's unsigned. */
2989 if (search_space_len
>= chunk_size
)
2990 search_space_len
-= chunk_size
;
2992 search_space_len
= 0;
2994 if (search_space_len
>= pattern_len
)
2996 unsigned keep_len
= search_buf_size
- chunk_size
;
2997 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
3000 /* Copy the trailing part of the previous iteration to the front
3001 of the buffer for the next iteration. */
3002 gdb_assert (keep_len
== pattern_len
- 1);
3003 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
3005 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
3007 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
3008 search_buf
+ keep_len
, read_addr
,
3009 nr_to_read
) != nr_to_read
)
3011 warning (_("Unable to access %s bytes of target "
3012 "memory at %s, halting search."),
3013 plongest (nr_to_read
),
3014 hex_string (read_addr
));
3015 do_cleanups (old_cleanups
);
3019 start_addr
+= chunk_size
;
3025 do_cleanups (old_cleanups
);
3029 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
3030 sequence of bytes in PATTERN with length PATTERN_LEN.
3032 The result is 1 if found, 0 if not found, and -1 if there was an error
3033 requiring halting of the search (e.g. memory read error).
3034 If the pattern is found the address is recorded in FOUND_ADDRP. */
3037 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
3038 const gdb_byte
*pattern
, ULONGEST pattern_len
,
3039 CORE_ADDR
*found_addrp
)
3041 struct target_ops
*t
;
3044 /* We don't use INHERIT to set current_target.to_search_memory,
3045 so we have to scan the target stack and handle targetdebug
3049 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
3050 hex_string (start_addr
));
3052 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3053 if (t
->to_search_memory
!= NULL
)
3058 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
3059 pattern
, pattern_len
, found_addrp
);
3063 /* If a special version of to_search_memory isn't available, use the
3065 found
= simple_search_memory (current_target
.beneath
,
3066 start_addr
, search_space_len
,
3067 pattern
, pattern_len
, found_addrp
);
3071 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
3076 /* Look through the currently pushed targets. If none of them will
3077 be able to restart the currently running process, issue an error
3081 target_require_runnable (void)
3083 struct target_ops
*t
;
3085 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3087 /* If this target knows how to create a new program, then
3088 assume we will still be able to after killing the current
3089 one. Either killing and mourning will not pop T, or else
3090 find_default_run_target will find it again. */
3091 if (t
->to_create_inferior
!= NULL
)
3094 /* Do not worry about thread_stratum targets that can not
3095 create inferiors. Assume they will be pushed again if
3096 necessary, and continue to the process_stratum. */
3097 if (t
->to_stratum
== thread_stratum
3098 || t
->to_stratum
== arch_stratum
)
3101 error (_("The \"%s\" target does not support \"run\". "
3102 "Try \"help target\" or \"continue\"."),
3106 /* This function is only called if the target is running. In that
3107 case there should have been a process_stratum target and it
3108 should either know how to create inferiors, or not... */
3109 internal_error (__FILE__
, __LINE__
, _("No targets found"));
3112 /* Look through the list of possible targets for a target that can
3113 execute a run or attach command without any other data. This is
3114 used to locate the default process stratum.
3116 If DO_MESG is not NULL, the result is always valid (error() is
3117 called for errors); else, return NULL on error. */
3119 static struct target_ops
*
3120 find_default_run_target (char *do_mesg
)
3122 struct target_ops
**t
;
3123 struct target_ops
*runable
= NULL
;
3128 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
3131 if ((*t
)->to_can_run
&& target_can_run (*t
))
3141 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
3150 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3152 struct target_ops
*t
;
3154 t
= find_default_run_target ("attach");
3155 (t
->to_attach
) (t
, args
, from_tty
);
3160 find_default_create_inferior (struct target_ops
*ops
,
3161 char *exec_file
, char *allargs
, char **env
,
3164 struct target_ops
*t
;
3166 t
= find_default_run_target ("run");
3167 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
3172 find_default_can_async_p (struct target_ops
*ignore
)
3174 struct target_ops
*t
;
3176 /* This may be called before the target is pushed on the stack;
3177 look for the default process stratum. If there's none, gdb isn't
3178 configured with a native debugger, and target remote isn't
3180 t
= find_default_run_target (NULL
);
3181 if (t
&& t
->to_can_async_p
!= delegate_can_async_p
)
3182 return (t
->to_can_async_p
) (t
);
3187 find_default_is_async_p (struct target_ops
*ignore
)
3189 struct target_ops
*t
;
3191 /* This may be called before the target is pushed on the stack;
3192 look for the default process stratum. If there's none, gdb isn't
3193 configured with a native debugger, and target remote isn't
3195 t
= find_default_run_target (NULL
);
3196 if (t
&& t
->to_is_async_p
!= delegate_is_async_p
)
3197 return (t
->to_is_async_p
) (t
);
3202 find_default_supports_non_stop (void)
3204 struct target_ops
*t
;
3206 t
= find_default_run_target (NULL
);
3207 if (t
&& t
->to_supports_non_stop
)
3208 return (t
->to_supports_non_stop
) ();
3213 target_supports_non_stop (void)
3215 struct target_ops
*t
;
3217 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3218 if (t
->to_supports_non_stop
)
3219 return t
->to_supports_non_stop ();
3224 /* Implement the "info proc" command. */
3227 target_info_proc (char *args
, enum info_proc_what what
)
3229 struct target_ops
*t
;
3231 /* If we're already connected to something that can get us OS
3232 related data, use it. Otherwise, try using the native
3234 if (current_target
.to_stratum
>= process_stratum
)
3235 t
= current_target
.beneath
;
3237 t
= find_default_run_target (NULL
);
3239 for (; t
!= NULL
; t
= t
->beneath
)
3241 if (t
->to_info_proc
!= NULL
)
3243 t
->to_info_proc (t
, args
, what
);
3246 fprintf_unfiltered (gdb_stdlog
,
3247 "target_info_proc (\"%s\", %d)\n", args
, what
);
3257 find_default_supports_disable_randomization (void)
3259 struct target_ops
*t
;
3261 t
= find_default_run_target (NULL
);
3262 if (t
&& t
->to_supports_disable_randomization
)
3263 return (t
->to_supports_disable_randomization
) ();
3268 target_supports_disable_randomization (void)
3270 struct target_ops
*t
;
3272 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3273 if (t
->to_supports_disable_randomization
)
3274 return t
->to_supports_disable_randomization ();
3280 target_get_osdata (const char *type
)
3282 struct target_ops
*t
;
3284 /* If we're already connected to something that can get us OS
3285 related data, use it. Otherwise, try using the native
3287 if (current_target
.to_stratum
>= process_stratum
)
3288 t
= current_target
.beneath
;
3290 t
= find_default_run_target ("get OS data");
3295 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
3298 /* Determine the current address space of thread PTID. */
3300 struct address_space
*
3301 target_thread_address_space (ptid_t ptid
)
3303 struct address_space
*aspace
;
3304 struct inferior
*inf
;
3305 struct target_ops
*t
;
3307 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3309 if (t
->to_thread_address_space
!= NULL
)
3311 aspace
= t
->to_thread_address_space (t
, ptid
);
3312 gdb_assert (aspace
);
3315 fprintf_unfiltered (gdb_stdlog
,
3316 "target_thread_address_space (%s) = %d\n",
3317 target_pid_to_str (ptid
),
3318 address_space_num (aspace
));
3323 /* Fall-back to the "main" address space of the inferior. */
3324 inf
= find_inferior_pid (ptid_get_pid (ptid
));
3326 if (inf
== NULL
|| inf
->aspace
== NULL
)
3327 internal_error (__FILE__
, __LINE__
,
3328 _("Can't determine the current "
3329 "address space of thread %s\n"),
3330 target_pid_to_str (ptid
));
3336 /* Target file operations. */
3338 static struct target_ops
*
3339 default_fileio_target (void)
3341 /* If we're already connected to something that can perform
3342 file I/O, use it. Otherwise, try using the native target. */
3343 if (current_target
.to_stratum
>= process_stratum
)
3344 return current_target
.beneath
;
3346 return find_default_run_target ("file I/O");
3349 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3350 target file descriptor, or -1 if an error occurs (and set
3353 target_fileio_open (const char *filename
, int flags
, int mode
,
3356 struct target_ops
*t
;
3358 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3360 if (t
->to_fileio_open
!= NULL
)
3362 int fd
= t
->to_fileio_open (filename
, flags
, mode
, target_errno
);
3365 fprintf_unfiltered (gdb_stdlog
,
3366 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3367 filename
, flags
, mode
,
3368 fd
, fd
!= -1 ? 0 : *target_errno
);
3373 *target_errno
= FILEIO_ENOSYS
;
3377 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3378 Return the number of bytes written, or -1 if an error occurs
3379 (and set *TARGET_ERRNO). */
3381 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
3382 ULONGEST offset
, int *target_errno
)
3384 struct target_ops
*t
;
3386 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3388 if (t
->to_fileio_pwrite
!= NULL
)
3390 int ret
= t
->to_fileio_pwrite (fd
, write_buf
, len
, offset
,
3394 fprintf_unfiltered (gdb_stdlog
,
3395 "target_fileio_pwrite (%d,...,%d,%s) "
3397 fd
, len
, pulongest (offset
),
3398 ret
, ret
!= -1 ? 0 : *target_errno
);
3403 *target_errno
= FILEIO_ENOSYS
;
3407 /* Read up to LEN bytes FD on the target into READ_BUF.
3408 Return the number of bytes read, or -1 if an error occurs
3409 (and set *TARGET_ERRNO). */
3411 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
3412 ULONGEST offset
, int *target_errno
)
3414 struct target_ops
*t
;
3416 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3418 if (t
->to_fileio_pread
!= NULL
)
3420 int ret
= t
->to_fileio_pread (fd
, read_buf
, len
, offset
,
3424 fprintf_unfiltered (gdb_stdlog
,
3425 "target_fileio_pread (%d,...,%d,%s) "
3427 fd
, len
, pulongest (offset
),
3428 ret
, ret
!= -1 ? 0 : *target_errno
);
3433 *target_errno
= FILEIO_ENOSYS
;
3437 /* Close FD on the target. Return 0, or -1 if an error occurs
3438 (and set *TARGET_ERRNO). */
3440 target_fileio_close (int fd
, int *target_errno
)
3442 struct target_ops
*t
;
3444 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3446 if (t
->to_fileio_close
!= NULL
)
3448 int ret
= t
->to_fileio_close (fd
, target_errno
);
3451 fprintf_unfiltered (gdb_stdlog
,
3452 "target_fileio_close (%d) = %d (%d)\n",
3453 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
3458 *target_errno
= FILEIO_ENOSYS
;
3462 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3463 occurs (and set *TARGET_ERRNO). */
3465 target_fileio_unlink (const char *filename
, int *target_errno
)
3467 struct target_ops
*t
;
3469 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3471 if (t
->to_fileio_unlink
!= NULL
)
3473 int ret
= t
->to_fileio_unlink (filename
, target_errno
);
3476 fprintf_unfiltered (gdb_stdlog
,
3477 "target_fileio_unlink (%s) = %d (%d)\n",
3478 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
3483 *target_errno
= FILEIO_ENOSYS
;
3487 /* Read value of symbolic link FILENAME on the target. Return a
3488 null-terminated string allocated via xmalloc, or NULL if an error
3489 occurs (and set *TARGET_ERRNO). */
3491 target_fileio_readlink (const char *filename
, int *target_errno
)
3493 struct target_ops
*t
;
3495 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3497 if (t
->to_fileio_readlink
!= NULL
)
3499 char *ret
= t
->to_fileio_readlink (filename
, target_errno
);
3502 fprintf_unfiltered (gdb_stdlog
,
3503 "target_fileio_readlink (%s) = %s (%d)\n",
3504 filename
, ret
? ret
: "(nil)",
3505 ret
? 0 : *target_errno
);
3510 *target_errno
= FILEIO_ENOSYS
;
3515 target_fileio_close_cleanup (void *opaque
)
3517 int fd
= *(int *) opaque
;
3520 target_fileio_close (fd
, &target_errno
);
3523 /* Read target file FILENAME. Store the result in *BUF_P and
3524 return the size of the transferred data. PADDING additional bytes are
3525 available in *BUF_P. This is a helper function for
3526 target_fileio_read_alloc; see the declaration of that function for more
3530 target_fileio_read_alloc_1 (const char *filename
,
3531 gdb_byte
**buf_p
, int padding
)
3533 struct cleanup
*close_cleanup
;
3534 size_t buf_alloc
, buf_pos
;
3540 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
3544 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
3546 /* Start by reading up to 4K at a time. The target will throttle
3547 this number down if necessary. */
3549 buf
= xmalloc (buf_alloc
);
3553 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
3554 buf_alloc
- buf_pos
- padding
, buf_pos
,
3558 /* An error occurred. */
3559 do_cleanups (close_cleanup
);
3565 /* Read all there was. */
3566 do_cleanups (close_cleanup
);
3576 /* If the buffer is filling up, expand it. */
3577 if (buf_alloc
< buf_pos
* 2)
3580 buf
= xrealloc (buf
, buf_alloc
);
3587 /* Read target file FILENAME. Store the result in *BUF_P and return
3588 the size of the transferred data. See the declaration in "target.h"
3589 function for more information about the return value. */
3592 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
3594 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
3597 /* Read target file FILENAME. The result is NUL-terminated and
3598 returned as a string, allocated using xmalloc. If an error occurs
3599 or the transfer is unsupported, NULL is returned. Empty objects
3600 are returned as allocated but empty strings. A warning is issued
3601 if the result contains any embedded NUL bytes. */
3604 target_fileio_read_stralloc (const char *filename
)
3608 LONGEST i
, transferred
;
3610 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
3611 bufstr
= (char *) buffer
;
3613 if (transferred
< 0)
3616 if (transferred
== 0)
3617 return xstrdup ("");
3619 bufstr
[transferred
] = 0;
3621 /* Check for embedded NUL bytes; but allow trailing NULs. */
3622 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3625 warning (_("target file %s "
3626 "contained unexpected null characters"),
3636 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3638 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3642 default_watchpoint_addr_within_range (struct target_ops
*target
,
3644 CORE_ADDR start
, int length
)
3646 return addr
>= start
&& addr
< start
+ length
;
3649 static struct gdbarch
*
3650 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3652 return target_gdbarch ();
3668 return_minus_one (void)
3680 * Find the next target down the stack from the specified target.
3684 find_target_beneath (struct target_ops
*t
)
3692 find_target_at (enum strata stratum
)
3694 struct target_ops
*t
;
3696 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3697 if (t
->to_stratum
== stratum
)
3704 /* The inferior process has died. Long live the inferior! */
3707 generic_mourn_inferior (void)
3711 ptid
= inferior_ptid
;
3712 inferior_ptid
= null_ptid
;
3714 /* Mark breakpoints uninserted in case something tries to delete a
3715 breakpoint while we delete the inferior's threads (which would
3716 fail, since the inferior is long gone). */
3717 mark_breakpoints_out ();
3719 if (!ptid_equal (ptid
, null_ptid
))
3721 int pid
= ptid_get_pid (ptid
);
3722 exit_inferior (pid
);
3725 /* Note this wipes step-resume breakpoints, so needs to be done
3726 after exit_inferior, which ends up referencing the step-resume
3727 breakpoints through clear_thread_inferior_resources. */
3728 breakpoint_init_inferior (inf_exited
);
3730 registers_changed ();
3732 reopen_exec_file ();
3733 reinit_frame_cache ();
3735 if (deprecated_detach_hook
)
3736 deprecated_detach_hook ();
3739 /* Convert a normal process ID to a string. Returns the string in a
3743 normal_pid_to_str (ptid_t ptid
)
3745 static char buf
[32];
3747 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3752 dummy_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3754 return normal_pid_to_str (ptid
);
3757 /* Error-catcher for target_find_memory_regions. */
3759 dummy_find_memory_regions (find_memory_region_ftype ignore1
, void *ignore2
)
3761 error (_("Command not implemented for this target."));
3765 /* Error-catcher for target_make_corefile_notes. */
3767 dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
3769 error (_("Command not implemented for this target."));
3773 /* Error-catcher for target_get_bookmark. */
3775 dummy_get_bookmark (char *ignore1
, int ignore2
)
3781 /* Error-catcher for target_goto_bookmark. */
3783 dummy_goto_bookmark (gdb_byte
*ignore
, int from_tty
)
3788 /* Set up the handful of non-empty slots needed by the dummy target
3792 init_dummy_target (void)
3794 dummy_target
.to_shortname
= "None";
3795 dummy_target
.to_longname
= "None";
3796 dummy_target
.to_doc
= "";
3797 dummy_target
.to_attach
= find_default_attach
;
3798 dummy_target
.to_detach
=
3799 (void (*)(struct target_ops
*, const char *, int))target_ignore
;
3800 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3801 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3802 dummy_target
.to_supports_disable_randomization
3803 = find_default_supports_disable_randomization
;
3804 dummy_target
.to_pid_to_str
= dummy_pid_to_str
;
3805 dummy_target
.to_stratum
= dummy_stratum
;
3806 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
3807 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
3808 dummy_target
.to_get_bookmark
= dummy_get_bookmark
;
3809 dummy_target
.to_goto_bookmark
= dummy_goto_bookmark
;
3810 dummy_target
.to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
3811 dummy_target
.to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
3812 dummy_target
.to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
3813 dummy_target
.to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
3814 dummy_target
.to_has_execution
3815 = (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
3816 dummy_target
.to_magic
= OPS_MAGIC
;
3818 install_dummy_methods (&dummy_target
);
3822 debug_to_open (char *args
, int from_tty
)
3824 debug_target
.to_open (args
, from_tty
);
3826 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3830 target_close (struct target_ops
*targ
)
3832 gdb_assert (!target_is_pushed (targ
));
3834 if (targ
->to_xclose
!= NULL
)
3835 targ
->to_xclose (targ
);
3836 else if (targ
->to_close
!= NULL
)
3837 targ
->to_close (targ
);
3840 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3844 target_attach (char *args
, int from_tty
)
3846 struct target_ops
*t
;
3848 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3850 if (t
->to_attach
!= NULL
)
3852 t
->to_attach (t
, args
, from_tty
);
3854 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3860 internal_error (__FILE__
, __LINE__
,
3861 _("could not find a target to attach"));
3865 target_thread_alive (ptid_t ptid
)
3867 struct target_ops
*t
;
3869 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3871 if (t
->to_thread_alive
!= NULL
)
3875 retval
= t
->to_thread_alive (t
, ptid
);
3877 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3878 ptid_get_pid (ptid
), retval
);
3888 target_find_new_threads (void)
3890 struct target_ops
*t
;
3892 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3894 if (t
->to_find_new_threads
!= NULL
)
3896 t
->to_find_new_threads (t
);
3898 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3906 target_stop (ptid_t ptid
)
3910 warning (_("May not interrupt or stop the target, ignoring attempt"));
3914 (*current_target
.to_stop
) (ptid
);
3918 debug_to_post_attach (struct target_ops
*self
, int pid
)
3920 debug_target
.to_post_attach (&debug_target
, pid
);
3922 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3925 /* Concatenate ELEM to LIST, a comma separate list, and return the
3926 result. The LIST incoming argument is released. */
3929 str_comma_list_concat_elem (char *list
, const char *elem
)
3932 return xstrdup (elem
);
3934 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3937 /* Helper for target_options_to_string. If OPT is present in
3938 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3939 Returns the new resulting string. OPT is removed from
3943 do_option (int *target_options
, char *ret
,
3944 int opt
, char *opt_str
)
3946 if ((*target_options
& opt
) != 0)
3948 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3949 *target_options
&= ~opt
;
3956 target_options_to_string (int target_options
)
3960 #define DO_TARG_OPTION(OPT) \
3961 ret = do_option (&target_options, ret, OPT, #OPT)
3963 DO_TARG_OPTION (TARGET_WNOHANG
);
3965 if (target_options
!= 0)
3966 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3974 debug_print_register (const char * func
,
3975 struct regcache
*regcache
, int regno
)
3977 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3979 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3980 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3981 && gdbarch_register_name (gdbarch
, regno
) != NULL
3982 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3983 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3984 gdbarch_register_name (gdbarch
, regno
));
3986 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3987 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3989 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3990 int i
, size
= register_size (gdbarch
, regno
);
3991 gdb_byte buf
[MAX_REGISTER_SIZE
];
3993 regcache_raw_collect (regcache
, regno
, buf
);
3994 fprintf_unfiltered (gdb_stdlog
, " = ");
3995 for (i
= 0; i
< size
; i
++)
3997 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3999 if (size
<= sizeof (LONGEST
))
4001 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
4003 fprintf_unfiltered (gdb_stdlog
, " %s %s",
4004 core_addr_to_string_nz (val
), plongest (val
));
4007 fprintf_unfiltered (gdb_stdlog
, "\n");
4011 target_fetch_registers (struct regcache
*regcache
, int regno
)
4013 struct target_ops
*t
;
4015 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4017 if (t
->to_fetch_registers
!= NULL
)
4019 t
->to_fetch_registers (t
, regcache
, regno
);
4021 debug_print_register ("target_fetch_registers", regcache
, regno
);
4028 target_store_registers (struct regcache
*regcache
, int regno
)
4030 struct target_ops
*t
;
4032 if (!may_write_registers
)
4033 error (_("Writing to registers is not allowed (regno %d)"), regno
);
4035 current_target
.to_store_registers (¤t_target
, regcache
, regno
);
4038 debug_print_register ("target_store_registers", regcache
, regno
);
4043 target_core_of_thread (ptid_t ptid
)
4045 struct target_ops
*t
;
4047 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4049 if (t
->to_core_of_thread
!= NULL
)
4051 int retval
= t
->to_core_of_thread (t
, ptid
);
4054 fprintf_unfiltered (gdb_stdlog
,
4055 "target_core_of_thread (%d) = %d\n",
4056 ptid_get_pid (ptid
), retval
);
4065 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
4067 struct target_ops
*t
;
4069 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4071 if (t
->to_verify_memory
!= NULL
)
4073 int retval
= t
->to_verify_memory (t
, data
, memaddr
, size
);
4076 fprintf_unfiltered (gdb_stdlog
,
4077 "target_verify_memory (%s, %s) = %d\n",
4078 paddress (target_gdbarch (), memaddr
),
4088 /* The documentation for this function is in its prototype declaration in
4092 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4094 struct target_ops
*t
;
4096 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4097 if (t
->to_insert_mask_watchpoint
!= NULL
)
4101 ret
= t
->to_insert_mask_watchpoint (t
, addr
, mask
, rw
);
4104 fprintf_unfiltered (gdb_stdlog
, "\
4105 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
4106 core_addr_to_string (addr
),
4107 core_addr_to_string (mask
), rw
, ret
);
4115 /* The documentation for this function is in its prototype declaration in
4119 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4121 struct target_ops
*t
;
4123 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4124 if (t
->to_remove_mask_watchpoint
!= NULL
)
4128 ret
= t
->to_remove_mask_watchpoint (t
, addr
, mask
, rw
);
4131 fprintf_unfiltered (gdb_stdlog
, "\
4132 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
4133 core_addr_to_string (addr
),
4134 core_addr_to_string (mask
), rw
, ret
);
4142 /* The documentation for this function is in its prototype declaration
4146 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
4148 struct target_ops
*t
;
4150 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4151 if (t
->to_masked_watch_num_registers
!= NULL
)
4152 return t
->to_masked_watch_num_registers (t
, addr
, mask
);
4157 /* The documentation for this function is in its prototype declaration
4161 target_ranged_break_num_registers (void)
4163 struct target_ops
*t
;
4165 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4166 if (t
->to_ranged_break_num_registers
!= NULL
)
4167 return t
->to_ranged_break_num_registers (t
);
4174 struct btrace_target_info
*
4175 target_enable_btrace (ptid_t ptid
)
4177 struct target_ops
*t
;
4179 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4180 if (t
->to_enable_btrace
!= NULL
)
4181 return t
->to_enable_btrace (ptid
);
4190 target_disable_btrace (struct btrace_target_info
*btinfo
)
4192 struct target_ops
*t
;
4194 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4195 if (t
->to_disable_btrace
!= NULL
)
4197 t
->to_disable_btrace (btinfo
);
4207 target_teardown_btrace (struct btrace_target_info
*btinfo
)
4209 struct target_ops
*t
;
4211 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4212 if (t
->to_teardown_btrace
!= NULL
)
4214 t
->to_teardown_btrace (btinfo
);
4224 target_read_btrace (VEC (btrace_block_s
) **btrace
,
4225 struct btrace_target_info
*btinfo
,
4226 enum btrace_read_type type
)
4228 struct target_ops
*t
;
4230 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4231 if (t
->to_read_btrace
!= NULL
)
4232 return t
->to_read_btrace (btrace
, btinfo
, type
);
4235 return BTRACE_ERR_NOT_SUPPORTED
;
4241 target_stop_recording (void)
4243 struct target_ops
*t
;
4245 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4246 if (t
->to_stop_recording
!= NULL
)
4248 t
->to_stop_recording ();
4252 /* This is optional. */
4258 target_info_record (void)
4260 struct target_ops
*t
;
4262 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4263 if (t
->to_info_record
!= NULL
)
4265 t
->to_info_record ();
4275 target_save_record (const char *filename
)
4277 struct target_ops
*t
;
4279 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4280 if (t
->to_save_record
!= NULL
)
4282 t
->to_save_record (filename
);
4292 target_supports_delete_record (void)
4294 struct target_ops
*t
;
4296 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4297 if (t
->to_delete_record
!= NULL
)
4306 target_delete_record (void)
4308 struct target_ops
*t
;
4310 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4311 if (t
->to_delete_record
!= NULL
)
4313 t
->to_delete_record ();
4323 target_record_is_replaying (void)
4325 struct target_ops
*t
;
4327 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4328 if (t
->to_record_is_replaying
!= NULL
)
4329 return t
->to_record_is_replaying ();
4337 target_goto_record_begin (void)
4339 struct target_ops
*t
;
4341 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4342 if (t
->to_goto_record_begin
!= NULL
)
4344 t
->to_goto_record_begin ();
4354 target_goto_record_end (void)
4356 struct target_ops
*t
;
4358 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4359 if (t
->to_goto_record_end
!= NULL
)
4361 t
->to_goto_record_end ();
4371 target_goto_record (ULONGEST insn
)
4373 struct target_ops
*t
;
4375 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4376 if (t
->to_goto_record
!= NULL
)
4378 t
->to_goto_record (insn
);
4388 target_insn_history (int size
, int flags
)
4390 struct target_ops
*t
;
4392 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4393 if (t
->to_insn_history
!= NULL
)
4395 t
->to_insn_history (size
, flags
);
4405 target_insn_history_from (ULONGEST from
, int size
, int flags
)
4407 struct target_ops
*t
;
4409 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4410 if (t
->to_insn_history_from
!= NULL
)
4412 t
->to_insn_history_from (from
, size
, flags
);
4422 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4424 struct target_ops
*t
;
4426 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4427 if (t
->to_insn_history_range
!= NULL
)
4429 t
->to_insn_history_range (begin
, end
, flags
);
4439 target_call_history (int size
, int flags
)
4441 struct target_ops
*t
;
4443 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4444 if (t
->to_call_history
!= NULL
)
4446 t
->to_call_history (size
, flags
);
4456 target_call_history_from (ULONGEST begin
, int size
, int flags
)
4458 struct target_ops
*t
;
4460 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4461 if (t
->to_call_history_from
!= NULL
)
4463 t
->to_call_history_from (begin
, size
, flags
);
4473 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4475 struct target_ops
*t
;
4477 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4478 if (t
->to_call_history_range
!= NULL
)
4480 t
->to_call_history_range (begin
, end
, flags
);
4488 debug_to_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
4490 debug_target
.to_prepare_to_store (&debug_target
, regcache
);
4492 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
4497 const struct frame_unwind
*
4498 target_get_unwinder (void)
4500 struct target_ops
*t
;
4502 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4503 if (t
->to_get_unwinder
!= NULL
)
4504 return t
->to_get_unwinder
;
4511 const struct frame_unwind
*
4512 target_get_tailcall_unwinder (void)
4514 struct target_ops
*t
;
4516 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4517 if (t
->to_get_tailcall_unwinder
!= NULL
)
4518 return t
->to_get_tailcall_unwinder
;
4526 forward_target_decr_pc_after_break (struct target_ops
*ops
,
4527 struct gdbarch
*gdbarch
)
4529 for (; ops
!= NULL
; ops
= ops
->beneath
)
4530 if (ops
->to_decr_pc_after_break
!= NULL
)
4531 return ops
->to_decr_pc_after_break (ops
, gdbarch
);
4533 return gdbarch_decr_pc_after_break (gdbarch
);
4539 target_decr_pc_after_break (struct gdbarch
*gdbarch
)
4541 return forward_target_decr_pc_after_break (current_target
.beneath
, gdbarch
);
4545 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
4546 int write
, struct mem_attrib
*attrib
,
4547 struct target_ops
*target
)
4551 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
4554 fprintf_unfiltered (gdb_stdlog
,
4555 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4556 paddress (target_gdbarch (), memaddr
), len
,
4557 write
? "write" : "read", retval
);
4563 fputs_unfiltered (", bytes =", gdb_stdlog
);
4564 for (i
= 0; i
< retval
; i
++)
4566 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
4568 if (targetdebug
< 2 && i
> 0)
4570 fprintf_unfiltered (gdb_stdlog
, " ...");
4573 fprintf_unfiltered (gdb_stdlog
, "\n");
4576 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
4580 fputc_unfiltered ('\n', gdb_stdlog
);
4586 debug_to_files_info (struct target_ops
*target
)
4588 debug_target
.to_files_info (target
);
4590 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
4594 debug_to_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4595 struct bp_target_info
*bp_tgt
)
4599 retval
= debug_target
.to_insert_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4601 fprintf_unfiltered (gdb_stdlog
,
4602 "target_insert_breakpoint (%s, xxx) = %ld\n",
4603 core_addr_to_string (bp_tgt
->placed_address
),
4604 (unsigned long) retval
);
4609 debug_to_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4610 struct bp_target_info
*bp_tgt
)
4614 retval
= debug_target
.to_remove_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4616 fprintf_unfiltered (gdb_stdlog
,
4617 "target_remove_breakpoint (%s, xxx) = %ld\n",
4618 core_addr_to_string (bp_tgt
->placed_address
),
4619 (unsigned long) retval
);
4624 debug_to_can_use_hw_breakpoint (struct target_ops
*self
,
4625 int type
, int cnt
, int from_tty
)
4629 retval
= debug_target
.to_can_use_hw_breakpoint (&debug_target
,
4630 type
, cnt
, from_tty
);
4632 fprintf_unfiltered (gdb_stdlog
,
4633 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4634 (unsigned long) type
,
4635 (unsigned long) cnt
,
4636 (unsigned long) from_tty
,
4637 (unsigned long) retval
);
4642 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
4646 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
4648 fprintf_unfiltered (gdb_stdlog
,
4649 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4650 core_addr_to_string (addr
), (unsigned long) len
,
4651 core_addr_to_string (retval
));
4656 debug_to_can_accel_watchpoint_condition (CORE_ADDR addr
, int len
, int rw
,
4657 struct expression
*cond
)
4661 retval
= debug_target
.to_can_accel_watchpoint_condition (addr
, len
,
4664 fprintf_unfiltered (gdb_stdlog
,
4665 "target_can_accel_watchpoint_condition "
4666 "(%s, %d, %d, %s) = %ld\n",
4667 core_addr_to_string (addr
), len
, rw
,
4668 host_address_to_string (cond
), (unsigned long) retval
);
4673 debug_to_stopped_by_watchpoint (struct target_ops
*ops
)
4677 retval
= debug_target
.to_stopped_by_watchpoint (&debug_target
);
4679 fprintf_unfiltered (gdb_stdlog
,
4680 "target_stopped_by_watchpoint () = %ld\n",
4681 (unsigned long) retval
);
4686 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
4690 retval
= debug_target
.to_stopped_data_address (target
, addr
);
4692 fprintf_unfiltered (gdb_stdlog
,
4693 "target_stopped_data_address ([%s]) = %ld\n",
4694 core_addr_to_string (*addr
),
4695 (unsigned long)retval
);
4700 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
4702 CORE_ADDR start
, int length
)
4706 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
4709 fprintf_filtered (gdb_stdlog
,
4710 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4711 core_addr_to_string (addr
), core_addr_to_string (start
),
4717 debug_to_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
4718 struct bp_target_info
*bp_tgt
)
4722 retval
= debug_target
.to_insert_hw_breakpoint (gdbarch
, bp_tgt
);
4724 fprintf_unfiltered (gdb_stdlog
,
4725 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4726 core_addr_to_string (bp_tgt
->placed_address
),
4727 (unsigned long) retval
);
4732 debug_to_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
4733 struct bp_target_info
*bp_tgt
)
4737 retval
= debug_target
.to_remove_hw_breakpoint (gdbarch
, bp_tgt
);
4739 fprintf_unfiltered (gdb_stdlog
,
4740 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4741 core_addr_to_string (bp_tgt
->placed_address
),
4742 (unsigned long) retval
);
4747 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
4748 struct expression
*cond
)
4752 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
, cond
);
4754 fprintf_unfiltered (gdb_stdlog
,
4755 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4756 core_addr_to_string (addr
), len
, type
,
4757 host_address_to_string (cond
), (unsigned long) retval
);
4762 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
4763 struct expression
*cond
)
4767 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
, cond
);
4769 fprintf_unfiltered (gdb_stdlog
,
4770 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4771 core_addr_to_string (addr
), len
, type
,
4772 host_address_to_string (cond
), (unsigned long) retval
);
4777 debug_to_terminal_init (void)
4779 debug_target
.to_terminal_init ();
4781 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
4785 debug_to_terminal_inferior (void)
4787 debug_target
.to_terminal_inferior ();
4789 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
4793 debug_to_terminal_ours_for_output (void)
4795 debug_target
.to_terminal_ours_for_output ();
4797 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
4801 debug_to_terminal_ours (void)
4803 debug_target
.to_terminal_ours ();
4805 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
4809 debug_to_terminal_save_ours (void)
4811 debug_target
.to_terminal_save_ours ();
4813 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
4817 debug_to_terminal_info (const char *arg
, int from_tty
)
4819 debug_target
.to_terminal_info (arg
, from_tty
);
4821 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
4826 debug_to_load (char *args
, int from_tty
)
4828 debug_target
.to_load (args
, from_tty
);
4830 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
4834 debug_to_post_startup_inferior (ptid_t ptid
)
4836 debug_target
.to_post_startup_inferior (ptid
);
4838 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
4839 ptid_get_pid (ptid
));
4843 debug_to_insert_fork_catchpoint (int pid
)
4847 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
4849 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
4856 debug_to_remove_fork_catchpoint (int pid
)
4860 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
4862 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
4869 debug_to_insert_vfork_catchpoint (int pid
)
4873 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
4875 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
4882 debug_to_remove_vfork_catchpoint (int pid
)
4886 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
4888 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
4895 debug_to_insert_exec_catchpoint (int pid
)
4899 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
4901 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
4908 debug_to_remove_exec_catchpoint (int pid
)
4912 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
4914 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
4921 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
4925 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
4927 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
4928 pid
, wait_status
, *exit_status
, has_exited
);
4934 debug_to_can_run (void)
4938 retval
= debug_target
.to_can_run ();
4940 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4945 static struct gdbarch
*
4946 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4948 struct gdbarch
*retval
;
4950 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4952 fprintf_unfiltered (gdb_stdlog
,
4953 "target_thread_architecture (%s) = %s [%s]\n",
4954 target_pid_to_str (ptid
),
4955 host_address_to_string (retval
),
4956 gdbarch_bfd_arch_info (retval
)->printable_name
);
4961 debug_to_stop (ptid_t ptid
)
4963 debug_target
.to_stop (ptid
);
4965 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4966 target_pid_to_str (ptid
));
4970 debug_to_rcmd (char *command
,
4971 struct ui_file
*outbuf
)
4973 debug_target
.to_rcmd (command
, outbuf
);
4974 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4978 debug_to_pid_to_exec_file (int pid
)
4982 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
4984 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
4991 setup_target_debug (void)
4993 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
4995 current_target
.to_open
= debug_to_open
;
4996 current_target
.to_post_attach
= debug_to_post_attach
;
4997 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
4998 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
4999 current_target
.to_files_info
= debug_to_files_info
;
5000 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
5001 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
5002 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
5003 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
5004 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
5005 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
5006 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
5007 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
5008 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
5009 current_target
.to_watchpoint_addr_within_range
5010 = debug_to_watchpoint_addr_within_range
;
5011 current_target
.to_region_ok_for_hw_watchpoint
5012 = debug_to_region_ok_for_hw_watchpoint
;
5013 current_target
.to_can_accel_watchpoint_condition
5014 = debug_to_can_accel_watchpoint_condition
;
5015 current_target
.to_terminal_init
= debug_to_terminal_init
;
5016 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
5017 current_target
.to_terminal_ours_for_output
5018 = debug_to_terminal_ours_for_output
;
5019 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
5020 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
5021 current_target
.to_terminal_info
= debug_to_terminal_info
;
5022 current_target
.to_load
= debug_to_load
;
5023 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
5024 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
5025 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
5026 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
5027 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
5028 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
5029 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
5030 current_target
.to_has_exited
= debug_to_has_exited
;
5031 current_target
.to_can_run
= debug_to_can_run
;
5032 current_target
.to_stop
= debug_to_stop
;
5033 current_target
.to_rcmd
= debug_to_rcmd
;
5034 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
5035 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
5039 static char targ_desc
[] =
5040 "Names of targets and files being debugged.\nShows the entire \
5041 stack of targets currently in use (including the exec-file,\n\
5042 core-file, and process, if any), as well as the symbol file name.";
5045 do_monitor_command (char *cmd
,
5048 if ((current_target
.to_rcmd
5049 == (void (*) (char *, struct ui_file
*)) tcomplain
)
5050 || (current_target
.to_rcmd
== debug_to_rcmd
5051 && (debug_target
.to_rcmd
5052 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
5053 error (_("\"monitor\" command not supported by this target."));
5054 target_rcmd (cmd
, gdb_stdtarg
);
5057 /* Print the name of each layers of our target stack. */
5060 maintenance_print_target_stack (char *cmd
, int from_tty
)
5062 struct target_ops
*t
;
5064 printf_filtered (_("The current target stack is:\n"));
5066 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
5068 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
5072 /* Controls if async mode is permitted. */
5073 int target_async_permitted
= 0;
5075 /* The set command writes to this variable. If the inferior is
5076 executing, target_async_permitted is *not* updated. */
5077 static int target_async_permitted_1
= 0;
5080 set_target_async_command (char *args
, int from_tty
,
5081 struct cmd_list_element
*c
)
5083 if (have_live_inferiors ())
5085 target_async_permitted_1
= target_async_permitted
;
5086 error (_("Cannot change this setting while the inferior is running."));
5089 target_async_permitted
= target_async_permitted_1
;
5093 show_target_async_command (struct ui_file
*file
, int from_tty
,
5094 struct cmd_list_element
*c
,
5097 fprintf_filtered (file
,
5098 _("Controlling the inferior in "
5099 "asynchronous mode is %s.\n"), value
);
5102 /* Temporary copies of permission settings. */
5104 static int may_write_registers_1
= 1;
5105 static int may_write_memory_1
= 1;
5106 static int may_insert_breakpoints_1
= 1;
5107 static int may_insert_tracepoints_1
= 1;
5108 static int may_insert_fast_tracepoints_1
= 1;
5109 static int may_stop_1
= 1;
5111 /* Make the user-set values match the real values again. */
5114 update_target_permissions (void)
5116 may_write_registers_1
= may_write_registers
;
5117 may_write_memory_1
= may_write_memory
;
5118 may_insert_breakpoints_1
= may_insert_breakpoints
;
5119 may_insert_tracepoints_1
= may_insert_tracepoints
;
5120 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
5121 may_stop_1
= may_stop
;
5124 /* The one function handles (most of) the permission flags in the same
5128 set_target_permissions (char *args
, int from_tty
,
5129 struct cmd_list_element
*c
)
5131 if (target_has_execution
)
5133 update_target_permissions ();
5134 error (_("Cannot change this setting while the inferior is running."));
5137 /* Make the real values match the user-changed values. */
5138 may_write_registers
= may_write_registers_1
;
5139 may_insert_breakpoints
= may_insert_breakpoints_1
;
5140 may_insert_tracepoints
= may_insert_tracepoints_1
;
5141 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
5142 may_stop
= may_stop_1
;
5143 update_observer_mode ();
5146 /* Set memory write permission independently of observer mode. */
5149 set_write_memory_permission (char *args
, int from_tty
,
5150 struct cmd_list_element
*c
)
5152 /* Make the real values match the user-changed values. */
5153 may_write_memory
= may_write_memory_1
;
5154 update_observer_mode ();
5159 initialize_targets (void)
5161 init_dummy_target ();
5162 push_target (&dummy_target
);
5164 add_info ("target", target_info
, targ_desc
);
5165 add_info ("files", target_info
, targ_desc
);
5167 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
5168 Set target debugging."), _("\
5169 Show target debugging."), _("\
5170 When non-zero, target debugging is enabled. Higher numbers are more\n\
5171 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
5175 &setdebuglist
, &showdebuglist
);
5177 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
5178 &trust_readonly
, _("\
5179 Set mode for reading from readonly sections."), _("\
5180 Show mode for reading from readonly sections."), _("\
5181 When this mode is on, memory reads from readonly sections (such as .text)\n\
5182 will be read from the object file instead of from the target. This will\n\
5183 result in significant performance improvement for remote targets."),
5185 show_trust_readonly
,
5186 &setlist
, &showlist
);
5188 add_com ("monitor", class_obscure
, do_monitor_command
,
5189 _("Send a command to the remote monitor (remote targets only)."));
5191 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
5192 _("Print the name of each layer of the internal target stack."),
5193 &maintenanceprintlist
);
5195 add_setshow_boolean_cmd ("target-async", no_class
,
5196 &target_async_permitted_1
, _("\
5197 Set whether gdb controls the inferior in asynchronous mode."), _("\
5198 Show whether gdb controls the inferior in asynchronous mode."), _("\
5199 Tells gdb whether to control the inferior in asynchronous mode."),
5200 set_target_async_command
,
5201 show_target_async_command
,
5205 add_setshow_boolean_cmd ("may-write-registers", class_support
,
5206 &may_write_registers_1
, _("\
5207 Set permission to write into registers."), _("\
5208 Show permission to write into registers."), _("\
5209 When this permission is on, GDB may write into the target's registers.\n\
5210 Otherwise, any sort of write attempt will result in an error."),
5211 set_target_permissions
, NULL
,
5212 &setlist
, &showlist
);
5214 add_setshow_boolean_cmd ("may-write-memory", class_support
,
5215 &may_write_memory_1
, _("\
5216 Set permission to write into target memory."), _("\
5217 Show permission to write into target memory."), _("\
5218 When this permission is on, GDB may write into the target's memory.\n\
5219 Otherwise, any sort of write attempt will result in an error."),
5220 set_write_memory_permission
, NULL
,
5221 &setlist
, &showlist
);
5223 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
5224 &may_insert_breakpoints_1
, _("\
5225 Set permission to insert breakpoints in the target."), _("\
5226 Show permission to insert breakpoints in the target."), _("\
5227 When this permission is on, GDB may insert breakpoints in the program.\n\
5228 Otherwise, any sort of insertion attempt will result in an error."),
5229 set_target_permissions
, NULL
,
5230 &setlist
, &showlist
);
5232 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
5233 &may_insert_tracepoints_1
, _("\
5234 Set permission to insert tracepoints in the target."), _("\
5235 Show permission to insert tracepoints in the target."), _("\
5236 When this permission is on, GDB may insert tracepoints in the program.\n\
5237 Otherwise, any sort of insertion attempt will result in an error."),
5238 set_target_permissions
, NULL
,
5239 &setlist
, &showlist
);
5241 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
5242 &may_insert_fast_tracepoints_1
, _("\
5243 Set permission to insert fast tracepoints in the target."), _("\
5244 Show permission to insert fast tracepoints in the target."), _("\
5245 When this permission is on, GDB may insert fast tracepoints.\n\
5246 Otherwise, any sort of insertion attempt will result in an error."),
5247 set_target_permissions
, NULL
,
5248 &setlist
, &showlist
);
5250 add_setshow_boolean_cmd ("may-interrupt", class_support
,
5252 Set permission to interrupt or signal the target."), _("\
5253 Show permission to interrupt or signal the target."), _("\
5254 When this permission is on, GDB may interrupt/stop the target's execution.\n\
5255 Otherwise, any attempt to interrupt or stop will be ignored."),
5256 set_target_permissions
, NULL
,
5257 &setlist
, &showlist
);