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 (struct target_ops
*, 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 (struct target_ops
*,
58 static void default_rcmd (struct target_ops
*, char *, struct ui_file
*);
60 static void tcomplain (void) ATTRIBUTE_NORETURN
;
62 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
64 static int return_zero (void);
66 static int return_minus_one (void);
68 static void *return_null (void);
70 void target_ignore (void);
72 static void target_command (char *, int);
74 static struct target_ops
*find_default_run_target (char *);
76 static target_xfer_partial_ftype default_xfer_partial
;
78 static struct gdbarch
*default_thread_architecture (struct target_ops
*ops
,
81 static int find_default_can_async_p (struct target_ops
*ignore
);
83 static int find_default_is_async_p (struct target_ops
*ignore
);
85 #include "target-delegates.c"
87 static void init_dummy_target (void);
89 static struct target_ops debug_target
;
91 static void debug_to_open (char *, int);
93 static void debug_to_prepare_to_store (struct target_ops
*self
,
96 static void debug_to_files_info (struct target_ops
*);
98 static int debug_to_insert_breakpoint (struct target_ops
*, struct gdbarch
*,
99 struct bp_target_info
*);
101 static int debug_to_remove_breakpoint (struct target_ops
*, struct gdbarch
*,
102 struct bp_target_info
*);
104 static int debug_to_can_use_hw_breakpoint (struct target_ops
*self
,
107 static int debug_to_insert_hw_breakpoint (struct target_ops
*self
,
109 struct bp_target_info
*);
111 static int debug_to_remove_hw_breakpoint (struct target_ops
*self
,
113 struct bp_target_info
*);
115 static int debug_to_insert_watchpoint (struct target_ops
*self
,
117 struct expression
*);
119 static int debug_to_remove_watchpoint (struct target_ops
*self
,
121 struct expression
*);
123 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
125 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
126 CORE_ADDR
, CORE_ADDR
, int);
128 static int debug_to_region_ok_for_hw_watchpoint (struct target_ops
*self
,
131 static int debug_to_can_accel_watchpoint_condition (struct target_ops
*self
,
133 struct expression
*);
135 static void debug_to_terminal_init (struct target_ops
*self
);
137 static void debug_to_terminal_inferior (struct target_ops
*self
);
139 static void debug_to_terminal_ours_for_output (struct target_ops
*self
);
141 static void debug_to_terminal_save_ours (struct target_ops
*self
);
143 static void debug_to_terminal_ours (struct target_ops
*self
);
145 static void debug_to_load (struct target_ops
*self
, char *, int);
147 static int debug_to_can_run (struct target_ops
*self
);
149 static void debug_to_stop (struct target_ops
*self
, ptid_t
);
151 /* Pointer to array of target architecture structures; the size of the
152 array; the current index into the array; the allocated size of the
154 struct target_ops
**target_structs
;
155 unsigned target_struct_size
;
156 unsigned target_struct_allocsize
;
157 #define DEFAULT_ALLOCSIZE 10
159 /* The initial current target, so that there is always a semi-valid
162 static struct target_ops dummy_target
;
164 /* Top of target stack. */
166 static struct target_ops
*target_stack
;
168 /* The target structure we are currently using to talk to a process
169 or file or whatever "inferior" we have. */
171 struct target_ops current_target
;
173 /* Command list for target. */
175 static struct cmd_list_element
*targetlist
= NULL
;
177 /* Nonzero if we should trust readonly sections from the
178 executable when reading memory. */
180 static int trust_readonly
= 0;
182 /* Nonzero if we should show true memory content including
183 memory breakpoint inserted by gdb. */
185 static int show_memory_breakpoints
= 0;
187 /* These globals control whether GDB attempts to perform these
188 operations; they are useful for targets that need to prevent
189 inadvertant disruption, such as in non-stop mode. */
191 int may_write_registers
= 1;
193 int may_write_memory
= 1;
195 int may_insert_breakpoints
= 1;
197 int may_insert_tracepoints
= 1;
199 int may_insert_fast_tracepoints
= 1;
203 /* Non-zero if we want to see trace of target level stuff. */
205 static unsigned int targetdebug
= 0;
207 show_targetdebug (struct ui_file
*file
, int from_tty
,
208 struct cmd_list_element
*c
, const char *value
)
210 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
213 static void setup_target_debug (void);
215 /* The user just typed 'target' without the name of a target. */
218 target_command (char *arg
, int from_tty
)
220 fputs_filtered ("Argument required (target name). Try `help target'\n",
224 /* Default target_has_* methods for process_stratum targets. */
227 default_child_has_all_memory (struct target_ops
*ops
)
229 /* If no inferior selected, then we can't read memory here. */
230 if (ptid_equal (inferior_ptid
, null_ptid
))
237 default_child_has_memory (struct target_ops
*ops
)
239 /* If no inferior selected, then we can't read memory here. */
240 if (ptid_equal (inferior_ptid
, null_ptid
))
247 default_child_has_stack (struct target_ops
*ops
)
249 /* If no inferior selected, there's no stack. */
250 if (ptid_equal (inferior_ptid
, null_ptid
))
257 default_child_has_registers (struct target_ops
*ops
)
259 /* Can't read registers from no inferior. */
260 if (ptid_equal (inferior_ptid
, null_ptid
))
267 default_child_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
269 /* If there's no thread selected, then we can't make it run through
271 if (ptid_equal (the_ptid
, null_ptid
))
279 target_has_all_memory_1 (void)
281 struct target_ops
*t
;
283 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
284 if (t
->to_has_all_memory (t
))
291 target_has_memory_1 (void)
293 struct target_ops
*t
;
295 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
296 if (t
->to_has_memory (t
))
303 target_has_stack_1 (void)
305 struct target_ops
*t
;
307 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
308 if (t
->to_has_stack (t
))
315 target_has_registers_1 (void)
317 struct target_ops
*t
;
319 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
320 if (t
->to_has_registers (t
))
327 target_has_execution_1 (ptid_t the_ptid
)
329 struct target_ops
*t
;
331 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
332 if (t
->to_has_execution (t
, the_ptid
))
339 target_has_execution_current (void)
341 return target_has_execution_1 (inferior_ptid
);
344 /* Complete initialization of T. This ensures that various fields in
345 T are set, if needed by the target implementation. */
348 complete_target_initialization (struct target_ops
*t
)
350 /* Provide default values for all "must have" methods. */
351 if (t
->to_xfer_partial
== NULL
)
352 t
->to_xfer_partial
= default_xfer_partial
;
354 if (t
->to_has_all_memory
== NULL
)
355 t
->to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
357 if (t
->to_has_memory
== NULL
)
358 t
->to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
360 if (t
->to_has_stack
== NULL
)
361 t
->to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
363 if (t
->to_has_registers
== NULL
)
364 t
->to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
366 if (t
->to_has_execution
== NULL
)
367 t
->to_has_execution
= (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
369 install_delegators (t
);
372 /* Add possible target architecture T to the list and add a new
373 command 'target T->to_shortname'. Set COMPLETER as the command's
374 completer if not NULL. */
377 add_target_with_completer (struct target_ops
*t
,
378 completer_ftype
*completer
)
380 struct cmd_list_element
*c
;
382 complete_target_initialization (t
);
386 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
387 target_structs
= (struct target_ops
**) xmalloc
388 (target_struct_allocsize
* sizeof (*target_structs
));
390 if (target_struct_size
>= target_struct_allocsize
)
392 target_struct_allocsize
*= 2;
393 target_structs
= (struct target_ops
**)
394 xrealloc ((char *) target_structs
,
395 target_struct_allocsize
* sizeof (*target_structs
));
397 target_structs
[target_struct_size
++] = t
;
399 if (targetlist
== NULL
)
400 add_prefix_cmd ("target", class_run
, target_command
, _("\
401 Connect to a target machine or process.\n\
402 The first argument is the type or protocol of the target machine.\n\
403 Remaining arguments are interpreted by the target protocol. For more\n\
404 information on the arguments for a particular protocol, type\n\
405 `help target ' followed by the protocol name."),
406 &targetlist
, "target ", 0, &cmdlist
);
407 c
= add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
,
409 if (completer
!= NULL
)
410 set_cmd_completer (c
, completer
);
413 /* Add a possible target architecture to the list. */
416 add_target (struct target_ops
*t
)
418 add_target_with_completer (t
, NULL
);
424 add_deprecated_target_alias (struct target_ops
*t
, char *alias
)
426 struct cmd_list_element
*c
;
429 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
431 c
= add_cmd (alias
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
432 alt
= xstrprintf ("target %s", t
->to_shortname
);
433 deprecate_cmd (c
, alt
);
446 struct target_ops
*t
;
448 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
449 if (t
->to_kill
!= NULL
)
452 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
462 target_load (char *arg
, int from_tty
)
464 target_dcache_invalidate ();
465 (*current_target
.to_load
) (¤t_target
, arg
, from_tty
);
469 target_create_inferior (char *exec_file
, char *args
,
470 char **env
, int from_tty
)
472 struct target_ops
*t
;
474 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
476 if (t
->to_create_inferior
!= NULL
)
478 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
480 fprintf_unfiltered (gdb_stdlog
,
481 "target_create_inferior (%s, %s, xxx, %d)\n",
482 exec_file
, args
, from_tty
);
487 internal_error (__FILE__
, __LINE__
,
488 _("could not find a target to create inferior"));
492 target_terminal_inferior (void)
494 /* A background resume (``run&'') should leave GDB in control of the
495 terminal. Use target_can_async_p, not target_is_async_p, since at
496 this point the target is not async yet. However, if sync_execution
497 is not set, we know it will become async prior to resume. */
498 if (target_can_async_p () && !sync_execution
)
501 /* If GDB is resuming the inferior in the foreground, install
502 inferior's terminal modes. */
503 (*current_target
.to_terminal_inferior
) (¤t_target
);
507 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
508 struct target_ops
*t
)
510 errno
= EIO
; /* Can't read/write this location. */
511 return 0; /* No bytes handled. */
517 error (_("You can't do that when your target is `%s'"),
518 current_target
.to_shortname
);
524 error (_("You can't do that without a process to debug."));
528 default_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
530 printf_unfiltered (_("No saved terminal information.\n"));
533 /* A default implementation for the to_get_ada_task_ptid target method.
535 This function builds the PTID by using both LWP and TID as part of
536 the PTID lwp and tid elements. The pid used is the pid of the
540 default_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long tid
)
542 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
545 static enum exec_direction_kind
546 default_execution_direction (struct target_ops
*self
)
548 if (!target_can_execute_reverse
)
550 else if (!target_can_async_p ())
553 gdb_assert_not_reached ("\
554 to_execution_direction must be implemented for reverse async");
557 /* Go through the target stack from top to bottom, copying over zero
558 entries in current_target, then filling in still empty entries. In
559 effect, we are doing class inheritance through the pushed target
562 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
563 is currently implemented, is that it discards any knowledge of
564 which target an inherited method originally belonged to.
565 Consequently, new new target methods should instead explicitly and
566 locally search the target stack for the target that can handle the
570 update_current_target (void)
572 struct target_ops
*t
;
574 /* First, reset current's contents. */
575 memset (¤t_target
, 0, sizeof (current_target
));
577 /* Install the delegators. */
578 install_delegators (¤t_target
);
580 #define INHERIT(FIELD, TARGET) \
581 if (!current_target.FIELD) \
582 current_target.FIELD = (TARGET)->FIELD
584 for (t
= target_stack
; t
; t
= t
->beneath
)
586 INHERIT (to_shortname
, t
);
587 INHERIT (to_longname
, t
);
589 /* Do not inherit to_open. */
590 /* Do not inherit to_close. */
591 /* Do not inherit to_attach. */
592 /* Do not inherit to_post_attach. */
593 INHERIT (to_attach_no_wait
, t
);
594 /* Do not inherit to_detach. */
595 /* Do not inherit to_disconnect. */
596 /* Do not inherit to_resume. */
597 /* Do not inherit to_wait. */
598 /* Do not inherit to_fetch_registers. */
599 /* Do not inherit to_store_registers. */
600 /* Do not inherit to_prepare_to_store. */
601 INHERIT (deprecated_xfer_memory
, t
);
602 /* Do not inherit to_files_info. */
603 /* Do not inherit to_insert_breakpoint. */
604 /* Do not inherit to_remove_breakpoint. */
605 /* Do not inherit to_can_use_hw_breakpoint. */
606 /* Do not inherit to_insert_hw_breakpoint. */
607 /* Do not inherit to_remove_hw_breakpoint. */
608 /* Do not inherit to_ranged_break_num_registers. */
609 /* Do not inherit to_insert_watchpoint. */
610 /* Do not inherit to_remove_watchpoint. */
611 /* Do not inherit to_insert_mask_watchpoint. */
612 /* Do not inherit to_remove_mask_watchpoint. */
613 /* Do not inherit to_stopped_data_address. */
614 INHERIT (to_have_steppable_watchpoint
, t
);
615 INHERIT (to_have_continuable_watchpoint
, t
);
616 /* Do not inherit to_stopped_by_watchpoint. */
617 /* Do not inherit to_watchpoint_addr_within_range. */
618 /* Do not inherit to_region_ok_for_hw_watchpoint. */
619 /* Do not inherit to_can_accel_watchpoint_condition. */
620 /* Do not inherit to_masked_watch_num_registers. */
621 /* Do not inherit to_terminal_init. */
622 /* Do not inherit to_terminal_inferior. */
623 /* Do not inherit to_terminal_ours_for_output. */
624 /* Do not inherit to_terminal_ours. */
625 /* Do not inherit to_terminal_save_ours. */
626 /* Do not inherit to_terminal_info. */
627 /* Do not inherit to_kill. */
628 /* Do not inherit to_load. */
629 /* Do no inherit to_create_inferior. */
630 /* Do not inherit to_post_startup_inferior. */
631 /* Do not inherit to_insert_fork_catchpoint. */
632 /* Do not inherit to_remove_fork_catchpoint. */
633 /* Do not inherit to_insert_vfork_catchpoint. */
634 /* Do not inherit to_remove_vfork_catchpoint. */
635 /* Do not inherit to_follow_fork. */
636 /* Do not inherit to_insert_exec_catchpoint. */
637 /* Do not inherit to_remove_exec_catchpoint. */
638 /* Do not inherit to_set_syscall_catchpoint. */
639 /* Do not inherit to_has_exited. */
640 /* Do not inherit to_mourn_inferior. */
641 INHERIT (to_can_run
, t
);
642 /* Do not inherit to_pass_signals. */
643 /* Do not inherit to_program_signals. */
644 /* Do not inherit to_thread_alive. */
645 /* Do not inherit to_find_new_threads. */
646 /* Do not inherit to_pid_to_str. */
647 /* Do not inherit to_extra_thread_info. */
648 /* Do not inherit to_thread_name. */
649 INHERIT (to_stop
, t
);
650 /* Do not inherit to_xfer_partial. */
651 /* Do not inherit to_rcmd. */
652 /* Do not inherit to_pid_to_exec_file. */
653 INHERIT (to_log_command
, t
);
654 INHERIT (to_stratum
, t
);
655 /* Do not inherit to_has_all_memory. */
656 /* Do not inherit to_has_memory. */
657 /* Do not inherit to_has_stack. */
658 /* Do not inherit to_has_registers. */
659 /* Do not inherit to_has_execution. */
660 INHERIT (to_has_thread_control
, t
);
661 /* Do not inherit to_can_async_p. */
662 /* Do not inherit to_is_async_p. */
663 /* Do not inherit to_async. */
664 INHERIT (to_find_memory_regions
, t
);
665 INHERIT (to_make_corefile_notes
, t
);
666 INHERIT (to_get_bookmark
, t
);
667 INHERIT (to_goto_bookmark
, t
);
668 /* Do not inherit to_get_thread_local_address. */
669 INHERIT (to_can_execute_reverse
, t
);
670 INHERIT (to_execution_direction
, t
);
671 INHERIT (to_thread_architecture
, t
);
672 /* Do not inherit to_read_description. */
673 INHERIT (to_get_ada_task_ptid
, t
);
674 /* Do not inherit to_search_memory. */
675 INHERIT (to_supports_multi_process
, t
);
676 INHERIT (to_supports_enable_disable_tracepoint
, t
);
677 INHERIT (to_supports_string_tracing
, t
);
678 INHERIT (to_trace_init
, t
);
679 INHERIT (to_download_tracepoint
, t
);
680 INHERIT (to_can_download_tracepoint
, t
);
681 INHERIT (to_download_trace_state_variable
, t
);
682 INHERIT (to_enable_tracepoint
, t
);
683 INHERIT (to_disable_tracepoint
, t
);
684 INHERIT (to_trace_set_readonly_regions
, t
);
685 INHERIT (to_trace_start
, t
);
686 INHERIT (to_get_trace_status
, t
);
687 INHERIT (to_get_tracepoint_status
, t
);
688 INHERIT (to_trace_stop
, t
);
689 INHERIT (to_trace_find
, t
);
690 INHERIT (to_get_trace_state_variable_value
, t
);
691 INHERIT (to_save_trace_data
, t
);
692 INHERIT (to_upload_tracepoints
, t
);
693 INHERIT (to_upload_trace_state_variables
, t
);
694 INHERIT (to_get_raw_trace_data
, t
);
695 INHERIT (to_get_min_fast_tracepoint_insn_len
, t
);
696 INHERIT (to_set_disconnected_tracing
, t
);
697 INHERIT (to_set_circular_trace_buffer
, t
);
698 INHERIT (to_set_trace_buffer_size
, t
);
699 INHERIT (to_set_trace_notes
, t
);
700 INHERIT (to_get_tib_address
, t
);
701 INHERIT (to_set_permissions
, t
);
702 INHERIT (to_static_tracepoint_marker_at
, t
);
703 INHERIT (to_static_tracepoint_markers_by_strid
, t
);
704 INHERIT (to_traceframe_info
, t
);
705 INHERIT (to_use_agent
, t
);
706 INHERIT (to_can_use_agent
, t
);
707 INHERIT (to_augmented_libraries_svr4_read
, t
);
708 INHERIT (to_magic
, t
);
709 INHERIT (to_supports_evaluation_of_breakpoint_conditions
, t
);
710 INHERIT (to_can_run_breakpoint_commands
, t
);
711 /* Do not inherit to_memory_map. */
712 /* Do not inherit to_flash_erase. */
713 /* Do not inherit to_flash_done. */
717 /* Clean up a target struct so it no longer has any zero pointers in
718 it. Some entries are defaulted to a method that print an error,
719 others are hard-wired to a standard recursive default. */
721 #define de_fault(field, value) \
722 if (!current_target.field) \
723 current_target.field = value
726 (void (*) (char *, int))
729 (void (*) (struct target_ops
*))
731 de_fault (deprecated_xfer_memory
,
732 (int (*) (CORE_ADDR
, gdb_byte
*, int, int,
733 struct mem_attrib
*, struct target_ops
*))
735 de_fault (to_can_run
,
736 (int (*) (struct target_ops
*))
739 (void (*) (struct target_ops
*, ptid_t
))
741 de_fault (to_thread_architecture
,
742 default_thread_architecture
);
743 current_target
.to_read_description
= NULL
;
744 de_fault (to_get_ada_task_ptid
,
745 (ptid_t (*) (struct target_ops
*, long, long))
746 default_get_ada_task_ptid
);
747 de_fault (to_supports_multi_process
,
748 (int (*) (struct target_ops
*))
750 de_fault (to_supports_enable_disable_tracepoint
,
751 (int (*) (struct target_ops
*))
753 de_fault (to_supports_string_tracing
,
754 (int (*) (struct target_ops
*))
756 de_fault (to_trace_init
,
757 (void (*) (struct target_ops
*))
759 de_fault (to_download_tracepoint
,
760 (void (*) (struct target_ops
*, struct bp_location
*))
762 de_fault (to_can_download_tracepoint
,
763 (int (*) (struct target_ops
*))
765 de_fault (to_download_trace_state_variable
,
766 (void (*) (struct target_ops
*, struct trace_state_variable
*))
768 de_fault (to_enable_tracepoint
,
769 (void (*) (struct target_ops
*, struct bp_location
*))
771 de_fault (to_disable_tracepoint
,
772 (void (*) (struct target_ops
*, struct bp_location
*))
774 de_fault (to_trace_set_readonly_regions
,
775 (void (*) (struct target_ops
*))
777 de_fault (to_trace_start
,
778 (void (*) (struct target_ops
*))
780 de_fault (to_get_trace_status
,
781 (int (*) (struct target_ops
*, struct trace_status
*))
783 de_fault (to_get_tracepoint_status
,
784 (void (*) (struct target_ops
*, struct breakpoint
*,
785 struct uploaded_tp
*))
787 de_fault (to_trace_stop
,
788 (void (*) (struct target_ops
*))
790 de_fault (to_trace_find
,
791 (int (*) (struct target_ops
*,
792 enum trace_find_type
, int, CORE_ADDR
, CORE_ADDR
, int *))
794 de_fault (to_get_trace_state_variable_value
,
795 (int (*) (struct target_ops
*, int, LONGEST
*))
797 de_fault (to_save_trace_data
,
798 (int (*) (struct target_ops
*, const char *))
800 de_fault (to_upload_tracepoints
,
801 (int (*) (struct target_ops
*, struct uploaded_tp
**))
803 de_fault (to_upload_trace_state_variables
,
804 (int (*) (struct target_ops
*, struct uploaded_tsv
**))
806 de_fault (to_get_raw_trace_data
,
807 (LONGEST (*) (struct target_ops
*, gdb_byte
*, ULONGEST
, LONGEST
))
809 de_fault (to_get_min_fast_tracepoint_insn_len
,
810 (int (*) (struct target_ops
*))
812 de_fault (to_set_disconnected_tracing
,
813 (void (*) (struct target_ops
*, int))
815 de_fault (to_set_circular_trace_buffer
,
816 (void (*) (struct target_ops
*, int))
818 de_fault (to_set_trace_buffer_size
,
819 (void (*) (struct target_ops
*, LONGEST
))
821 de_fault (to_set_trace_notes
,
822 (int (*) (struct target_ops
*,
823 const char *, const char *, const char *))
825 de_fault (to_get_tib_address
,
826 (int (*) (struct target_ops
*, ptid_t
, CORE_ADDR
*))
828 de_fault (to_set_permissions
,
829 (void (*) (struct target_ops
*))
831 de_fault (to_static_tracepoint_marker_at
,
832 (int (*) (struct target_ops
*,
833 CORE_ADDR
, struct static_tracepoint_marker
*))
835 de_fault (to_static_tracepoint_markers_by_strid
,
836 (VEC(static_tracepoint_marker_p
) * (*) (struct target_ops
*,
839 de_fault (to_traceframe_info
,
840 (struct traceframe_info
* (*) (struct target_ops
*))
842 de_fault (to_supports_evaluation_of_breakpoint_conditions
,
843 (int (*) (struct target_ops
*))
845 de_fault (to_can_run_breakpoint_commands
,
846 (int (*) (struct target_ops
*))
848 de_fault (to_use_agent
,
849 (int (*) (struct target_ops
*, int))
851 de_fault (to_can_use_agent
,
852 (int (*) (struct target_ops
*))
854 de_fault (to_augmented_libraries_svr4_read
,
855 (int (*) (struct target_ops
*))
857 de_fault (to_execution_direction
, default_execution_direction
);
861 /* Finally, position the target-stack beneath the squashed
862 "current_target". That way code looking for a non-inherited
863 target method can quickly and simply find it. */
864 current_target
.beneath
= target_stack
;
867 setup_target_debug ();
870 /* Push a new target type into the stack of the existing target accessors,
871 possibly superseding some of the existing accessors.
873 Rather than allow an empty stack, we always have the dummy target at
874 the bottom stratum, so we can call the function vectors without
878 push_target (struct target_ops
*t
)
880 struct target_ops
**cur
;
882 /* Check magic number. If wrong, it probably means someone changed
883 the struct definition, but not all the places that initialize one. */
884 if (t
->to_magic
!= OPS_MAGIC
)
886 fprintf_unfiltered (gdb_stderr
,
887 "Magic number of %s target struct wrong\n",
889 internal_error (__FILE__
, __LINE__
,
890 _("failed internal consistency check"));
893 /* Find the proper stratum to install this target in. */
894 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
896 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
900 /* If there's already targets at this stratum, remove them. */
901 /* FIXME: cagney/2003-10-15: I think this should be popping all
902 targets to CUR, and not just those at this stratum level. */
903 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
905 /* There's already something at this stratum level. Close it,
906 and un-hook it from the stack. */
907 struct target_ops
*tmp
= (*cur
);
909 (*cur
) = (*cur
)->beneath
;
914 /* We have removed all targets in our stratum, now add the new one. */
918 update_current_target ();
921 /* Remove a target_ops vector from the stack, wherever it may be.
922 Return how many times it was removed (0 or 1). */
925 unpush_target (struct target_ops
*t
)
927 struct target_ops
**cur
;
928 struct target_ops
*tmp
;
930 if (t
->to_stratum
== dummy_stratum
)
931 internal_error (__FILE__
, __LINE__
,
932 _("Attempt to unpush the dummy target"));
934 /* Look for the specified target. Note that we assume that a target
935 can only occur once in the target stack. */
937 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
943 /* If we don't find target_ops, quit. Only open targets should be
948 /* Unchain the target. */
950 (*cur
) = (*cur
)->beneath
;
953 update_current_target ();
955 /* Finally close the target. Note we do this after unchaining, so
956 any target method calls from within the target_close
957 implementation don't end up in T anymore. */
964 pop_all_targets_above (enum strata above_stratum
)
966 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
968 if (!unpush_target (target_stack
))
970 fprintf_unfiltered (gdb_stderr
,
971 "pop_all_targets couldn't find target %s\n",
972 target_stack
->to_shortname
);
973 internal_error (__FILE__
, __LINE__
,
974 _("failed internal consistency check"));
981 pop_all_targets (void)
983 pop_all_targets_above (dummy_stratum
);
986 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
989 target_is_pushed (struct target_ops
*t
)
991 struct target_ops
**cur
;
993 /* Check magic number. If wrong, it probably means someone changed
994 the struct definition, but not all the places that initialize one. */
995 if (t
->to_magic
!= OPS_MAGIC
)
997 fprintf_unfiltered (gdb_stderr
,
998 "Magic number of %s target struct wrong\n",
1000 internal_error (__FILE__
, __LINE__
,
1001 _("failed internal consistency check"));
1004 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1011 /* Using the objfile specified in OBJFILE, find the address for the
1012 current thread's thread-local storage with offset OFFSET. */
1014 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
1016 volatile CORE_ADDR addr
= 0;
1017 struct target_ops
*target
;
1019 for (target
= current_target
.beneath
;
1021 target
= target
->beneath
)
1023 if (target
->to_get_thread_local_address
!= NULL
)
1028 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
1030 ptid_t ptid
= inferior_ptid
;
1031 volatile struct gdb_exception ex
;
1033 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1037 /* Fetch the load module address for this objfile. */
1038 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch (),
1040 /* If it's 0, throw the appropriate exception. */
1042 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
1043 _("TLS load module not found"));
1045 addr
= target
->to_get_thread_local_address (target
, ptid
,
1048 /* If an error occurred, print TLS related messages here. Otherwise,
1049 throw the error to some higher catcher. */
1052 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1056 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
1057 error (_("Cannot find thread-local variables "
1058 "in this thread library."));
1060 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
1061 if (objfile_is_library
)
1062 error (_("Cannot find shared library `%s' in dynamic"
1063 " linker's load module list"), objfile_name (objfile
));
1065 error (_("Cannot find executable file `%s' in dynamic"
1066 " linker's load module list"), objfile_name (objfile
));
1068 case TLS_NOT_ALLOCATED_YET_ERROR
:
1069 if (objfile_is_library
)
1070 error (_("The inferior has not yet allocated storage for"
1071 " thread-local variables in\n"
1072 "the shared library `%s'\n"
1074 objfile_name (objfile
), target_pid_to_str (ptid
));
1076 error (_("The inferior has not yet allocated storage for"
1077 " thread-local variables in\n"
1078 "the executable `%s'\n"
1080 objfile_name (objfile
), target_pid_to_str (ptid
));
1082 case TLS_GENERIC_ERROR
:
1083 if (objfile_is_library
)
1084 error (_("Cannot find thread-local storage for %s, "
1085 "shared library %s:\n%s"),
1086 target_pid_to_str (ptid
),
1087 objfile_name (objfile
), ex
.message
);
1089 error (_("Cannot find thread-local storage for %s, "
1090 "executable file %s:\n%s"),
1091 target_pid_to_str (ptid
),
1092 objfile_name (objfile
), ex
.message
);
1095 throw_exception (ex
);
1100 /* It wouldn't be wrong here to try a gdbarch method, too; finding
1101 TLS is an ABI-specific thing. But we don't do that yet. */
1103 error (_("Cannot find thread-local variables on this target"));
1109 target_xfer_status_to_string (enum target_xfer_status err
)
1111 #define CASE(X) case X: return #X
1114 CASE(TARGET_XFER_E_IO
);
1115 CASE(TARGET_XFER_E_UNAVAILABLE
);
1124 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1126 /* target_read_string -- read a null terminated string, up to LEN bytes,
1127 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1128 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1129 is responsible for freeing it. Return the number of bytes successfully
1133 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
1135 int tlen
, offset
, i
;
1139 int buffer_allocated
;
1141 unsigned int nbytes_read
= 0;
1143 gdb_assert (string
);
1145 /* Small for testing. */
1146 buffer_allocated
= 4;
1147 buffer
= xmalloc (buffer_allocated
);
1152 tlen
= MIN (len
, 4 - (memaddr
& 3));
1153 offset
= memaddr
& 3;
1155 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
1158 /* The transfer request might have crossed the boundary to an
1159 unallocated region of memory. Retry the transfer, requesting
1163 errcode
= target_read_memory (memaddr
, buf
, 1);
1168 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
1172 bytes
= bufptr
- buffer
;
1173 buffer_allocated
*= 2;
1174 buffer
= xrealloc (buffer
, buffer_allocated
);
1175 bufptr
= buffer
+ bytes
;
1178 for (i
= 0; i
< tlen
; i
++)
1180 *bufptr
++ = buf
[i
+ offset
];
1181 if (buf
[i
+ offset
] == '\000')
1183 nbytes_read
+= i
+ 1;
1190 nbytes_read
+= tlen
;
1199 struct target_section_table
*
1200 target_get_section_table (struct target_ops
*target
)
1202 struct target_ops
*t
;
1205 fprintf_unfiltered (gdb_stdlog
, "target_get_section_table ()\n");
1207 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1208 if (t
->to_get_section_table
!= NULL
)
1209 return (*t
->to_get_section_table
) (t
);
1214 /* Find a section containing ADDR. */
1216 struct target_section
*
1217 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1219 struct target_section_table
*table
= target_get_section_table (target
);
1220 struct target_section
*secp
;
1225 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
1227 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1233 /* Read memory from the live target, even if currently inspecting a
1234 traceframe. The return is the same as that of target_read. */
1236 static enum target_xfer_status
1237 target_read_live_memory (enum target_object object
,
1238 ULONGEST memaddr
, gdb_byte
*myaddr
, ULONGEST len
,
1239 ULONGEST
*xfered_len
)
1241 enum target_xfer_status ret
;
1242 struct cleanup
*cleanup
;
1244 /* Switch momentarily out of tfind mode so to access live memory.
1245 Note that this must not clear global state, such as the frame
1246 cache, which must still remain valid for the previous traceframe.
1247 We may be _building_ the frame cache at this point. */
1248 cleanup
= make_cleanup_restore_traceframe_number ();
1249 set_traceframe_number (-1);
1251 ret
= target_xfer_partial (current_target
.beneath
, object
, NULL
,
1252 myaddr
, NULL
, memaddr
, len
, xfered_len
);
1254 do_cleanups (cleanup
);
1258 /* Using the set of read-only target sections of OPS, read live
1259 read-only memory. Note that the actual reads start from the
1260 top-most target again.
1262 For interface/parameters/return description see target.h,
1265 static enum target_xfer_status
1266 memory_xfer_live_readonly_partial (struct target_ops
*ops
,
1267 enum target_object object
,
1268 gdb_byte
*readbuf
, ULONGEST memaddr
,
1269 ULONGEST len
, ULONGEST
*xfered_len
)
1271 struct target_section
*secp
;
1272 struct target_section_table
*table
;
1274 secp
= target_section_by_addr (ops
, memaddr
);
1276 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1277 secp
->the_bfd_section
)
1280 struct target_section
*p
;
1281 ULONGEST memend
= memaddr
+ len
;
1283 table
= target_get_section_table (ops
);
1285 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1287 if (memaddr
>= p
->addr
)
1289 if (memend
<= p
->endaddr
)
1291 /* Entire transfer is within this section. */
1292 return target_read_live_memory (object
, memaddr
,
1293 readbuf
, len
, xfered_len
);
1295 else if (memaddr
>= p
->endaddr
)
1297 /* This section ends before the transfer starts. */
1302 /* This section overlaps the transfer. Just do half. */
1303 len
= p
->endaddr
- memaddr
;
1304 return target_read_live_memory (object
, memaddr
,
1305 readbuf
, len
, xfered_len
);
1311 return TARGET_XFER_EOF
;
1314 /* Read memory from more than one valid target. A core file, for
1315 instance, could have some of memory but delegate other bits to
1316 the target below it. So, we must manually try all targets. */
1318 static enum target_xfer_status
1319 raw_memory_xfer_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
1320 const gdb_byte
*writebuf
, ULONGEST memaddr
, LONGEST len
,
1321 ULONGEST
*xfered_len
)
1323 enum target_xfer_status res
;
1327 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1328 readbuf
, writebuf
, memaddr
, len
,
1330 if (res
== TARGET_XFER_OK
)
1333 /* Stop if the target reports that the memory is not available. */
1334 if (res
== TARGET_XFER_E_UNAVAILABLE
)
1337 /* We want to continue past core files to executables, but not
1338 past a running target's memory. */
1339 if (ops
->to_has_all_memory (ops
))
1344 while (ops
!= NULL
);
1349 /* Perform a partial memory transfer.
1350 For docs see target.h, to_xfer_partial. */
1352 static enum target_xfer_status
1353 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
1354 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
1355 ULONGEST len
, ULONGEST
*xfered_len
)
1357 enum target_xfer_status res
;
1359 struct mem_region
*region
;
1360 struct inferior
*inf
;
1362 /* For accesses to unmapped overlay sections, read directly from
1363 files. Must do this first, as MEMADDR may need adjustment. */
1364 if (readbuf
!= NULL
&& overlay_debugging
)
1366 struct obj_section
*section
= find_pc_overlay (memaddr
);
1368 if (pc_in_unmapped_range (memaddr
, section
))
1370 struct target_section_table
*table
1371 = target_get_section_table (ops
);
1372 const char *section_name
= section
->the_bfd_section
->name
;
1374 memaddr
= overlay_mapped_address (memaddr
, section
);
1375 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1376 memaddr
, len
, xfered_len
,
1378 table
->sections_end
,
1383 /* Try the executable files, if "trust-readonly-sections" is set. */
1384 if (readbuf
!= NULL
&& trust_readonly
)
1386 struct target_section
*secp
;
1387 struct target_section_table
*table
;
1389 secp
= target_section_by_addr (ops
, memaddr
);
1391 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1392 secp
->the_bfd_section
)
1395 table
= target_get_section_table (ops
);
1396 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1397 memaddr
, len
, xfered_len
,
1399 table
->sections_end
,
1404 /* If reading unavailable memory in the context of traceframes, and
1405 this address falls within a read-only section, fallback to
1406 reading from live memory. */
1407 if (readbuf
!= NULL
&& get_traceframe_number () != -1)
1409 VEC(mem_range_s
) *available
;
1411 /* If we fail to get the set of available memory, then the
1412 target does not support querying traceframe info, and so we
1413 attempt reading from the traceframe anyway (assuming the
1414 target implements the old QTro packet then). */
1415 if (traceframe_available_memory (&available
, memaddr
, len
))
1417 struct cleanup
*old_chain
;
1419 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
1421 if (VEC_empty (mem_range_s
, available
)
1422 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
1424 /* Don't read into the traceframe's available
1426 if (!VEC_empty (mem_range_s
, available
))
1428 LONGEST oldlen
= len
;
1430 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
1431 gdb_assert (len
<= oldlen
);
1434 do_cleanups (old_chain
);
1436 /* This goes through the topmost target again. */
1437 res
= memory_xfer_live_readonly_partial (ops
, object
,
1440 if (res
== TARGET_XFER_OK
)
1441 return TARGET_XFER_OK
;
1444 /* No use trying further, we know some memory starting
1445 at MEMADDR isn't available. */
1447 return TARGET_XFER_E_UNAVAILABLE
;
1451 /* Don't try to read more than how much is available, in
1452 case the target implements the deprecated QTro packet to
1453 cater for older GDBs (the target's knowledge of read-only
1454 sections may be outdated by now). */
1455 len
= VEC_index (mem_range_s
, available
, 0)->length
;
1457 do_cleanups (old_chain
);
1461 /* Try GDB's internal data cache. */
1462 region
= lookup_mem_region (memaddr
);
1463 /* region->hi == 0 means there's no upper bound. */
1464 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1467 reg_len
= region
->hi
- memaddr
;
1469 switch (region
->attrib
.mode
)
1472 if (writebuf
!= NULL
)
1473 return TARGET_XFER_E_IO
;
1477 if (readbuf
!= NULL
)
1478 return TARGET_XFER_E_IO
;
1482 /* We only support writing to flash during "load" for now. */
1483 if (writebuf
!= NULL
)
1484 error (_("Writing to flash memory forbidden in this context"));
1488 return TARGET_XFER_E_IO
;
1491 if (!ptid_equal (inferior_ptid
, null_ptid
))
1492 inf
= find_inferior_pid (ptid_get_pid (inferior_ptid
));
1497 /* The dcache reads whole cache lines; that doesn't play well
1498 with reading from a trace buffer, because reading outside of
1499 the collected memory range fails. */
1500 && get_traceframe_number () == -1
1501 && (region
->attrib
.cache
1502 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1503 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1505 DCACHE
*dcache
= target_dcache_get_or_init ();
1508 if (readbuf
!= NULL
)
1509 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, readbuf
, reg_len
, 0);
1511 /* FIXME drow/2006-08-09: If we're going to preserve const
1512 correctness dcache_xfer_memory should take readbuf and
1514 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, (void *) writebuf
,
1517 return TARGET_XFER_E_IO
;
1520 *xfered_len
= (ULONGEST
) l
;
1521 return TARGET_XFER_OK
;
1525 /* If none of those methods found the memory we wanted, fall back
1526 to a target partial transfer. Normally a single call to
1527 to_xfer_partial is enough; if it doesn't recognize an object
1528 it will call the to_xfer_partial of the next target down.
1529 But for memory this won't do. Memory is the only target
1530 object which can be read from more than one valid target.
1531 A core file, for instance, could have some of memory but
1532 delegate other bits to the target below it. So, we must
1533 manually try all targets. */
1535 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
,
1538 /* Make sure the cache gets updated no matter what - if we are writing
1539 to the stack. Even if this write is not tagged as such, we still need
1540 to update the cache. */
1542 if (res
== TARGET_XFER_OK
1545 && target_dcache_init_p ()
1546 && !region
->attrib
.cache
1547 && ((stack_cache_enabled_p () && object
!= TARGET_OBJECT_STACK_MEMORY
)
1548 || (code_cache_enabled_p () && object
!= TARGET_OBJECT_CODE_MEMORY
)))
1550 DCACHE
*dcache
= target_dcache_get ();
1552 dcache_update (dcache
, memaddr
, (void *) writebuf
, reg_len
);
1555 /* If we still haven't got anything, return the last error. We
1560 /* Perform a partial memory transfer. For docs see target.h,
1563 static enum target_xfer_status
1564 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1565 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1566 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1568 enum target_xfer_status res
;
1570 /* Zero length requests are ok and require no work. */
1572 return TARGET_XFER_EOF
;
1574 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1575 breakpoint insns, thus hiding out from higher layers whether
1576 there are software breakpoints inserted in the code stream. */
1577 if (readbuf
!= NULL
)
1579 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
,
1582 if (res
== TARGET_XFER_OK
&& !show_memory_breakpoints
)
1583 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, res
);
1588 struct cleanup
*old_chain
;
1590 /* A large write request is likely to be partially satisfied
1591 by memory_xfer_partial_1. We will continually malloc
1592 and free a copy of the entire write request for breakpoint
1593 shadow handling even though we only end up writing a small
1594 subset of it. Cap writes to 4KB to mitigate this. */
1595 len
= min (4096, len
);
1597 buf
= xmalloc (len
);
1598 old_chain
= make_cleanup (xfree
, buf
);
1599 memcpy (buf
, writebuf
, len
);
1601 breakpoint_xfer_memory (NULL
, buf
, writebuf
, memaddr
, len
);
1602 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
, memaddr
, len
,
1605 do_cleanups (old_chain
);
1612 restore_show_memory_breakpoints (void *arg
)
1614 show_memory_breakpoints
= (uintptr_t) arg
;
1618 make_show_memory_breakpoints_cleanup (int show
)
1620 int current
= show_memory_breakpoints
;
1622 show_memory_breakpoints
= show
;
1623 return make_cleanup (restore_show_memory_breakpoints
,
1624 (void *) (uintptr_t) current
);
1627 /* For docs see target.h, to_xfer_partial. */
1629 enum target_xfer_status
1630 target_xfer_partial (struct target_ops
*ops
,
1631 enum target_object object
, const char *annex
,
1632 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1633 ULONGEST offset
, ULONGEST len
,
1634 ULONGEST
*xfered_len
)
1636 enum target_xfer_status retval
;
1638 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1640 /* Transfer is done when LEN is zero. */
1642 return TARGET_XFER_EOF
;
1644 if (writebuf
&& !may_write_memory
)
1645 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1646 core_addr_to_string_nz (offset
), plongest (len
));
1650 /* If this is a memory transfer, let the memory-specific code
1651 have a look at it instead. Memory transfers are more
1653 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1654 || object
== TARGET_OBJECT_CODE_MEMORY
)
1655 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1656 writebuf
, offset
, len
, xfered_len
);
1657 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1659 /* Request the normal memory object from other layers. */
1660 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
,
1664 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
,
1665 writebuf
, offset
, len
, xfered_len
);
1669 const unsigned char *myaddr
= NULL
;
1671 fprintf_unfiltered (gdb_stdlog
,
1672 "%s:target_xfer_partial "
1673 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1676 (annex
? annex
: "(null)"),
1677 host_address_to_string (readbuf
),
1678 host_address_to_string (writebuf
),
1679 core_addr_to_string_nz (offset
),
1680 pulongest (len
), retval
,
1681 pulongest (*xfered_len
));
1687 if (retval
== TARGET_XFER_OK
&& myaddr
!= NULL
)
1691 fputs_unfiltered (", bytes =", gdb_stdlog
);
1692 for (i
= 0; i
< *xfered_len
; i
++)
1694 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1696 if (targetdebug
< 2 && i
> 0)
1698 fprintf_unfiltered (gdb_stdlog
, " ...");
1701 fprintf_unfiltered (gdb_stdlog
, "\n");
1704 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1708 fputc_unfiltered ('\n', gdb_stdlog
);
1711 /* Check implementations of to_xfer_partial update *XFERED_LEN
1712 properly. Do assertion after printing debug messages, so that we
1713 can find more clues on assertion failure from debugging messages. */
1714 if (retval
== TARGET_XFER_OK
|| retval
== TARGET_XFER_E_UNAVAILABLE
)
1715 gdb_assert (*xfered_len
> 0);
1720 /* Read LEN bytes of target memory at address MEMADDR, placing the
1721 results in GDB's memory at MYADDR. Returns either 0 for success or
1722 TARGET_XFER_E_IO if any error occurs.
1724 If an error occurs, no guarantee is made about the contents of the data at
1725 MYADDR. In particular, the caller should not depend upon partial reads
1726 filling the buffer with good data. There is no way for the caller to know
1727 how much good data might have been transfered anyway. Callers that can
1728 deal with partial reads should call target_read (which will retry until
1729 it makes no progress, and then return how much was transferred). */
1732 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1734 /* Dispatch to the topmost target, not the flattened current_target.
1735 Memory accesses check target->to_has_(all_)memory, and the
1736 flattened target doesn't inherit those. */
1737 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1738 myaddr
, memaddr
, len
) == len
)
1741 return TARGET_XFER_E_IO
;
1744 /* Like target_read_memory, but specify explicitly that this is a read
1745 from the target's raw memory. That is, this read bypasses the
1746 dcache, breakpoint shadowing, etc. */
1749 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1751 /* See comment in target_read_memory about why the request starts at
1752 current_target.beneath. */
1753 if (target_read (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1754 myaddr
, memaddr
, len
) == len
)
1757 return TARGET_XFER_E_IO
;
1760 /* Like target_read_memory, but specify explicitly that this is a read from
1761 the target's stack. This may trigger different cache behavior. */
1764 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1766 /* See comment in target_read_memory about why the request starts at
1767 current_target.beneath. */
1768 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1769 myaddr
, memaddr
, len
) == len
)
1772 return TARGET_XFER_E_IO
;
1775 /* Like target_read_memory, but specify explicitly that this is a read from
1776 the target's code. This may trigger different cache behavior. */
1779 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1781 /* See comment in target_read_memory about why the request starts at
1782 current_target.beneath. */
1783 if (target_read (current_target
.beneath
, TARGET_OBJECT_CODE_MEMORY
, NULL
,
1784 myaddr
, memaddr
, len
) == len
)
1787 return TARGET_XFER_E_IO
;
1790 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1791 Returns either 0 for success or TARGET_XFER_E_IO if any
1792 error occurs. If an error occurs, no guarantee is made about how
1793 much data got written. Callers that can deal with partial writes
1794 should call target_write. */
1797 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1799 /* See comment in target_read_memory about why the request starts at
1800 current_target.beneath. */
1801 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1802 myaddr
, memaddr
, len
) == len
)
1805 return TARGET_XFER_E_IO
;
1808 /* Write LEN bytes from MYADDR to target raw memory at address
1809 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1810 if any error occurs. If an error occurs, no guarantee is made
1811 about how much data got written. Callers that can deal with
1812 partial writes should call target_write. */
1815 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1817 /* See comment in target_read_memory about why the request starts at
1818 current_target.beneath. */
1819 if (target_write (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1820 myaddr
, memaddr
, len
) == len
)
1823 return TARGET_XFER_E_IO
;
1826 /* Fetch the target's memory map. */
1829 target_memory_map (void)
1831 VEC(mem_region_s
) *result
;
1832 struct mem_region
*last_one
, *this_one
;
1834 struct target_ops
*t
;
1837 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1839 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1840 if (t
->to_memory_map
!= NULL
)
1846 result
= t
->to_memory_map (t
);
1850 qsort (VEC_address (mem_region_s
, result
),
1851 VEC_length (mem_region_s
, result
),
1852 sizeof (struct mem_region
), mem_region_cmp
);
1854 /* Check that regions do not overlap. Simultaneously assign
1855 a numbering for the "mem" commands to use to refer to
1858 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1860 this_one
->number
= ix
;
1862 if (last_one
&& last_one
->hi
> this_one
->lo
)
1864 warning (_("Overlapping regions in memory map: ignoring"));
1865 VEC_free (mem_region_s
, result
);
1868 last_one
= this_one
;
1875 target_flash_erase (ULONGEST address
, LONGEST length
)
1877 struct target_ops
*t
;
1879 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1880 if (t
->to_flash_erase
!= NULL
)
1883 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1884 hex_string (address
), phex (length
, 0));
1885 t
->to_flash_erase (t
, address
, length
);
1893 target_flash_done (void)
1895 struct target_ops
*t
;
1897 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1898 if (t
->to_flash_done
!= NULL
)
1901 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1902 t
->to_flash_done (t
);
1910 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1911 struct cmd_list_element
*c
, const char *value
)
1913 fprintf_filtered (file
,
1914 _("Mode for reading from readonly sections is %s.\n"),
1918 /* More generic transfers. */
1920 static enum target_xfer_status
1921 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1922 const char *annex
, gdb_byte
*readbuf
,
1923 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
1924 ULONGEST
*xfered_len
)
1926 if (object
== TARGET_OBJECT_MEMORY
1927 && ops
->deprecated_xfer_memory
!= NULL
)
1928 /* If available, fall back to the target's
1929 "deprecated_xfer_memory" method. */
1934 if (writebuf
!= NULL
)
1936 void *buffer
= xmalloc (len
);
1937 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1939 memcpy (buffer
, writebuf
, len
);
1940 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1941 1/*write*/, NULL
, ops
);
1942 do_cleanups (cleanup
);
1944 if (readbuf
!= NULL
)
1945 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1946 0/*read*/, NULL
, ops
);
1949 *xfered_len
= (ULONGEST
) xfered
;
1950 return TARGET_XFER_E_IO
;
1952 else if (xfered
== 0 && errno
== 0)
1953 /* "deprecated_xfer_memory" uses 0, cross checked against
1954 ERRNO as one indication of an error. */
1955 return TARGET_XFER_EOF
;
1957 return TARGET_XFER_E_IO
;
1961 gdb_assert (ops
->beneath
!= NULL
);
1962 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1963 readbuf
, writebuf
, offset
, len
,
1968 /* Target vector read/write partial wrapper functions. */
1970 static enum target_xfer_status
1971 target_read_partial (struct target_ops
*ops
,
1972 enum target_object object
,
1973 const char *annex
, gdb_byte
*buf
,
1974 ULONGEST offset
, ULONGEST len
,
1975 ULONGEST
*xfered_len
)
1977 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
,
1981 static enum target_xfer_status
1982 target_write_partial (struct target_ops
*ops
,
1983 enum target_object object
,
1984 const char *annex
, const gdb_byte
*buf
,
1985 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
1987 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
,
1991 /* Wrappers to perform the full transfer. */
1993 /* For docs on target_read see target.h. */
1996 target_read (struct target_ops
*ops
,
1997 enum target_object object
,
1998 const char *annex
, gdb_byte
*buf
,
1999 ULONGEST offset
, LONGEST len
)
2003 while (xfered
< len
)
2005 ULONGEST xfered_len
;
2006 enum target_xfer_status status
;
2008 status
= target_read_partial (ops
, object
, annex
,
2009 (gdb_byte
*) buf
+ xfered
,
2010 offset
+ xfered
, len
- xfered
,
2013 /* Call an observer, notifying them of the xfer progress? */
2014 if (status
== TARGET_XFER_EOF
)
2016 else if (status
== TARGET_XFER_OK
)
2018 xfered
+= xfered_len
;
2028 /* Assuming that the entire [begin, end) range of memory cannot be
2029 read, try to read whatever subrange is possible to read.
2031 The function returns, in RESULT, either zero or one memory block.
2032 If there's a readable subrange at the beginning, it is completely
2033 read and returned. Any further readable subrange will not be read.
2034 Otherwise, if there's a readable subrange at the end, it will be
2035 completely read and returned. Any readable subranges before it
2036 (obviously, not starting at the beginning), will be ignored. In
2037 other cases -- either no readable subrange, or readable subrange(s)
2038 that is neither at the beginning, or end, nothing is returned.
2040 The purpose of this function is to handle a read across a boundary
2041 of accessible memory in a case when memory map is not available.
2042 The above restrictions are fine for this case, but will give
2043 incorrect results if the memory is 'patchy'. However, supporting
2044 'patchy' memory would require trying to read every single byte,
2045 and it seems unacceptable solution. Explicit memory map is
2046 recommended for this case -- and target_read_memory_robust will
2047 take care of reading multiple ranges then. */
2050 read_whatever_is_readable (struct target_ops
*ops
,
2051 ULONGEST begin
, ULONGEST end
,
2052 VEC(memory_read_result_s
) **result
)
2054 gdb_byte
*buf
= xmalloc (end
- begin
);
2055 ULONGEST current_begin
= begin
;
2056 ULONGEST current_end
= end
;
2058 memory_read_result_s r
;
2059 ULONGEST xfered_len
;
2061 /* If we previously failed to read 1 byte, nothing can be done here. */
2062 if (end
- begin
<= 1)
2068 /* Check that either first or the last byte is readable, and give up
2069 if not. This heuristic is meant to permit reading accessible memory
2070 at the boundary of accessible region. */
2071 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2072 buf
, begin
, 1, &xfered_len
) == TARGET_XFER_OK
)
2077 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2078 buf
+ (end
-begin
) - 1, end
- 1, 1,
2079 &xfered_len
) == TARGET_XFER_OK
)
2090 /* Loop invariant is that the [current_begin, current_end) was previously
2091 found to be not readable as a whole.
2093 Note loop condition -- if the range has 1 byte, we can't divide the range
2094 so there's no point trying further. */
2095 while (current_end
- current_begin
> 1)
2097 ULONGEST first_half_begin
, first_half_end
;
2098 ULONGEST second_half_begin
, second_half_end
;
2100 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
2104 first_half_begin
= current_begin
;
2105 first_half_end
= middle
;
2106 second_half_begin
= middle
;
2107 second_half_end
= current_end
;
2111 first_half_begin
= middle
;
2112 first_half_end
= current_end
;
2113 second_half_begin
= current_begin
;
2114 second_half_end
= middle
;
2117 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2118 buf
+ (first_half_begin
- begin
),
2120 first_half_end
- first_half_begin
);
2122 if (xfer
== first_half_end
- first_half_begin
)
2124 /* This half reads up fine. So, the error must be in the
2126 current_begin
= second_half_begin
;
2127 current_end
= second_half_end
;
2131 /* This half is not readable. Because we've tried one byte, we
2132 know some part of this half if actually redable. Go to the next
2133 iteration to divide again and try to read.
2135 We don't handle the other half, because this function only tries
2136 to read a single readable subrange. */
2137 current_begin
= first_half_begin
;
2138 current_end
= first_half_end
;
2144 /* The [begin, current_begin) range has been read. */
2146 r
.end
= current_begin
;
2151 /* The [current_end, end) range has been read. */
2152 LONGEST rlen
= end
- current_end
;
2154 r
.data
= xmalloc (rlen
);
2155 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
2156 r
.begin
= current_end
;
2160 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
2164 free_memory_read_result_vector (void *x
)
2166 VEC(memory_read_result_s
) *v
= x
;
2167 memory_read_result_s
*current
;
2170 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
2172 xfree (current
->data
);
2174 VEC_free (memory_read_result_s
, v
);
2177 VEC(memory_read_result_s
) *
2178 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
2180 VEC(memory_read_result_s
) *result
= 0;
2183 while (xfered
< len
)
2185 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
2188 /* If there is no explicit region, a fake one should be created. */
2189 gdb_assert (region
);
2191 if (region
->hi
== 0)
2192 rlen
= len
- xfered
;
2194 rlen
= region
->hi
- offset
;
2196 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
2198 /* Cannot read this region. Note that we can end up here only
2199 if the region is explicitly marked inaccessible, or
2200 'inaccessible-by-default' is in effect. */
2205 LONGEST to_read
= min (len
- xfered
, rlen
);
2206 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
2208 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2209 (gdb_byte
*) buffer
,
2210 offset
+ xfered
, to_read
);
2211 /* Call an observer, notifying them of the xfer progress? */
2214 /* Got an error reading full chunk. See if maybe we can read
2217 read_whatever_is_readable (ops
, offset
+ xfered
,
2218 offset
+ xfered
+ to_read
, &result
);
2223 struct memory_read_result r
;
2225 r
.begin
= offset
+ xfered
;
2226 r
.end
= r
.begin
+ xfer
;
2227 VEC_safe_push (memory_read_result_s
, result
, &r
);
2237 /* An alternative to target_write with progress callbacks. */
2240 target_write_with_progress (struct target_ops
*ops
,
2241 enum target_object object
,
2242 const char *annex
, const gdb_byte
*buf
,
2243 ULONGEST offset
, LONGEST len
,
2244 void (*progress
) (ULONGEST
, void *), void *baton
)
2248 /* Give the progress callback a chance to set up. */
2250 (*progress
) (0, baton
);
2252 while (xfered
< len
)
2254 ULONGEST xfered_len
;
2255 enum target_xfer_status status
;
2257 status
= target_write_partial (ops
, object
, annex
,
2258 (gdb_byte
*) buf
+ xfered
,
2259 offset
+ xfered
, len
- xfered
,
2262 if (status
== TARGET_XFER_EOF
)
2264 if (TARGET_XFER_STATUS_ERROR_P (status
))
2267 gdb_assert (status
== TARGET_XFER_OK
);
2269 (*progress
) (xfered_len
, baton
);
2271 xfered
+= xfered_len
;
2277 /* For docs on target_write see target.h. */
2280 target_write (struct target_ops
*ops
,
2281 enum target_object object
,
2282 const char *annex
, const gdb_byte
*buf
,
2283 ULONGEST offset
, LONGEST len
)
2285 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2289 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2290 the size of the transferred data. PADDING additional bytes are
2291 available in *BUF_P. This is a helper function for
2292 target_read_alloc; see the declaration of that function for more
2296 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2297 const char *annex
, gdb_byte
**buf_p
, int padding
)
2299 size_t buf_alloc
, buf_pos
;
2302 /* This function does not have a length parameter; it reads the
2303 entire OBJECT). Also, it doesn't support objects fetched partly
2304 from one target and partly from another (in a different stratum,
2305 e.g. a core file and an executable). Both reasons make it
2306 unsuitable for reading memory. */
2307 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2309 /* Start by reading up to 4K at a time. The target will throttle
2310 this number down if necessary. */
2312 buf
= xmalloc (buf_alloc
);
2316 ULONGEST xfered_len
;
2317 enum target_xfer_status status
;
2319 status
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2320 buf_pos
, buf_alloc
- buf_pos
- padding
,
2323 if (status
== TARGET_XFER_EOF
)
2325 /* Read all there was. */
2332 else if (status
!= TARGET_XFER_OK
)
2334 /* An error occurred. */
2336 return TARGET_XFER_E_IO
;
2339 buf_pos
+= xfered_len
;
2341 /* If the buffer is filling up, expand it. */
2342 if (buf_alloc
< buf_pos
* 2)
2345 buf
= xrealloc (buf
, buf_alloc
);
2352 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2353 the size of the transferred data. See the declaration in "target.h"
2354 function for more information about the return value. */
2357 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2358 const char *annex
, gdb_byte
**buf_p
)
2360 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2363 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2364 returned as a string, allocated using xmalloc. If an error occurs
2365 or the transfer is unsupported, NULL is returned. Empty objects
2366 are returned as allocated but empty strings. A warning is issued
2367 if the result contains any embedded NUL bytes. */
2370 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2375 LONGEST i
, transferred
;
2377 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2378 bufstr
= (char *) buffer
;
2380 if (transferred
< 0)
2383 if (transferred
== 0)
2384 return xstrdup ("");
2386 bufstr
[transferred
] = 0;
2388 /* Check for embedded NUL bytes; but allow trailing NULs. */
2389 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2392 warning (_("target object %d, annex %s, "
2393 "contained unexpected null characters"),
2394 (int) object
, annex
? annex
: "(none)");
2401 /* Memory transfer methods. */
2404 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2407 /* This method is used to read from an alternate, non-current
2408 target. This read must bypass the overlay support (as symbols
2409 don't match this target), and GDB's internal cache (wrong cache
2410 for this target). */
2411 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2413 memory_error (TARGET_XFER_E_IO
, addr
);
2417 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2418 int len
, enum bfd_endian byte_order
)
2420 gdb_byte buf
[sizeof (ULONGEST
)];
2422 gdb_assert (len
<= sizeof (buf
));
2423 get_target_memory (ops
, addr
, buf
, len
);
2424 return extract_unsigned_integer (buf
, len
, byte_order
);
2430 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2431 struct bp_target_info
*bp_tgt
)
2433 if (!may_insert_breakpoints
)
2435 warning (_("May not insert breakpoints"));
2439 return current_target
.to_insert_breakpoint (¤t_target
,
2446 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2447 struct bp_target_info
*bp_tgt
)
2449 /* This is kind of a weird case to handle, but the permission might
2450 have been changed after breakpoints were inserted - in which case
2451 we should just take the user literally and assume that any
2452 breakpoints should be left in place. */
2453 if (!may_insert_breakpoints
)
2455 warning (_("May not remove breakpoints"));
2459 return current_target
.to_remove_breakpoint (¤t_target
,
2464 target_info (char *args
, int from_tty
)
2466 struct target_ops
*t
;
2467 int has_all_mem
= 0;
2469 if (symfile_objfile
!= NULL
)
2470 printf_unfiltered (_("Symbols from \"%s\".\n"),
2471 objfile_name (symfile_objfile
));
2473 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2475 if (!(*t
->to_has_memory
) (t
))
2478 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2481 printf_unfiltered (_("\tWhile running this, "
2482 "GDB does not access memory from...\n"));
2483 printf_unfiltered ("%s:\n", t
->to_longname
);
2484 (t
->to_files_info
) (t
);
2485 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2489 /* This function is called before any new inferior is created, e.g.
2490 by running a program, attaching, or connecting to a target.
2491 It cleans up any state from previous invocations which might
2492 change between runs. This is a subset of what target_preopen
2493 resets (things which might change between targets). */
2496 target_pre_inferior (int from_tty
)
2498 /* Clear out solib state. Otherwise the solib state of the previous
2499 inferior might have survived and is entirely wrong for the new
2500 target. This has been observed on GNU/Linux using glibc 2.3. How
2512 Cannot access memory at address 0xdeadbeef
2515 /* In some OSs, the shared library list is the same/global/shared
2516 across inferiors. If code is shared between processes, so are
2517 memory regions and features. */
2518 if (!gdbarch_has_global_solist (target_gdbarch ()))
2520 no_shared_libraries (NULL
, from_tty
);
2522 invalidate_target_mem_regions ();
2524 target_clear_description ();
2527 agent_capability_invalidate ();
2530 /* Callback for iterate_over_inferiors. Gets rid of the given
2534 dispose_inferior (struct inferior
*inf
, void *args
)
2536 struct thread_info
*thread
;
2538 thread
= any_thread_of_process (inf
->pid
);
2541 switch_to_thread (thread
->ptid
);
2543 /* Core inferiors actually should be detached, not killed. */
2544 if (target_has_execution
)
2547 target_detach (NULL
, 0);
2553 /* This is to be called by the open routine before it does
2557 target_preopen (int from_tty
)
2561 if (have_inferiors ())
2564 || !have_live_inferiors ()
2565 || query (_("A program is being debugged already. Kill it? ")))
2566 iterate_over_inferiors (dispose_inferior
, NULL
);
2568 error (_("Program not killed."));
2571 /* Calling target_kill may remove the target from the stack. But if
2572 it doesn't (which seems like a win for UDI), remove it now. */
2573 /* Leave the exec target, though. The user may be switching from a
2574 live process to a core of the same program. */
2575 pop_all_targets_above (file_stratum
);
2577 target_pre_inferior (from_tty
);
2580 /* Detach a target after doing deferred register stores. */
2583 target_detach (const char *args
, int from_tty
)
2585 struct target_ops
* t
;
2587 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2588 /* Don't remove global breakpoints here. They're removed on
2589 disconnection from the target. */
2592 /* If we're in breakpoints-always-inserted mode, have to remove
2593 them before detaching. */
2594 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2596 prepare_for_detach ();
2598 current_target
.to_detach (¤t_target
, args
, from_tty
);
2600 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2605 target_disconnect (char *args
, int from_tty
)
2607 struct target_ops
*t
;
2609 /* If we're in breakpoints-always-inserted mode or if breakpoints
2610 are global across processes, we have to remove them before
2612 remove_breakpoints ();
2614 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2615 if (t
->to_disconnect
!= NULL
)
2618 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2620 t
->to_disconnect (t
, args
, from_tty
);
2628 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2630 struct target_ops
*t
;
2631 ptid_t retval
= (current_target
.to_wait
) (¤t_target
, ptid
,
2636 char *status_string
;
2637 char *options_string
;
2639 status_string
= target_waitstatus_to_string (status
);
2640 options_string
= target_options_to_string (options
);
2641 fprintf_unfiltered (gdb_stdlog
,
2642 "target_wait (%d, status, options={%s})"
2644 ptid_get_pid (ptid
), options_string
,
2645 ptid_get_pid (retval
), status_string
);
2646 xfree (status_string
);
2647 xfree (options_string
);
2654 target_pid_to_str (ptid_t ptid
)
2656 struct target_ops
*t
;
2658 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2660 if (t
->to_pid_to_str
!= NULL
)
2661 return (*t
->to_pid_to_str
) (t
, ptid
);
2664 return normal_pid_to_str (ptid
);
2668 target_thread_name (struct thread_info
*info
)
2670 return current_target
.to_thread_name (¤t_target
, info
);
2674 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2676 struct target_ops
*t
;
2678 target_dcache_invalidate ();
2680 current_target
.to_resume (¤t_target
, ptid
, step
, signal
);
2682 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2683 ptid_get_pid (ptid
),
2684 step
? "step" : "continue",
2685 gdb_signal_to_name (signal
));
2687 registers_changed_ptid (ptid
);
2688 set_executing (ptid
, 1);
2689 set_running (ptid
, 1);
2690 clear_inline_frame_state (ptid
);
2694 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2696 struct target_ops
*t
;
2698 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2700 if (t
->to_pass_signals
!= NULL
)
2706 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2709 for (i
= 0; i
< numsigs
; i
++)
2710 if (pass_signals
[i
])
2711 fprintf_unfiltered (gdb_stdlog
, " %s",
2712 gdb_signal_to_name (i
));
2714 fprintf_unfiltered (gdb_stdlog
, " })\n");
2717 (*t
->to_pass_signals
) (t
, numsigs
, pass_signals
);
2724 target_program_signals (int numsigs
, unsigned char *program_signals
)
2726 struct target_ops
*t
;
2728 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2730 if (t
->to_program_signals
!= NULL
)
2736 fprintf_unfiltered (gdb_stdlog
, "target_program_signals (%d, {",
2739 for (i
= 0; i
< numsigs
; i
++)
2740 if (program_signals
[i
])
2741 fprintf_unfiltered (gdb_stdlog
, " %s",
2742 gdb_signal_to_name (i
));
2744 fprintf_unfiltered (gdb_stdlog
, " })\n");
2747 (*t
->to_program_signals
) (t
, numsigs
, program_signals
);
2753 /* Look through the list of possible targets for a target that can
2757 target_follow_fork (int follow_child
, int detach_fork
)
2759 struct target_ops
*t
;
2761 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2763 if (t
->to_follow_fork
!= NULL
)
2765 int retval
= t
->to_follow_fork (t
, follow_child
, detach_fork
);
2768 fprintf_unfiltered (gdb_stdlog
,
2769 "target_follow_fork (%d, %d) = %d\n",
2770 follow_child
, detach_fork
, retval
);
2775 /* Some target returned a fork event, but did not know how to follow it. */
2776 internal_error (__FILE__
, __LINE__
,
2777 _("could not find a target to follow fork"));
2781 target_mourn_inferior (void)
2783 struct target_ops
*t
;
2785 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2787 if (t
->to_mourn_inferior
!= NULL
)
2789 t
->to_mourn_inferior (t
);
2791 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2793 /* We no longer need to keep handles on any of the object files.
2794 Make sure to release them to avoid unnecessarily locking any
2795 of them while we're not actually debugging. */
2796 bfd_cache_close_all ();
2802 internal_error (__FILE__
, __LINE__
,
2803 _("could not find a target to follow mourn inferior"));
2806 /* Look for a target which can describe architectural features, starting
2807 from TARGET. If we find one, return its description. */
2809 const struct target_desc
*
2810 target_read_description (struct target_ops
*target
)
2812 struct target_ops
*t
;
2814 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
2815 if (t
->to_read_description
!= NULL
)
2817 const struct target_desc
*tdesc
;
2819 tdesc
= t
->to_read_description (t
);
2827 /* The default implementation of to_search_memory.
2828 This implements a basic search of memory, reading target memory and
2829 performing the search here (as opposed to performing the search in on the
2830 target side with, for example, gdbserver). */
2833 simple_search_memory (struct target_ops
*ops
,
2834 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2835 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2836 CORE_ADDR
*found_addrp
)
2838 /* NOTE: also defined in find.c testcase. */
2839 #define SEARCH_CHUNK_SIZE 16000
2840 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2841 /* Buffer to hold memory contents for searching. */
2842 gdb_byte
*search_buf
;
2843 unsigned search_buf_size
;
2844 struct cleanup
*old_cleanups
;
2846 search_buf_size
= chunk_size
+ pattern_len
- 1;
2848 /* No point in trying to allocate a buffer larger than the search space. */
2849 if (search_space_len
< search_buf_size
)
2850 search_buf_size
= search_space_len
;
2852 search_buf
= malloc (search_buf_size
);
2853 if (search_buf
== NULL
)
2854 error (_("Unable to allocate memory to perform the search."));
2855 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2857 /* Prime the search buffer. */
2859 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2860 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2862 warning (_("Unable to access %s bytes of target "
2863 "memory at %s, halting search."),
2864 pulongest (search_buf_size
), hex_string (start_addr
));
2865 do_cleanups (old_cleanups
);
2869 /* Perform the search.
2871 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2872 When we've scanned N bytes we copy the trailing bytes to the start and
2873 read in another N bytes. */
2875 while (search_space_len
>= pattern_len
)
2877 gdb_byte
*found_ptr
;
2878 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2880 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2881 pattern
, pattern_len
);
2883 if (found_ptr
!= NULL
)
2885 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2887 *found_addrp
= found_addr
;
2888 do_cleanups (old_cleanups
);
2892 /* Not found in this chunk, skip to next chunk. */
2894 /* Don't let search_space_len wrap here, it's unsigned. */
2895 if (search_space_len
>= chunk_size
)
2896 search_space_len
-= chunk_size
;
2898 search_space_len
= 0;
2900 if (search_space_len
>= pattern_len
)
2902 unsigned keep_len
= search_buf_size
- chunk_size
;
2903 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2906 /* Copy the trailing part of the previous iteration to the front
2907 of the buffer for the next iteration. */
2908 gdb_assert (keep_len
== pattern_len
- 1);
2909 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
2911 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
2913 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2914 search_buf
+ keep_len
, read_addr
,
2915 nr_to_read
) != nr_to_read
)
2917 warning (_("Unable to access %s bytes of target "
2918 "memory at %s, halting search."),
2919 plongest (nr_to_read
),
2920 hex_string (read_addr
));
2921 do_cleanups (old_cleanups
);
2925 start_addr
+= chunk_size
;
2931 do_cleanups (old_cleanups
);
2935 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2936 sequence of bytes in PATTERN with length PATTERN_LEN.
2938 The result is 1 if found, 0 if not found, and -1 if there was an error
2939 requiring halting of the search (e.g. memory read error).
2940 If the pattern is found the address is recorded in FOUND_ADDRP. */
2943 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2944 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2945 CORE_ADDR
*found_addrp
)
2947 struct target_ops
*t
;
2950 /* We don't use INHERIT to set current_target.to_search_memory,
2951 so we have to scan the target stack and handle targetdebug
2955 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2956 hex_string (start_addr
));
2958 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2959 if (t
->to_search_memory
!= NULL
)
2964 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2965 pattern
, pattern_len
, found_addrp
);
2969 /* If a special version of to_search_memory isn't available, use the
2971 found
= simple_search_memory (current_target
.beneath
,
2972 start_addr
, search_space_len
,
2973 pattern
, pattern_len
, found_addrp
);
2977 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2982 /* Look through the currently pushed targets. If none of them will
2983 be able to restart the currently running process, issue an error
2987 target_require_runnable (void)
2989 struct target_ops
*t
;
2991 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2993 /* If this target knows how to create a new program, then
2994 assume we will still be able to after killing the current
2995 one. Either killing and mourning will not pop T, or else
2996 find_default_run_target will find it again. */
2997 if (t
->to_create_inferior
!= NULL
)
3000 /* Do not worry about thread_stratum targets that can not
3001 create inferiors. Assume they will be pushed again if
3002 necessary, and continue to the process_stratum. */
3003 if (t
->to_stratum
== thread_stratum
3004 || t
->to_stratum
== arch_stratum
)
3007 error (_("The \"%s\" target does not support \"run\". "
3008 "Try \"help target\" or \"continue\"."),
3012 /* This function is only called if the target is running. In that
3013 case there should have been a process_stratum target and it
3014 should either know how to create inferiors, or not... */
3015 internal_error (__FILE__
, __LINE__
, _("No targets found"));
3018 /* Look through the list of possible targets for a target that can
3019 execute a run or attach command without any other data. This is
3020 used to locate the default process stratum.
3022 If DO_MESG is not NULL, the result is always valid (error() is
3023 called for errors); else, return NULL on error. */
3025 static struct target_ops
*
3026 find_default_run_target (char *do_mesg
)
3028 struct target_ops
**t
;
3029 struct target_ops
*runable
= NULL
;
3034 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
3037 if ((*t
)->to_can_run
&& target_can_run (*t
))
3047 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
3056 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3058 struct target_ops
*t
;
3060 t
= find_default_run_target ("attach");
3061 (t
->to_attach
) (t
, args
, from_tty
);
3066 find_default_create_inferior (struct target_ops
*ops
,
3067 char *exec_file
, char *allargs
, char **env
,
3070 struct target_ops
*t
;
3072 t
= find_default_run_target ("run");
3073 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
3078 find_default_can_async_p (struct target_ops
*ignore
)
3080 struct target_ops
*t
;
3082 /* This may be called before the target is pushed on the stack;
3083 look for the default process stratum. If there's none, gdb isn't
3084 configured with a native debugger, and target remote isn't
3086 t
= find_default_run_target (NULL
);
3087 if (t
&& t
->to_can_async_p
!= delegate_can_async_p
)
3088 return (t
->to_can_async_p
) (t
);
3093 find_default_is_async_p (struct target_ops
*ignore
)
3095 struct target_ops
*t
;
3097 /* This may be called before the target is pushed on the stack;
3098 look for the default process stratum. If there's none, gdb isn't
3099 configured with a native debugger, and target remote isn't
3101 t
= find_default_run_target (NULL
);
3102 if (t
&& t
->to_is_async_p
!= delegate_is_async_p
)
3103 return (t
->to_is_async_p
) (t
);
3108 find_default_supports_non_stop (struct target_ops
*self
)
3110 struct target_ops
*t
;
3112 t
= find_default_run_target (NULL
);
3113 if (t
&& t
->to_supports_non_stop
)
3114 return (t
->to_supports_non_stop
) (t
);
3119 target_supports_non_stop (void)
3121 struct target_ops
*t
;
3123 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3124 if (t
->to_supports_non_stop
)
3125 return t
->to_supports_non_stop (t
);
3130 /* Implement the "info proc" command. */
3133 target_info_proc (char *args
, enum info_proc_what what
)
3135 struct target_ops
*t
;
3137 /* If we're already connected to something that can get us OS
3138 related data, use it. Otherwise, try using the native
3140 if (current_target
.to_stratum
>= process_stratum
)
3141 t
= current_target
.beneath
;
3143 t
= find_default_run_target (NULL
);
3145 for (; t
!= NULL
; t
= t
->beneath
)
3147 if (t
->to_info_proc
!= NULL
)
3149 t
->to_info_proc (t
, args
, what
);
3152 fprintf_unfiltered (gdb_stdlog
,
3153 "target_info_proc (\"%s\", %d)\n", args
, what
);
3163 find_default_supports_disable_randomization (struct target_ops
*self
)
3165 struct target_ops
*t
;
3167 t
= find_default_run_target (NULL
);
3168 if (t
&& t
->to_supports_disable_randomization
)
3169 return (t
->to_supports_disable_randomization
) (t
);
3174 target_supports_disable_randomization (void)
3176 struct target_ops
*t
;
3178 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3179 if (t
->to_supports_disable_randomization
)
3180 return t
->to_supports_disable_randomization (t
);
3186 target_get_osdata (const char *type
)
3188 struct target_ops
*t
;
3190 /* If we're already connected to something that can get us OS
3191 related data, use it. Otherwise, try using the native
3193 if (current_target
.to_stratum
>= process_stratum
)
3194 t
= current_target
.beneath
;
3196 t
= find_default_run_target ("get OS data");
3201 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
3204 /* Determine the current address space of thread PTID. */
3206 struct address_space
*
3207 target_thread_address_space (ptid_t ptid
)
3209 struct address_space
*aspace
;
3210 struct inferior
*inf
;
3211 struct target_ops
*t
;
3213 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3215 if (t
->to_thread_address_space
!= NULL
)
3217 aspace
= t
->to_thread_address_space (t
, ptid
);
3218 gdb_assert (aspace
);
3221 fprintf_unfiltered (gdb_stdlog
,
3222 "target_thread_address_space (%s) = %d\n",
3223 target_pid_to_str (ptid
),
3224 address_space_num (aspace
));
3229 /* Fall-back to the "main" address space of the inferior. */
3230 inf
= find_inferior_pid (ptid_get_pid (ptid
));
3232 if (inf
== NULL
|| inf
->aspace
== NULL
)
3233 internal_error (__FILE__
, __LINE__
,
3234 _("Can't determine the current "
3235 "address space of thread %s\n"),
3236 target_pid_to_str (ptid
));
3242 /* Target file operations. */
3244 static struct target_ops
*
3245 default_fileio_target (void)
3247 /* If we're already connected to something that can perform
3248 file I/O, use it. Otherwise, try using the native target. */
3249 if (current_target
.to_stratum
>= process_stratum
)
3250 return current_target
.beneath
;
3252 return find_default_run_target ("file I/O");
3255 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3256 target file descriptor, or -1 if an error occurs (and set
3259 target_fileio_open (const char *filename
, int flags
, int mode
,
3262 struct target_ops
*t
;
3264 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3266 if (t
->to_fileio_open
!= NULL
)
3268 int fd
= t
->to_fileio_open (t
, filename
, flags
, mode
, target_errno
);
3271 fprintf_unfiltered (gdb_stdlog
,
3272 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3273 filename
, flags
, mode
,
3274 fd
, fd
!= -1 ? 0 : *target_errno
);
3279 *target_errno
= FILEIO_ENOSYS
;
3283 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3284 Return the number of bytes written, or -1 if an error occurs
3285 (and set *TARGET_ERRNO). */
3287 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
3288 ULONGEST offset
, int *target_errno
)
3290 struct target_ops
*t
;
3292 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3294 if (t
->to_fileio_pwrite
!= NULL
)
3296 int ret
= t
->to_fileio_pwrite (t
, fd
, write_buf
, len
, offset
,
3300 fprintf_unfiltered (gdb_stdlog
,
3301 "target_fileio_pwrite (%d,...,%d,%s) "
3303 fd
, len
, pulongest (offset
),
3304 ret
, ret
!= -1 ? 0 : *target_errno
);
3309 *target_errno
= FILEIO_ENOSYS
;
3313 /* Read up to LEN bytes FD on the target into READ_BUF.
3314 Return the number of bytes read, or -1 if an error occurs
3315 (and set *TARGET_ERRNO). */
3317 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
3318 ULONGEST offset
, int *target_errno
)
3320 struct target_ops
*t
;
3322 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3324 if (t
->to_fileio_pread
!= NULL
)
3326 int ret
= t
->to_fileio_pread (t
, fd
, read_buf
, len
, offset
,
3330 fprintf_unfiltered (gdb_stdlog
,
3331 "target_fileio_pread (%d,...,%d,%s) "
3333 fd
, len
, pulongest (offset
),
3334 ret
, ret
!= -1 ? 0 : *target_errno
);
3339 *target_errno
= FILEIO_ENOSYS
;
3343 /* Close FD on the target. Return 0, or -1 if an error occurs
3344 (and set *TARGET_ERRNO). */
3346 target_fileio_close (int fd
, int *target_errno
)
3348 struct target_ops
*t
;
3350 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3352 if (t
->to_fileio_close
!= NULL
)
3354 int ret
= t
->to_fileio_close (t
, fd
, target_errno
);
3357 fprintf_unfiltered (gdb_stdlog
,
3358 "target_fileio_close (%d) = %d (%d)\n",
3359 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
3364 *target_errno
= FILEIO_ENOSYS
;
3368 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3369 occurs (and set *TARGET_ERRNO). */
3371 target_fileio_unlink (const char *filename
, int *target_errno
)
3373 struct target_ops
*t
;
3375 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3377 if (t
->to_fileio_unlink
!= NULL
)
3379 int ret
= t
->to_fileio_unlink (t
, filename
, target_errno
);
3382 fprintf_unfiltered (gdb_stdlog
,
3383 "target_fileio_unlink (%s) = %d (%d)\n",
3384 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
3389 *target_errno
= FILEIO_ENOSYS
;
3393 /* Read value of symbolic link FILENAME on the target. Return a
3394 null-terminated string allocated via xmalloc, or NULL if an error
3395 occurs (and set *TARGET_ERRNO). */
3397 target_fileio_readlink (const char *filename
, int *target_errno
)
3399 struct target_ops
*t
;
3401 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3403 if (t
->to_fileio_readlink
!= NULL
)
3405 char *ret
= t
->to_fileio_readlink (t
, filename
, target_errno
);
3408 fprintf_unfiltered (gdb_stdlog
,
3409 "target_fileio_readlink (%s) = %s (%d)\n",
3410 filename
, ret
? ret
: "(nil)",
3411 ret
? 0 : *target_errno
);
3416 *target_errno
= FILEIO_ENOSYS
;
3421 target_fileio_close_cleanup (void *opaque
)
3423 int fd
= *(int *) opaque
;
3426 target_fileio_close (fd
, &target_errno
);
3429 /* Read target file FILENAME. Store the result in *BUF_P and
3430 return the size of the transferred data. PADDING additional bytes are
3431 available in *BUF_P. This is a helper function for
3432 target_fileio_read_alloc; see the declaration of that function for more
3436 target_fileio_read_alloc_1 (const char *filename
,
3437 gdb_byte
**buf_p
, int padding
)
3439 struct cleanup
*close_cleanup
;
3440 size_t buf_alloc
, buf_pos
;
3446 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
3450 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
3452 /* Start by reading up to 4K at a time. The target will throttle
3453 this number down if necessary. */
3455 buf
= xmalloc (buf_alloc
);
3459 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
3460 buf_alloc
- buf_pos
- padding
, buf_pos
,
3464 /* An error occurred. */
3465 do_cleanups (close_cleanup
);
3471 /* Read all there was. */
3472 do_cleanups (close_cleanup
);
3482 /* If the buffer is filling up, expand it. */
3483 if (buf_alloc
< buf_pos
* 2)
3486 buf
= xrealloc (buf
, buf_alloc
);
3493 /* Read target file FILENAME. Store the result in *BUF_P and return
3494 the size of the transferred data. See the declaration in "target.h"
3495 function for more information about the return value. */
3498 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
3500 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
3503 /* Read target file FILENAME. The result is NUL-terminated and
3504 returned as a string, allocated using xmalloc. If an error occurs
3505 or the transfer is unsupported, NULL is returned. Empty objects
3506 are returned as allocated but empty strings. A warning is issued
3507 if the result contains any embedded NUL bytes. */
3510 target_fileio_read_stralloc (const char *filename
)
3514 LONGEST i
, transferred
;
3516 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
3517 bufstr
= (char *) buffer
;
3519 if (transferred
< 0)
3522 if (transferred
== 0)
3523 return xstrdup ("");
3525 bufstr
[transferred
] = 0;
3527 /* Check for embedded NUL bytes; but allow trailing NULs. */
3528 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3531 warning (_("target file %s "
3532 "contained unexpected null characters"),
3542 default_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3543 CORE_ADDR addr
, int len
)
3545 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3549 default_watchpoint_addr_within_range (struct target_ops
*target
,
3551 CORE_ADDR start
, int length
)
3553 return addr
>= start
&& addr
< start
+ length
;
3556 static struct gdbarch
*
3557 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3559 return target_gdbarch ();
3569 return_minus_one (void)
3581 * Find the next target down the stack from the specified target.
3585 find_target_beneath (struct target_ops
*t
)
3593 find_target_at (enum strata stratum
)
3595 struct target_ops
*t
;
3597 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3598 if (t
->to_stratum
== stratum
)
3605 /* The inferior process has died. Long live the inferior! */
3608 generic_mourn_inferior (void)
3612 ptid
= inferior_ptid
;
3613 inferior_ptid
= null_ptid
;
3615 /* Mark breakpoints uninserted in case something tries to delete a
3616 breakpoint while we delete the inferior's threads (which would
3617 fail, since the inferior is long gone). */
3618 mark_breakpoints_out ();
3620 if (!ptid_equal (ptid
, null_ptid
))
3622 int pid
= ptid_get_pid (ptid
);
3623 exit_inferior (pid
);
3626 /* Note this wipes step-resume breakpoints, so needs to be done
3627 after exit_inferior, which ends up referencing the step-resume
3628 breakpoints through clear_thread_inferior_resources. */
3629 breakpoint_init_inferior (inf_exited
);
3631 registers_changed ();
3633 reopen_exec_file ();
3634 reinit_frame_cache ();
3636 if (deprecated_detach_hook
)
3637 deprecated_detach_hook ();
3640 /* Convert a normal process ID to a string. Returns the string in a
3644 normal_pid_to_str (ptid_t ptid
)
3646 static char buf
[32];
3648 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3653 dummy_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3655 return normal_pid_to_str (ptid
);
3658 /* Error-catcher for target_find_memory_regions. */
3660 dummy_find_memory_regions (struct target_ops
*self
,
3661 find_memory_region_ftype ignore1
, void *ignore2
)
3663 error (_("Command not implemented for this target."));
3667 /* Error-catcher for target_make_corefile_notes. */
3669 dummy_make_corefile_notes (struct target_ops
*self
,
3670 bfd
*ignore1
, int *ignore2
)
3672 error (_("Command not implemented for this target."));
3676 /* Error-catcher for target_get_bookmark. */
3678 dummy_get_bookmark (struct target_ops
*self
, char *ignore1
, int ignore2
)
3684 /* Error-catcher for target_goto_bookmark. */
3686 dummy_goto_bookmark (struct target_ops
*self
, gdb_byte
*ignore
, int from_tty
)
3691 /* Set up the handful of non-empty slots needed by the dummy target
3695 init_dummy_target (void)
3697 dummy_target
.to_shortname
= "None";
3698 dummy_target
.to_longname
= "None";
3699 dummy_target
.to_doc
= "";
3700 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3701 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3702 dummy_target
.to_supports_disable_randomization
3703 = find_default_supports_disable_randomization
;
3704 dummy_target
.to_pid_to_str
= dummy_pid_to_str
;
3705 dummy_target
.to_stratum
= dummy_stratum
;
3706 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
3707 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
3708 dummy_target
.to_get_bookmark
= dummy_get_bookmark
;
3709 dummy_target
.to_goto_bookmark
= dummy_goto_bookmark
;
3710 dummy_target
.to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
3711 dummy_target
.to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
3712 dummy_target
.to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
3713 dummy_target
.to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
3714 dummy_target
.to_has_execution
3715 = (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
3716 dummy_target
.to_magic
= OPS_MAGIC
;
3718 install_dummy_methods (&dummy_target
);
3722 debug_to_open (char *args
, int from_tty
)
3724 debug_target
.to_open (args
, from_tty
);
3726 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3730 target_close (struct target_ops
*targ
)
3732 gdb_assert (!target_is_pushed (targ
));
3734 if (targ
->to_xclose
!= NULL
)
3735 targ
->to_xclose (targ
);
3736 else if (targ
->to_close
!= NULL
)
3737 targ
->to_close (targ
);
3740 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3744 target_attach (char *args
, int from_tty
)
3746 current_target
.to_attach (¤t_target
, args
, from_tty
);
3748 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3753 target_thread_alive (ptid_t ptid
)
3755 struct target_ops
*t
;
3757 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3759 if (t
->to_thread_alive
!= NULL
)
3763 retval
= t
->to_thread_alive (t
, ptid
);
3765 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3766 ptid_get_pid (ptid
), retval
);
3776 target_find_new_threads (void)
3778 struct target_ops
*t
;
3780 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3782 if (t
->to_find_new_threads
!= NULL
)
3784 t
->to_find_new_threads (t
);
3786 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3794 target_stop (ptid_t ptid
)
3798 warning (_("May not interrupt or stop the target, ignoring attempt"));
3802 (*current_target
.to_stop
) (¤t_target
, ptid
);
3806 debug_to_post_attach (struct target_ops
*self
, int pid
)
3808 debug_target
.to_post_attach (&debug_target
, pid
);
3810 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3813 /* Concatenate ELEM to LIST, a comma separate list, and return the
3814 result. The LIST incoming argument is released. */
3817 str_comma_list_concat_elem (char *list
, const char *elem
)
3820 return xstrdup (elem
);
3822 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3825 /* Helper for target_options_to_string. If OPT is present in
3826 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3827 Returns the new resulting string. OPT is removed from
3831 do_option (int *target_options
, char *ret
,
3832 int opt
, char *opt_str
)
3834 if ((*target_options
& opt
) != 0)
3836 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3837 *target_options
&= ~opt
;
3844 target_options_to_string (int target_options
)
3848 #define DO_TARG_OPTION(OPT) \
3849 ret = do_option (&target_options, ret, OPT, #OPT)
3851 DO_TARG_OPTION (TARGET_WNOHANG
);
3853 if (target_options
!= 0)
3854 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3862 debug_print_register (const char * func
,
3863 struct regcache
*regcache
, int regno
)
3865 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3867 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3868 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3869 && gdbarch_register_name (gdbarch
, regno
) != NULL
3870 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3871 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3872 gdbarch_register_name (gdbarch
, regno
));
3874 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3875 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3877 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3878 int i
, size
= register_size (gdbarch
, regno
);
3879 gdb_byte buf
[MAX_REGISTER_SIZE
];
3881 regcache_raw_collect (regcache
, regno
, buf
);
3882 fprintf_unfiltered (gdb_stdlog
, " = ");
3883 for (i
= 0; i
< size
; i
++)
3885 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3887 if (size
<= sizeof (LONGEST
))
3889 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
3891 fprintf_unfiltered (gdb_stdlog
, " %s %s",
3892 core_addr_to_string_nz (val
), plongest (val
));
3895 fprintf_unfiltered (gdb_stdlog
, "\n");
3899 target_fetch_registers (struct regcache
*regcache
, int regno
)
3901 struct target_ops
*t
;
3903 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3905 if (t
->to_fetch_registers
!= NULL
)
3907 t
->to_fetch_registers (t
, regcache
, regno
);
3909 debug_print_register ("target_fetch_registers", regcache
, regno
);
3916 target_store_registers (struct regcache
*regcache
, int regno
)
3918 struct target_ops
*t
;
3920 if (!may_write_registers
)
3921 error (_("Writing to registers is not allowed (regno %d)"), regno
);
3923 current_target
.to_store_registers (¤t_target
, regcache
, regno
);
3926 debug_print_register ("target_store_registers", regcache
, regno
);
3931 target_core_of_thread (ptid_t ptid
)
3933 struct target_ops
*t
;
3935 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3937 if (t
->to_core_of_thread
!= NULL
)
3939 int retval
= t
->to_core_of_thread (t
, ptid
);
3942 fprintf_unfiltered (gdb_stdlog
,
3943 "target_core_of_thread (%d) = %d\n",
3944 ptid_get_pid (ptid
), retval
);
3953 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3955 struct target_ops
*t
;
3957 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3959 if (t
->to_verify_memory
!= NULL
)
3961 int retval
= t
->to_verify_memory (t
, data
, memaddr
, size
);
3964 fprintf_unfiltered (gdb_stdlog
,
3965 "target_verify_memory (%s, %s) = %d\n",
3966 paddress (target_gdbarch (), memaddr
),
3976 /* The documentation for this function is in its prototype declaration in
3980 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3982 struct target_ops
*t
;
3984 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3985 if (t
->to_insert_mask_watchpoint
!= NULL
)
3989 ret
= t
->to_insert_mask_watchpoint (t
, addr
, mask
, rw
);
3992 fprintf_unfiltered (gdb_stdlog
, "\
3993 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
3994 core_addr_to_string (addr
),
3995 core_addr_to_string (mask
), rw
, ret
);
4003 /* The documentation for this function is in its prototype declaration in
4007 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4009 struct target_ops
*t
;
4011 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4012 if (t
->to_remove_mask_watchpoint
!= NULL
)
4016 ret
= t
->to_remove_mask_watchpoint (t
, addr
, mask
, rw
);
4019 fprintf_unfiltered (gdb_stdlog
, "\
4020 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
4021 core_addr_to_string (addr
),
4022 core_addr_to_string (mask
), rw
, ret
);
4030 /* The documentation for this function is in its prototype declaration
4034 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
4036 struct target_ops
*t
;
4038 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4039 if (t
->to_masked_watch_num_registers
!= NULL
)
4040 return t
->to_masked_watch_num_registers (t
, addr
, mask
);
4045 /* The documentation for this function is in its prototype declaration
4049 target_ranged_break_num_registers (void)
4051 struct target_ops
*t
;
4053 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4054 if (t
->to_ranged_break_num_registers
!= NULL
)
4055 return t
->to_ranged_break_num_registers (t
);
4062 struct btrace_target_info
*
4063 target_enable_btrace (ptid_t ptid
)
4065 struct target_ops
*t
;
4067 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4068 if (t
->to_enable_btrace
!= NULL
)
4069 return t
->to_enable_btrace (t
, ptid
);
4078 target_disable_btrace (struct btrace_target_info
*btinfo
)
4080 struct target_ops
*t
;
4082 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4083 if (t
->to_disable_btrace
!= NULL
)
4085 t
->to_disable_btrace (t
, btinfo
);
4095 target_teardown_btrace (struct btrace_target_info
*btinfo
)
4097 struct target_ops
*t
;
4099 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4100 if (t
->to_teardown_btrace
!= NULL
)
4102 t
->to_teardown_btrace (t
, btinfo
);
4112 target_read_btrace (VEC (btrace_block_s
) **btrace
,
4113 struct btrace_target_info
*btinfo
,
4114 enum btrace_read_type type
)
4116 struct target_ops
*t
;
4118 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4119 if (t
->to_read_btrace
!= NULL
)
4120 return t
->to_read_btrace (t
, btrace
, btinfo
, type
);
4123 return BTRACE_ERR_NOT_SUPPORTED
;
4129 target_stop_recording (void)
4131 struct target_ops
*t
;
4133 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4134 if (t
->to_stop_recording
!= NULL
)
4136 t
->to_stop_recording (t
);
4140 /* This is optional. */
4146 target_info_record (void)
4148 struct target_ops
*t
;
4150 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4151 if (t
->to_info_record
!= NULL
)
4153 t
->to_info_record (t
);
4163 target_save_record (const char *filename
)
4165 struct target_ops
*t
;
4167 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4168 if (t
->to_save_record
!= NULL
)
4170 t
->to_save_record (t
, filename
);
4180 target_supports_delete_record (void)
4182 struct target_ops
*t
;
4184 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4185 if (t
->to_delete_record
!= NULL
)
4194 target_delete_record (void)
4196 struct target_ops
*t
;
4198 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4199 if (t
->to_delete_record
!= NULL
)
4201 t
->to_delete_record (t
);
4211 target_record_is_replaying (void)
4213 struct target_ops
*t
;
4215 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4216 if (t
->to_record_is_replaying
!= NULL
)
4217 return t
->to_record_is_replaying (t
);
4225 target_goto_record_begin (void)
4227 struct target_ops
*t
;
4229 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4230 if (t
->to_goto_record_begin
!= NULL
)
4232 t
->to_goto_record_begin (t
);
4242 target_goto_record_end (void)
4244 struct target_ops
*t
;
4246 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4247 if (t
->to_goto_record_end
!= NULL
)
4249 t
->to_goto_record_end (t
);
4259 target_goto_record (ULONGEST insn
)
4261 struct target_ops
*t
;
4263 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4264 if (t
->to_goto_record
!= NULL
)
4266 t
->to_goto_record (t
, insn
);
4276 target_insn_history (int size
, int flags
)
4278 struct target_ops
*t
;
4280 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4281 if (t
->to_insn_history
!= NULL
)
4283 t
->to_insn_history (t
, size
, flags
);
4293 target_insn_history_from (ULONGEST from
, int size
, int flags
)
4295 struct target_ops
*t
;
4297 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4298 if (t
->to_insn_history_from
!= NULL
)
4300 t
->to_insn_history_from (t
, from
, size
, flags
);
4310 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4312 struct target_ops
*t
;
4314 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4315 if (t
->to_insn_history_range
!= NULL
)
4317 t
->to_insn_history_range (t
, begin
, end
, flags
);
4327 target_call_history (int size
, int flags
)
4329 struct target_ops
*t
;
4331 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4332 if (t
->to_call_history
!= NULL
)
4334 t
->to_call_history (t
, size
, flags
);
4344 target_call_history_from (ULONGEST begin
, int size
, int flags
)
4346 struct target_ops
*t
;
4348 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4349 if (t
->to_call_history_from
!= NULL
)
4351 t
->to_call_history_from (t
, begin
, size
, flags
);
4361 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4363 struct target_ops
*t
;
4365 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4366 if (t
->to_call_history_range
!= NULL
)
4368 t
->to_call_history_range (t
, begin
, end
, flags
);
4376 debug_to_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
4378 debug_target
.to_prepare_to_store (&debug_target
, regcache
);
4380 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
4385 const struct frame_unwind
*
4386 target_get_unwinder (void)
4388 struct target_ops
*t
;
4390 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4391 if (t
->to_get_unwinder
!= NULL
)
4392 return t
->to_get_unwinder
;
4399 const struct frame_unwind
*
4400 target_get_tailcall_unwinder (void)
4402 struct target_ops
*t
;
4404 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4405 if (t
->to_get_tailcall_unwinder
!= NULL
)
4406 return t
->to_get_tailcall_unwinder
;
4414 forward_target_decr_pc_after_break (struct target_ops
*ops
,
4415 struct gdbarch
*gdbarch
)
4417 for (; ops
!= NULL
; ops
= ops
->beneath
)
4418 if (ops
->to_decr_pc_after_break
!= NULL
)
4419 return ops
->to_decr_pc_after_break (ops
, gdbarch
);
4421 return gdbarch_decr_pc_after_break (gdbarch
);
4427 target_decr_pc_after_break (struct gdbarch
*gdbarch
)
4429 return forward_target_decr_pc_after_break (current_target
.beneath
, gdbarch
);
4433 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
4434 int write
, struct mem_attrib
*attrib
,
4435 struct target_ops
*target
)
4439 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
4442 fprintf_unfiltered (gdb_stdlog
,
4443 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4444 paddress (target_gdbarch (), memaddr
), len
,
4445 write
? "write" : "read", retval
);
4451 fputs_unfiltered (", bytes =", gdb_stdlog
);
4452 for (i
= 0; i
< retval
; i
++)
4454 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
4456 if (targetdebug
< 2 && i
> 0)
4458 fprintf_unfiltered (gdb_stdlog
, " ...");
4461 fprintf_unfiltered (gdb_stdlog
, "\n");
4464 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
4468 fputc_unfiltered ('\n', gdb_stdlog
);
4474 debug_to_files_info (struct target_ops
*target
)
4476 debug_target
.to_files_info (target
);
4478 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
4482 debug_to_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4483 struct bp_target_info
*bp_tgt
)
4487 retval
= debug_target
.to_insert_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4489 fprintf_unfiltered (gdb_stdlog
,
4490 "target_insert_breakpoint (%s, xxx) = %ld\n",
4491 core_addr_to_string (bp_tgt
->placed_address
),
4492 (unsigned long) retval
);
4497 debug_to_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4498 struct bp_target_info
*bp_tgt
)
4502 retval
= debug_target
.to_remove_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4504 fprintf_unfiltered (gdb_stdlog
,
4505 "target_remove_breakpoint (%s, xxx) = %ld\n",
4506 core_addr_to_string (bp_tgt
->placed_address
),
4507 (unsigned long) retval
);
4512 debug_to_can_use_hw_breakpoint (struct target_ops
*self
,
4513 int type
, int cnt
, int from_tty
)
4517 retval
= debug_target
.to_can_use_hw_breakpoint (&debug_target
,
4518 type
, cnt
, from_tty
);
4520 fprintf_unfiltered (gdb_stdlog
,
4521 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4522 (unsigned long) type
,
4523 (unsigned long) cnt
,
4524 (unsigned long) from_tty
,
4525 (unsigned long) retval
);
4530 debug_to_region_ok_for_hw_watchpoint (struct target_ops
*self
,
4531 CORE_ADDR addr
, int len
)
4535 retval
= debug_target
.to_region_ok_for_hw_watchpoint (&debug_target
,
4538 fprintf_unfiltered (gdb_stdlog
,
4539 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4540 core_addr_to_string (addr
), (unsigned long) len
,
4541 core_addr_to_string (retval
));
4546 debug_to_can_accel_watchpoint_condition (struct target_ops
*self
,
4547 CORE_ADDR addr
, int len
, int rw
,
4548 struct expression
*cond
)
4552 retval
= debug_target
.to_can_accel_watchpoint_condition (&debug_target
,
4556 fprintf_unfiltered (gdb_stdlog
,
4557 "target_can_accel_watchpoint_condition "
4558 "(%s, %d, %d, %s) = %ld\n",
4559 core_addr_to_string (addr
), len
, rw
,
4560 host_address_to_string (cond
), (unsigned long) retval
);
4565 debug_to_stopped_by_watchpoint (struct target_ops
*ops
)
4569 retval
= debug_target
.to_stopped_by_watchpoint (&debug_target
);
4571 fprintf_unfiltered (gdb_stdlog
,
4572 "target_stopped_by_watchpoint () = %ld\n",
4573 (unsigned long) retval
);
4578 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
4582 retval
= debug_target
.to_stopped_data_address (target
, addr
);
4584 fprintf_unfiltered (gdb_stdlog
,
4585 "target_stopped_data_address ([%s]) = %ld\n",
4586 core_addr_to_string (*addr
),
4587 (unsigned long)retval
);
4592 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
4594 CORE_ADDR start
, int length
)
4598 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
4601 fprintf_filtered (gdb_stdlog
,
4602 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4603 core_addr_to_string (addr
), core_addr_to_string (start
),
4609 debug_to_insert_hw_breakpoint (struct target_ops
*self
,
4610 struct gdbarch
*gdbarch
,
4611 struct bp_target_info
*bp_tgt
)
4615 retval
= debug_target
.to_insert_hw_breakpoint (&debug_target
,
4618 fprintf_unfiltered (gdb_stdlog
,
4619 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4620 core_addr_to_string (bp_tgt
->placed_address
),
4621 (unsigned long) retval
);
4626 debug_to_remove_hw_breakpoint (struct target_ops
*self
,
4627 struct gdbarch
*gdbarch
,
4628 struct bp_target_info
*bp_tgt
)
4632 retval
= debug_target
.to_remove_hw_breakpoint (&debug_target
,
4635 fprintf_unfiltered (gdb_stdlog
,
4636 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4637 core_addr_to_string (bp_tgt
->placed_address
),
4638 (unsigned long) retval
);
4643 debug_to_insert_watchpoint (struct target_ops
*self
,
4644 CORE_ADDR addr
, int len
, int type
,
4645 struct expression
*cond
)
4649 retval
= debug_target
.to_insert_watchpoint (&debug_target
,
4650 addr
, len
, type
, cond
);
4652 fprintf_unfiltered (gdb_stdlog
,
4653 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4654 core_addr_to_string (addr
), len
, type
,
4655 host_address_to_string (cond
), (unsigned long) retval
);
4660 debug_to_remove_watchpoint (struct target_ops
*self
,
4661 CORE_ADDR addr
, int len
, int type
,
4662 struct expression
*cond
)
4666 retval
= debug_target
.to_remove_watchpoint (&debug_target
,
4667 addr
, len
, type
, cond
);
4669 fprintf_unfiltered (gdb_stdlog
,
4670 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4671 core_addr_to_string (addr
), len
, type
,
4672 host_address_to_string (cond
), (unsigned long) retval
);
4677 debug_to_terminal_init (struct target_ops
*self
)
4679 debug_target
.to_terminal_init (&debug_target
);
4681 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
4685 debug_to_terminal_inferior (struct target_ops
*self
)
4687 debug_target
.to_terminal_inferior (&debug_target
);
4689 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
4693 debug_to_terminal_ours_for_output (struct target_ops
*self
)
4695 debug_target
.to_terminal_ours_for_output (&debug_target
);
4697 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
4701 debug_to_terminal_ours (struct target_ops
*self
)
4703 debug_target
.to_terminal_ours (&debug_target
);
4705 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
4709 debug_to_terminal_save_ours (struct target_ops
*self
)
4711 debug_target
.to_terminal_save_ours (&debug_target
);
4713 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
4717 debug_to_terminal_info (struct target_ops
*self
,
4718 const char *arg
, int from_tty
)
4720 debug_target
.to_terminal_info (&debug_target
, arg
, from_tty
);
4722 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
4727 debug_to_load (struct target_ops
*self
, char *args
, int from_tty
)
4729 debug_target
.to_load (&debug_target
, args
, from_tty
);
4731 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
4735 debug_to_post_startup_inferior (struct target_ops
*self
, ptid_t ptid
)
4737 debug_target
.to_post_startup_inferior (&debug_target
, ptid
);
4739 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
4740 ptid_get_pid (ptid
));
4744 debug_to_insert_fork_catchpoint (struct target_ops
*self
, int pid
)
4748 retval
= debug_target
.to_insert_fork_catchpoint (&debug_target
, pid
);
4750 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
4757 debug_to_remove_fork_catchpoint (struct target_ops
*self
, int pid
)
4761 retval
= debug_target
.to_remove_fork_catchpoint (&debug_target
, pid
);
4763 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
4770 debug_to_insert_vfork_catchpoint (struct target_ops
*self
, int pid
)
4774 retval
= debug_target
.to_insert_vfork_catchpoint (&debug_target
, pid
);
4776 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
4783 debug_to_remove_vfork_catchpoint (struct target_ops
*self
, int pid
)
4787 retval
= debug_target
.to_remove_vfork_catchpoint (&debug_target
, pid
);
4789 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
4796 debug_to_insert_exec_catchpoint (struct target_ops
*self
, int pid
)
4800 retval
= debug_target
.to_insert_exec_catchpoint (&debug_target
, pid
);
4802 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
4809 debug_to_remove_exec_catchpoint (struct target_ops
*self
, int pid
)
4813 retval
= debug_target
.to_remove_exec_catchpoint (&debug_target
, pid
);
4815 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
4822 debug_to_has_exited (struct target_ops
*self
,
4823 int pid
, int wait_status
, int *exit_status
)
4827 has_exited
= debug_target
.to_has_exited (&debug_target
,
4828 pid
, wait_status
, exit_status
);
4830 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
4831 pid
, wait_status
, *exit_status
, has_exited
);
4837 debug_to_can_run (struct target_ops
*self
)
4841 retval
= debug_target
.to_can_run (&debug_target
);
4843 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4848 static struct gdbarch
*
4849 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4851 struct gdbarch
*retval
;
4853 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4855 fprintf_unfiltered (gdb_stdlog
,
4856 "target_thread_architecture (%s) = %s [%s]\n",
4857 target_pid_to_str (ptid
),
4858 host_address_to_string (retval
),
4859 gdbarch_bfd_arch_info (retval
)->printable_name
);
4864 debug_to_stop (struct target_ops
*self
, ptid_t ptid
)
4866 debug_target
.to_stop (&debug_target
, ptid
);
4868 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4869 target_pid_to_str (ptid
));
4873 debug_to_rcmd (struct target_ops
*self
, char *command
,
4874 struct ui_file
*outbuf
)
4876 debug_target
.to_rcmd (&debug_target
, command
, outbuf
);
4877 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4881 debug_to_pid_to_exec_file (struct target_ops
*self
, int pid
)
4885 exec_file
= debug_target
.to_pid_to_exec_file (&debug_target
, pid
);
4887 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
4894 setup_target_debug (void)
4896 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
4898 current_target
.to_open
= debug_to_open
;
4899 current_target
.to_post_attach
= debug_to_post_attach
;
4900 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
4901 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
4902 current_target
.to_files_info
= debug_to_files_info
;
4903 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
4904 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
4905 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
4906 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
4907 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
4908 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
4909 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
4910 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
4911 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
4912 current_target
.to_watchpoint_addr_within_range
4913 = debug_to_watchpoint_addr_within_range
;
4914 current_target
.to_region_ok_for_hw_watchpoint
4915 = debug_to_region_ok_for_hw_watchpoint
;
4916 current_target
.to_can_accel_watchpoint_condition
4917 = debug_to_can_accel_watchpoint_condition
;
4918 current_target
.to_terminal_init
= debug_to_terminal_init
;
4919 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
4920 current_target
.to_terminal_ours_for_output
4921 = debug_to_terminal_ours_for_output
;
4922 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
4923 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
4924 current_target
.to_terminal_info
= debug_to_terminal_info
;
4925 current_target
.to_load
= debug_to_load
;
4926 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
4927 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
4928 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
4929 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
4930 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
4931 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
4932 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
4933 current_target
.to_has_exited
= debug_to_has_exited
;
4934 current_target
.to_can_run
= debug_to_can_run
;
4935 current_target
.to_stop
= debug_to_stop
;
4936 current_target
.to_rcmd
= debug_to_rcmd
;
4937 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
4938 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
4942 static char targ_desc
[] =
4943 "Names of targets and files being debugged.\nShows the entire \
4944 stack of targets currently in use (including the exec-file,\n\
4945 core-file, and process, if any), as well as the symbol file name.";
4948 default_rcmd (struct target_ops
*self
, char *command
, struct ui_file
*output
)
4950 error (_("\"monitor\" command not supported by this target."));
4954 do_monitor_command (char *cmd
,
4957 target_rcmd (cmd
, gdb_stdtarg
);
4960 /* Print the name of each layers of our target stack. */
4963 maintenance_print_target_stack (char *cmd
, int from_tty
)
4965 struct target_ops
*t
;
4967 printf_filtered (_("The current target stack is:\n"));
4969 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
4971 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
4975 /* Controls if async mode is permitted. */
4976 int target_async_permitted
= 0;
4978 /* The set command writes to this variable. If the inferior is
4979 executing, target_async_permitted is *not* updated. */
4980 static int target_async_permitted_1
= 0;
4983 set_target_async_command (char *args
, int from_tty
,
4984 struct cmd_list_element
*c
)
4986 if (have_live_inferiors ())
4988 target_async_permitted_1
= target_async_permitted
;
4989 error (_("Cannot change this setting while the inferior is running."));
4992 target_async_permitted
= target_async_permitted_1
;
4996 show_target_async_command (struct ui_file
*file
, int from_tty
,
4997 struct cmd_list_element
*c
,
5000 fprintf_filtered (file
,
5001 _("Controlling the inferior in "
5002 "asynchronous mode is %s.\n"), value
);
5005 /* Temporary copies of permission settings. */
5007 static int may_write_registers_1
= 1;
5008 static int may_write_memory_1
= 1;
5009 static int may_insert_breakpoints_1
= 1;
5010 static int may_insert_tracepoints_1
= 1;
5011 static int may_insert_fast_tracepoints_1
= 1;
5012 static int may_stop_1
= 1;
5014 /* Make the user-set values match the real values again. */
5017 update_target_permissions (void)
5019 may_write_registers_1
= may_write_registers
;
5020 may_write_memory_1
= may_write_memory
;
5021 may_insert_breakpoints_1
= may_insert_breakpoints
;
5022 may_insert_tracepoints_1
= may_insert_tracepoints
;
5023 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
5024 may_stop_1
= may_stop
;
5027 /* The one function handles (most of) the permission flags in the same
5031 set_target_permissions (char *args
, int from_tty
,
5032 struct cmd_list_element
*c
)
5034 if (target_has_execution
)
5036 update_target_permissions ();
5037 error (_("Cannot change this setting while the inferior is running."));
5040 /* Make the real values match the user-changed values. */
5041 may_write_registers
= may_write_registers_1
;
5042 may_insert_breakpoints
= may_insert_breakpoints_1
;
5043 may_insert_tracepoints
= may_insert_tracepoints_1
;
5044 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
5045 may_stop
= may_stop_1
;
5046 update_observer_mode ();
5049 /* Set memory write permission independently of observer mode. */
5052 set_write_memory_permission (char *args
, int from_tty
,
5053 struct cmd_list_element
*c
)
5055 /* Make the real values match the user-changed values. */
5056 may_write_memory
= may_write_memory_1
;
5057 update_observer_mode ();
5062 initialize_targets (void)
5064 init_dummy_target ();
5065 push_target (&dummy_target
);
5067 add_info ("target", target_info
, targ_desc
);
5068 add_info ("files", target_info
, targ_desc
);
5070 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
5071 Set target debugging."), _("\
5072 Show target debugging."), _("\
5073 When non-zero, target debugging is enabled. Higher numbers are more\n\
5074 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
5078 &setdebuglist
, &showdebuglist
);
5080 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
5081 &trust_readonly
, _("\
5082 Set mode for reading from readonly sections."), _("\
5083 Show mode for reading from readonly sections."), _("\
5084 When this mode is on, memory reads from readonly sections (such as .text)\n\
5085 will be read from the object file instead of from the target. This will\n\
5086 result in significant performance improvement for remote targets."),
5088 show_trust_readonly
,
5089 &setlist
, &showlist
);
5091 add_com ("monitor", class_obscure
, do_monitor_command
,
5092 _("Send a command to the remote monitor (remote targets only)."));
5094 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
5095 _("Print the name of each layer of the internal target stack."),
5096 &maintenanceprintlist
);
5098 add_setshow_boolean_cmd ("target-async", no_class
,
5099 &target_async_permitted_1
, _("\
5100 Set whether gdb controls the inferior in asynchronous mode."), _("\
5101 Show whether gdb controls the inferior in asynchronous mode."), _("\
5102 Tells gdb whether to control the inferior in asynchronous mode."),
5103 set_target_async_command
,
5104 show_target_async_command
,
5108 add_setshow_boolean_cmd ("may-write-registers", class_support
,
5109 &may_write_registers_1
, _("\
5110 Set permission to write into registers."), _("\
5111 Show permission to write into registers."), _("\
5112 When this permission is on, GDB may write into the target's registers.\n\
5113 Otherwise, any sort of write attempt will result in an error."),
5114 set_target_permissions
, NULL
,
5115 &setlist
, &showlist
);
5117 add_setshow_boolean_cmd ("may-write-memory", class_support
,
5118 &may_write_memory_1
, _("\
5119 Set permission to write into target memory."), _("\
5120 Show permission to write into target memory."), _("\
5121 When this permission is on, GDB may write into the target's memory.\n\
5122 Otherwise, any sort of write attempt will result in an error."),
5123 set_write_memory_permission
, NULL
,
5124 &setlist
, &showlist
);
5126 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
5127 &may_insert_breakpoints_1
, _("\
5128 Set permission to insert breakpoints in the target."), _("\
5129 Show permission to insert breakpoints in the target."), _("\
5130 When this permission is on, GDB may insert breakpoints in the program.\n\
5131 Otherwise, any sort of insertion attempt will result in an error."),
5132 set_target_permissions
, NULL
,
5133 &setlist
, &showlist
);
5135 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
5136 &may_insert_tracepoints_1
, _("\
5137 Set permission to insert tracepoints in the target."), _("\
5138 Show permission to insert tracepoints in the target."), _("\
5139 When this permission is on, GDB may insert tracepoints in the program.\n\
5140 Otherwise, any sort of insertion attempt will result in an error."),
5141 set_target_permissions
, NULL
,
5142 &setlist
, &showlist
);
5144 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
5145 &may_insert_fast_tracepoints_1
, _("\
5146 Set permission to insert fast tracepoints in the target."), _("\
5147 Show permission to insert fast tracepoints in the target."), _("\
5148 When this permission is on, GDB may insert fast tracepoints.\n\
5149 Otherwise, any sort of insertion attempt will result in an error."),
5150 set_target_permissions
, NULL
,
5151 &setlist
, &showlist
);
5153 add_setshow_boolean_cmd ("may-interrupt", class_support
,
5155 Set permission to interrupt or signal the target."), _("\
5156 Show permission to interrupt or signal the target."), _("\
5157 When this permission is on, GDB may interrupt/stop the target's execution.\n\
5158 Otherwise, any attempt to interrupt or stop will be ignored."),
5159 set_target_permissions
, NULL
,
5160 &setlist
, &showlist
);