1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "target-dcache.h"
36 #include "gdb_assert.h"
38 #include "exceptions.h"
39 #include "target-descriptions.h"
40 #include "gdbthread.h"
43 #include "inline-frame.h"
44 #include "tracepoint.h"
45 #include "gdb/fileio.h"
48 static void target_info (char *, int);
50 static void default_terminal_info (const char *, int);
52 static int default_watchpoint_addr_within_range (struct target_ops
*,
53 CORE_ADDR
, CORE_ADDR
, int);
55 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
57 static void tcomplain (void) ATTRIBUTE_NORETURN
;
59 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
61 static int return_zero (void);
63 static int return_one (void);
65 static int return_minus_one (void);
67 static void *return_null (void);
69 void target_ignore (void);
71 static void target_command (char *, int);
73 static struct target_ops
*find_default_run_target (char *);
75 static target_xfer_partial_ftype default_xfer_partial
;
77 static struct gdbarch
*default_thread_architecture (struct target_ops
*ops
,
80 static int find_default_can_async_p (struct target_ops
*ignore
);
82 static int find_default_is_async_p (struct target_ops
*ignore
);
84 #include "target-delegates.c"
86 static void init_dummy_target (void);
88 static struct target_ops debug_target
;
90 static void debug_to_open (char *, int);
92 static void debug_to_prepare_to_store (struct target_ops
*self
,
95 static void debug_to_files_info (struct target_ops
*);
97 static int debug_to_insert_breakpoint (struct target_ops
*, struct gdbarch
*,
98 struct bp_target_info
*);
100 static int debug_to_remove_breakpoint (struct target_ops
*, struct gdbarch
*,
101 struct bp_target_info
*);
103 static int debug_to_can_use_hw_breakpoint (int, int, int);
105 static int debug_to_insert_hw_breakpoint (struct gdbarch
*,
106 struct bp_target_info
*);
108 static int debug_to_remove_hw_breakpoint (struct gdbarch
*,
109 struct bp_target_info
*);
111 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int,
112 struct expression
*);
114 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int,
115 struct expression
*);
117 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
119 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
120 CORE_ADDR
, CORE_ADDR
, int);
122 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
124 static int debug_to_can_accel_watchpoint_condition (CORE_ADDR
, int, int,
125 struct expression
*);
127 static void debug_to_terminal_init (void);
129 static void debug_to_terminal_inferior (void);
131 static void debug_to_terminal_ours_for_output (void);
133 static void debug_to_terminal_save_ours (void);
135 static void debug_to_terminal_ours (void);
137 static void debug_to_load (char *, int);
139 static int debug_to_can_run (void);
141 static void debug_to_stop (ptid_t
);
143 /* Pointer to array of target architecture structures; the size of the
144 array; the current index into the array; the allocated size of the
146 struct target_ops
**target_structs
;
147 unsigned target_struct_size
;
148 unsigned target_struct_allocsize
;
149 #define DEFAULT_ALLOCSIZE 10
151 /* The initial current target, so that there is always a semi-valid
154 static struct target_ops dummy_target
;
156 /* Top of target stack. */
158 static struct target_ops
*target_stack
;
160 /* The target structure we are currently using to talk to a process
161 or file or whatever "inferior" we have. */
163 struct target_ops current_target
;
165 /* Command list for target. */
167 static struct cmd_list_element
*targetlist
= NULL
;
169 /* Nonzero if we should trust readonly sections from the
170 executable when reading memory. */
172 static int trust_readonly
= 0;
174 /* Nonzero if we should show true memory content including
175 memory breakpoint inserted by gdb. */
177 static int show_memory_breakpoints
= 0;
179 /* These globals control whether GDB attempts to perform these
180 operations; they are useful for targets that need to prevent
181 inadvertant disruption, such as in non-stop mode. */
183 int may_write_registers
= 1;
185 int may_write_memory
= 1;
187 int may_insert_breakpoints
= 1;
189 int may_insert_tracepoints
= 1;
191 int may_insert_fast_tracepoints
= 1;
195 /* Non-zero if we want to see trace of target level stuff. */
197 static unsigned int targetdebug
= 0;
199 show_targetdebug (struct ui_file
*file
, int from_tty
,
200 struct cmd_list_element
*c
, const char *value
)
202 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
205 static void setup_target_debug (void);
207 /* The user just typed 'target' without the name of a target. */
210 target_command (char *arg
, int from_tty
)
212 fputs_filtered ("Argument required (target name). Try `help target'\n",
216 /* Default target_has_* methods for process_stratum targets. */
219 default_child_has_all_memory (struct target_ops
*ops
)
221 /* If no inferior selected, then we can't read memory here. */
222 if (ptid_equal (inferior_ptid
, null_ptid
))
229 default_child_has_memory (struct target_ops
*ops
)
231 /* If no inferior selected, then we can't read memory here. */
232 if (ptid_equal (inferior_ptid
, null_ptid
))
239 default_child_has_stack (struct target_ops
*ops
)
241 /* If no inferior selected, there's no stack. */
242 if (ptid_equal (inferior_ptid
, null_ptid
))
249 default_child_has_registers (struct target_ops
*ops
)
251 /* Can't read registers from no inferior. */
252 if (ptid_equal (inferior_ptid
, null_ptid
))
259 default_child_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
261 /* If there's no thread selected, then we can't make it run through
263 if (ptid_equal (the_ptid
, null_ptid
))
271 target_has_all_memory_1 (void)
273 struct target_ops
*t
;
275 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
276 if (t
->to_has_all_memory (t
))
283 target_has_memory_1 (void)
285 struct target_ops
*t
;
287 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
288 if (t
->to_has_memory (t
))
295 target_has_stack_1 (void)
297 struct target_ops
*t
;
299 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
300 if (t
->to_has_stack (t
))
307 target_has_registers_1 (void)
309 struct target_ops
*t
;
311 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
312 if (t
->to_has_registers (t
))
319 target_has_execution_1 (ptid_t the_ptid
)
321 struct target_ops
*t
;
323 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
324 if (t
->to_has_execution (t
, the_ptid
))
331 target_has_execution_current (void)
333 return target_has_execution_1 (inferior_ptid
);
336 /* Complete initialization of T. This ensures that various fields in
337 T are set, if needed by the target implementation. */
340 complete_target_initialization (struct target_ops
*t
)
342 /* Provide default values for all "must have" methods. */
343 if (t
->to_xfer_partial
== NULL
)
344 t
->to_xfer_partial
= default_xfer_partial
;
346 if (t
->to_has_all_memory
== NULL
)
347 t
->to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
349 if (t
->to_has_memory
== NULL
)
350 t
->to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
352 if (t
->to_has_stack
== NULL
)
353 t
->to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
355 if (t
->to_has_registers
== NULL
)
356 t
->to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
358 if (t
->to_has_execution
== NULL
)
359 t
->to_has_execution
= (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
361 install_delegators (t
);
364 /* Add possible target architecture T to the list and add a new
365 command 'target T->to_shortname'. Set COMPLETER as the command's
366 completer if not NULL. */
369 add_target_with_completer (struct target_ops
*t
,
370 completer_ftype
*completer
)
372 struct cmd_list_element
*c
;
374 complete_target_initialization (t
);
378 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
379 target_structs
= (struct target_ops
**) xmalloc
380 (target_struct_allocsize
* sizeof (*target_structs
));
382 if (target_struct_size
>= target_struct_allocsize
)
384 target_struct_allocsize
*= 2;
385 target_structs
= (struct target_ops
**)
386 xrealloc ((char *) target_structs
,
387 target_struct_allocsize
* sizeof (*target_structs
));
389 target_structs
[target_struct_size
++] = t
;
391 if (targetlist
== NULL
)
392 add_prefix_cmd ("target", class_run
, target_command
, _("\
393 Connect to a target machine or process.\n\
394 The first argument is the type or protocol of the target machine.\n\
395 Remaining arguments are interpreted by the target protocol. For more\n\
396 information on the arguments for a particular protocol, type\n\
397 `help target ' followed by the protocol name."),
398 &targetlist
, "target ", 0, &cmdlist
);
399 c
= add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
,
401 if (completer
!= NULL
)
402 set_cmd_completer (c
, completer
);
405 /* Add a possible target architecture to the list. */
408 add_target (struct target_ops
*t
)
410 add_target_with_completer (t
, NULL
);
416 add_deprecated_target_alias (struct target_ops
*t
, char *alias
)
418 struct cmd_list_element
*c
;
421 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
423 c
= add_cmd (alias
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
424 alt
= xstrprintf ("target %s", t
->to_shortname
);
425 deprecate_cmd (c
, alt
);
438 struct target_ops
*t
;
440 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
441 if (t
->to_kill
!= NULL
)
444 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
454 target_load (char *arg
, int from_tty
)
456 target_dcache_invalidate ();
457 (*current_target
.to_load
) (arg
, from_tty
);
461 target_create_inferior (char *exec_file
, char *args
,
462 char **env
, int from_tty
)
464 struct target_ops
*t
;
466 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
468 if (t
->to_create_inferior
!= NULL
)
470 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
472 fprintf_unfiltered (gdb_stdlog
,
473 "target_create_inferior (%s, %s, xxx, %d)\n",
474 exec_file
, args
, from_tty
);
479 internal_error (__FILE__
, __LINE__
,
480 _("could not find a target to create inferior"));
484 target_terminal_inferior (void)
486 /* A background resume (``run&'') should leave GDB in control of the
487 terminal. Use target_can_async_p, not target_is_async_p, since at
488 this point the target is not async yet. However, if sync_execution
489 is not set, we know it will become async prior to resume. */
490 if (target_can_async_p () && !sync_execution
)
493 /* If GDB is resuming the inferior in the foreground, install
494 inferior's terminal modes. */
495 (*current_target
.to_terminal_inferior
) ();
499 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
500 struct target_ops
*t
)
502 errno
= EIO
; /* Can't read/write this location. */
503 return 0; /* No bytes handled. */
509 error (_("You can't do that when your target is `%s'"),
510 current_target
.to_shortname
);
516 error (_("You can't do that without a process to debug."));
520 default_terminal_info (const char *args
, int from_tty
)
522 printf_unfiltered (_("No saved terminal information.\n"));
525 /* A default implementation for the to_get_ada_task_ptid target method.
527 This function builds the PTID by using both LWP and TID as part of
528 the PTID lwp and tid elements. The pid used is the pid of the
532 default_get_ada_task_ptid (long lwp
, long tid
)
534 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
537 static enum exec_direction_kind
538 default_execution_direction (void)
540 if (!target_can_execute_reverse
)
542 else if (!target_can_async_p ())
545 gdb_assert_not_reached ("\
546 to_execution_direction must be implemented for reverse async");
549 /* Go through the target stack from top to bottom, copying over zero
550 entries in current_target, then filling in still empty entries. In
551 effect, we are doing class inheritance through the pushed target
554 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
555 is currently implemented, is that it discards any knowledge of
556 which target an inherited method originally belonged to.
557 Consequently, new new target methods should instead explicitly and
558 locally search the target stack for the target that can handle the
562 update_current_target (void)
564 struct target_ops
*t
;
566 /* First, reset current's contents. */
567 memset (¤t_target
, 0, sizeof (current_target
));
569 /* Install the delegators. */
570 install_delegators (¤t_target
);
572 #define INHERIT(FIELD, TARGET) \
573 if (!current_target.FIELD) \
574 current_target.FIELD = (TARGET)->FIELD
576 for (t
= target_stack
; t
; t
= t
->beneath
)
578 INHERIT (to_shortname
, t
);
579 INHERIT (to_longname
, t
);
581 /* Do not inherit to_open. */
582 /* Do not inherit to_close. */
583 /* Do not inherit to_attach. */
584 INHERIT (to_post_attach
, t
);
585 INHERIT (to_attach_no_wait
, t
);
586 /* Do not inherit to_detach. */
587 /* Do not inherit to_disconnect. */
588 /* Do not inherit to_resume. */
589 /* Do not inherit to_wait. */
590 /* Do not inherit to_fetch_registers. */
591 /* Do not inherit to_store_registers. */
592 INHERIT (to_prepare_to_store
, t
);
593 INHERIT (deprecated_xfer_memory
, t
);
594 INHERIT (to_files_info
, t
);
595 /* Do not inherit to_insert_breakpoint. */
596 /* Do not inherit to_remove_breakpoint. */
597 INHERIT (to_can_use_hw_breakpoint
, t
);
598 INHERIT (to_insert_hw_breakpoint
, t
);
599 INHERIT (to_remove_hw_breakpoint
, t
);
600 /* Do not inherit to_ranged_break_num_registers. */
601 INHERIT (to_insert_watchpoint
, t
);
602 INHERIT (to_remove_watchpoint
, t
);
603 /* Do not inherit to_insert_mask_watchpoint. */
604 /* Do not inherit to_remove_mask_watchpoint. */
605 /* Do not inherit to_stopped_data_address. */
606 INHERIT (to_have_steppable_watchpoint
, t
);
607 INHERIT (to_have_continuable_watchpoint
, t
);
608 /* Do not inherit to_stopped_by_watchpoint. */
609 INHERIT (to_watchpoint_addr_within_range
, t
);
610 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
611 INHERIT (to_can_accel_watchpoint_condition
, t
);
612 /* Do not inherit to_masked_watch_num_registers. */
613 INHERIT (to_terminal_init
, t
);
614 INHERIT (to_terminal_inferior
, t
);
615 INHERIT (to_terminal_ours_for_output
, t
);
616 INHERIT (to_terminal_ours
, t
);
617 INHERIT (to_terminal_save_ours
, t
);
618 INHERIT (to_terminal_info
, t
);
619 /* Do not inherit to_kill. */
620 INHERIT (to_load
, t
);
621 /* Do no inherit to_create_inferior. */
622 INHERIT (to_post_startup_inferior
, t
);
623 INHERIT (to_insert_fork_catchpoint
, t
);
624 INHERIT (to_remove_fork_catchpoint
, t
);
625 INHERIT (to_insert_vfork_catchpoint
, t
);
626 INHERIT (to_remove_vfork_catchpoint
, t
);
627 /* Do not inherit to_follow_fork. */
628 INHERIT (to_insert_exec_catchpoint
, t
);
629 INHERIT (to_remove_exec_catchpoint
, t
);
630 INHERIT (to_set_syscall_catchpoint
, t
);
631 INHERIT (to_has_exited
, t
);
632 /* Do not inherit to_mourn_inferior. */
633 INHERIT (to_can_run
, t
);
634 /* Do not inherit to_pass_signals. */
635 /* Do not inherit to_program_signals. */
636 /* Do not inherit to_thread_alive. */
637 /* Do not inherit to_find_new_threads. */
638 /* Do not inherit to_pid_to_str. */
639 INHERIT (to_extra_thread_info
, t
);
640 INHERIT (to_thread_name
, t
);
641 INHERIT (to_stop
, t
);
642 /* Do not inherit to_xfer_partial. */
643 INHERIT (to_rcmd
, t
);
644 INHERIT (to_pid_to_exec_file
, t
);
645 INHERIT (to_log_command
, t
);
646 INHERIT (to_stratum
, t
);
647 /* Do not inherit to_has_all_memory. */
648 /* Do not inherit to_has_memory. */
649 /* Do not inherit to_has_stack. */
650 /* Do not inherit to_has_registers. */
651 /* Do not inherit to_has_execution. */
652 INHERIT (to_has_thread_control
, t
);
653 /* Do not inherit to_can_async_p. */
654 /* Do not inherit to_is_async_p. */
655 /* Do not inherit to_async. */
656 INHERIT (to_find_memory_regions
, t
);
657 INHERIT (to_make_corefile_notes
, t
);
658 INHERIT (to_get_bookmark
, t
);
659 INHERIT (to_goto_bookmark
, t
);
660 /* Do not inherit to_get_thread_local_address. */
661 INHERIT (to_can_execute_reverse
, t
);
662 INHERIT (to_execution_direction
, t
);
663 INHERIT (to_thread_architecture
, t
);
664 /* Do not inherit to_read_description. */
665 INHERIT (to_get_ada_task_ptid
, t
);
666 /* Do not inherit to_search_memory. */
667 INHERIT (to_supports_multi_process
, t
);
668 INHERIT (to_supports_enable_disable_tracepoint
, t
);
669 INHERIT (to_supports_string_tracing
, t
);
670 INHERIT (to_trace_init
, t
);
671 INHERIT (to_download_tracepoint
, t
);
672 INHERIT (to_can_download_tracepoint
, t
);
673 INHERIT (to_download_trace_state_variable
, t
);
674 INHERIT (to_enable_tracepoint
, t
);
675 INHERIT (to_disable_tracepoint
, t
);
676 INHERIT (to_trace_set_readonly_regions
, t
);
677 INHERIT (to_trace_start
, t
);
678 INHERIT (to_get_trace_status
, t
);
679 INHERIT (to_get_tracepoint_status
, t
);
680 INHERIT (to_trace_stop
, t
);
681 INHERIT (to_trace_find
, t
);
682 INHERIT (to_get_trace_state_variable_value
, t
);
683 INHERIT (to_save_trace_data
, t
);
684 INHERIT (to_upload_tracepoints
, t
);
685 INHERIT (to_upload_trace_state_variables
, t
);
686 INHERIT (to_get_raw_trace_data
, t
);
687 INHERIT (to_get_min_fast_tracepoint_insn_len
, t
);
688 INHERIT (to_set_disconnected_tracing
, t
);
689 INHERIT (to_set_circular_trace_buffer
, t
);
690 INHERIT (to_set_trace_buffer_size
, t
);
691 INHERIT (to_set_trace_notes
, t
);
692 INHERIT (to_get_tib_address
, t
);
693 INHERIT (to_set_permissions
, t
);
694 INHERIT (to_static_tracepoint_marker_at
, t
);
695 INHERIT (to_static_tracepoint_markers_by_strid
, t
);
696 INHERIT (to_traceframe_info
, t
);
697 INHERIT (to_use_agent
, t
);
698 INHERIT (to_can_use_agent
, t
);
699 INHERIT (to_augmented_libraries_svr4_read
, t
);
700 INHERIT (to_magic
, t
);
701 INHERIT (to_supports_evaluation_of_breakpoint_conditions
, t
);
702 INHERIT (to_can_run_breakpoint_commands
, t
);
703 /* Do not inherit to_memory_map. */
704 /* Do not inherit to_flash_erase. */
705 /* Do not inherit to_flash_done. */
709 /* Clean up a target struct so it no longer has any zero pointers in
710 it. Some entries are defaulted to a method that print an error,
711 others are hard-wired to a standard recursive default. */
713 #define de_fault(field, value) \
714 if (!current_target.field) \
715 current_target.field = value
718 (void (*) (char *, int))
721 (void (*) (struct target_ops
*))
723 de_fault (to_post_attach
,
726 de_fault (to_prepare_to_store
,
727 (void (*) (struct target_ops
*, struct regcache
*))
729 de_fault (deprecated_xfer_memory
,
730 (int (*) (CORE_ADDR
, gdb_byte
*, int, int,
731 struct mem_attrib
*, struct target_ops
*))
733 de_fault (to_files_info
,
734 (void (*) (struct target_ops
*))
736 de_fault (to_can_use_hw_breakpoint
,
737 (int (*) (int, int, int))
739 de_fault (to_insert_hw_breakpoint
,
740 (int (*) (struct gdbarch
*, struct bp_target_info
*))
742 de_fault (to_remove_hw_breakpoint
,
743 (int (*) (struct gdbarch
*, struct bp_target_info
*))
745 de_fault (to_insert_watchpoint
,
746 (int (*) (CORE_ADDR
, int, int, struct expression
*))
748 de_fault (to_remove_watchpoint
,
749 (int (*) (CORE_ADDR
, int, int, struct expression
*))
751 de_fault (to_watchpoint_addr_within_range
,
752 default_watchpoint_addr_within_range
);
753 de_fault (to_region_ok_for_hw_watchpoint
,
754 default_region_ok_for_hw_watchpoint
);
755 de_fault (to_can_accel_watchpoint_condition
,
756 (int (*) (CORE_ADDR
, int, int, struct expression
*))
758 de_fault (to_terminal_init
,
761 de_fault (to_terminal_inferior
,
764 de_fault (to_terminal_ours_for_output
,
767 de_fault (to_terminal_ours
,
770 de_fault (to_terminal_save_ours
,
773 de_fault (to_terminal_info
,
774 default_terminal_info
);
776 (void (*) (char *, int))
778 de_fault (to_post_startup_inferior
,
781 de_fault (to_insert_fork_catchpoint
,
784 de_fault (to_remove_fork_catchpoint
,
787 de_fault (to_insert_vfork_catchpoint
,
790 de_fault (to_remove_vfork_catchpoint
,
793 de_fault (to_insert_exec_catchpoint
,
796 de_fault (to_remove_exec_catchpoint
,
799 de_fault (to_set_syscall_catchpoint
,
800 (int (*) (int, int, int, int, int *))
802 de_fault (to_has_exited
,
803 (int (*) (int, int, int *))
805 de_fault (to_can_run
,
807 de_fault (to_extra_thread_info
,
808 (char *(*) (struct thread_info
*))
810 de_fault (to_thread_name
,
811 (char *(*) (struct thread_info
*))
817 (void (*) (char *, struct ui_file
*))
819 de_fault (to_pid_to_exec_file
,
822 de_fault (to_thread_architecture
,
823 default_thread_architecture
);
824 current_target
.to_read_description
= NULL
;
825 de_fault (to_get_ada_task_ptid
,
826 (ptid_t (*) (long, long))
827 default_get_ada_task_ptid
);
828 de_fault (to_supports_multi_process
,
831 de_fault (to_supports_enable_disable_tracepoint
,
834 de_fault (to_supports_string_tracing
,
837 de_fault (to_trace_init
,
840 de_fault (to_download_tracepoint
,
841 (void (*) (struct bp_location
*))
843 de_fault (to_can_download_tracepoint
,
846 de_fault (to_download_trace_state_variable
,
847 (void (*) (struct trace_state_variable
*))
849 de_fault (to_enable_tracepoint
,
850 (void (*) (struct bp_location
*))
852 de_fault (to_disable_tracepoint
,
853 (void (*) (struct bp_location
*))
855 de_fault (to_trace_set_readonly_regions
,
858 de_fault (to_trace_start
,
861 de_fault (to_get_trace_status
,
862 (int (*) (struct trace_status
*))
864 de_fault (to_get_tracepoint_status
,
865 (void (*) (struct breakpoint
*, struct uploaded_tp
*))
867 de_fault (to_trace_stop
,
870 de_fault (to_trace_find
,
871 (int (*) (enum trace_find_type
, int, CORE_ADDR
, CORE_ADDR
, int *))
873 de_fault (to_get_trace_state_variable_value
,
874 (int (*) (int, LONGEST
*))
876 de_fault (to_save_trace_data
,
877 (int (*) (const char *))
879 de_fault (to_upload_tracepoints
,
880 (int (*) (struct uploaded_tp
**))
882 de_fault (to_upload_trace_state_variables
,
883 (int (*) (struct uploaded_tsv
**))
885 de_fault (to_get_raw_trace_data
,
886 (LONGEST (*) (gdb_byte
*, ULONGEST
, LONGEST
))
888 de_fault (to_get_min_fast_tracepoint_insn_len
,
891 de_fault (to_set_disconnected_tracing
,
894 de_fault (to_set_circular_trace_buffer
,
897 de_fault (to_set_trace_buffer_size
,
900 de_fault (to_set_trace_notes
,
901 (int (*) (const char *, const char *, const char *))
903 de_fault (to_get_tib_address
,
904 (int (*) (ptid_t
, CORE_ADDR
*))
906 de_fault (to_set_permissions
,
909 de_fault (to_static_tracepoint_marker_at
,
910 (int (*) (CORE_ADDR
, struct static_tracepoint_marker
*))
912 de_fault (to_static_tracepoint_markers_by_strid
,
913 (VEC(static_tracepoint_marker_p
) * (*) (const char *))
915 de_fault (to_traceframe_info
,
916 (struct traceframe_info
* (*) (void))
918 de_fault (to_supports_evaluation_of_breakpoint_conditions
,
921 de_fault (to_can_run_breakpoint_commands
,
924 de_fault (to_use_agent
,
927 de_fault (to_can_use_agent
,
930 de_fault (to_augmented_libraries_svr4_read
,
933 de_fault (to_execution_direction
, default_execution_direction
);
937 /* Finally, position the target-stack beneath the squashed
938 "current_target". That way code looking for a non-inherited
939 target method can quickly and simply find it. */
940 current_target
.beneath
= target_stack
;
943 setup_target_debug ();
946 /* Push a new target type into the stack of the existing target accessors,
947 possibly superseding some of the existing accessors.
949 Rather than allow an empty stack, we always have the dummy target at
950 the bottom stratum, so we can call the function vectors without
954 push_target (struct target_ops
*t
)
956 struct target_ops
**cur
;
958 /* Check magic number. If wrong, it probably means someone changed
959 the struct definition, but not all the places that initialize one. */
960 if (t
->to_magic
!= OPS_MAGIC
)
962 fprintf_unfiltered (gdb_stderr
,
963 "Magic number of %s target struct wrong\n",
965 internal_error (__FILE__
, __LINE__
,
966 _("failed internal consistency check"));
969 /* Find the proper stratum to install this target in. */
970 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
972 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
976 /* If there's already targets at this stratum, remove them. */
977 /* FIXME: cagney/2003-10-15: I think this should be popping all
978 targets to CUR, and not just those at this stratum level. */
979 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
981 /* There's already something at this stratum level. Close it,
982 and un-hook it from the stack. */
983 struct target_ops
*tmp
= (*cur
);
985 (*cur
) = (*cur
)->beneath
;
990 /* We have removed all targets in our stratum, now add the new one. */
994 update_current_target ();
997 /* Remove a target_ops vector from the stack, wherever it may be.
998 Return how many times it was removed (0 or 1). */
1001 unpush_target (struct target_ops
*t
)
1003 struct target_ops
**cur
;
1004 struct target_ops
*tmp
;
1006 if (t
->to_stratum
== dummy_stratum
)
1007 internal_error (__FILE__
, __LINE__
,
1008 _("Attempt to unpush the dummy target"));
1010 /* Look for the specified target. Note that we assume that a target
1011 can only occur once in the target stack. */
1013 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1019 /* If we don't find target_ops, quit. Only open targets should be
1024 /* Unchain the target. */
1026 (*cur
) = (*cur
)->beneath
;
1027 tmp
->beneath
= NULL
;
1029 update_current_target ();
1031 /* Finally close the target. Note we do this after unchaining, so
1032 any target method calls from within the target_close
1033 implementation don't end up in T anymore. */
1040 pop_all_targets_above (enum strata above_stratum
)
1042 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
1044 if (!unpush_target (target_stack
))
1046 fprintf_unfiltered (gdb_stderr
,
1047 "pop_all_targets couldn't find target %s\n",
1048 target_stack
->to_shortname
);
1049 internal_error (__FILE__
, __LINE__
,
1050 _("failed internal consistency check"));
1057 pop_all_targets (void)
1059 pop_all_targets_above (dummy_stratum
);
1062 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
1065 target_is_pushed (struct target_ops
*t
)
1067 struct target_ops
**cur
;
1069 /* Check magic number. If wrong, it probably means someone changed
1070 the struct definition, but not all the places that initialize one. */
1071 if (t
->to_magic
!= OPS_MAGIC
)
1073 fprintf_unfiltered (gdb_stderr
,
1074 "Magic number of %s target struct wrong\n",
1076 internal_error (__FILE__
, __LINE__
,
1077 _("failed internal consistency check"));
1080 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1087 /* Using the objfile specified in OBJFILE, find the address for the
1088 current thread's thread-local storage with offset OFFSET. */
1090 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
1092 volatile CORE_ADDR addr
= 0;
1093 struct target_ops
*target
;
1095 for (target
= current_target
.beneath
;
1097 target
= target
->beneath
)
1099 if (target
->to_get_thread_local_address
!= NULL
)
1104 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
1106 ptid_t ptid
= inferior_ptid
;
1107 volatile struct gdb_exception ex
;
1109 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1113 /* Fetch the load module address for this objfile. */
1114 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch (),
1116 /* If it's 0, throw the appropriate exception. */
1118 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
1119 _("TLS load module not found"));
1121 addr
= target
->to_get_thread_local_address (target
, ptid
,
1124 /* If an error occurred, print TLS related messages here. Otherwise,
1125 throw the error to some higher catcher. */
1128 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1132 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
1133 error (_("Cannot find thread-local variables "
1134 "in this thread library."));
1136 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
1137 if (objfile_is_library
)
1138 error (_("Cannot find shared library `%s' in dynamic"
1139 " linker's load module list"), objfile_name (objfile
));
1141 error (_("Cannot find executable file `%s' in dynamic"
1142 " linker's load module list"), objfile_name (objfile
));
1144 case TLS_NOT_ALLOCATED_YET_ERROR
:
1145 if (objfile_is_library
)
1146 error (_("The inferior has not yet allocated storage for"
1147 " thread-local variables in\n"
1148 "the shared library `%s'\n"
1150 objfile_name (objfile
), target_pid_to_str (ptid
));
1152 error (_("The inferior has not yet allocated storage for"
1153 " thread-local variables in\n"
1154 "the executable `%s'\n"
1156 objfile_name (objfile
), target_pid_to_str (ptid
));
1158 case TLS_GENERIC_ERROR
:
1159 if (objfile_is_library
)
1160 error (_("Cannot find thread-local storage for %s, "
1161 "shared library %s:\n%s"),
1162 target_pid_to_str (ptid
),
1163 objfile_name (objfile
), ex
.message
);
1165 error (_("Cannot find thread-local storage for %s, "
1166 "executable file %s:\n%s"),
1167 target_pid_to_str (ptid
),
1168 objfile_name (objfile
), ex
.message
);
1171 throw_exception (ex
);
1176 /* It wouldn't be wrong here to try a gdbarch method, too; finding
1177 TLS is an ABI-specific thing. But we don't do that yet. */
1179 error (_("Cannot find thread-local variables on this target"));
1185 target_xfer_status_to_string (enum target_xfer_status err
)
1187 #define CASE(X) case X: return #X
1190 CASE(TARGET_XFER_E_IO
);
1191 CASE(TARGET_XFER_E_UNAVAILABLE
);
1200 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1202 /* target_read_string -- read a null terminated string, up to LEN bytes,
1203 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1204 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1205 is responsible for freeing it. Return the number of bytes successfully
1209 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
1211 int tlen
, offset
, i
;
1215 int buffer_allocated
;
1217 unsigned int nbytes_read
= 0;
1219 gdb_assert (string
);
1221 /* Small for testing. */
1222 buffer_allocated
= 4;
1223 buffer
= xmalloc (buffer_allocated
);
1228 tlen
= MIN (len
, 4 - (memaddr
& 3));
1229 offset
= memaddr
& 3;
1231 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
1234 /* The transfer request might have crossed the boundary to an
1235 unallocated region of memory. Retry the transfer, requesting
1239 errcode
= target_read_memory (memaddr
, buf
, 1);
1244 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
1248 bytes
= bufptr
- buffer
;
1249 buffer_allocated
*= 2;
1250 buffer
= xrealloc (buffer
, buffer_allocated
);
1251 bufptr
= buffer
+ bytes
;
1254 for (i
= 0; i
< tlen
; i
++)
1256 *bufptr
++ = buf
[i
+ offset
];
1257 if (buf
[i
+ offset
] == '\000')
1259 nbytes_read
+= i
+ 1;
1266 nbytes_read
+= tlen
;
1275 struct target_section_table
*
1276 target_get_section_table (struct target_ops
*target
)
1278 struct target_ops
*t
;
1281 fprintf_unfiltered (gdb_stdlog
, "target_get_section_table ()\n");
1283 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1284 if (t
->to_get_section_table
!= NULL
)
1285 return (*t
->to_get_section_table
) (t
);
1290 /* Find a section containing ADDR. */
1292 struct target_section
*
1293 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1295 struct target_section_table
*table
= target_get_section_table (target
);
1296 struct target_section
*secp
;
1301 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
1303 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1309 /* Read memory from the live target, even if currently inspecting a
1310 traceframe. The return is the same as that of target_read. */
1312 static enum target_xfer_status
1313 target_read_live_memory (enum target_object object
,
1314 ULONGEST memaddr
, gdb_byte
*myaddr
, ULONGEST len
,
1315 ULONGEST
*xfered_len
)
1317 enum target_xfer_status ret
;
1318 struct cleanup
*cleanup
;
1320 /* Switch momentarily out of tfind mode so to access live memory.
1321 Note that this must not clear global state, such as the frame
1322 cache, which must still remain valid for the previous traceframe.
1323 We may be _building_ the frame cache at this point. */
1324 cleanup
= make_cleanup_restore_traceframe_number ();
1325 set_traceframe_number (-1);
1327 ret
= target_xfer_partial (current_target
.beneath
, object
, NULL
,
1328 myaddr
, NULL
, memaddr
, len
, xfered_len
);
1330 do_cleanups (cleanup
);
1334 /* Using the set of read-only target sections of OPS, read live
1335 read-only memory. Note that the actual reads start from the
1336 top-most target again.
1338 For interface/parameters/return description see target.h,
1341 static enum target_xfer_status
1342 memory_xfer_live_readonly_partial (struct target_ops
*ops
,
1343 enum target_object object
,
1344 gdb_byte
*readbuf
, ULONGEST memaddr
,
1345 ULONGEST len
, ULONGEST
*xfered_len
)
1347 struct target_section
*secp
;
1348 struct target_section_table
*table
;
1350 secp
= target_section_by_addr (ops
, memaddr
);
1352 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1353 secp
->the_bfd_section
)
1356 struct target_section
*p
;
1357 ULONGEST memend
= memaddr
+ len
;
1359 table
= target_get_section_table (ops
);
1361 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1363 if (memaddr
>= p
->addr
)
1365 if (memend
<= p
->endaddr
)
1367 /* Entire transfer is within this section. */
1368 return target_read_live_memory (object
, memaddr
,
1369 readbuf
, len
, xfered_len
);
1371 else if (memaddr
>= p
->endaddr
)
1373 /* This section ends before the transfer starts. */
1378 /* This section overlaps the transfer. Just do half. */
1379 len
= p
->endaddr
- memaddr
;
1380 return target_read_live_memory (object
, memaddr
,
1381 readbuf
, len
, xfered_len
);
1387 return TARGET_XFER_EOF
;
1390 /* Read memory from more than one valid target. A core file, for
1391 instance, could have some of memory but delegate other bits to
1392 the target below it. So, we must manually try all targets. */
1394 static enum target_xfer_status
1395 raw_memory_xfer_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
1396 const gdb_byte
*writebuf
, ULONGEST memaddr
, LONGEST len
,
1397 ULONGEST
*xfered_len
)
1399 enum target_xfer_status res
;
1403 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1404 readbuf
, writebuf
, memaddr
, len
,
1406 if (res
== TARGET_XFER_OK
)
1409 /* Stop if the target reports that the memory is not available. */
1410 if (res
== TARGET_XFER_E_UNAVAILABLE
)
1413 /* We want to continue past core files to executables, but not
1414 past a running target's memory. */
1415 if (ops
->to_has_all_memory (ops
))
1420 while (ops
!= NULL
);
1425 /* Perform a partial memory transfer.
1426 For docs see target.h, to_xfer_partial. */
1428 static enum target_xfer_status
1429 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
1430 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
1431 ULONGEST len
, ULONGEST
*xfered_len
)
1433 enum target_xfer_status res
;
1435 struct mem_region
*region
;
1436 struct inferior
*inf
;
1438 /* For accesses to unmapped overlay sections, read directly from
1439 files. Must do this first, as MEMADDR may need adjustment. */
1440 if (readbuf
!= NULL
&& overlay_debugging
)
1442 struct obj_section
*section
= find_pc_overlay (memaddr
);
1444 if (pc_in_unmapped_range (memaddr
, section
))
1446 struct target_section_table
*table
1447 = target_get_section_table (ops
);
1448 const char *section_name
= section
->the_bfd_section
->name
;
1450 memaddr
= overlay_mapped_address (memaddr
, section
);
1451 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1452 memaddr
, len
, xfered_len
,
1454 table
->sections_end
,
1459 /* Try the executable files, if "trust-readonly-sections" is set. */
1460 if (readbuf
!= NULL
&& trust_readonly
)
1462 struct target_section
*secp
;
1463 struct target_section_table
*table
;
1465 secp
= target_section_by_addr (ops
, memaddr
);
1467 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1468 secp
->the_bfd_section
)
1471 table
= target_get_section_table (ops
);
1472 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1473 memaddr
, len
, xfered_len
,
1475 table
->sections_end
,
1480 /* If reading unavailable memory in the context of traceframes, and
1481 this address falls within a read-only section, fallback to
1482 reading from live memory. */
1483 if (readbuf
!= NULL
&& get_traceframe_number () != -1)
1485 VEC(mem_range_s
) *available
;
1487 /* If we fail to get the set of available memory, then the
1488 target does not support querying traceframe info, and so we
1489 attempt reading from the traceframe anyway (assuming the
1490 target implements the old QTro packet then). */
1491 if (traceframe_available_memory (&available
, memaddr
, len
))
1493 struct cleanup
*old_chain
;
1495 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
1497 if (VEC_empty (mem_range_s
, available
)
1498 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
1500 /* Don't read into the traceframe's available
1502 if (!VEC_empty (mem_range_s
, available
))
1504 LONGEST oldlen
= len
;
1506 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
1507 gdb_assert (len
<= oldlen
);
1510 do_cleanups (old_chain
);
1512 /* This goes through the topmost target again. */
1513 res
= memory_xfer_live_readonly_partial (ops
, object
,
1516 if (res
== TARGET_XFER_OK
)
1517 return TARGET_XFER_OK
;
1520 /* No use trying further, we know some memory starting
1521 at MEMADDR isn't available. */
1523 return TARGET_XFER_E_UNAVAILABLE
;
1527 /* Don't try to read more than how much is available, in
1528 case the target implements the deprecated QTro packet to
1529 cater for older GDBs (the target's knowledge of read-only
1530 sections may be outdated by now). */
1531 len
= VEC_index (mem_range_s
, available
, 0)->length
;
1533 do_cleanups (old_chain
);
1537 /* Try GDB's internal data cache. */
1538 region
= lookup_mem_region (memaddr
);
1539 /* region->hi == 0 means there's no upper bound. */
1540 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1543 reg_len
= region
->hi
- memaddr
;
1545 switch (region
->attrib
.mode
)
1548 if (writebuf
!= NULL
)
1549 return TARGET_XFER_E_IO
;
1553 if (readbuf
!= NULL
)
1554 return TARGET_XFER_E_IO
;
1558 /* We only support writing to flash during "load" for now. */
1559 if (writebuf
!= NULL
)
1560 error (_("Writing to flash memory forbidden in this context"));
1564 return TARGET_XFER_E_IO
;
1567 if (!ptid_equal (inferior_ptid
, null_ptid
))
1568 inf
= find_inferior_pid (ptid_get_pid (inferior_ptid
));
1573 /* The dcache reads whole cache lines; that doesn't play well
1574 with reading from a trace buffer, because reading outside of
1575 the collected memory range fails. */
1576 && get_traceframe_number () == -1
1577 && (region
->attrib
.cache
1578 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1579 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1581 DCACHE
*dcache
= target_dcache_get_or_init ();
1584 if (readbuf
!= NULL
)
1585 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, readbuf
, reg_len
, 0);
1587 /* FIXME drow/2006-08-09: If we're going to preserve const
1588 correctness dcache_xfer_memory should take readbuf and
1590 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, (void *) writebuf
,
1593 return TARGET_XFER_E_IO
;
1596 *xfered_len
= (ULONGEST
) l
;
1597 return TARGET_XFER_OK
;
1601 /* If none of those methods found the memory we wanted, fall back
1602 to a target partial transfer. Normally a single call to
1603 to_xfer_partial is enough; if it doesn't recognize an object
1604 it will call the to_xfer_partial of the next target down.
1605 But for memory this won't do. Memory is the only target
1606 object which can be read from more than one valid target.
1607 A core file, for instance, could have some of memory but
1608 delegate other bits to the target below it. So, we must
1609 manually try all targets. */
1611 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
,
1614 /* Make sure the cache gets updated no matter what - if we are writing
1615 to the stack. Even if this write is not tagged as such, we still need
1616 to update the cache. */
1618 if (res
== TARGET_XFER_OK
1621 && target_dcache_init_p ()
1622 && !region
->attrib
.cache
1623 && ((stack_cache_enabled_p () && object
!= TARGET_OBJECT_STACK_MEMORY
)
1624 || (code_cache_enabled_p () && object
!= TARGET_OBJECT_CODE_MEMORY
)))
1626 DCACHE
*dcache
= target_dcache_get ();
1628 dcache_update (dcache
, memaddr
, (void *) writebuf
, reg_len
);
1631 /* If we still haven't got anything, return the last error. We
1636 /* Perform a partial memory transfer. For docs see target.h,
1639 static enum target_xfer_status
1640 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1641 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1642 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1644 enum target_xfer_status res
;
1646 /* Zero length requests are ok and require no work. */
1648 return TARGET_XFER_EOF
;
1650 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1651 breakpoint insns, thus hiding out from higher layers whether
1652 there are software breakpoints inserted in the code stream. */
1653 if (readbuf
!= NULL
)
1655 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
,
1658 if (res
== TARGET_XFER_OK
&& !show_memory_breakpoints
)
1659 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, res
);
1664 struct cleanup
*old_chain
;
1666 /* A large write request is likely to be partially satisfied
1667 by memory_xfer_partial_1. We will continually malloc
1668 and free a copy of the entire write request for breakpoint
1669 shadow handling even though we only end up writing a small
1670 subset of it. Cap writes to 4KB to mitigate this. */
1671 len
= min (4096, len
);
1673 buf
= xmalloc (len
);
1674 old_chain
= make_cleanup (xfree
, buf
);
1675 memcpy (buf
, writebuf
, len
);
1677 breakpoint_xfer_memory (NULL
, buf
, writebuf
, memaddr
, len
);
1678 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
, memaddr
, len
,
1681 do_cleanups (old_chain
);
1688 restore_show_memory_breakpoints (void *arg
)
1690 show_memory_breakpoints
= (uintptr_t) arg
;
1694 make_show_memory_breakpoints_cleanup (int show
)
1696 int current
= show_memory_breakpoints
;
1698 show_memory_breakpoints
= show
;
1699 return make_cleanup (restore_show_memory_breakpoints
,
1700 (void *) (uintptr_t) current
);
1703 /* For docs see target.h, to_xfer_partial. */
1705 enum target_xfer_status
1706 target_xfer_partial (struct target_ops
*ops
,
1707 enum target_object object
, const char *annex
,
1708 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1709 ULONGEST offset
, ULONGEST len
,
1710 ULONGEST
*xfered_len
)
1712 enum target_xfer_status retval
;
1714 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1716 /* Transfer is done when LEN is zero. */
1718 return TARGET_XFER_EOF
;
1720 if (writebuf
&& !may_write_memory
)
1721 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1722 core_addr_to_string_nz (offset
), plongest (len
));
1726 /* If this is a memory transfer, let the memory-specific code
1727 have a look at it instead. Memory transfers are more
1729 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1730 || object
== TARGET_OBJECT_CODE_MEMORY
)
1731 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1732 writebuf
, offset
, len
, xfered_len
);
1733 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1735 /* Request the normal memory object from other layers. */
1736 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
,
1740 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
,
1741 writebuf
, offset
, len
, xfered_len
);
1745 const unsigned char *myaddr
= NULL
;
1747 fprintf_unfiltered (gdb_stdlog
,
1748 "%s:target_xfer_partial "
1749 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1752 (annex
? annex
: "(null)"),
1753 host_address_to_string (readbuf
),
1754 host_address_to_string (writebuf
),
1755 core_addr_to_string_nz (offset
),
1756 pulongest (len
), retval
,
1757 pulongest (*xfered_len
));
1763 if (retval
== TARGET_XFER_OK
&& myaddr
!= NULL
)
1767 fputs_unfiltered (", bytes =", gdb_stdlog
);
1768 for (i
= 0; i
< *xfered_len
; i
++)
1770 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1772 if (targetdebug
< 2 && i
> 0)
1774 fprintf_unfiltered (gdb_stdlog
, " ...");
1777 fprintf_unfiltered (gdb_stdlog
, "\n");
1780 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1784 fputc_unfiltered ('\n', gdb_stdlog
);
1787 /* Check implementations of to_xfer_partial update *XFERED_LEN
1788 properly. Do assertion after printing debug messages, so that we
1789 can find more clues on assertion failure from debugging messages. */
1790 if (retval
== TARGET_XFER_OK
|| retval
== TARGET_XFER_E_UNAVAILABLE
)
1791 gdb_assert (*xfered_len
> 0);
1796 /* Read LEN bytes of target memory at address MEMADDR, placing the
1797 results in GDB's memory at MYADDR. Returns either 0 for success or
1798 TARGET_XFER_E_IO if any error occurs.
1800 If an error occurs, no guarantee is made about the contents of the data at
1801 MYADDR. In particular, the caller should not depend upon partial reads
1802 filling the buffer with good data. There is no way for the caller to know
1803 how much good data might have been transfered anyway. Callers that can
1804 deal with partial reads should call target_read (which will retry until
1805 it makes no progress, and then return how much was transferred). */
1808 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1810 /* Dispatch to the topmost target, not the flattened current_target.
1811 Memory accesses check target->to_has_(all_)memory, and the
1812 flattened target doesn't inherit those. */
1813 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1814 myaddr
, memaddr
, len
) == len
)
1817 return TARGET_XFER_E_IO
;
1820 /* Like target_read_memory, but specify explicitly that this is a read
1821 from the target's raw memory. That is, this read bypasses the
1822 dcache, breakpoint shadowing, etc. */
1825 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1827 /* See comment in target_read_memory about why the request starts at
1828 current_target.beneath. */
1829 if (target_read (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1830 myaddr
, memaddr
, len
) == len
)
1833 return TARGET_XFER_E_IO
;
1836 /* Like target_read_memory, but specify explicitly that this is a read from
1837 the target's stack. This may trigger different cache behavior. */
1840 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1842 /* See comment in target_read_memory about why the request starts at
1843 current_target.beneath. */
1844 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1845 myaddr
, memaddr
, len
) == len
)
1848 return TARGET_XFER_E_IO
;
1851 /* Like target_read_memory, but specify explicitly that this is a read from
1852 the target's code. This may trigger different cache behavior. */
1855 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1857 /* See comment in target_read_memory about why the request starts at
1858 current_target.beneath. */
1859 if (target_read (current_target
.beneath
, TARGET_OBJECT_CODE_MEMORY
, NULL
,
1860 myaddr
, memaddr
, len
) == len
)
1863 return TARGET_XFER_E_IO
;
1866 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1867 Returns either 0 for success or TARGET_XFER_E_IO if any
1868 error occurs. If an error occurs, no guarantee is made about how
1869 much data got written. Callers that can deal with partial writes
1870 should call target_write. */
1873 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1875 /* See comment in target_read_memory about why the request starts at
1876 current_target.beneath. */
1877 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1878 myaddr
, memaddr
, len
) == len
)
1881 return TARGET_XFER_E_IO
;
1884 /* Write LEN bytes from MYADDR to target raw memory at address
1885 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1886 if any error occurs. If an error occurs, no guarantee is made
1887 about how much data got written. Callers that can deal with
1888 partial writes should call target_write. */
1891 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1893 /* See comment in target_read_memory about why the request starts at
1894 current_target.beneath. */
1895 if (target_write (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1896 myaddr
, memaddr
, len
) == len
)
1899 return TARGET_XFER_E_IO
;
1902 /* Fetch the target's memory map. */
1905 target_memory_map (void)
1907 VEC(mem_region_s
) *result
;
1908 struct mem_region
*last_one
, *this_one
;
1910 struct target_ops
*t
;
1913 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1915 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1916 if (t
->to_memory_map
!= NULL
)
1922 result
= t
->to_memory_map (t
);
1926 qsort (VEC_address (mem_region_s
, result
),
1927 VEC_length (mem_region_s
, result
),
1928 sizeof (struct mem_region
), mem_region_cmp
);
1930 /* Check that regions do not overlap. Simultaneously assign
1931 a numbering for the "mem" commands to use to refer to
1934 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1936 this_one
->number
= ix
;
1938 if (last_one
&& last_one
->hi
> this_one
->lo
)
1940 warning (_("Overlapping regions in memory map: ignoring"));
1941 VEC_free (mem_region_s
, result
);
1944 last_one
= this_one
;
1951 target_flash_erase (ULONGEST address
, LONGEST length
)
1953 struct target_ops
*t
;
1955 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1956 if (t
->to_flash_erase
!= NULL
)
1959 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1960 hex_string (address
), phex (length
, 0));
1961 t
->to_flash_erase (t
, address
, length
);
1969 target_flash_done (void)
1971 struct target_ops
*t
;
1973 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1974 if (t
->to_flash_done
!= NULL
)
1977 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1978 t
->to_flash_done (t
);
1986 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1987 struct cmd_list_element
*c
, const char *value
)
1989 fprintf_filtered (file
,
1990 _("Mode for reading from readonly sections is %s.\n"),
1994 /* More generic transfers. */
1996 static enum target_xfer_status
1997 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1998 const char *annex
, gdb_byte
*readbuf
,
1999 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2000 ULONGEST
*xfered_len
)
2002 if (object
== TARGET_OBJECT_MEMORY
2003 && ops
->deprecated_xfer_memory
!= NULL
)
2004 /* If available, fall back to the target's
2005 "deprecated_xfer_memory" method. */
2010 if (writebuf
!= NULL
)
2012 void *buffer
= xmalloc (len
);
2013 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
2015 memcpy (buffer
, writebuf
, len
);
2016 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
2017 1/*write*/, NULL
, ops
);
2018 do_cleanups (cleanup
);
2020 if (readbuf
!= NULL
)
2021 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
2022 0/*read*/, NULL
, ops
);
2025 *xfered_len
= (ULONGEST
) xfered
;
2026 return TARGET_XFER_E_IO
;
2028 else if (xfered
== 0 && errno
== 0)
2029 /* "deprecated_xfer_memory" uses 0, cross checked against
2030 ERRNO as one indication of an error. */
2031 return TARGET_XFER_EOF
;
2033 return TARGET_XFER_E_IO
;
2037 gdb_assert (ops
->beneath
!= NULL
);
2038 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2039 readbuf
, writebuf
, offset
, len
,
2044 /* Target vector read/write partial wrapper functions. */
2046 static enum target_xfer_status
2047 target_read_partial (struct target_ops
*ops
,
2048 enum target_object object
,
2049 const char *annex
, gdb_byte
*buf
,
2050 ULONGEST offset
, ULONGEST len
,
2051 ULONGEST
*xfered_len
)
2053 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
,
2057 static enum target_xfer_status
2058 target_write_partial (struct target_ops
*ops
,
2059 enum target_object object
,
2060 const char *annex
, const gdb_byte
*buf
,
2061 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
2063 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
,
2067 /* Wrappers to perform the full transfer. */
2069 /* For docs on target_read see target.h. */
2072 target_read (struct target_ops
*ops
,
2073 enum target_object object
,
2074 const char *annex
, gdb_byte
*buf
,
2075 ULONGEST offset
, LONGEST len
)
2079 while (xfered
< len
)
2081 ULONGEST xfered_len
;
2082 enum target_xfer_status status
;
2084 status
= target_read_partial (ops
, object
, annex
,
2085 (gdb_byte
*) buf
+ xfered
,
2086 offset
+ xfered
, len
- xfered
,
2089 /* Call an observer, notifying them of the xfer progress? */
2090 if (status
== TARGET_XFER_EOF
)
2092 else if (status
== TARGET_XFER_OK
)
2094 xfered
+= xfered_len
;
2104 /* Assuming that the entire [begin, end) range of memory cannot be
2105 read, try to read whatever subrange is possible to read.
2107 The function returns, in RESULT, either zero or one memory block.
2108 If there's a readable subrange at the beginning, it is completely
2109 read and returned. Any further readable subrange will not be read.
2110 Otherwise, if there's a readable subrange at the end, it will be
2111 completely read and returned. Any readable subranges before it
2112 (obviously, not starting at the beginning), will be ignored. In
2113 other cases -- either no readable subrange, or readable subrange(s)
2114 that is neither at the beginning, or end, nothing is returned.
2116 The purpose of this function is to handle a read across a boundary
2117 of accessible memory in a case when memory map is not available.
2118 The above restrictions are fine for this case, but will give
2119 incorrect results if the memory is 'patchy'. However, supporting
2120 'patchy' memory would require trying to read every single byte,
2121 and it seems unacceptable solution. Explicit memory map is
2122 recommended for this case -- and target_read_memory_robust will
2123 take care of reading multiple ranges then. */
2126 read_whatever_is_readable (struct target_ops
*ops
,
2127 ULONGEST begin
, ULONGEST end
,
2128 VEC(memory_read_result_s
) **result
)
2130 gdb_byte
*buf
= xmalloc (end
- begin
);
2131 ULONGEST current_begin
= begin
;
2132 ULONGEST current_end
= end
;
2134 memory_read_result_s r
;
2135 ULONGEST xfered_len
;
2137 /* If we previously failed to read 1 byte, nothing can be done here. */
2138 if (end
- begin
<= 1)
2144 /* Check that either first or the last byte is readable, and give up
2145 if not. This heuristic is meant to permit reading accessible memory
2146 at the boundary of accessible region. */
2147 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2148 buf
, begin
, 1, &xfered_len
) == TARGET_XFER_OK
)
2153 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2154 buf
+ (end
-begin
) - 1, end
- 1, 1,
2155 &xfered_len
) == TARGET_XFER_OK
)
2166 /* Loop invariant is that the [current_begin, current_end) was previously
2167 found to be not readable as a whole.
2169 Note loop condition -- if the range has 1 byte, we can't divide the range
2170 so there's no point trying further. */
2171 while (current_end
- current_begin
> 1)
2173 ULONGEST first_half_begin
, first_half_end
;
2174 ULONGEST second_half_begin
, second_half_end
;
2176 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
2180 first_half_begin
= current_begin
;
2181 first_half_end
= middle
;
2182 second_half_begin
= middle
;
2183 second_half_end
= current_end
;
2187 first_half_begin
= middle
;
2188 first_half_end
= current_end
;
2189 second_half_begin
= current_begin
;
2190 second_half_end
= middle
;
2193 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2194 buf
+ (first_half_begin
- begin
),
2196 first_half_end
- first_half_begin
);
2198 if (xfer
== first_half_end
- first_half_begin
)
2200 /* This half reads up fine. So, the error must be in the
2202 current_begin
= second_half_begin
;
2203 current_end
= second_half_end
;
2207 /* This half is not readable. Because we've tried one byte, we
2208 know some part of this half if actually redable. Go to the next
2209 iteration to divide again and try to read.
2211 We don't handle the other half, because this function only tries
2212 to read a single readable subrange. */
2213 current_begin
= first_half_begin
;
2214 current_end
= first_half_end
;
2220 /* The [begin, current_begin) range has been read. */
2222 r
.end
= current_begin
;
2227 /* The [current_end, end) range has been read. */
2228 LONGEST rlen
= end
- current_end
;
2230 r
.data
= xmalloc (rlen
);
2231 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
2232 r
.begin
= current_end
;
2236 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
2240 free_memory_read_result_vector (void *x
)
2242 VEC(memory_read_result_s
) *v
= x
;
2243 memory_read_result_s
*current
;
2246 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
2248 xfree (current
->data
);
2250 VEC_free (memory_read_result_s
, v
);
2253 VEC(memory_read_result_s
) *
2254 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
2256 VEC(memory_read_result_s
) *result
= 0;
2259 while (xfered
< len
)
2261 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
2264 /* If there is no explicit region, a fake one should be created. */
2265 gdb_assert (region
);
2267 if (region
->hi
== 0)
2268 rlen
= len
- xfered
;
2270 rlen
= region
->hi
- offset
;
2272 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
2274 /* Cannot read this region. Note that we can end up here only
2275 if the region is explicitly marked inaccessible, or
2276 'inaccessible-by-default' is in effect. */
2281 LONGEST to_read
= min (len
- xfered
, rlen
);
2282 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
2284 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2285 (gdb_byte
*) buffer
,
2286 offset
+ xfered
, to_read
);
2287 /* Call an observer, notifying them of the xfer progress? */
2290 /* Got an error reading full chunk. See if maybe we can read
2293 read_whatever_is_readable (ops
, offset
+ xfered
,
2294 offset
+ xfered
+ to_read
, &result
);
2299 struct memory_read_result r
;
2301 r
.begin
= offset
+ xfered
;
2302 r
.end
= r
.begin
+ xfer
;
2303 VEC_safe_push (memory_read_result_s
, result
, &r
);
2313 /* An alternative to target_write with progress callbacks. */
2316 target_write_with_progress (struct target_ops
*ops
,
2317 enum target_object object
,
2318 const char *annex
, const gdb_byte
*buf
,
2319 ULONGEST offset
, LONGEST len
,
2320 void (*progress
) (ULONGEST
, void *), void *baton
)
2324 /* Give the progress callback a chance to set up. */
2326 (*progress
) (0, baton
);
2328 while (xfered
< len
)
2330 ULONGEST xfered_len
;
2331 enum target_xfer_status status
;
2333 status
= target_write_partial (ops
, object
, annex
,
2334 (gdb_byte
*) buf
+ xfered
,
2335 offset
+ xfered
, len
- xfered
,
2338 if (status
== TARGET_XFER_EOF
)
2340 if (TARGET_XFER_STATUS_ERROR_P (status
))
2343 gdb_assert (status
== TARGET_XFER_OK
);
2345 (*progress
) (xfered_len
, baton
);
2347 xfered
+= xfered_len
;
2353 /* For docs on target_write see target.h. */
2356 target_write (struct target_ops
*ops
,
2357 enum target_object object
,
2358 const char *annex
, const gdb_byte
*buf
,
2359 ULONGEST offset
, LONGEST len
)
2361 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2365 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2366 the size of the transferred data. PADDING additional bytes are
2367 available in *BUF_P. This is a helper function for
2368 target_read_alloc; see the declaration of that function for more
2372 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2373 const char *annex
, gdb_byte
**buf_p
, int padding
)
2375 size_t buf_alloc
, buf_pos
;
2378 /* This function does not have a length parameter; it reads the
2379 entire OBJECT). Also, it doesn't support objects fetched partly
2380 from one target and partly from another (in a different stratum,
2381 e.g. a core file and an executable). Both reasons make it
2382 unsuitable for reading memory. */
2383 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2385 /* Start by reading up to 4K at a time. The target will throttle
2386 this number down if necessary. */
2388 buf
= xmalloc (buf_alloc
);
2392 ULONGEST xfered_len
;
2393 enum target_xfer_status status
;
2395 status
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2396 buf_pos
, buf_alloc
- buf_pos
- padding
,
2399 if (status
== TARGET_XFER_EOF
)
2401 /* Read all there was. */
2408 else if (status
!= TARGET_XFER_OK
)
2410 /* An error occurred. */
2412 return TARGET_XFER_E_IO
;
2415 buf_pos
+= xfered_len
;
2417 /* If the buffer is filling up, expand it. */
2418 if (buf_alloc
< buf_pos
* 2)
2421 buf
= xrealloc (buf
, buf_alloc
);
2428 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2429 the size of the transferred data. See the declaration in "target.h"
2430 function for more information about the return value. */
2433 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2434 const char *annex
, gdb_byte
**buf_p
)
2436 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2439 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2440 returned as a string, allocated using xmalloc. If an error occurs
2441 or the transfer is unsupported, NULL is returned. Empty objects
2442 are returned as allocated but empty strings. A warning is issued
2443 if the result contains any embedded NUL bytes. */
2446 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2451 LONGEST i
, transferred
;
2453 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2454 bufstr
= (char *) buffer
;
2456 if (transferred
< 0)
2459 if (transferred
== 0)
2460 return xstrdup ("");
2462 bufstr
[transferred
] = 0;
2464 /* Check for embedded NUL bytes; but allow trailing NULs. */
2465 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2468 warning (_("target object %d, annex %s, "
2469 "contained unexpected null characters"),
2470 (int) object
, annex
? annex
: "(none)");
2477 /* Memory transfer methods. */
2480 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2483 /* This method is used to read from an alternate, non-current
2484 target. This read must bypass the overlay support (as symbols
2485 don't match this target), and GDB's internal cache (wrong cache
2486 for this target). */
2487 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2489 memory_error (TARGET_XFER_E_IO
, addr
);
2493 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2494 int len
, enum bfd_endian byte_order
)
2496 gdb_byte buf
[sizeof (ULONGEST
)];
2498 gdb_assert (len
<= sizeof (buf
));
2499 get_target_memory (ops
, addr
, buf
, len
);
2500 return extract_unsigned_integer (buf
, len
, byte_order
);
2506 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2507 struct bp_target_info
*bp_tgt
)
2509 if (!may_insert_breakpoints
)
2511 warning (_("May not insert breakpoints"));
2515 return current_target
.to_insert_breakpoint (¤t_target
,
2522 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2523 struct bp_target_info
*bp_tgt
)
2525 /* This is kind of a weird case to handle, but the permission might
2526 have been changed after breakpoints were inserted - in which case
2527 we should just take the user literally and assume that any
2528 breakpoints should be left in place. */
2529 if (!may_insert_breakpoints
)
2531 warning (_("May not remove breakpoints"));
2535 return current_target
.to_remove_breakpoint (¤t_target
,
2540 target_info (char *args
, int from_tty
)
2542 struct target_ops
*t
;
2543 int has_all_mem
= 0;
2545 if (symfile_objfile
!= NULL
)
2546 printf_unfiltered (_("Symbols from \"%s\".\n"),
2547 objfile_name (symfile_objfile
));
2549 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2551 if (!(*t
->to_has_memory
) (t
))
2554 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2557 printf_unfiltered (_("\tWhile running this, "
2558 "GDB does not access memory from...\n"));
2559 printf_unfiltered ("%s:\n", t
->to_longname
);
2560 (t
->to_files_info
) (t
);
2561 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2565 /* This function is called before any new inferior is created, e.g.
2566 by running a program, attaching, or connecting to a target.
2567 It cleans up any state from previous invocations which might
2568 change between runs. This is a subset of what target_preopen
2569 resets (things which might change between targets). */
2572 target_pre_inferior (int from_tty
)
2574 /* Clear out solib state. Otherwise the solib state of the previous
2575 inferior might have survived and is entirely wrong for the new
2576 target. This has been observed on GNU/Linux using glibc 2.3. How
2588 Cannot access memory at address 0xdeadbeef
2591 /* In some OSs, the shared library list is the same/global/shared
2592 across inferiors. If code is shared between processes, so are
2593 memory regions and features. */
2594 if (!gdbarch_has_global_solist (target_gdbarch ()))
2596 no_shared_libraries (NULL
, from_tty
);
2598 invalidate_target_mem_regions ();
2600 target_clear_description ();
2603 agent_capability_invalidate ();
2606 /* Callback for iterate_over_inferiors. Gets rid of the given
2610 dispose_inferior (struct inferior
*inf
, void *args
)
2612 struct thread_info
*thread
;
2614 thread
= any_thread_of_process (inf
->pid
);
2617 switch_to_thread (thread
->ptid
);
2619 /* Core inferiors actually should be detached, not killed. */
2620 if (target_has_execution
)
2623 target_detach (NULL
, 0);
2629 /* This is to be called by the open routine before it does
2633 target_preopen (int from_tty
)
2637 if (have_inferiors ())
2640 || !have_live_inferiors ()
2641 || query (_("A program is being debugged already. Kill it? ")))
2642 iterate_over_inferiors (dispose_inferior
, NULL
);
2644 error (_("Program not killed."));
2647 /* Calling target_kill may remove the target from the stack. But if
2648 it doesn't (which seems like a win for UDI), remove it now. */
2649 /* Leave the exec target, though. The user may be switching from a
2650 live process to a core of the same program. */
2651 pop_all_targets_above (file_stratum
);
2653 target_pre_inferior (from_tty
);
2656 /* Detach a target after doing deferred register stores. */
2659 target_detach (const char *args
, int from_tty
)
2661 struct target_ops
* t
;
2663 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2664 /* Don't remove global breakpoints here. They're removed on
2665 disconnection from the target. */
2668 /* If we're in breakpoints-always-inserted mode, have to remove
2669 them before detaching. */
2670 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2672 prepare_for_detach ();
2674 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2676 if (t
->to_detach
!= NULL
)
2678 t
->to_detach (t
, args
, from_tty
);
2680 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2686 internal_error (__FILE__
, __LINE__
, _("could not find a target to detach"));
2690 target_disconnect (char *args
, int from_tty
)
2692 struct target_ops
*t
;
2694 /* If we're in breakpoints-always-inserted mode or if breakpoints
2695 are global across processes, we have to remove them before
2697 remove_breakpoints ();
2699 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2700 if (t
->to_disconnect
!= NULL
)
2703 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2705 t
->to_disconnect (t
, args
, from_tty
);
2713 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2715 struct target_ops
*t
;
2716 ptid_t retval
= (current_target
.to_wait
) (¤t_target
, ptid
,
2721 char *status_string
;
2722 char *options_string
;
2724 status_string
= target_waitstatus_to_string (status
);
2725 options_string
= target_options_to_string (options
);
2726 fprintf_unfiltered (gdb_stdlog
,
2727 "target_wait (%d, status, options={%s})"
2729 ptid_get_pid (ptid
), options_string
,
2730 ptid_get_pid (retval
), status_string
);
2731 xfree (status_string
);
2732 xfree (options_string
);
2739 target_pid_to_str (ptid_t ptid
)
2741 struct target_ops
*t
;
2743 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2745 if (t
->to_pid_to_str
!= NULL
)
2746 return (*t
->to_pid_to_str
) (t
, ptid
);
2749 return normal_pid_to_str (ptid
);
2753 target_thread_name (struct thread_info
*info
)
2755 struct target_ops
*t
;
2757 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2759 if (t
->to_thread_name
!= NULL
)
2760 return (*t
->to_thread_name
) (info
);
2767 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2769 struct target_ops
*t
;
2771 target_dcache_invalidate ();
2773 current_target
.to_resume (¤t_target
, ptid
, step
, signal
);
2775 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2776 ptid_get_pid (ptid
),
2777 step
? "step" : "continue",
2778 gdb_signal_to_name (signal
));
2780 registers_changed_ptid (ptid
);
2781 set_executing (ptid
, 1);
2782 set_running (ptid
, 1);
2783 clear_inline_frame_state (ptid
);
2787 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2789 struct target_ops
*t
;
2791 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2793 if (t
->to_pass_signals
!= NULL
)
2799 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2802 for (i
= 0; i
< numsigs
; i
++)
2803 if (pass_signals
[i
])
2804 fprintf_unfiltered (gdb_stdlog
, " %s",
2805 gdb_signal_to_name (i
));
2807 fprintf_unfiltered (gdb_stdlog
, " })\n");
2810 (*t
->to_pass_signals
) (numsigs
, pass_signals
);
2817 target_program_signals (int numsigs
, unsigned char *program_signals
)
2819 struct target_ops
*t
;
2821 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2823 if (t
->to_program_signals
!= NULL
)
2829 fprintf_unfiltered (gdb_stdlog
, "target_program_signals (%d, {",
2832 for (i
= 0; i
< numsigs
; i
++)
2833 if (program_signals
[i
])
2834 fprintf_unfiltered (gdb_stdlog
, " %s",
2835 gdb_signal_to_name (i
));
2837 fprintf_unfiltered (gdb_stdlog
, " })\n");
2840 (*t
->to_program_signals
) (numsigs
, program_signals
);
2846 /* Look through the list of possible targets for a target that can
2850 target_follow_fork (int follow_child
, int detach_fork
)
2852 struct target_ops
*t
;
2854 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2856 if (t
->to_follow_fork
!= NULL
)
2858 int retval
= t
->to_follow_fork (t
, follow_child
, detach_fork
);
2861 fprintf_unfiltered (gdb_stdlog
,
2862 "target_follow_fork (%d, %d) = %d\n",
2863 follow_child
, detach_fork
, retval
);
2868 /* Some target returned a fork event, but did not know how to follow it. */
2869 internal_error (__FILE__
, __LINE__
,
2870 _("could not find a target to follow fork"));
2874 target_mourn_inferior (void)
2876 struct target_ops
*t
;
2878 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2880 if (t
->to_mourn_inferior
!= NULL
)
2882 t
->to_mourn_inferior (t
);
2884 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2886 /* We no longer need to keep handles on any of the object files.
2887 Make sure to release them to avoid unnecessarily locking any
2888 of them while we're not actually debugging. */
2889 bfd_cache_close_all ();
2895 internal_error (__FILE__
, __LINE__
,
2896 _("could not find a target to follow mourn inferior"));
2899 /* Look for a target which can describe architectural features, starting
2900 from TARGET. If we find one, return its description. */
2902 const struct target_desc
*
2903 target_read_description (struct target_ops
*target
)
2905 struct target_ops
*t
;
2907 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
2908 if (t
->to_read_description
!= NULL
)
2910 const struct target_desc
*tdesc
;
2912 tdesc
= t
->to_read_description (t
);
2920 /* The default implementation of to_search_memory.
2921 This implements a basic search of memory, reading target memory and
2922 performing the search here (as opposed to performing the search in on the
2923 target side with, for example, gdbserver). */
2926 simple_search_memory (struct target_ops
*ops
,
2927 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2928 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2929 CORE_ADDR
*found_addrp
)
2931 /* NOTE: also defined in find.c testcase. */
2932 #define SEARCH_CHUNK_SIZE 16000
2933 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2934 /* Buffer to hold memory contents for searching. */
2935 gdb_byte
*search_buf
;
2936 unsigned search_buf_size
;
2937 struct cleanup
*old_cleanups
;
2939 search_buf_size
= chunk_size
+ pattern_len
- 1;
2941 /* No point in trying to allocate a buffer larger than the search space. */
2942 if (search_space_len
< search_buf_size
)
2943 search_buf_size
= search_space_len
;
2945 search_buf
= malloc (search_buf_size
);
2946 if (search_buf
== NULL
)
2947 error (_("Unable to allocate memory to perform the search."));
2948 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2950 /* Prime the search buffer. */
2952 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2953 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2955 warning (_("Unable to access %s bytes of target "
2956 "memory at %s, halting search."),
2957 pulongest (search_buf_size
), hex_string (start_addr
));
2958 do_cleanups (old_cleanups
);
2962 /* Perform the search.
2964 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2965 When we've scanned N bytes we copy the trailing bytes to the start and
2966 read in another N bytes. */
2968 while (search_space_len
>= pattern_len
)
2970 gdb_byte
*found_ptr
;
2971 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2973 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2974 pattern
, pattern_len
);
2976 if (found_ptr
!= NULL
)
2978 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2980 *found_addrp
= found_addr
;
2981 do_cleanups (old_cleanups
);
2985 /* Not found in this chunk, skip to next chunk. */
2987 /* Don't let search_space_len wrap here, it's unsigned. */
2988 if (search_space_len
>= chunk_size
)
2989 search_space_len
-= chunk_size
;
2991 search_space_len
= 0;
2993 if (search_space_len
>= pattern_len
)
2995 unsigned keep_len
= search_buf_size
- chunk_size
;
2996 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2999 /* Copy the trailing part of the previous iteration to the front
3000 of the buffer for the next iteration. */
3001 gdb_assert (keep_len
== pattern_len
- 1);
3002 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
3004 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
3006 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
3007 search_buf
+ keep_len
, read_addr
,
3008 nr_to_read
) != nr_to_read
)
3010 warning (_("Unable to access %s bytes of target "
3011 "memory at %s, halting search."),
3012 plongest (nr_to_read
),
3013 hex_string (read_addr
));
3014 do_cleanups (old_cleanups
);
3018 start_addr
+= chunk_size
;
3024 do_cleanups (old_cleanups
);
3028 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
3029 sequence of bytes in PATTERN with length PATTERN_LEN.
3031 The result is 1 if found, 0 if not found, and -1 if there was an error
3032 requiring halting of the search (e.g. memory read error).
3033 If the pattern is found the address is recorded in FOUND_ADDRP. */
3036 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
3037 const gdb_byte
*pattern
, ULONGEST pattern_len
,
3038 CORE_ADDR
*found_addrp
)
3040 struct target_ops
*t
;
3043 /* We don't use INHERIT to set current_target.to_search_memory,
3044 so we have to scan the target stack and handle targetdebug
3048 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
3049 hex_string (start_addr
));
3051 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3052 if (t
->to_search_memory
!= NULL
)
3057 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
3058 pattern
, pattern_len
, found_addrp
);
3062 /* If a special version of to_search_memory isn't available, use the
3064 found
= simple_search_memory (current_target
.beneath
,
3065 start_addr
, search_space_len
,
3066 pattern
, pattern_len
, found_addrp
);
3070 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
3075 /* Look through the currently pushed targets. If none of them will
3076 be able to restart the currently running process, issue an error
3080 target_require_runnable (void)
3082 struct target_ops
*t
;
3084 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3086 /* If this target knows how to create a new program, then
3087 assume we will still be able to after killing the current
3088 one. Either killing and mourning will not pop T, or else
3089 find_default_run_target will find it again. */
3090 if (t
->to_create_inferior
!= NULL
)
3093 /* Do not worry about thread_stratum targets that can not
3094 create inferiors. Assume they will be pushed again if
3095 necessary, and continue to the process_stratum. */
3096 if (t
->to_stratum
== thread_stratum
3097 || t
->to_stratum
== arch_stratum
)
3100 error (_("The \"%s\" target does not support \"run\". "
3101 "Try \"help target\" or \"continue\"."),
3105 /* This function is only called if the target is running. In that
3106 case there should have been a process_stratum target and it
3107 should either know how to create inferiors, or not... */
3108 internal_error (__FILE__
, __LINE__
, _("No targets found"));
3111 /* Look through the list of possible targets for a target that can
3112 execute a run or attach command without any other data. This is
3113 used to locate the default process stratum.
3115 If DO_MESG is not NULL, the result is always valid (error() is
3116 called for errors); else, return NULL on error. */
3118 static struct target_ops
*
3119 find_default_run_target (char *do_mesg
)
3121 struct target_ops
**t
;
3122 struct target_ops
*runable
= NULL
;
3127 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
3130 if ((*t
)->to_can_run
&& target_can_run (*t
))
3140 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
3149 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3151 struct target_ops
*t
;
3153 t
= find_default_run_target ("attach");
3154 (t
->to_attach
) (t
, args
, from_tty
);
3159 find_default_create_inferior (struct target_ops
*ops
,
3160 char *exec_file
, char *allargs
, char **env
,
3163 struct target_ops
*t
;
3165 t
= find_default_run_target ("run");
3166 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
3171 find_default_can_async_p (struct target_ops
*ignore
)
3173 struct target_ops
*t
;
3175 /* This may be called before the target is pushed on the stack;
3176 look for the default process stratum. If there's none, gdb isn't
3177 configured with a native debugger, and target remote isn't
3179 t
= find_default_run_target (NULL
);
3180 if (t
&& t
->to_can_async_p
!= delegate_can_async_p
)
3181 return (t
->to_can_async_p
) (t
);
3186 find_default_is_async_p (struct target_ops
*ignore
)
3188 struct target_ops
*t
;
3190 /* This may be called before the target is pushed on the stack;
3191 look for the default process stratum. If there's none, gdb isn't
3192 configured with a native debugger, and target remote isn't
3194 t
= find_default_run_target (NULL
);
3195 if (t
&& t
->to_is_async_p
!= delegate_is_async_p
)
3196 return (t
->to_is_async_p
) (t
);
3201 find_default_supports_non_stop (void)
3203 struct target_ops
*t
;
3205 t
= find_default_run_target (NULL
);
3206 if (t
&& t
->to_supports_non_stop
)
3207 return (t
->to_supports_non_stop
) ();
3212 target_supports_non_stop (void)
3214 struct target_ops
*t
;
3216 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3217 if (t
->to_supports_non_stop
)
3218 return t
->to_supports_non_stop ();
3223 /* Implement the "info proc" command. */
3226 target_info_proc (char *args
, enum info_proc_what what
)
3228 struct target_ops
*t
;
3230 /* If we're already connected to something that can get us OS
3231 related data, use it. Otherwise, try using the native
3233 if (current_target
.to_stratum
>= process_stratum
)
3234 t
= current_target
.beneath
;
3236 t
= find_default_run_target (NULL
);
3238 for (; t
!= NULL
; t
= t
->beneath
)
3240 if (t
->to_info_proc
!= NULL
)
3242 t
->to_info_proc (t
, args
, what
);
3245 fprintf_unfiltered (gdb_stdlog
,
3246 "target_info_proc (\"%s\", %d)\n", args
, what
);
3256 find_default_supports_disable_randomization (void)
3258 struct target_ops
*t
;
3260 t
= find_default_run_target (NULL
);
3261 if (t
&& t
->to_supports_disable_randomization
)
3262 return (t
->to_supports_disable_randomization
) ();
3267 target_supports_disable_randomization (void)
3269 struct target_ops
*t
;
3271 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3272 if (t
->to_supports_disable_randomization
)
3273 return t
->to_supports_disable_randomization ();
3279 target_get_osdata (const char *type
)
3281 struct target_ops
*t
;
3283 /* If we're already connected to something that can get us OS
3284 related data, use it. Otherwise, try using the native
3286 if (current_target
.to_stratum
>= process_stratum
)
3287 t
= current_target
.beneath
;
3289 t
= find_default_run_target ("get OS data");
3294 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
3297 /* Determine the current address space of thread PTID. */
3299 struct address_space
*
3300 target_thread_address_space (ptid_t ptid
)
3302 struct address_space
*aspace
;
3303 struct inferior
*inf
;
3304 struct target_ops
*t
;
3306 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3308 if (t
->to_thread_address_space
!= NULL
)
3310 aspace
= t
->to_thread_address_space (t
, ptid
);
3311 gdb_assert (aspace
);
3314 fprintf_unfiltered (gdb_stdlog
,
3315 "target_thread_address_space (%s) = %d\n",
3316 target_pid_to_str (ptid
),
3317 address_space_num (aspace
));
3322 /* Fall-back to the "main" address space of the inferior. */
3323 inf
= find_inferior_pid (ptid_get_pid (ptid
));
3325 if (inf
== NULL
|| inf
->aspace
== NULL
)
3326 internal_error (__FILE__
, __LINE__
,
3327 _("Can't determine the current "
3328 "address space of thread %s\n"),
3329 target_pid_to_str (ptid
));
3335 /* Target file operations. */
3337 static struct target_ops
*
3338 default_fileio_target (void)
3340 /* If we're already connected to something that can perform
3341 file I/O, use it. Otherwise, try using the native target. */
3342 if (current_target
.to_stratum
>= process_stratum
)
3343 return current_target
.beneath
;
3345 return find_default_run_target ("file I/O");
3348 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3349 target file descriptor, or -1 if an error occurs (and set
3352 target_fileio_open (const char *filename
, int flags
, int mode
,
3355 struct target_ops
*t
;
3357 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3359 if (t
->to_fileio_open
!= NULL
)
3361 int fd
= t
->to_fileio_open (filename
, flags
, mode
, target_errno
);
3364 fprintf_unfiltered (gdb_stdlog
,
3365 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3366 filename
, flags
, mode
,
3367 fd
, fd
!= -1 ? 0 : *target_errno
);
3372 *target_errno
= FILEIO_ENOSYS
;
3376 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3377 Return the number of bytes written, or -1 if an error occurs
3378 (and set *TARGET_ERRNO). */
3380 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
3381 ULONGEST offset
, int *target_errno
)
3383 struct target_ops
*t
;
3385 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3387 if (t
->to_fileio_pwrite
!= NULL
)
3389 int ret
= t
->to_fileio_pwrite (fd
, write_buf
, len
, offset
,
3393 fprintf_unfiltered (gdb_stdlog
,
3394 "target_fileio_pwrite (%d,...,%d,%s) "
3396 fd
, len
, pulongest (offset
),
3397 ret
, ret
!= -1 ? 0 : *target_errno
);
3402 *target_errno
= FILEIO_ENOSYS
;
3406 /* Read up to LEN bytes FD on the target into READ_BUF.
3407 Return the number of bytes read, or -1 if an error occurs
3408 (and set *TARGET_ERRNO). */
3410 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
3411 ULONGEST offset
, int *target_errno
)
3413 struct target_ops
*t
;
3415 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3417 if (t
->to_fileio_pread
!= NULL
)
3419 int ret
= t
->to_fileio_pread (fd
, read_buf
, len
, offset
,
3423 fprintf_unfiltered (gdb_stdlog
,
3424 "target_fileio_pread (%d,...,%d,%s) "
3426 fd
, len
, pulongest (offset
),
3427 ret
, ret
!= -1 ? 0 : *target_errno
);
3432 *target_errno
= FILEIO_ENOSYS
;
3436 /* Close FD on the target. Return 0, or -1 if an error occurs
3437 (and set *TARGET_ERRNO). */
3439 target_fileio_close (int fd
, int *target_errno
)
3441 struct target_ops
*t
;
3443 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3445 if (t
->to_fileio_close
!= NULL
)
3447 int ret
= t
->to_fileio_close (fd
, target_errno
);
3450 fprintf_unfiltered (gdb_stdlog
,
3451 "target_fileio_close (%d) = %d (%d)\n",
3452 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
3457 *target_errno
= FILEIO_ENOSYS
;
3461 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3462 occurs (and set *TARGET_ERRNO). */
3464 target_fileio_unlink (const char *filename
, int *target_errno
)
3466 struct target_ops
*t
;
3468 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3470 if (t
->to_fileio_unlink
!= NULL
)
3472 int ret
= t
->to_fileio_unlink (filename
, target_errno
);
3475 fprintf_unfiltered (gdb_stdlog
,
3476 "target_fileio_unlink (%s) = %d (%d)\n",
3477 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
3482 *target_errno
= FILEIO_ENOSYS
;
3486 /* Read value of symbolic link FILENAME on the target. Return a
3487 null-terminated string allocated via xmalloc, or NULL if an error
3488 occurs (and set *TARGET_ERRNO). */
3490 target_fileio_readlink (const char *filename
, int *target_errno
)
3492 struct target_ops
*t
;
3494 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3496 if (t
->to_fileio_readlink
!= NULL
)
3498 char *ret
= t
->to_fileio_readlink (filename
, target_errno
);
3501 fprintf_unfiltered (gdb_stdlog
,
3502 "target_fileio_readlink (%s) = %s (%d)\n",
3503 filename
, ret
? ret
: "(nil)",
3504 ret
? 0 : *target_errno
);
3509 *target_errno
= FILEIO_ENOSYS
;
3514 target_fileio_close_cleanup (void *opaque
)
3516 int fd
= *(int *) opaque
;
3519 target_fileio_close (fd
, &target_errno
);
3522 /* Read target file FILENAME. Store the result in *BUF_P and
3523 return the size of the transferred data. PADDING additional bytes are
3524 available in *BUF_P. This is a helper function for
3525 target_fileio_read_alloc; see the declaration of that function for more
3529 target_fileio_read_alloc_1 (const char *filename
,
3530 gdb_byte
**buf_p
, int padding
)
3532 struct cleanup
*close_cleanup
;
3533 size_t buf_alloc
, buf_pos
;
3539 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
3543 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
3545 /* Start by reading up to 4K at a time. The target will throttle
3546 this number down if necessary. */
3548 buf
= xmalloc (buf_alloc
);
3552 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
3553 buf_alloc
- buf_pos
- padding
, buf_pos
,
3557 /* An error occurred. */
3558 do_cleanups (close_cleanup
);
3564 /* Read all there was. */
3565 do_cleanups (close_cleanup
);
3575 /* If the buffer is filling up, expand it. */
3576 if (buf_alloc
< buf_pos
* 2)
3579 buf
= xrealloc (buf
, buf_alloc
);
3586 /* Read target file FILENAME. Store the result in *BUF_P and return
3587 the size of the transferred data. See the declaration in "target.h"
3588 function for more information about the return value. */
3591 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
3593 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
3596 /* Read target file FILENAME. The result is NUL-terminated and
3597 returned as a string, allocated using xmalloc. If an error occurs
3598 or the transfer is unsupported, NULL is returned. Empty objects
3599 are returned as allocated but empty strings. A warning is issued
3600 if the result contains any embedded NUL bytes. */
3603 target_fileio_read_stralloc (const char *filename
)
3607 LONGEST i
, transferred
;
3609 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
3610 bufstr
= (char *) buffer
;
3612 if (transferred
< 0)
3615 if (transferred
== 0)
3616 return xstrdup ("");
3618 bufstr
[transferred
] = 0;
3620 /* Check for embedded NUL bytes; but allow trailing NULs. */
3621 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3624 warning (_("target file %s "
3625 "contained unexpected null characters"),
3635 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3637 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3641 default_watchpoint_addr_within_range (struct target_ops
*target
,
3643 CORE_ADDR start
, int length
)
3645 return addr
>= start
&& addr
< start
+ length
;
3648 static struct gdbarch
*
3649 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3651 return target_gdbarch ();
3667 return_minus_one (void)
3679 * Find the next target down the stack from the specified target.
3683 find_target_beneath (struct target_ops
*t
)
3691 find_target_at (enum strata stratum
)
3693 struct target_ops
*t
;
3695 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3696 if (t
->to_stratum
== stratum
)
3703 /* The inferior process has died. Long live the inferior! */
3706 generic_mourn_inferior (void)
3710 ptid
= inferior_ptid
;
3711 inferior_ptid
= null_ptid
;
3713 /* Mark breakpoints uninserted in case something tries to delete a
3714 breakpoint while we delete the inferior's threads (which would
3715 fail, since the inferior is long gone). */
3716 mark_breakpoints_out ();
3718 if (!ptid_equal (ptid
, null_ptid
))
3720 int pid
= ptid_get_pid (ptid
);
3721 exit_inferior (pid
);
3724 /* Note this wipes step-resume breakpoints, so needs to be done
3725 after exit_inferior, which ends up referencing the step-resume
3726 breakpoints through clear_thread_inferior_resources. */
3727 breakpoint_init_inferior (inf_exited
);
3729 registers_changed ();
3731 reopen_exec_file ();
3732 reinit_frame_cache ();
3734 if (deprecated_detach_hook
)
3735 deprecated_detach_hook ();
3738 /* Convert a normal process ID to a string. Returns the string in a
3742 normal_pid_to_str (ptid_t ptid
)
3744 static char buf
[32];
3746 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3751 dummy_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3753 return normal_pid_to_str (ptid
);
3756 /* Error-catcher for target_find_memory_regions. */
3758 dummy_find_memory_regions (find_memory_region_ftype ignore1
, void *ignore2
)
3760 error (_("Command not implemented for this target."));
3764 /* Error-catcher for target_make_corefile_notes. */
3766 dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
3768 error (_("Command not implemented for this target."));
3772 /* Error-catcher for target_get_bookmark. */
3774 dummy_get_bookmark (char *ignore1
, int ignore2
)
3780 /* Error-catcher for target_goto_bookmark. */
3782 dummy_goto_bookmark (gdb_byte
*ignore
, int from_tty
)
3787 /* Set up the handful of non-empty slots needed by the dummy target
3791 init_dummy_target (void)
3793 dummy_target
.to_shortname
= "None";
3794 dummy_target
.to_longname
= "None";
3795 dummy_target
.to_doc
= "";
3796 dummy_target
.to_attach
= find_default_attach
;
3797 dummy_target
.to_detach
=
3798 (void (*)(struct target_ops
*, const char *, int))target_ignore
;
3799 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3800 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3801 dummy_target
.to_supports_disable_randomization
3802 = find_default_supports_disable_randomization
;
3803 dummy_target
.to_pid_to_str
= dummy_pid_to_str
;
3804 dummy_target
.to_stratum
= dummy_stratum
;
3805 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
3806 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
3807 dummy_target
.to_get_bookmark
= dummy_get_bookmark
;
3808 dummy_target
.to_goto_bookmark
= dummy_goto_bookmark
;
3809 dummy_target
.to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
3810 dummy_target
.to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
3811 dummy_target
.to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
3812 dummy_target
.to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
3813 dummy_target
.to_has_execution
3814 = (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
3815 dummy_target
.to_magic
= OPS_MAGIC
;
3817 install_dummy_methods (&dummy_target
);
3821 debug_to_open (char *args
, int from_tty
)
3823 debug_target
.to_open (args
, from_tty
);
3825 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3829 target_close (struct target_ops
*targ
)
3831 gdb_assert (!target_is_pushed (targ
));
3833 if (targ
->to_xclose
!= NULL
)
3834 targ
->to_xclose (targ
);
3835 else if (targ
->to_close
!= NULL
)
3836 targ
->to_close (targ
);
3839 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3843 target_attach (char *args
, int from_tty
)
3845 struct target_ops
*t
;
3847 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3849 if (t
->to_attach
!= NULL
)
3851 t
->to_attach (t
, args
, from_tty
);
3853 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3859 internal_error (__FILE__
, __LINE__
,
3860 _("could not find a target to attach"));
3864 target_thread_alive (ptid_t ptid
)
3866 struct target_ops
*t
;
3868 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3870 if (t
->to_thread_alive
!= NULL
)
3874 retval
= t
->to_thread_alive (t
, ptid
);
3876 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3877 ptid_get_pid (ptid
), retval
);
3887 target_find_new_threads (void)
3889 struct target_ops
*t
;
3891 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3893 if (t
->to_find_new_threads
!= NULL
)
3895 t
->to_find_new_threads (t
);
3897 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3905 target_stop (ptid_t ptid
)
3909 warning (_("May not interrupt or stop the target, ignoring attempt"));
3913 (*current_target
.to_stop
) (ptid
);
3917 debug_to_post_attach (int pid
)
3919 debug_target
.to_post_attach (pid
);
3921 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3924 /* Concatenate ELEM to LIST, a comma separate list, and return the
3925 result. The LIST incoming argument is released. */
3928 str_comma_list_concat_elem (char *list
, const char *elem
)
3931 return xstrdup (elem
);
3933 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3936 /* Helper for target_options_to_string. If OPT is present in
3937 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3938 Returns the new resulting string. OPT is removed from
3942 do_option (int *target_options
, char *ret
,
3943 int opt
, char *opt_str
)
3945 if ((*target_options
& opt
) != 0)
3947 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3948 *target_options
&= ~opt
;
3955 target_options_to_string (int target_options
)
3959 #define DO_TARG_OPTION(OPT) \
3960 ret = do_option (&target_options, ret, OPT, #OPT)
3962 DO_TARG_OPTION (TARGET_WNOHANG
);
3964 if (target_options
!= 0)
3965 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3973 debug_print_register (const char * func
,
3974 struct regcache
*regcache
, int regno
)
3976 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3978 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3979 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3980 && gdbarch_register_name (gdbarch
, regno
) != NULL
3981 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3982 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3983 gdbarch_register_name (gdbarch
, regno
));
3985 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3986 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3988 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3989 int i
, size
= register_size (gdbarch
, regno
);
3990 gdb_byte buf
[MAX_REGISTER_SIZE
];
3992 regcache_raw_collect (regcache
, regno
, buf
);
3993 fprintf_unfiltered (gdb_stdlog
, " = ");
3994 for (i
= 0; i
< size
; i
++)
3996 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3998 if (size
<= sizeof (LONGEST
))
4000 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
4002 fprintf_unfiltered (gdb_stdlog
, " %s %s",
4003 core_addr_to_string_nz (val
), plongest (val
));
4006 fprintf_unfiltered (gdb_stdlog
, "\n");
4010 target_fetch_registers (struct regcache
*regcache
, int regno
)
4012 struct target_ops
*t
;
4014 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4016 if (t
->to_fetch_registers
!= NULL
)
4018 t
->to_fetch_registers (t
, regcache
, regno
);
4020 debug_print_register ("target_fetch_registers", regcache
, regno
);
4027 target_store_registers (struct regcache
*regcache
, int regno
)
4029 struct target_ops
*t
;
4031 if (!may_write_registers
)
4032 error (_("Writing to registers is not allowed (regno %d)"), regno
);
4034 current_target
.to_store_registers (¤t_target
, regcache
, regno
);
4037 debug_print_register ("target_store_registers", regcache
, regno
);
4042 target_core_of_thread (ptid_t ptid
)
4044 struct target_ops
*t
;
4046 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4048 if (t
->to_core_of_thread
!= NULL
)
4050 int retval
= t
->to_core_of_thread (t
, ptid
);
4053 fprintf_unfiltered (gdb_stdlog
,
4054 "target_core_of_thread (%d) = %d\n",
4055 ptid_get_pid (ptid
), retval
);
4064 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
4066 struct target_ops
*t
;
4068 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4070 if (t
->to_verify_memory
!= NULL
)
4072 int retval
= t
->to_verify_memory (t
, data
, memaddr
, size
);
4075 fprintf_unfiltered (gdb_stdlog
,
4076 "target_verify_memory (%s, %s) = %d\n",
4077 paddress (target_gdbarch (), memaddr
),
4087 /* The documentation for this function is in its prototype declaration in
4091 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4093 struct target_ops
*t
;
4095 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4096 if (t
->to_insert_mask_watchpoint
!= NULL
)
4100 ret
= t
->to_insert_mask_watchpoint (t
, addr
, mask
, rw
);
4103 fprintf_unfiltered (gdb_stdlog
, "\
4104 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
4105 core_addr_to_string (addr
),
4106 core_addr_to_string (mask
), rw
, ret
);
4114 /* The documentation for this function is in its prototype declaration in
4118 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4120 struct target_ops
*t
;
4122 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4123 if (t
->to_remove_mask_watchpoint
!= NULL
)
4127 ret
= t
->to_remove_mask_watchpoint (t
, addr
, mask
, rw
);
4130 fprintf_unfiltered (gdb_stdlog
, "\
4131 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
4132 core_addr_to_string (addr
),
4133 core_addr_to_string (mask
), rw
, ret
);
4141 /* The documentation for this function is in its prototype declaration
4145 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
4147 struct target_ops
*t
;
4149 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4150 if (t
->to_masked_watch_num_registers
!= NULL
)
4151 return t
->to_masked_watch_num_registers (t
, addr
, mask
);
4156 /* The documentation for this function is in its prototype declaration
4160 target_ranged_break_num_registers (void)
4162 struct target_ops
*t
;
4164 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4165 if (t
->to_ranged_break_num_registers
!= NULL
)
4166 return t
->to_ranged_break_num_registers (t
);
4173 struct btrace_target_info
*
4174 target_enable_btrace (ptid_t ptid
)
4176 struct target_ops
*t
;
4178 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4179 if (t
->to_enable_btrace
!= NULL
)
4180 return t
->to_enable_btrace (ptid
);
4189 target_disable_btrace (struct btrace_target_info
*btinfo
)
4191 struct target_ops
*t
;
4193 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4194 if (t
->to_disable_btrace
!= NULL
)
4196 t
->to_disable_btrace (btinfo
);
4206 target_teardown_btrace (struct btrace_target_info
*btinfo
)
4208 struct target_ops
*t
;
4210 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4211 if (t
->to_teardown_btrace
!= NULL
)
4213 t
->to_teardown_btrace (btinfo
);
4223 target_read_btrace (VEC (btrace_block_s
) **btrace
,
4224 struct btrace_target_info
*btinfo
,
4225 enum btrace_read_type type
)
4227 struct target_ops
*t
;
4229 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4230 if (t
->to_read_btrace
!= NULL
)
4231 return t
->to_read_btrace (btrace
, btinfo
, type
);
4234 return BTRACE_ERR_NOT_SUPPORTED
;
4240 target_stop_recording (void)
4242 struct target_ops
*t
;
4244 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4245 if (t
->to_stop_recording
!= NULL
)
4247 t
->to_stop_recording ();
4251 /* This is optional. */
4257 target_info_record (void)
4259 struct target_ops
*t
;
4261 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4262 if (t
->to_info_record
!= NULL
)
4264 t
->to_info_record ();
4274 target_save_record (const char *filename
)
4276 struct target_ops
*t
;
4278 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4279 if (t
->to_save_record
!= NULL
)
4281 t
->to_save_record (filename
);
4291 target_supports_delete_record (void)
4293 struct target_ops
*t
;
4295 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4296 if (t
->to_delete_record
!= NULL
)
4305 target_delete_record (void)
4307 struct target_ops
*t
;
4309 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4310 if (t
->to_delete_record
!= NULL
)
4312 t
->to_delete_record ();
4322 target_record_is_replaying (void)
4324 struct target_ops
*t
;
4326 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4327 if (t
->to_record_is_replaying
!= NULL
)
4328 return t
->to_record_is_replaying ();
4336 target_goto_record_begin (void)
4338 struct target_ops
*t
;
4340 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4341 if (t
->to_goto_record_begin
!= NULL
)
4343 t
->to_goto_record_begin ();
4353 target_goto_record_end (void)
4355 struct target_ops
*t
;
4357 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4358 if (t
->to_goto_record_end
!= NULL
)
4360 t
->to_goto_record_end ();
4370 target_goto_record (ULONGEST insn
)
4372 struct target_ops
*t
;
4374 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4375 if (t
->to_goto_record
!= NULL
)
4377 t
->to_goto_record (insn
);
4387 target_insn_history (int size
, int flags
)
4389 struct target_ops
*t
;
4391 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4392 if (t
->to_insn_history
!= NULL
)
4394 t
->to_insn_history (size
, flags
);
4404 target_insn_history_from (ULONGEST from
, int size
, int flags
)
4406 struct target_ops
*t
;
4408 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4409 if (t
->to_insn_history_from
!= NULL
)
4411 t
->to_insn_history_from (from
, size
, flags
);
4421 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4423 struct target_ops
*t
;
4425 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4426 if (t
->to_insn_history_range
!= NULL
)
4428 t
->to_insn_history_range (begin
, end
, flags
);
4438 target_call_history (int size
, int flags
)
4440 struct target_ops
*t
;
4442 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4443 if (t
->to_call_history
!= NULL
)
4445 t
->to_call_history (size
, flags
);
4455 target_call_history_from (ULONGEST begin
, int size
, int flags
)
4457 struct target_ops
*t
;
4459 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4460 if (t
->to_call_history_from
!= NULL
)
4462 t
->to_call_history_from (begin
, size
, flags
);
4472 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4474 struct target_ops
*t
;
4476 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4477 if (t
->to_call_history_range
!= NULL
)
4479 t
->to_call_history_range (begin
, end
, flags
);
4487 debug_to_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
4489 debug_target
.to_prepare_to_store (&debug_target
, regcache
);
4491 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
4496 const struct frame_unwind
*
4497 target_get_unwinder (void)
4499 struct target_ops
*t
;
4501 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4502 if (t
->to_get_unwinder
!= NULL
)
4503 return t
->to_get_unwinder
;
4510 const struct frame_unwind
*
4511 target_get_tailcall_unwinder (void)
4513 struct target_ops
*t
;
4515 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4516 if (t
->to_get_tailcall_unwinder
!= NULL
)
4517 return t
->to_get_tailcall_unwinder
;
4525 forward_target_decr_pc_after_break (struct target_ops
*ops
,
4526 struct gdbarch
*gdbarch
)
4528 for (; ops
!= NULL
; ops
= ops
->beneath
)
4529 if (ops
->to_decr_pc_after_break
!= NULL
)
4530 return ops
->to_decr_pc_after_break (ops
, gdbarch
);
4532 return gdbarch_decr_pc_after_break (gdbarch
);
4538 target_decr_pc_after_break (struct gdbarch
*gdbarch
)
4540 return forward_target_decr_pc_after_break (current_target
.beneath
, gdbarch
);
4544 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
4545 int write
, struct mem_attrib
*attrib
,
4546 struct target_ops
*target
)
4550 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
4553 fprintf_unfiltered (gdb_stdlog
,
4554 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4555 paddress (target_gdbarch (), memaddr
), len
,
4556 write
? "write" : "read", retval
);
4562 fputs_unfiltered (", bytes =", gdb_stdlog
);
4563 for (i
= 0; i
< retval
; i
++)
4565 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
4567 if (targetdebug
< 2 && i
> 0)
4569 fprintf_unfiltered (gdb_stdlog
, " ...");
4572 fprintf_unfiltered (gdb_stdlog
, "\n");
4575 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
4579 fputc_unfiltered ('\n', gdb_stdlog
);
4585 debug_to_files_info (struct target_ops
*target
)
4587 debug_target
.to_files_info (target
);
4589 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
4593 debug_to_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4594 struct bp_target_info
*bp_tgt
)
4598 retval
= debug_target
.to_insert_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4600 fprintf_unfiltered (gdb_stdlog
,
4601 "target_insert_breakpoint (%s, xxx) = %ld\n",
4602 core_addr_to_string (bp_tgt
->placed_address
),
4603 (unsigned long) retval
);
4608 debug_to_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4609 struct bp_target_info
*bp_tgt
)
4613 retval
= debug_target
.to_remove_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4615 fprintf_unfiltered (gdb_stdlog
,
4616 "target_remove_breakpoint (%s, xxx) = %ld\n",
4617 core_addr_to_string (bp_tgt
->placed_address
),
4618 (unsigned long) retval
);
4623 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
4627 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
4629 fprintf_unfiltered (gdb_stdlog
,
4630 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4631 (unsigned long) type
,
4632 (unsigned long) cnt
,
4633 (unsigned long) from_tty
,
4634 (unsigned long) retval
);
4639 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
4643 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
4645 fprintf_unfiltered (gdb_stdlog
,
4646 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4647 core_addr_to_string (addr
), (unsigned long) len
,
4648 core_addr_to_string (retval
));
4653 debug_to_can_accel_watchpoint_condition (CORE_ADDR addr
, int len
, int rw
,
4654 struct expression
*cond
)
4658 retval
= debug_target
.to_can_accel_watchpoint_condition (addr
, len
,
4661 fprintf_unfiltered (gdb_stdlog
,
4662 "target_can_accel_watchpoint_condition "
4663 "(%s, %d, %d, %s) = %ld\n",
4664 core_addr_to_string (addr
), len
, rw
,
4665 host_address_to_string (cond
), (unsigned long) retval
);
4670 debug_to_stopped_by_watchpoint (struct target_ops
*ops
)
4674 retval
= debug_target
.to_stopped_by_watchpoint (&debug_target
);
4676 fprintf_unfiltered (gdb_stdlog
,
4677 "target_stopped_by_watchpoint () = %ld\n",
4678 (unsigned long) retval
);
4683 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
4687 retval
= debug_target
.to_stopped_data_address (target
, addr
);
4689 fprintf_unfiltered (gdb_stdlog
,
4690 "target_stopped_data_address ([%s]) = %ld\n",
4691 core_addr_to_string (*addr
),
4692 (unsigned long)retval
);
4697 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
4699 CORE_ADDR start
, int length
)
4703 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
4706 fprintf_filtered (gdb_stdlog
,
4707 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4708 core_addr_to_string (addr
), core_addr_to_string (start
),
4714 debug_to_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
4715 struct bp_target_info
*bp_tgt
)
4719 retval
= debug_target
.to_insert_hw_breakpoint (gdbarch
, bp_tgt
);
4721 fprintf_unfiltered (gdb_stdlog
,
4722 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4723 core_addr_to_string (bp_tgt
->placed_address
),
4724 (unsigned long) retval
);
4729 debug_to_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
4730 struct bp_target_info
*bp_tgt
)
4734 retval
= debug_target
.to_remove_hw_breakpoint (gdbarch
, bp_tgt
);
4736 fprintf_unfiltered (gdb_stdlog
,
4737 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4738 core_addr_to_string (bp_tgt
->placed_address
),
4739 (unsigned long) retval
);
4744 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
4745 struct expression
*cond
)
4749 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
, cond
);
4751 fprintf_unfiltered (gdb_stdlog
,
4752 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4753 core_addr_to_string (addr
), len
, type
,
4754 host_address_to_string (cond
), (unsigned long) retval
);
4759 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
4760 struct expression
*cond
)
4764 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
, cond
);
4766 fprintf_unfiltered (gdb_stdlog
,
4767 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4768 core_addr_to_string (addr
), len
, type
,
4769 host_address_to_string (cond
), (unsigned long) retval
);
4774 debug_to_terminal_init (void)
4776 debug_target
.to_terminal_init ();
4778 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
4782 debug_to_terminal_inferior (void)
4784 debug_target
.to_terminal_inferior ();
4786 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
4790 debug_to_terminal_ours_for_output (void)
4792 debug_target
.to_terminal_ours_for_output ();
4794 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
4798 debug_to_terminal_ours (void)
4800 debug_target
.to_terminal_ours ();
4802 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
4806 debug_to_terminal_save_ours (void)
4808 debug_target
.to_terminal_save_ours ();
4810 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
4814 debug_to_terminal_info (const char *arg
, int from_tty
)
4816 debug_target
.to_terminal_info (arg
, from_tty
);
4818 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
4823 debug_to_load (char *args
, int from_tty
)
4825 debug_target
.to_load (args
, from_tty
);
4827 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
4831 debug_to_post_startup_inferior (ptid_t ptid
)
4833 debug_target
.to_post_startup_inferior (ptid
);
4835 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
4836 ptid_get_pid (ptid
));
4840 debug_to_insert_fork_catchpoint (int pid
)
4844 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
4846 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
4853 debug_to_remove_fork_catchpoint (int pid
)
4857 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
4859 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
4866 debug_to_insert_vfork_catchpoint (int pid
)
4870 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
4872 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
4879 debug_to_remove_vfork_catchpoint (int pid
)
4883 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
4885 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
4892 debug_to_insert_exec_catchpoint (int pid
)
4896 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
4898 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
4905 debug_to_remove_exec_catchpoint (int pid
)
4909 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
4911 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
4918 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
4922 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
4924 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
4925 pid
, wait_status
, *exit_status
, has_exited
);
4931 debug_to_can_run (void)
4935 retval
= debug_target
.to_can_run ();
4937 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4942 static struct gdbarch
*
4943 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4945 struct gdbarch
*retval
;
4947 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4949 fprintf_unfiltered (gdb_stdlog
,
4950 "target_thread_architecture (%s) = %s [%s]\n",
4951 target_pid_to_str (ptid
),
4952 host_address_to_string (retval
),
4953 gdbarch_bfd_arch_info (retval
)->printable_name
);
4958 debug_to_stop (ptid_t ptid
)
4960 debug_target
.to_stop (ptid
);
4962 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4963 target_pid_to_str (ptid
));
4967 debug_to_rcmd (char *command
,
4968 struct ui_file
*outbuf
)
4970 debug_target
.to_rcmd (command
, outbuf
);
4971 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4975 debug_to_pid_to_exec_file (int pid
)
4979 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
4981 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
4988 setup_target_debug (void)
4990 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
4992 current_target
.to_open
= debug_to_open
;
4993 current_target
.to_post_attach
= debug_to_post_attach
;
4994 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
4995 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
4996 current_target
.to_files_info
= debug_to_files_info
;
4997 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
4998 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
4999 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
5000 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
5001 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
5002 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
5003 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
5004 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
5005 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
5006 current_target
.to_watchpoint_addr_within_range
5007 = debug_to_watchpoint_addr_within_range
;
5008 current_target
.to_region_ok_for_hw_watchpoint
5009 = debug_to_region_ok_for_hw_watchpoint
;
5010 current_target
.to_can_accel_watchpoint_condition
5011 = debug_to_can_accel_watchpoint_condition
;
5012 current_target
.to_terminal_init
= debug_to_terminal_init
;
5013 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
5014 current_target
.to_terminal_ours_for_output
5015 = debug_to_terminal_ours_for_output
;
5016 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
5017 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
5018 current_target
.to_terminal_info
= debug_to_terminal_info
;
5019 current_target
.to_load
= debug_to_load
;
5020 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
5021 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
5022 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
5023 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
5024 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
5025 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
5026 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
5027 current_target
.to_has_exited
= debug_to_has_exited
;
5028 current_target
.to_can_run
= debug_to_can_run
;
5029 current_target
.to_stop
= debug_to_stop
;
5030 current_target
.to_rcmd
= debug_to_rcmd
;
5031 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
5032 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
5036 static char targ_desc
[] =
5037 "Names of targets and files being debugged.\nShows the entire \
5038 stack of targets currently in use (including the exec-file,\n\
5039 core-file, and process, if any), as well as the symbol file name.";
5042 do_monitor_command (char *cmd
,
5045 if ((current_target
.to_rcmd
5046 == (void (*) (char *, struct ui_file
*)) tcomplain
)
5047 || (current_target
.to_rcmd
== debug_to_rcmd
5048 && (debug_target
.to_rcmd
5049 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
5050 error (_("\"monitor\" command not supported by this target."));
5051 target_rcmd (cmd
, gdb_stdtarg
);
5054 /* Print the name of each layers of our target stack. */
5057 maintenance_print_target_stack (char *cmd
, int from_tty
)
5059 struct target_ops
*t
;
5061 printf_filtered (_("The current target stack is:\n"));
5063 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
5065 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
5069 /* Controls if async mode is permitted. */
5070 int target_async_permitted
= 0;
5072 /* The set command writes to this variable. If the inferior is
5073 executing, target_async_permitted is *not* updated. */
5074 static int target_async_permitted_1
= 0;
5077 set_target_async_command (char *args
, int from_tty
,
5078 struct cmd_list_element
*c
)
5080 if (have_live_inferiors ())
5082 target_async_permitted_1
= target_async_permitted
;
5083 error (_("Cannot change this setting while the inferior is running."));
5086 target_async_permitted
= target_async_permitted_1
;
5090 show_target_async_command (struct ui_file
*file
, int from_tty
,
5091 struct cmd_list_element
*c
,
5094 fprintf_filtered (file
,
5095 _("Controlling the inferior in "
5096 "asynchronous mode is %s.\n"), value
);
5099 /* Temporary copies of permission settings. */
5101 static int may_write_registers_1
= 1;
5102 static int may_write_memory_1
= 1;
5103 static int may_insert_breakpoints_1
= 1;
5104 static int may_insert_tracepoints_1
= 1;
5105 static int may_insert_fast_tracepoints_1
= 1;
5106 static int may_stop_1
= 1;
5108 /* Make the user-set values match the real values again. */
5111 update_target_permissions (void)
5113 may_write_registers_1
= may_write_registers
;
5114 may_write_memory_1
= may_write_memory
;
5115 may_insert_breakpoints_1
= may_insert_breakpoints
;
5116 may_insert_tracepoints_1
= may_insert_tracepoints
;
5117 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
5118 may_stop_1
= may_stop
;
5121 /* The one function handles (most of) the permission flags in the same
5125 set_target_permissions (char *args
, int from_tty
,
5126 struct cmd_list_element
*c
)
5128 if (target_has_execution
)
5130 update_target_permissions ();
5131 error (_("Cannot change this setting while the inferior is running."));
5134 /* Make the real values match the user-changed values. */
5135 may_write_registers
= may_write_registers_1
;
5136 may_insert_breakpoints
= may_insert_breakpoints_1
;
5137 may_insert_tracepoints
= may_insert_tracepoints_1
;
5138 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
5139 may_stop
= may_stop_1
;
5140 update_observer_mode ();
5143 /* Set memory write permission independently of observer mode. */
5146 set_write_memory_permission (char *args
, int from_tty
,
5147 struct cmd_list_element
*c
)
5149 /* Make the real values match the user-changed values. */
5150 may_write_memory
= may_write_memory_1
;
5151 update_observer_mode ();
5156 initialize_targets (void)
5158 init_dummy_target ();
5159 push_target (&dummy_target
);
5161 add_info ("target", target_info
, targ_desc
);
5162 add_info ("files", target_info
, targ_desc
);
5164 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
5165 Set target debugging."), _("\
5166 Show target debugging."), _("\
5167 When non-zero, target debugging is enabled. Higher numbers are more\n\
5168 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
5172 &setdebuglist
, &showdebuglist
);
5174 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
5175 &trust_readonly
, _("\
5176 Set mode for reading from readonly sections."), _("\
5177 Show mode for reading from readonly sections."), _("\
5178 When this mode is on, memory reads from readonly sections (such as .text)\n\
5179 will be read from the object file instead of from the target. This will\n\
5180 result in significant performance improvement for remote targets."),
5182 show_trust_readonly
,
5183 &setlist
, &showlist
);
5185 add_com ("monitor", class_obscure
, do_monitor_command
,
5186 _("Send a command to the remote monitor (remote targets only)."));
5188 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
5189 _("Print the name of each layer of the internal target stack."),
5190 &maintenanceprintlist
);
5192 add_setshow_boolean_cmd ("target-async", no_class
,
5193 &target_async_permitted_1
, _("\
5194 Set whether gdb controls the inferior in asynchronous mode."), _("\
5195 Show whether gdb controls the inferior in asynchronous mode."), _("\
5196 Tells gdb whether to control the inferior in asynchronous mode."),
5197 set_target_async_command
,
5198 show_target_async_command
,
5202 add_setshow_boolean_cmd ("may-write-registers", class_support
,
5203 &may_write_registers_1
, _("\
5204 Set permission to write into registers."), _("\
5205 Show permission to write into registers."), _("\
5206 When this permission is on, GDB may write into the target's registers.\n\
5207 Otherwise, any sort of write attempt will result in an error."),
5208 set_target_permissions
, NULL
,
5209 &setlist
, &showlist
);
5211 add_setshow_boolean_cmd ("may-write-memory", class_support
,
5212 &may_write_memory_1
, _("\
5213 Set permission to write into target memory."), _("\
5214 Show permission to write into target memory."), _("\
5215 When this permission is on, GDB may write into the target's memory.\n\
5216 Otherwise, any sort of write attempt will result in an error."),
5217 set_write_memory_permission
, NULL
,
5218 &setlist
, &showlist
);
5220 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
5221 &may_insert_breakpoints_1
, _("\
5222 Set permission to insert breakpoints in the target."), _("\
5223 Show permission to insert breakpoints in the target."), _("\
5224 When this permission is on, GDB may insert breakpoints in the program.\n\
5225 Otherwise, any sort of insertion attempt will result in an error."),
5226 set_target_permissions
, NULL
,
5227 &setlist
, &showlist
);
5229 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
5230 &may_insert_tracepoints_1
, _("\
5231 Set permission to insert tracepoints in the target."), _("\
5232 Show permission to insert tracepoints in the target."), _("\
5233 When this permission is on, GDB may insert tracepoints in the program.\n\
5234 Otherwise, any sort of insertion attempt will result in an error."),
5235 set_target_permissions
, NULL
,
5236 &setlist
, &showlist
);
5238 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
5239 &may_insert_fast_tracepoints_1
, _("\
5240 Set permission to insert fast tracepoints in the target."), _("\
5241 Show permission to insert fast tracepoints in the target."), _("\
5242 When this permission is on, GDB may insert fast tracepoints.\n\
5243 Otherwise, any sort of insertion attempt will result in an error."),
5244 set_target_permissions
, NULL
,
5245 &setlist
, &showlist
);
5247 add_setshow_boolean_cmd ("may-interrupt", class_support
,
5249 Set permission to interrupt or signal the target."), _("\
5250 Show permission to interrupt or signal the target."), _("\
5251 When this permission is on, GDB may interrupt/stop the target's execution.\n\
5252 Otherwise, any attempt to interrupt or stop will be ignored."),
5253 set_target_permissions
, NULL
,
5254 &setlist
, &showlist
);