1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdb_string.h"
38 #include "gdb_assert.h"
40 #include "exceptions.h"
41 #include "target-descriptions.h"
42 #include "gdbthread.h"
45 #include "inline-frame.h"
46 #include "tracepoint.h"
48 static void target_info (char *, int);
50 static void default_terminal_info (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 void target_ignore (void);
69 static void target_command (char *, int);
71 static struct target_ops
*find_default_run_target (char *);
73 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
74 enum target_object object
,
75 const char *annex
, gdb_byte
*readbuf
,
76 const gdb_byte
*writebuf
,
77 ULONGEST offset
, LONGEST len
);
79 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
80 enum target_object object
,
81 const char *annex
, gdb_byte
*readbuf
,
82 const gdb_byte
*writebuf
,
83 ULONGEST offset
, LONGEST len
);
85 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
86 enum target_object object
,
88 void *readbuf
, const void *writebuf
,
89 ULONGEST offset
, LONGEST len
);
91 static struct gdbarch
*default_thread_architecture (struct target_ops
*ops
,
94 static void init_dummy_target (void);
96 static struct target_ops debug_target
;
98 static void debug_to_open (char *, int);
100 static void debug_to_prepare_to_store (struct regcache
*);
102 static void debug_to_files_info (struct target_ops
*);
104 static int debug_to_insert_breakpoint (struct gdbarch
*,
105 struct bp_target_info
*);
107 static int debug_to_remove_breakpoint (struct gdbarch
*,
108 struct bp_target_info
*);
110 static int debug_to_can_use_hw_breakpoint (int, int, int);
112 static int debug_to_insert_hw_breakpoint (struct gdbarch
*,
113 struct bp_target_info
*);
115 static int debug_to_remove_hw_breakpoint (struct gdbarch
*,
116 struct bp_target_info
*);
118 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int,
119 struct expression
*);
121 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int,
122 struct expression
*);
124 static int debug_to_stopped_by_watchpoint (void);
126 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
128 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
129 CORE_ADDR
, CORE_ADDR
, int);
131 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
133 static int debug_to_can_accel_watchpoint_condition (CORE_ADDR
, int, int,
134 struct expression
*);
136 static void debug_to_terminal_init (void);
138 static void debug_to_terminal_inferior (void);
140 static void debug_to_terminal_ours_for_output (void);
142 static void debug_to_terminal_save_ours (void);
144 static void debug_to_terminal_ours (void);
146 static void debug_to_terminal_info (char *, int);
148 static void debug_to_load (char *, int);
150 static int debug_to_can_run (void);
152 static void debug_to_stop (ptid_t
);
154 /* Pointer to array of target architecture structures; the size of the
155 array; the current index into the array; the allocated size of the
157 struct target_ops
**target_structs
;
158 unsigned target_struct_size
;
159 unsigned target_struct_index
;
160 unsigned target_struct_allocsize
;
161 #define DEFAULT_ALLOCSIZE 10
163 /* The initial current target, so that there is always a semi-valid
166 static struct target_ops dummy_target
;
168 /* Top of target stack. */
170 static struct target_ops
*target_stack
;
172 /* The target structure we are currently using to talk to a process
173 or file or whatever "inferior" we have. */
175 struct target_ops current_target
;
177 /* Command list for target. */
179 static struct cmd_list_element
*targetlist
= NULL
;
181 /* Nonzero if we should trust readonly sections from the
182 executable when reading memory. */
184 static int trust_readonly
= 0;
186 /* Nonzero if we should show true memory content including
187 memory breakpoint inserted by gdb. */
189 static int show_memory_breakpoints
= 0;
191 /* These globals control whether GDB attempts to perform these
192 operations; they are useful for targets that need to prevent
193 inadvertant disruption, such as in non-stop mode. */
195 int may_write_registers
= 1;
197 int may_write_memory
= 1;
199 int may_insert_breakpoints
= 1;
201 int may_insert_tracepoints
= 1;
203 int may_insert_fast_tracepoints
= 1;
207 /* Non-zero if we want to see trace of target level stuff. */
209 static int targetdebug
= 0;
211 show_targetdebug (struct ui_file
*file
, int from_tty
,
212 struct cmd_list_element
*c
, const char *value
)
214 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
217 static void setup_target_debug (void);
219 /* The option sets this. */
220 static int stack_cache_enabled_p_1
= 1;
221 /* And set_stack_cache_enabled_p updates this.
222 The reason for the separation is so that we don't flush the cache for
223 on->on transitions. */
224 static int stack_cache_enabled_p
= 1;
226 /* This is called *after* the stack-cache has been set.
227 Flush the cache for off->on and on->off transitions.
228 There's no real need to flush the cache for on->off transitions,
229 except cleanliness. */
232 set_stack_cache_enabled_p (char *args
, int from_tty
,
233 struct cmd_list_element
*c
)
235 if (stack_cache_enabled_p
!= stack_cache_enabled_p_1
)
236 target_dcache_invalidate ();
238 stack_cache_enabled_p
= stack_cache_enabled_p_1
;
242 show_stack_cache_enabled_p (struct ui_file
*file
, int from_tty
,
243 struct cmd_list_element
*c
, const char *value
)
245 fprintf_filtered (file
, _("Cache use for stack accesses is %s.\n"), value
);
248 /* Cache of memory operations, to speed up remote access. */
249 static DCACHE
*target_dcache
;
251 /* Invalidate the target dcache. */
254 target_dcache_invalidate (void)
256 dcache_invalidate (target_dcache
);
259 /* The user just typed 'target' without the name of a target. */
262 target_command (char *arg
, int from_tty
)
264 fputs_filtered ("Argument required (target name). Try `help target'\n",
268 /* Default target_has_* methods for process_stratum targets. */
271 default_child_has_all_memory (struct target_ops
*ops
)
273 /* If no inferior selected, then we can't read memory here. */
274 if (ptid_equal (inferior_ptid
, null_ptid
))
281 default_child_has_memory (struct target_ops
*ops
)
283 /* If no inferior selected, then we can't read memory here. */
284 if (ptid_equal (inferior_ptid
, null_ptid
))
291 default_child_has_stack (struct target_ops
*ops
)
293 /* If no inferior selected, there's no stack. */
294 if (ptid_equal (inferior_ptid
, null_ptid
))
301 default_child_has_registers (struct target_ops
*ops
)
303 /* Can't read registers from no inferior. */
304 if (ptid_equal (inferior_ptid
, null_ptid
))
311 default_child_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
313 /* If there's no thread selected, then we can't make it run through
315 if (ptid_equal (the_ptid
, null_ptid
))
323 target_has_all_memory_1 (void)
325 struct target_ops
*t
;
327 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
328 if (t
->to_has_all_memory (t
))
335 target_has_memory_1 (void)
337 struct target_ops
*t
;
339 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
340 if (t
->to_has_memory (t
))
347 target_has_stack_1 (void)
349 struct target_ops
*t
;
351 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
352 if (t
->to_has_stack (t
))
359 target_has_registers_1 (void)
361 struct target_ops
*t
;
363 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
364 if (t
->to_has_registers (t
))
371 target_has_execution_1 (ptid_t the_ptid
)
373 struct target_ops
*t
;
375 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
376 if (t
->to_has_execution (t
, the_ptid
))
383 target_has_execution_current (void)
385 return target_has_execution_1 (inferior_ptid
);
388 /* Add a possible target architecture to the list. */
391 add_target (struct target_ops
*t
)
393 /* Provide default values for all "must have" methods. */
394 if (t
->to_xfer_partial
== NULL
)
395 t
->to_xfer_partial
= default_xfer_partial
;
397 if (t
->to_has_all_memory
== NULL
)
398 t
->to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
400 if (t
->to_has_memory
== NULL
)
401 t
->to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
403 if (t
->to_has_stack
== NULL
)
404 t
->to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
406 if (t
->to_has_registers
== NULL
)
407 t
->to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
409 if (t
->to_has_execution
== NULL
)
410 t
->to_has_execution
= (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
414 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
415 target_structs
= (struct target_ops
**) xmalloc
416 (target_struct_allocsize
* sizeof (*target_structs
));
418 if (target_struct_size
>= target_struct_allocsize
)
420 target_struct_allocsize
*= 2;
421 target_structs
= (struct target_ops
**)
422 xrealloc ((char *) target_structs
,
423 target_struct_allocsize
* sizeof (*target_structs
));
425 target_structs
[target_struct_size
++] = t
;
427 if (targetlist
== NULL
)
428 add_prefix_cmd ("target", class_run
, target_command
, _("\
429 Connect to a target machine or process.\n\
430 The first argument is the type or protocol of the target machine.\n\
431 Remaining arguments are interpreted by the target protocol. For more\n\
432 information on the arguments for a particular protocol, type\n\
433 `help target ' followed by the protocol name."),
434 &targetlist
, "target ", 0, &cmdlist
);
435 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
448 struct target_ops
*t
;
450 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
451 if (t
->to_kill
!= NULL
)
454 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
464 target_load (char *arg
, int from_tty
)
466 target_dcache_invalidate ();
467 (*current_target
.to_load
) (arg
, from_tty
);
471 target_create_inferior (char *exec_file
, char *args
,
472 char **env
, int from_tty
)
474 struct target_ops
*t
;
476 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
478 if (t
->to_create_inferior
!= NULL
)
480 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
482 fprintf_unfiltered (gdb_stdlog
,
483 "target_create_inferior (%s, %s, xxx, %d)\n",
484 exec_file
, args
, from_tty
);
489 internal_error (__FILE__
, __LINE__
,
490 _("could not find a target to create inferior"));
494 target_terminal_inferior (void)
496 /* A background resume (``run&'') should leave GDB in control of the
497 terminal. Use target_can_async_p, not target_is_async_p, since at
498 this point the target is not async yet. However, if sync_execution
499 is not set, we know it will become async prior to resume. */
500 if (target_can_async_p () && !sync_execution
)
503 /* If GDB is resuming the inferior in the foreground, install
504 inferior's terminal modes. */
505 (*current_target
.to_terminal_inferior
) ();
509 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
510 struct target_ops
*t
)
512 errno
= EIO
; /* Can't read/write this location. */
513 return 0; /* No bytes handled. */
519 error (_("You can't do that when your target is `%s'"),
520 current_target
.to_shortname
);
526 error (_("You can't do that without a process to debug."));
530 default_terminal_info (char *args
, int from_tty
)
532 printf_unfiltered (_("No saved terminal information.\n"));
535 /* A default implementation for the to_get_ada_task_ptid target method.
537 This function builds the PTID by using both LWP and TID as part of
538 the PTID lwp and tid elements. The pid used is the pid of the
542 default_get_ada_task_ptid (long lwp
, long tid
)
544 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
547 /* Go through the target stack from top to bottom, copying over zero
548 entries in current_target, then filling in still empty entries. In
549 effect, we are doing class inheritance through the pushed target
552 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
553 is currently implemented, is that it discards any knowledge of
554 which target an inherited method originally belonged to.
555 Consequently, new new target methods should instead explicitly and
556 locally search the target stack for the target that can handle the
560 update_current_target (void)
562 struct target_ops
*t
;
564 /* First, reset current's contents. */
565 memset (¤t_target
, 0, sizeof (current_target
));
567 #define INHERIT(FIELD, TARGET) \
568 if (!current_target.FIELD) \
569 current_target.FIELD = (TARGET)->FIELD
571 for (t
= target_stack
; t
; t
= t
->beneath
)
573 INHERIT (to_shortname
, t
);
574 INHERIT (to_longname
, t
);
576 /* Do not inherit to_open. */
577 /* Do not inherit to_close. */
578 /* Do not inherit to_attach. */
579 INHERIT (to_post_attach
, t
);
580 INHERIT (to_attach_no_wait
, t
);
581 /* Do not inherit to_detach. */
582 /* Do not inherit to_disconnect. */
583 /* Do not inherit to_resume. */
584 /* Do not inherit to_wait. */
585 /* Do not inherit to_fetch_registers. */
586 /* Do not inherit to_store_registers. */
587 INHERIT (to_prepare_to_store
, t
);
588 INHERIT (deprecated_xfer_memory
, t
);
589 INHERIT (to_files_info
, t
);
590 INHERIT (to_insert_breakpoint
, t
);
591 INHERIT (to_remove_breakpoint
, t
);
592 INHERIT (to_can_use_hw_breakpoint
, t
);
593 INHERIT (to_insert_hw_breakpoint
, t
);
594 INHERIT (to_remove_hw_breakpoint
, t
);
595 /* Do not inherit to_ranged_break_num_registers. */
596 INHERIT (to_insert_watchpoint
, t
);
597 INHERIT (to_remove_watchpoint
, t
);
598 /* Do not inherit to_insert_mask_watchpoint. */
599 /* Do not inherit to_remove_mask_watchpoint. */
600 INHERIT (to_stopped_data_address
, t
);
601 INHERIT (to_have_steppable_watchpoint
, t
);
602 INHERIT (to_have_continuable_watchpoint
, t
);
603 INHERIT (to_stopped_by_watchpoint
, t
);
604 INHERIT (to_watchpoint_addr_within_range
, t
);
605 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
606 INHERIT (to_can_accel_watchpoint_condition
, t
);
607 /* Do not inherit to_masked_watch_num_registers. */
608 INHERIT (to_terminal_init
, t
);
609 INHERIT (to_terminal_inferior
, t
);
610 INHERIT (to_terminal_ours_for_output
, t
);
611 INHERIT (to_terminal_ours
, t
);
612 INHERIT (to_terminal_save_ours
, t
);
613 INHERIT (to_terminal_info
, t
);
614 /* Do not inherit to_kill. */
615 INHERIT (to_load
, t
);
616 /* Do no inherit to_create_inferior. */
617 INHERIT (to_post_startup_inferior
, t
);
618 INHERIT (to_insert_fork_catchpoint
, t
);
619 INHERIT (to_remove_fork_catchpoint
, t
);
620 INHERIT (to_insert_vfork_catchpoint
, t
);
621 INHERIT (to_remove_vfork_catchpoint
, t
);
622 /* Do not inherit to_follow_fork. */
623 INHERIT (to_insert_exec_catchpoint
, t
);
624 INHERIT (to_remove_exec_catchpoint
, t
);
625 INHERIT (to_set_syscall_catchpoint
, t
);
626 INHERIT (to_has_exited
, t
);
627 /* Do not inherit to_mourn_inferior. */
628 INHERIT (to_can_run
, t
);
629 /* Do not inherit to_pass_signals. */
630 /* Do not inherit to_thread_alive. */
631 /* Do not inherit to_find_new_threads. */
632 /* Do not inherit to_pid_to_str. */
633 INHERIT (to_extra_thread_info
, t
);
634 INHERIT (to_thread_name
, t
);
635 INHERIT (to_stop
, t
);
636 /* Do not inherit to_xfer_partial. */
637 INHERIT (to_rcmd
, t
);
638 INHERIT (to_pid_to_exec_file
, t
);
639 INHERIT (to_log_command
, t
);
640 INHERIT (to_stratum
, t
);
641 /* Do not inherit to_has_all_memory. */
642 /* Do not inherit to_has_memory. */
643 /* Do not inherit to_has_stack. */
644 /* Do not inherit to_has_registers. */
645 /* Do not inherit to_has_execution. */
646 INHERIT (to_has_thread_control
, t
);
647 INHERIT (to_can_async_p
, t
);
648 INHERIT (to_is_async_p
, t
);
649 INHERIT (to_async
, t
);
650 INHERIT (to_async_mask
, t
);
651 INHERIT (to_find_memory_regions
, t
);
652 INHERIT (to_make_corefile_notes
, t
);
653 INHERIT (to_get_bookmark
, t
);
654 INHERIT (to_goto_bookmark
, t
);
655 /* Do not inherit to_get_thread_local_address. */
656 INHERIT (to_can_execute_reverse
, t
);
657 INHERIT (to_thread_architecture
, t
);
658 /* Do not inherit to_read_description. */
659 INHERIT (to_get_ada_task_ptid
, t
);
660 /* Do not inherit to_search_memory. */
661 INHERIT (to_supports_multi_process
, t
);
662 INHERIT (to_trace_init
, t
);
663 INHERIT (to_download_tracepoint
, t
);
664 INHERIT (to_download_trace_state_variable
, t
);
665 INHERIT (to_trace_set_readonly_regions
, t
);
666 INHERIT (to_trace_start
, t
);
667 INHERIT (to_get_trace_status
, t
);
668 INHERIT (to_trace_stop
, t
);
669 INHERIT (to_trace_find
, t
);
670 INHERIT (to_get_trace_state_variable_value
, t
);
671 INHERIT (to_save_trace_data
, t
);
672 INHERIT (to_upload_tracepoints
, t
);
673 INHERIT (to_upload_trace_state_variables
, t
);
674 INHERIT (to_get_raw_trace_data
, t
);
675 INHERIT (to_set_disconnected_tracing
, t
);
676 INHERIT (to_set_circular_trace_buffer
, t
);
677 INHERIT (to_get_tib_address
, t
);
678 INHERIT (to_set_permissions
, t
);
679 INHERIT (to_static_tracepoint_marker_at
, t
);
680 INHERIT (to_static_tracepoint_markers_by_strid
, t
);
681 INHERIT (to_traceframe_info
, t
);
682 INHERIT (to_magic
, t
);
683 /* Do not inherit to_memory_map. */
684 /* Do not inherit to_flash_erase. */
685 /* Do not inherit to_flash_done. */
689 /* Clean up a target struct so it no longer has any zero pointers in
690 it. Some entries are defaulted to a method that print an error,
691 others are hard-wired to a standard recursive default. */
693 #define de_fault(field, value) \
694 if (!current_target.field) \
695 current_target.field = value
698 (void (*) (char *, int))
703 de_fault (to_post_attach
,
706 de_fault (to_prepare_to_store
,
707 (void (*) (struct regcache
*))
709 de_fault (deprecated_xfer_memory
,
710 (int (*) (CORE_ADDR
, gdb_byte
*, int, int,
711 struct mem_attrib
*, struct target_ops
*))
713 de_fault (to_files_info
,
714 (void (*) (struct target_ops
*))
716 de_fault (to_insert_breakpoint
,
717 memory_insert_breakpoint
);
718 de_fault (to_remove_breakpoint
,
719 memory_remove_breakpoint
);
720 de_fault (to_can_use_hw_breakpoint
,
721 (int (*) (int, int, int))
723 de_fault (to_insert_hw_breakpoint
,
724 (int (*) (struct gdbarch
*, struct bp_target_info
*))
726 de_fault (to_remove_hw_breakpoint
,
727 (int (*) (struct gdbarch
*, struct bp_target_info
*))
729 de_fault (to_insert_watchpoint
,
730 (int (*) (CORE_ADDR
, int, int, struct expression
*))
732 de_fault (to_remove_watchpoint
,
733 (int (*) (CORE_ADDR
, int, int, struct expression
*))
735 de_fault (to_stopped_by_watchpoint
,
738 de_fault (to_stopped_data_address
,
739 (int (*) (struct target_ops
*, CORE_ADDR
*))
741 de_fault (to_watchpoint_addr_within_range
,
742 default_watchpoint_addr_within_range
);
743 de_fault (to_region_ok_for_hw_watchpoint
,
744 default_region_ok_for_hw_watchpoint
);
745 de_fault (to_can_accel_watchpoint_condition
,
746 (int (*) (CORE_ADDR
, int, int, struct expression
*))
748 de_fault (to_terminal_init
,
751 de_fault (to_terminal_inferior
,
754 de_fault (to_terminal_ours_for_output
,
757 de_fault (to_terminal_ours
,
760 de_fault (to_terminal_save_ours
,
763 de_fault (to_terminal_info
,
764 default_terminal_info
);
766 (void (*) (char *, int))
768 de_fault (to_post_startup_inferior
,
771 de_fault (to_insert_fork_catchpoint
,
774 de_fault (to_remove_fork_catchpoint
,
777 de_fault (to_insert_vfork_catchpoint
,
780 de_fault (to_remove_vfork_catchpoint
,
783 de_fault (to_insert_exec_catchpoint
,
786 de_fault (to_remove_exec_catchpoint
,
789 de_fault (to_set_syscall_catchpoint
,
790 (int (*) (int, int, int, int, int *))
792 de_fault (to_has_exited
,
793 (int (*) (int, int, int *))
795 de_fault (to_can_run
,
797 de_fault (to_extra_thread_info
,
798 (char *(*) (struct thread_info
*))
800 de_fault (to_thread_name
,
801 (char *(*) (struct thread_info
*))
806 current_target
.to_xfer_partial
= current_xfer_partial
;
808 (void (*) (char *, struct ui_file
*))
810 de_fault (to_pid_to_exec_file
,
814 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
816 de_fault (to_async_mask
,
819 de_fault (to_thread_architecture
,
820 default_thread_architecture
);
821 current_target
.to_read_description
= NULL
;
822 de_fault (to_get_ada_task_ptid
,
823 (ptid_t (*) (long, long))
824 default_get_ada_task_ptid
);
825 de_fault (to_supports_multi_process
,
828 de_fault (to_trace_init
,
831 de_fault (to_download_tracepoint
,
832 (void (*) (struct breakpoint
*))
834 de_fault (to_download_trace_state_variable
,
835 (void (*) (struct trace_state_variable
*))
837 de_fault (to_trace_set_readonly_regions
,
840 de_fault (to_trace_start
,
843 de_fault (to_get_trace_status
,
844 (int (*) (struct trace_status
*))
846 de_fault (to_trace_stop
,
849 de_fault (to_trace_find
,
850 (int (*) (enum trace_find_type
, int, ULONGEST
, ULONGEST
, int *))
852 de_fault (to_get_trace_state_variable_value
,
853 (int (*) (int, LONGEST
*))
855 de_fault (to_save_trace_data
,
856 (int (*) (const char *))
858 de_fault (to_upload_tracepoints
,
859 (int (*) (struct uploaded_tp
**))
861 de_fault (to_upload_trace_state_variables
,
862 (int (*) (struct uploaded_tsv
**))
864 de_fault (to_get_raw_trace_data
,
865 (LONGEST (*) (gdb_byte
*, ULONGEST
, LONGEST
))
867 de_fault (to_set_disconnected_tracing
,
870 de_fault (to_set_circular_trace_buffer
,
873 de_fault (to_get_tib_address
,
874 (int (*) (ptid_t
, CORE_ADDR
*))
876 de_fault (to_set_permissions
,
879 de_fault (to_static_tracepoint_marker_at
,
880 (int (*) (CORE_ADDR
, struct static_tracepoint_marker
*))
882 de_fault (to_static_tracepoint_markers_by_strid
,
883 (VEC(static_tracepoint_marker_p
) * (*) (const char *))
885 de_fault (to_traceframe_info
,
886 (struct traceframe_info
* (*) (void))
890 /* Finally, position the target-stack beneath the squashed
891 "current_target". That way code looking for a non-inherited
892 target method can quickly and simply find it. */
893 current_target
.beneath
= target_stack
;
896 setup_target_debug ();
899 /* Push a new target type into the stack of the existing target accessors,
900 possibly superseding some of the existing accessors.
902 Rather than allow an empty stack, we always have the dummy target at
903 the bottom stratum, so we can call the function vectors without
907 push_target (struct target_ops
*t
)
909 struct target_ops
**cur
;
911 /* Check magic number. If wrong, it probably means someone changed
912 the struct definition, but not all the places that initialize one. */
913 if (t
->to_magic
!= OPS_MAGIC
)
915 fprintf_unfiltered (gdb_stderr
,
916 "Magic number of %s target struct wrong\n",
918 internal_error (__FILE__
, __LINE__
,
919 _("failed internal consistency check"));
922 /* Find the proper stratum to install this target in. */
923 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
925 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
929 /* If there's already targets at this stratum, remove them. */
930 /* FIXME: cagney/2003-10-15: I think this should be popping all
931 targets to CUR, and not just those at this stratum level. */
932 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
934 /* There's already something at this stratum level. Close it,
935 and un-hook it from the stack. */
936 struct target_ops
*tmp
= (*cur
);
938 (*cur
) = (*cur
)->beneath
;
940 target_close (tmp
, 0);
943 /* We have removed all targets in our stratum, now add the new one. */
947 update_current_target ();
950 /* Remove a target_ops vector from the stack, wherever it may be.
951 Return how many times it was removed (0 or 1). */
954 unpush_target (struct target_ops
*t
)
956 struct target_ops
**cur
;
957 struct target_ops
*tmp
;
959 if (t
->to_stratum
== dummy_stratum
)
960 internal_error (__FILE__
, __LINE__
,
961 _("Attempt to unpush the dummy target"));
963 /* Look for the specified target. Note that we assume that a target
964 can only occur once in the target stack. */
966 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
973 return 0; /* Didn't find target_ops, quit now. */
975 /* NOTE: cagney/2003-12-06: In '94 the close call was made
976 unconditional by moving it to before the above check that the
977 target was in the target stack (something about "Change the way
978 pushing and popping of targets work to support target overlays
979 and inheritance"). This doesn't make much sense - only open
980 targets should be closed. */
983 /* Unchain the target. */
985 (*cur
) = (*cur
)->beneath
;
988 update_current_target ();
996 target_close (target_stack
, 0); /* Let it clean up. */
997 if (unpush_target (target_stack
) == 1)
1000 fprintf_unfiltered (gdb_stderr
,
1001 "pop_target couldn't find target %s\n",
1002 current_target
.to_shortname
);
1003 internal_error (__FILE__
, __LINE__
,
1004 _("failed internal consistency check"));
1008 pop_all_targets_above (enum strata above_stratum
, int quitting
)
1010 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
1012 target_close (target_stack
, quitting
);
1013 if (!unpush_target (target_stack
))
1015 fprintf_unfiltered (gdb_stderr
,
1016 "pop_all_targets couldn't find target %s\n",
1017 target_stack
->to_shortname
);
1018 internal_error (__FILE__
, __LINE__
,
1019 _("failed internal consistency check"));
1026 pop_all_targets (int quitting
)
1028 pop_all_targets_above (dummy_stratum
, quitting
);
1031 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
1034 target_is_pushed (struct target_ops
*t
)
1036 struct target_ops
**cur
;
1038 /* Check magic number. If wrong, it probably means someone changed
1039 the struct definition, but not all the places that initialize one. */
1040 if (t
->to_magic
!= OPS_MAGIC
)
1042 fprintf_unfiltered (gdb_stderr
,
1043 "Magic number of %s target struct wrong\n",
1045 internal_error (__FILE__
, __LINE__
,
1046 _("failed internal consistency check"));
1049 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1056 /* Using the objfile specified in OBJFILE, find the address for the
1057 current thread's thread-local storage with offset OFFSET. */
1059 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
1061 volatile CORE_ADDR addr
= 0;
1062 struct target_ops
*target
;
1064 for (target
= current_target
.beneath
;
1066 target
= target
->beneath
)
1068 if (target
->to_get_thread_local_address
!= NULL
)
1073 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch
))
1075 ptid_t ptid
= inferior_ptid
;
1076 volatile struct gdb_exception ex
;
1078 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1082 /* Fetch the load module address for this objfile. */
1083 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch
,
1085 /* If it's 0, throw the appropriate exception. */
1087 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
1088 _("TLS load module not found"));
1090 addr
= target
->to_get_thread_local_address (target
, ptid
,
1093 /* If an error occurred, print TLS related messages here. Otherwise,
1094 throw the error to some higher catcher. */
1097 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1101 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
1102 error (_("Cannot find thread-local variables "
1103 "in this thread library."));
1105 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
1106 if (objfile_is_library
)
1107 error (_("Cannot find shared library `%s' in dynamic"
1108 " linker's load module list"), objfile
->name
);
1110 error (_("Cannot find executable file `%s' in dynamic"
1111 " linker's load module list"), objfile
->name
);
1113 case TLS_NOT_ALLOCATED_YET_ERROR
:
1114 if (objfile_is_library
)
1115 error (_("The inferior has not yet allocated storage for"
1116 " thread-local variables in\n"
1117 "the shared library `%s'\n"
1119 objfile
->name
, target_pid_to_str (ptid
));
1121 error (_("The inferior has not yet allocated storage for"
1122 " thread-local variables in\n"
1123 "the executable `%s'\n"
1125 objfile
->name
, target_pid_to_str (ptid
));
1127 case TLS_GENERIC_ERROR
:
1128 if (objfile_is_library
)
1129 error (_("Cannot find thread-local storage for %s, "
1130 "shared library %s:\n%s"),
1131 target_pid_to_str (ptid
),
1132 objfile
->name
, ex
.message
);
1134 error (_("Cannot find thread-local storage for %s, "
1135 "executable file %s:\n%s"),
1136 target_pid_to_str (ptid
),
1137 objfile
->name
, ex
.message
);
1140 throw_exception (ex
);
1145 /* It wouldn't be wrong here to try a gdbarch method, too; finding
1146 TLS is an ABI-specific thing. But we don't do that yet. */
1148 error (_("Cannot find thread-local variables on this target"));
1154 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1156 /* target_read_string -- read a null terminated string, up to LEN bytes,
1157 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1158 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1159 is responsible for freeing it. Return the number of bytes successfully
1163 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
1165 int tlen
, origlen
, offset
, i
;
1169 int buffer_allocated
;
1171 unsigned int nbytes_read
= 0;
1173 gdb_assert (string
);
1175 /* Small for testing. */
1176 buffer_allocated
= 4;
1177 buffer
= xmalloc (buffer_allocated
);
1184 tlen
= MIN (len
, 4 - (memaddr
& 3));
1185 offset
= memaddr
& 3;
1187 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
1190 /* The transfer request might have crossed the boundary to an
1191 unallocated region of memory. Retry the transfer, requesting
1195 errcode
= target_read_memory (memaddr
, buf
, 1);
1200 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
1204 bytes
= bufptr
- buffer
;
1205 buffer_allocated
*= 2;
1206 buffer
= xrealloc (buffer
, buffer_allocated
);
1207 bufptr
= buffer
+ bytes
;
1210 for (i
= 0; i
< tlen
; i
++)
1212 *bufptr
++ = buf
[i
+ offset
];
1213 if (buf
[i
+ offset
] == '\000')
1215 nbytes_read
+= i
+ 1;
1222 nbytes_read
+= tlen
;
1231 struct target_section_table
*
1232 target_get_section_table (struct target_ops
*target
)
1234 struct target_ops
*t
;
1237 fprintf_unfiltered (gdb_stdlog
, "target_get_section_table ()\n");
1239 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1240 if (t
->to_get_section_table
!= NULL
)
1241 return (*t
->to_get_section_table
) (t
);
1246 /* Find a section containing ADDR. */
1248 struct target_section
*
1249 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1251 struct target_section_table
*table
= target_get_section_table (target
);
1252 struct target_section
*secp
;
1257 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
1259 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1265 /* Read memory from the live target, even if currently inspecting a
1266 traceframe. The return is the same as that of target_read. */
1269 target_read_live_memory (enum target_object object
,
1270 ULONGEST memaddr
, gdb_byte
*myaddr
, LONGEST len
)
1273 struct cleanup
*cleanup
;
1275 /* Switch momentarily out of tfind mode so to access live memory.
1276 Note that this must not clear global state, such as the frame
1277 cache, which must still remain valid for the previous traceframe.
1278 We may be _building_ the frame cache at this point. */
1279 cleanup
= make_cleanup_restore_traceframe_number ();
1280 set_traceframe_number (-1);
1282 ret
= target_read (current_target
.beneath
, object
, NULL
,
1283 myaddr
, memaddr
, len
);
1285 do_cleanups (cleanup
);
1289 /* Using the set of read-only target sections of OPS, read live
1290 read-only memory. Note that the actual reads start from the
1291 top-most target again.
1293 For interface/parameters/return description see target.h,
1297 memory_xfer_live_readonly_partial (struct target_ops
*ops
,
1298 enum target_object object
,
1299 gdb_byte
*readbuf
, ULONGEST memaddr
,
1302 struct target_section
*secp
;
1303 struct target_section_table
*table
;
1305 secp
= target_section_by_addr (ops
, memaddr
);
1307 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1310 struct target_section
*p
;
1311 ULONGEST memend
= memaddr
+ len
;
1313 table
= target_get_section_table (ops
);
1315 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1317 if (memaddr
>= p
->addr
)
1319 if (memend
<= p
->endaddr
)
1321 /* Entire transfer is within this section. */
1322 return target_read_live_memory (object
, memaddr
,
1325 else if (memaddr
>= p
->endaddr
)
1327 /* This section ends before the transfer starts. */
1332 /* This section overlaps the transfer. Just do half. */
1333 len
= p
->endaddr
- memaddr
;
1334 return target_read_live_memory (object
, memaddr
,
1344 /* Perform a partial memory transfer.
1345 For docs see target.h, to_xfer_partial. */
1348 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1349 void *readbuf
, const void *writebuf
, ULONGEST memaddr
,
1354 struct mem_region
*region
;
1355 struct inferior
*inf
;
1357 /* Zero length requests are ok and require no work. */
1361 /* For accesses to unmapped overlay sections, read directly from
1362 files. Must do this first, as MEMADDR may need adjustment. */
1363 if (readbuf
!= NULL
&& overlay_debugging
)
1365 struct obj_section
*section
= find_pc_overlay (memaddr
);
1367 if (pc_in_unmapped_range (memaddr
, section
))
1369 struct target_section_table
*table
1370 = target_get_section_table (ops
);
1371 const char *section_name
= section
->the_bfd_section
->name
;
1373 memaddr
= overlay_mapped_address (memaddr
, section
);
1374 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1377 table
->sections_end
,
1382 /* Try the executable files, if "trust-readonly-sections" is set. */
1383 if (readbuf
!= NULL
&& trust_readonly
)
1385 struct target_section
*secp
;
1386 struct target_section_table
*table
;
1388 secp
= target_section_by_addr (ops
, memaddr
);
1390 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1393 table
= target_get_section_table (ops
);
1394 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1397 table
->sections_end
,
1402 /* If reading unavailable memory in the context of traceframes, and
1403 this address falls within a read-only section, fallback to
1404 reading from live memory. */
1405 if (readbuf
!= NULL
&& get_traceframe_number () != -1)
1407 VEC(mem_range_s
) *available
;
1409 /* If we fail to get the set of available memory, then the
1410 target does not support querying traceframe info, and so we
1411 attempt reading from the traceframe anyway (assuming the
1412 target implements the old QTro packet then). */
1413 if (traceframe_available_memory (&available
, memaddr
, len
))
1415 struct cleanup
*old_chain
;
1417 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
1419 if (VEC_empty (mem_range_s
, available
)
1420 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
1422 /* Don't read into the traceframe's available
1424 if (!VEC_empty (mem_range_s
, available
))
1426 LONGEST oldlen
= len
;
1428 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
1429 gdb_assert (len
<= oldlen
);
1432 do_cleanups (old_chain
);
1434 /* This goes through the topmost target again. */
1435 res
= memory_xfer_live_readonly_partial (ops
, object
,
1436 readbuf
, memaddr
, len
);
1440 /* No use trying further, we know some memory starting
1441 at MEMADDR isn't available. */
1445 /* Don't try to read more than how much is available, in
1446 case the target implements the deprecated QTro packet to
1447 cater for older GDBs (the target's knowledge of read-only
1448 sections may be outdated by now). */
1449 len
= VEC_index (mem_range_s
, available
, 0)->length
;
1451 do_cleanups (old_chain
);
1455 /* Try GDB's internal data cache. */
1456 region
= lookup_mem_region (memaddr
);
1457 /* region->hi == 0 means there's no upper bound. */
1458 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1461 reg_len
= region
->hi
- memaddr
;
1463 switch (region
->attrib
.mode
)
1466 if (writebuf
!= NULL
)
1471 if (readbuf
!= NULL
)
1476 /* We only support writing to flash during "load" for now. */
1477 if (writebuf
!= NULL
)
1478 error (_("Writing to flash memory forbidden in this context"));
1485 if (!ptid_equal (inferior_ptid
, null_ptid
))
1486 inf
= find_inferior_pid (ptid_get_pid (inferior_ptid
));
1491 /* The dcache reads whole cache lines; that doesn't play well
1492 with reading from a trace buffer, because reading outside of
1493 the collected memory range fails. */
1494 && get_traceframe_number () == -1
1495 && (region
->attrib
.cache
1496 || (stack_cache_enabled_p
&& object
== TARGET_OBJECT_STACK_MEMORY
)))
1498 if (readbuf
!= NULL
)
1499 res
= dcache_xfer_memory (ops
, target_dcache
, memaddr
, readbuf
,
1502 /* FIXME drow/2006-08-09: If we're going to preserve const
1503 correctness dcache_xfer_memory should take readbuf and
1505 res
= dcache_xfer_memory (ops
, target_dcache
, memaddr
,
1512 if (readbuf
&& !show_memory_breakpoints
)
1513 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1518 /* If none of those methods found the memory we wanted, fall back
1519 to a target partial transfer. Normally a single call to
1520 to_xfer_partial is enough; if it doesn't recognize an object
1521 it will call the to_xfer_partial of the next target down.
1522 But for memory this won't do. Memory is the only target
1523 object which can be read from more than one valid target.
1524 A core file, for instance, could have some of memory but
1525 delegate other bits to the target below it. So, we must
1526 manually try all targets. */
1530 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1531 readbuf
, writebuf
, memaddr
, reg_len
);
1535 /* We want to continue past core files to executables, but not
1536 past a running target's memory. */
1537 if (ops
->to_has_all_memory (ops
))
1542 while (ops
!= NULL
);
1544 if (res
> 0 && readbuf
!= NULL
&& !show_memory_breakpoints
)
1545 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1547 /* Make sure the cache gets updated no matter what - if we are writing
1548 to the stack. Even if this write is not tagged as such, we still need
1549 to update the cache. */
1554 && !region
->attrib
.cache
1555 && stack_cache_enabled_p
1556 && object
!= TARGET_OBJECT_STACK_MEMORY
)
1558 dcache_update (target_dcache
, memaddr
, (void *) writebuf
, res
);
1561 /* If we still haven't got anything, return the last error. We
1567 restore_show_memory_breakpoints (void *arg
)
1569 show_memory_breakpoints
= (uintptr_t) arg
;
1573 make_show_memory_breakpoints_cleanup (int show
)
1575 int current
= show_memory_breakpoints
;
1577 show_memory_breakpoints
= show
;
1578 return make_cleanup (restore_show_memory_breakpoints
,
1579 (void *) (uintptr_t) current
);
1582 /* For docs see target.h, to_xfer_partial. */
1585 target_xfer_partial (struct target_ops
*ops
,
1586 enum target_object object
, const char *annex
,
1587 void *readbuf
, const void *writebuf
,
1588 ULONGEST offset
, LONGEST len
)
1592 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1594 if (writebuf
&& !may_write_memory
)
1595 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1596 core_addr_to_string_nz (offset
), plongest (len
));
1598 /* If this is a memory transfer, let the memory-specific code
1599 have a look at it instead. Memory transfers are more
1601 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
)
1602 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1603 writebuf
, offset
, len
);
1606 enum target_object raw_object
= object
;
1608 /* If this is a raw memory transfer, request the normal
1609 memory object from other layers. */
1610 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1611 raw_object
= TARGET_OBJECT_MEMORY
;
1613 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1614 writebuf
, offset
, len
);
1619 const unsigned char *myaddr
= NULL
;
1621 fprintf_unfiltered (gdb_stdlog
,
1622 "%s:target_xfer_partial "
1623 "(%d, %s, %s, %s, %s, %s) = %s",
1626 (annex
? annex
: "(null)"),
1627 host_address_to_string (readbuf
),
1628 host_address_to_string (writebuf
),
1629 core_addr_to_string_nz (offset
),
1630 plongest (len
), plongest (retval
));
1636 if (retval
> 0 && myaddr
!= NULL
)
1640 fputs_unfiltered (", bytes =", gdb_stdlog
);
1641 for (i
= 0; i
< retval
; i
++)
1643 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1645 if (targetdebug
< 2 && i
> 0)
1647 fprintf_unfiltered (gdb_stdlog
, " ...");
1650 fprintf_unfiltered (gdb_stdlog
, "\n");
1653 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1657 fputc_unfiltered ('\n', gdb_stdlog
);
1662 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1663 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1664 if any error occurs.
1666 If an error occurs, no guarantee is made about the contents of the data at
1667 MYADDR. In particular, the caller should not depend upon partial reads
1668 filling the buffer with good data. There is no way for the caller to know
1669 how much good data might have been transfered anyway. Callers that can
1670 deal with partial reads should call target_read (which will retry until
1671 it makes no progress, and then return how much was transferred). */
1674 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1676 /* Dispatch to the topmost target, not the flattened current_target.
1677 Memory accesses check target->to_has_(all_)memory, and the
1678 flattened target doesn't inherit those. */
1679 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1680 myaddr
, memaddr
, len
) == len
)
1686 /* Like target_read_memory, but specify explicitly that this is a read from
1687 the target's stack. This may trigger different cache behavior. */
1690 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1692 /* Dispatch to the topmost target, not the flattened current_target.
1693 Memory accesses check target->to_has_(all_)memory, and the
1694 flattened target doesn't inherit those. */
1696 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1697 myaddr
, memaddr
, len
) == len
)
1703 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1704 Returns either 0 for success or an errno value if any error occurs.
1705 If an error occurs, no guarantee is made about how much data got written.
1706 Callers that can deal with partial writes should call target_write. */
1709 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1711 /* Dispatch to the topmost target, not the flattened current_target.
1712 Memory accesses check target->to_has_(all_)memory, and the
1713 flattened target doesn't inherit those. */
1714 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1715 myaddr
, memaddr
, len
) == len
)
1721 /* Fetch the target's memory map. */
1724 target_memory_map (void)
1726 VEC(mem_region_s
) *result
;
1727 struct mem_region
*last_one
, *this_one
;
1729 struct target_ops
*t
;
1732 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1734 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1735 if (t
->to_memory_map
!= NULL
)
1741 result
= t
->to_memory_map (t
);
1745 qsort (VEC_address (mem_region_s
, result
),
1746 VEC_length (mem_region_s
, result
),
1747 sizeof (struct mem_region
), mem_region_cmp
);
1749 /* Check that regions do not overlap. Simultaneously assign
1750 a numbering for the "mem" commands to use to refer to
1753 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1755 this_one
->number
= ix
;
1757 if (last_one
&& last_one
->hi
> this_one
->lo
)
1759 warning (_("Overlapping regions in memory map: ignoring"));
1760 VEC_free (mem_region_s
, result
);
1763 last_one
= this_one
;
1770 target_flash_erase (ULONGEST address
, LONGEST length
)
1772 struct target_ops
*t
;
1774 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1775 if (t
->to_flash_erase
!= NULL
)
1778 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1779 hex_string (address
), phex (length
, 0));
1780 t
->to_flash_erase (t
, address
, length
);
1788 target_flash_done (void)
1790 struct target_ops
*t
;
1792 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1793 if (t
->to_flash_done
!= NULL
)
1796 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1797 t
->to_flash_done (t
);
1805 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1806 struct cmd_list_element
*c
, const char *value
)
1808 fprintf_filtered (file
,
1809 _("Mode for reading from readonly sections is %s.\n"),
1813 /* More generic transfers. */
1816 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1817 const char *annex
, gdb_byte
*readbuf
,
1818 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1820 if (object
== TARGET_OBJECT_MEMORY
1821 && ops
->deprecated_xfer_memory
!= NULL
)
1822 /* If available, fall back to the target's
1823 "deprecated_xfer_memory" method. */
1828 if (writebuf
!= NULL
)
1830 void *buffer
= xmalloc (len
);
1831 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1833 memcpy (buffer
, writebuf
, len
);
1834 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1835 1/*write*/, NULL
, ops
);
1836 do_cleanups (cleanup
);
1838 if (readbuf
!= NULL
)
1839 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1840 0/*read*/, NULL
, ops
);
1843 else if (xfered
== 0 && errno
== 0)
1844 /* "deprecated_xfer_memory" uses 0, cross checked against
1845 ERRNO as one indication of an error. */
1850 else if (ops
->beneath
!= NULL
)
1851 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1852 readbuf
, writebuf
, offset
, len
);
1857 /* The xfer_partial handler for the topmost target. Unlike the default,
1858 it does not need to handle memory specially; it just passes all
1859 requests down the stack. */
1862 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1863 const char *annex
, gdb_byte
*readbuf
,
1864 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1866 if (ops
->beneath
!= NULL
)
1867 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1868 readbuf
, writebuf
, offset
, len
);
1873 /* Target vector read/write partial wrapper functions. */
1876 target_read_partial (struct target_ops
*ops
,
1877 enum target_object object
,
1878 const char *annex
, gdb_byte
*buf
,
1879 ULONGEST offset
, LONGEST len
)
1881 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1885 target_write_partial (struct target_ops
*ops
,
1886 enum target_object object
,
1887 const char *annex
, const gdb_byte
*buf
,
1888 ULONGEST offset
, LONGEST len
)
1890 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1893 /* Wrappers to perform the full transfer. */
1895 /* For docs on target_read see target.h. */
1898 target_read (struct target_ops
*ops
,
1899 enum target_object object
,
1900 const char *annex
, gdb_byte
*buf
,
1901 ULONGEST offset
, LONGEST len
)
1905 while (xfered
< len
)
1907 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1908 (gdb_byte
*) buf
+ xfered
,
1909 offset
+ xfered
, len
- xfered
);
1911 /* Call an observer, notifying them of the xfer progress? */
1922 /* Assuming that the entire [begin, end) range of memory cannot be
1923 read, try to read whatever subrange is possible to read.
1925 The function returns, in RESULT, either zero or one memory block.
1926 If there's a readable subrange at the beginning, it is completely
1927 read and returned. Any further readable subrange will not be read.
1928 Otherwise, if there's a readable subrange at the end, it will be
1929 completely read and returned. Any readable subranges before it
1930 (obviously, not starting at the beginning), will be ignored. In
1931 other cases -- either no readable subrange, or readable subrange(s)
1932 that is neither at the beginning, or end, nothing is returned.
1934 The purpose of this function is to handle a read across a boundary
1935 of accessible memory in a case when memory map is not available.
1936 The above restrictions are fine for this case, but will give
1937 incorrect results if the memory is 'patchy'. However, supporting
1938 'patchy' memory would require trying to read every single byte,
1939 and it seems unacceptable solution. Explicit memory map is
1940 recommended for this case -- and target_read_memory_robust will
1941 take care of reading multiple ranges then. */
1944 read_whatever_is_readable (struct target_ops
*ops
,
1945 ULONGEST begin
, ULONGEST end
,
1946 VEC(memory_read_result_s
) **result
)
1948 gdb_byte
*buf
= xmalloc (end
- begin
);
1949 ULONGEST current_begin
= begin
;
1950 ULONGEST current_end
= end
;
1952 memory_read_result_s r
;
1954 /* If we previously failed to read 1 byte, nothing can be done here. */
1955 if (end
- begin
<= 1)
1961 /* Check that either first or the last byte is readable, and give up
1962 if not. This heuristic is meant to permit reading accessible memory
1963 at the boundary of accessible region. */
1964 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1965 buf
, begin
, 1) == 1)
1970 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1971 buf
+ (end
-begin
) - 1, end
- 1, 1) == 1)
1982 /* Loop invariant is that the [current_begin, current_end) was previously
1983 found to be not readable as a whole.
1985 Note loop condition -- if the range has 1 byte, we can't divide the range
1986 so there's no point trying further. */
1987 while (current_end
- current_begin
> 1)
1989 ULONGEST first_half_begin
, first_half_end
;
1990 ULONGEST second_half_begin
, second_half_end
;
1992 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
1996 first_half_begin
= current_begin
;
1997 first_half_end
= middle
;
1998 second_half_begin
= middle
;
1999 second_half_end
= current_end
;
2003 first_half_begin
= middle
;
2004 first_half_end
= current_end
;
2005 second_half_begin
= current_begin
;
2006 second_half_end
= middle
;
2009 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2010 buf
+ (first_half_begin
- begin
),
2012 first_half_end
- first_half_begin
);
2014 if (xfer
== first_half_end
- first_half_begin
)
2016 /* This half reads up fine. So, the error must be in the
2018 current_begin
= second_half_begin
;
2019 current_end
= second_half_end
;
2023 /* This half is not readable. Because we've tried one byte, we
2024 know some part of this half if actually redable. Go to the next
2025 iteration to divide again and try to read.
2027 We don't handle the other half, because this function only tries
2028 to read a single readable subrange. */
2029 current_begin
= first_half_begin
;
2030 current_end
= first_half_end
;
2036 /* The [begin, current_begin) range has been read. */
2038 r
.end
= current_begin
;
2043 /* The [current_end, end) range has been read. */
2044 LONGEST rlen
= end
- current_end
;
2046 r
.data
= xmalloc (rlen
);
2047 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
2048 r
.begin
= current_end
;
2052 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
2056 free_memory_read_result_vector (void *x
)
2058 VEC(memory_read_result_s
) *v
= x
;
2059 memory_read_result_s
*current
;
2062 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
2064 xfree (current
->data
);
2066 VEC_free (memory_read_result_s
, v
);
2069 VEC(memory_read_result_s
) *
2070 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
2072 VEC(memory_read_result_s
) *result
= 0;
2075 while (xfered
< len
)
2077 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
2080 /* If there is no explicit region, a fake one should be created. */
2081 gdb_assert (region
);
2083 if (region
->hi
== 0)
2084 rlen
= len
- xfered
;
2086 rlen
= region
->hi
- offset
;
2088 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
2090 /* Cannot read this region. Note that we can end up here only
2091 if the region is explicitly marked inaccessible, or
2092 'inaccessible-by-default' is in effect. */
2097 LONGEST to_read
= min (len
- xfered
, rlen
);
2098 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
2100 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2101 (gdb_byte
*) buffer
,
2102 offset
+ xfered
, to_read
);
2103 /* Call an observer, notifying them of the xfer progress? */
2106 /* Got an error reading full chunk. See if maybe we can read
2109 read_whatever_is_readable (ops
, offset
+ xfered
,
2110 offset
+ xfered
+ to_read
, &result
);
2115 struct memory_read_result r
;
2117 r
.begin
= offset
+ xfered
;
2118 r
.end
= r
.begin
+ xfer
;
2119 VEC_safe_push (memory_read_result_s
, result
, &r
);
2129 /* An alternative to target_write with progress callbacks. */
2132 target_write_with_progress (struct target_ops
*ops
,
2133 enum target_object object
,
2134 const char *annex
, const gdb_byte
*buf
,
2135 ULONGEST offset
, LONGEST len
,
2136 void (*progress
) (ULONGEST
, void *), void *baton
)
2140 /* Give the progress callback a chance to set up. */
2142 (*progress
) (0, baton
);
2144 while (xfered
< len
)
2146 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
2147 (gdb_byte
*) buf
+ xfered
,
2148 offset
+ xfered
, len
- xfered
);
2156 (*progress
) (xfer
, baton
);
2164 /* For docs on target_write see target.h. */
2167 target_write (struct target_ops
*ops
,
2168 enum target_object object
,
2169 const char *annex
, const gdb_byte
*buf
,
2170 ULONGEST offset
, LONGEST len
)
2172 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2176 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2177 the size of the transferred data. PADDING additional bytes are
2178 available in *BUF_P. This is a helper function for
2179 target_read_alloc; see the declaration of that function for more
2183 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2184 const char *annex
, gdb_byte
**buf_p
, int padding
)
2186 size_t buf_alloc
, buf_pos
;
2190 /* This function does not have a length parameter; it reads the
2191 entire OBJECT). Also, it doesn't support objects fetched partly
2192 from one target and partly from another (in a different stratum,
2193 e.g. a core file and an executable). Both reasons make it
2194 unsuitable for reading memory. */
2195 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2197 /* Start by reading up to 4K at a time. The target will throttle
2198 this number down if necessary. */
2200 buf
= xmalloc (buf_alloc
);
2204 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2205 buf_pos
, buf_alloc
- buf_pos
- padding
);
2208 /* An error occurred. */
2214 /* Read all there was. */
2224 /* If the buffer is filling up, expand it. */
2225 if (buf_alloc
< buf_pos
* 2)
2228 buf
= xrealloc (buf
, buf_alloc
);
2235 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2236 the size of the transferred data. See the declaration in "target.h"
2237 function for more information about the return value. */
2240 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2241 const char *annex
, gdb_byte
**buf_p
)
2243 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2246 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2247 returned as a string, allocated using xmalloc. If an error occurs
2248 or the transfer is unsupported, NULL is returned. Empty objects
2249 are returned as allocated but empty strings. A warning is issued
2250 if the result contains any embedded NUL bytes. */
2253 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2257 LONGEST transferred
;
2259 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2261 if (transferred
< 0)
2264 if (transferred
== 0)
2265 return xstrdup ("");
2267 buffer
[transferred
] = 0;
2268 if (strlen (buffer
) < transferred
)
2269 warning (_("target object %d, annex %s, "
2270 "contained unexpected null characters"),
2271 (int) object
, annex
? annex
: "(none)");
2273 return (char *) buffer
;
2276 /* Memory transfer methods. */
2279 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2282 /* This method is used to read from an alternate, non-current
2283 target. This read must bypass the overlay support (as symbols
2284 don't match this target), and GDB's internal cache (wrong cache
2285 for this target). */
2286 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2288 memory_error (EIO
, addr
);
2292 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2293 int len
, enum bfd_endian byte_order
)
2295 gdb_byte buf
[sizeof (ULONGEST
)];
2297 gdb_assert (len
<= sizeof (buf
));
2298 get_target_memory (ops
, addr
, buf
, len
);
2299 return extract_unsigned_integer (buf
, len
, byte_order
);
2303 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2304 struct bp_target_info
*bp_tgt
)
2306 if (!may_insert_breakpoints
)
2308 warning (_("May not insert breakpoints"));
2312 return (*current_target
.to_insert_breakpoint
) (gdbarch
, bp_tgt
);
2316 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2317 struct bp_target_info
*bp_tgt
)
2319 /* This is kind of a weird case to handle, but the permission might
2320 have been changed after breakpoints were inserted - in which case
2321 we should just take the user literally and assume that any
2322 breakpoints should be left in place. */
2323 if (!may_insert_breakpoints
)
2325 warning (_("May not remove breakpoints"));
2329 return (*current_target
.to_remove_breakpoint
) (gdbarch
, bp_tgt
);
2333 target_info (char *args
, int from_tty
)
2335 struct target_ops
*t
;
2336 int has_all_mem
= 0;
2338 if (symfile_objfile
!= NULL
)
2339 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
2341 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2343 if (!(*t
->to_has_memory
) (t
))
2346 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2349 printf_unfiltered (_("\tWhile running this, "
2350 "GDB does not access memory from...\n"));
2351 printf_unfiltered ("%s:\n", t
->to_longname
);
2352 (t
->to_files_info
) (t
);
2353 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2357 /* This function is called before any new inferior is created, e.g.
2358 by running a program, attaching, or connecting to a target.
2359 It cleans up any state from previous invocations which might
2360 change between runs. This is a subset of what target_preopen
2361 resets (things which might change between targets). */
2364 target_pre_inferior (int from_tty
)
2366 /* Clear out solib state. Otherwise the solib state of the previous
2367 inferior might have survived and is entirely wrong for the new
2368 target. This has been observed on GNU/Linux using glibc 2.3. How
2380 Cannot access memory at address 0xdeadbeef
2383 /* In some OSs, the shared library list is the same/global/shared
2384 across inferiors. If code is shared between processes, so are
2385 memory regions and features. */
2386 if (!gdbarch_has_global_solist (target_gdbarch
))
2388 no_shared_libraries (NULL
, from_tty
);
2390 invalidate_target_mem_regions ();
2392 target_clear_description ();
2396 /* Callback for iterate_over_inferiors. Gets rid of the given
2400 dispose_inferior (struct inferior
*inf
, void *args
)
2402 struct thread_info
*thread
;
2404 thread
= any_thread_of_process (inf
->pid
);
2407 switch_to_thread (thread
->ptid
);
2409 /* Core inferiors actually should be detached, not killed. */
2410 if (target_has_execution
)
2413 target_detach (NULL
, 0);
2419 /* This is to be called by the open routine before it does
2423 target_preopen (int from_tty
)
2427 if (have_inferiors ())
2430 || !have_live_inferiors ()
2431 || query (_("A program is being debugged already. Kill it? ")))
2432 iterate_over_inferiors (dispose_inferior
, NULL
);
2434 error (_("Program not killed."));
2437 /* Calling target_kill may remove the target from the stack. But if
2438 it doesn't (which seems like a win for UDI), remove it now. */
2439 /* Leave the exec target, though. The user may be switching from a
2440 live process to a core of the same program. */
2441 pop_all_targets_above (file_stratum
, 0);
2443 target_pre_inferior (from_tty
);
2446 /* Detach a target after doing deferred register stores. */
2449 target_detach (char *args
, int from_tty
)
2451 struct target_ops
* t
;
2453 if (gdbarch_has_global_breakpoints (target_gdbarch
))
2454 /* Don't remove global breakpoints here. They're removed on
2455 disconnection from the target. */
2458 /* If we're in breakpoints-always-inserted mode, have to remove
2459 them before detaching. */
2460 remove_breakpoints_pid (PIDGET (inferior_ptid
));
2462 prepare_for_detach ();
2464 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2466 if (t
->to_detach
!= NULL
)
2468 t
->to_detach (t
, args
, from_tty
);
2470 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2476 internal_error (__FILE__
, __LINE__
, _("could not find a target to detach"));
2480 target_disconnect (char *args
, int from_tty
)
2482 struct target_ops
*t
;
2484 /* If we're in breakpoints-always-inserted mode or if breakpoints
2485 are global across processes, we have to remove them before
2487 remove_breakpoints ();
2489 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2490 if (t
->to_disconnect
!= NULL
)
2493 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2495 t
->to_disconnect (t
, args
, from_tty
);
2503 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2505 struct target_ops
*t
;
2507 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2509 if (t
->to_wait
!= NULL
)
2511 ptid_t retval
= (*t
->to_wait
) (t
, ptid
, status
, options
);
2515 char *status_string
;
2517 status_string
= target_waitstatus_to_string (status
);
2518 fprintf_unfiltered (gdb_stdlog
,
2519 "target_wait (%d, status) = %d, %s\n",
2520 PIDGET (ptid
), PIDGET (retval
),
2522 xfree (status_string
);
2533 target_pid_to_str (ptid_t ptid
)
2535 struct target_ops
*t
;
2537 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2539 if (t
->to_pid_to_str
!= NULL
)
2540 return (*t
->to_pid_to_str
) (t
, ptid
);
2543 return normal_pid_to_str (ptid
);
2547 target_thread_name (struct thread_info
*info
)
2549 struct target_ops
*t
;
2551 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2553 if (t
->to_thread_name
!= NULL
)
2554 return (*t
->to_thread_name
) (info
);
2561 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
2563 struct target_ops
*t
;
2565 target_dcache_invalidate ();
2567 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2569 if (t
->to_resume
!= NULL
)
2571 t
->to_resume (t
, ptid
, step
, signal
);
2573 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2575 step
? "step" : "continue",
2576 target_signal_to_name (signal
));
2578 registers_changed_ptid (ptid
);
2579 set_executing (ptid
, 1);
2580 set_running (ptid
, 1);
2581 clear_inline_frame_state (ptid
);
2590 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2592 struct target_ops
*t
;
2594 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2596 if (t
->to_pass_signals
!= NULL
)
2602 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2605 for (i
= 0; i
< numsigs
; i
++)
2606 if (pass_signals
[i
])
2607 fprintf_unfiltered (gdb_stdlog
, " %s",
2608 target_signal_to_name (i
));
2610 fprintf_unfiltered (gdb_stdlog
, " })\n");
2613 (*t
->to_pass_signals
) (numsigs
, pass_signals
);
2619 /* Look through the list of possible targets for a target that can
2623 target_follow_fork (int follow_child
)
2625 struct target_ops
*t
;
2627 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2629 if (t
->to_follow_fork
!= NULL
)
2631 int retval
= t
->to_follow_fork (t
, follow_child
);
2634 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2635 follow_child
, retval
);
2640 /* Some target returned a fork event, but did not know how to follow it. */
2641 internal_error (__FILE__
, __LINE__
,
2642 _("could not find a target to follow fork"));
2646 target_mourn_inferior (void)
2648 struct target_ops
*t
;
2650 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2652 if (t
->to_mourn_inferior
!= NULL
)
2654 t
->to_mourn_inferior (t
);
2656 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2658 /* We no longer need to keep handles on any of the object files.
2659 Make sure to release them to avoid unnecessarily locking any
2660 of them while we're not actually debugging. */
2661 bfd_cache_close_all ();
2667 internal_error (__FILE__
, __LINE__
,
2668 _("could not find a target to follow mourn inferior"));
2671 /* Look for a target which can describe architectural features, starting
2672 from TARGET. If we find one, return its description. */
2674 const struct target_desc
*
2675 target_read_description (struct target_ops
*target
)
2677 struct target_ops
*t
;
2679 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
2680 if (t
->to_read_description
!= NULL
)
2682 const struct target_desc
*tdesc
;
2684 tdesc
= t
->to_read_description (t
);
2692 /* The default implementation of to_search_memory.
2693 This implements a basic search of memory, reading target memory and
2694 performing the search here (as opposed to performing the search in on the
2695 target side with, for example, gdbserver). */
2698 simple_search_memory (struct target_ops
*ops
,
2699 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2700 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2701 CORE_ADDR
*found_addrp
)
2703 /* NOTE: also defined in find.c testcase. */
2704 #define SEARCH_CHUNK_SIZE 16000
2705 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2706 /* Buffer to hold memory contents for searching. */
2707 gdb_byte
*search_buf
;
2708 unsigned search_buf_size
;
2709 struct cleanup
*old_cleanups
;
2711 search_buf_size
= chunk_size
+ pattern_len
- 1;
2713 /* No point in trying to allocate a buffer larger than the search space. */
2714 if (search_space_len
< search_buf_size
)
2715 search_buf_size
= search_space_len
;
2717 search_buf
= malloc (search_buf_size
);
2718 if (search_buf
== NULL
)
2719 error (_("Unable to allocate memory to perform the search."));
2720 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2722 /* Prime the search buffer. */
2724 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2725 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2727 warning (_("Unable to access target memory at %s, halting search."),
2728 hex_string (start_addr
));
2729 do_cleanups (old_cleanups
);
2733 /* Perform the search.
2735 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2736 When we've scanned N bytes we copy the trailing bytes to the start and
2737 read in another N bytes. */
2739 while (search_space_len
>= pattern_len
)
2741 gdb_byte
*found_ptr
;
2742 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2744 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2745 pattern
, pattern_len
);
2747 if (found_ptr
!= NULL
)
2749 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2751 *found_addrp
= found_addr
;
2752 do_cleanups (old_cleanups
);
2756 /* Not found in this chunk, skip to next chunk. */
2758 /* Don't let search_space_len wrap here, it's unsigned. */
2759 if (search_space_len
>= chunk_size
)
2760 search_space_len
-= chunk_size
;
2762 search_space_len
= 0;
2764 if (search_space_len
>= pattern_len
)
2766 unsigned keep_len
= search_buf_size
- chunk_size
;
2767 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2770 /* Copy the trailing part of the previous iteration to the front
2771 of the buffer for the next iteration. */
2772 gdb_assert (keep_len
== pattern_len
- 1);
2773 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
2775 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
2777 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2778 search_buf
+ keep_len
, read_addr
,
2779 nr_to_read
) != nr_to_read
)
2781 warning (_("Unable to access target "
2782 "memory at %s, halting search."),
2783 hex_string (read_addr
));
2784 do_cleanups (old_cleanups
);
2788 start_addr
+= chunk_size
;
2794 do_cleanups (old_cleanups
);
2798 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2799 sequence of bytes in PATTERN with length PATTERN_LEN.
2801 The result is 1 if found, 0 if not found, and -1 if there was an error
2802 requiring halting of the search (e.g. memory read error).
2803 If the pattern is found the address is recorded in FOUND_ADDRP. */
2806 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2807 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2808 CORE_ADDR
*found_addrp
)
2810 struct target_ops
*t
;
2813 /* We don't use INHERIT to set current_target.to_search_memory,
2814 so we have to scan the target stack and handle targetdebug
2818 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2819 hex_string (start_addr
));
2821 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2822 if (t
->to_search_memory
!= NULL
)
2827 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2828 pattern
, pattern_len
, found_addrp
);
2832 /* If a special version of to_search_memory isn't available, use the
2834 found
= simple_search_memory (current_target
.beneath
,
2835 start_addr
, search_space_len
,
2836 pattern
, pattern_len
, found_addrp
);
2840 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2845 /* Look through the currently pushed targets. If none of them will
2846 be able to restart the currently running process, issue an error
2850 target_require_runnable (void)
2852 struct target_ops
*t
;
2854 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2856 /* If this target knows how to create a new program, then
2857 assume we will still be able to after killing the current
2858 one. Either killing and mourning will not pop T, or else
2859 find_default_run_target will find it again. */
2860 if (t
->to_create_inferior
!= NULL
)
2863 /* Do not worry about thread_stratum targets that can not
2864 create inferiors. Assume they will be pushed again if
2865 necessary, and continue to the process_stratum. */
2866 if (t
->to_stratum
== thread_stratum
2867 || t
->to_stratum
== arch_stratum
)
2870 error (_("The \"%s\" target does not support \"run\". "
2871 "Try \"help target\" or \"continue\"."),
2875 /* This function is only called if the target is running. In that
2876 case there should have been a process_stratum target and it
2877 should either know how to create inferiors, or not... */
2878 internal_error (__FILE__
, __LINE__
, _("No targets found"));
2881 /* Look through the list of possible targets for a target that can
2882 execute a run or attach command without any other data. This is
2883 used to locate the default process stratum.
2885 If DO_MESG is not NULL, the result is always valid (error() is
2886 called for errors); else, return NULL on error. */
2888 static struct target_ops
*
2889 find_default_run_target (char *do_mesg
)
2891 struct target_ops
**t
;
2892 struct target_ops
*runable
= NULL
;
2897 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2900 if ((*t
)->to_can_run
&& target_can_run (*t
))
2910 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2919 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2921 struct target_ops
*t
;
2923 t
= find_default_run_target ("attach");
2924 (t
->to_attach
) (t
, args
, from_tty
);
2929 find_default_create_inferior (struct target_ops
*ops
,
2930 char *exec_file
, char *allargs
, char **env
,
2933 struct target_ops
*t
;
2935 t
= find_default_run_target ("run");
2936 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
2941 find_default_can_async_p (void)
2943 struct target_ops
*t
;
2945 /* This may be called before the target is pushed on the stack;
2946 look for the default process stratum. If there's none, gdb isn't
2947 configured with a native debugger, and target remote isn't
2949 t
= find_default_run_target (NULL
);
2950 if (t
&& t
->to_can_async_p
)
2951 return (t
->to_can_async_p
) ();
2956 find_default_is_async_p (void)
2958 struct target_ops
*t
;
2960 /* This may be called before the target is pushed on the stack;
2961 look for the default process stratum. If there's none, gdb isn't
2962 configured with a native debugger, and target remote isn't
2964 t
= find_default_run_target (NULL
);
2965 if (t
&& t
->to_is_async_p
)
2966 return (t
->to_is_async_p
) ();
2971 find_default_supports_non_stop (void)
2973 struct target_ops
*t
;
2975 t
= find_default_run_target (NULL
);
2976 if (t
&& t
->to_supports_non_stop
)
2977 return (t
->to_supports_non_stop
) ();
2982 target_supports_non_stop (void)
2984 struct target_ops
*t
;
2986 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2987 if (t
->to_supports_non_stop
)
2988 return t
->to_supports_non_stop ();
2995 target_get_osdata (const char *type
)
2997 struct target_ops
*t
;
2999 /* If we're already connected to something that can get us OS
3000 related data, use it. Otherwise, try using the native
3002 if (current_target
.to_stratum
>= process_stratum
)
3003 t
= current_target
.beneath
;
3005 t
= find_default_run_target ("get OS data");
3010 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
3013 /* Determine the current address space of thread PTID. */
3015 struct address_space
*
3016 target_thread_address_space (ptid_t ptid
)
3018 struct address_space
*aspace
;
3019 struct inferior
*inf
;
3020 struct target_ops
*t
;
3022 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3024 if (t
->to_thread_address_space
!= NULL
)
3026 aspace
= t
->to_thread_address_space (t
, ptid
);
3027 gdb_assert (aspace
);
3030 fprintf_unfiltered (gdb_stdlog
,
3031 "target_thread_address_space (%s) = %d\n",
3032 target_pid_to_str (ptid
),
3033 address_space_num (aspace
));
3038 /* Fall-back to the "main" address space of the inferior. */
3039 inf
= find_inferior_pid (ptid_get_pid (ptid
));
3041 if (inf
== NULL
|| inf
->aspace
== NULL
)
3042 internal_error (__FILE__
, __LINE__
,
3043 _("Can't determine the current "
3044 "address space of thread %s\n"),
3045 target_pid_to_str (ptid
));
3051 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3053 return (len
<= gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
);
3057 default_watchpoint_addr_within_range (struct target_ops
*target
,
3059 CORE_ADDR start
, int length
)
3061 return addr
>= start
&& addr
< start
+ length
;
3064 static struct gdbarch
*
3065 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3067 return target_gdbarch
;
3083 return_minus_one (void)
3088 /* Find a single runnable target in the stack and return it. If for
3089 some reason there is more than one, return NULL. */
3092 find_run_target (void)
3094 struct target_ops
**t
;
3095 struct target_ops
*runable
= NULL
;
3100 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
3102 if ((*t
)->to_can_run
&& target_can_run (*t
))
3109 return (count
== 1 ? runable
: NULL
);
3113 * Find the next target down the stack from the specified target.
3117 find_target_beneath (struct target_ops
*t
)
3123 /* The inferior process has died. Long live the inferior! */
3126 generic_mourn_inferior (void)
3130 ptid
= inferior_ptid
;
3131 inferior_ptid
= null_ptid
;
3133 if (!ptid_equal (ptid
, null_ptid
))
3135 int pid
= ptid_get_pid (ptid
);
3136 exit_inferior (pid
);
3139 breakpoint_init_inferior (inf_exited
);
3140 registers_changed ();
3142 reopen_exec_file ();
3143 reinit_frame_cache ();
3145 if (deprecated_detach_hook
)
3146 deprecated_detach_hook ();
3149 /* Helper function for child_wait and the derivatives of child_wait.
3150 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
3151 translation of that in OURSTATUS. */
3153 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
3155 if (WIFEXITED (hoststatus
))
3157 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
3158 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
3160 else if (!WIFSTOPPED (hoststatus
))
3162 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
3163 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
3167 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
3168 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
3172 /* Convert a normal process ID to a string. Returns the string in a
3176 normal_pid_to_str (ptid_t ptid
)
3178 static char buf
[32];
3180 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3185 dummy_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3187 return normal_pid_to_str (ptid
);
3190 /* Error-catcher for target_find_memory_regions. */
3192 dummy_find_memory_regions (find_memory_region_ftype ignore1
, void *ignore2
)
3194 error (_("Command not implemented for this target."));
3198 /* Error-catcher for target_make_corefile_notes. */
3200 dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
3202 error (_("Command not implemented for this target."));
3206 /* Error-catcher for target_get_bookmark. */
3208 dummy_get_bookmark (char *ignore1
, int ignore2
)
3214 /* Error-catcher for target_goto_bookmark. */
3216 dummy_goto_bookmark (gdb_byte
*ignore
, int from_tty
)
3221 /* Set up the handful of non-empty slots needed by the dummy target
3225 init_dummy_target (void)
3227 dummy_target
.to_shortname
= "None";
3228 dummy_target
.to_longname
= "None";
3229 dummy_target
.to_doc
= "";
3230 dummy_target
.to_attach
= find_default_attach
;
3231 dummy_target
.to_detach
=
3232 (void (*)(struct target_ops
*, char *, int))target_ignore
;
3233 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3234 dummy_target
.to_can_async_p
= find_default_can_async_p
;
3235 dummy_target
.to_is_async_p
= find_default_is_async_p
;
3236 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3237 dummy_target
.to_pid_to_str
= dummy_pid_to_str
;
3238 dummy_target
.to_stratum
= dummy_stratum
;
3239 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
3240 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
3241 dummy_target
.to_get_bookmark
= dummy_get_bookmark
;
3242 dummy_target
.to_goto_bookmark
= dummy_goto_bookmark
;
3243 dummy_target
.to_xfer_partial
= default_xfer_partial
;
3244 dummy_target
.to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
3245 dummy_target
.to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
3246 dummy_target
.to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
3247 dummy_target
.to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
3248 dummy_target
.to_has_execution
3249 = (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
3250 dummy_target
.to_stopped_by_watchpoint
= return_zero
;
3251 dummy_target
.to_stopped_data_address
=
3252 (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
;
3253 dummy_target
.to_magic
= OPS_MAGIC
;
3257 debug_to_open (char *args
, int from_tty
)
3259 debug_target
.to_open (args
, from_tty
);
3261 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3265 target_close (struct target_ops
*targ
, int quitting
)
3267 if (targ
->to_xclose
!= NULL
)
3268 targ
->to_xclose (targ
, quitting
);
3269 else if (targ
->to_close
!= NULL
)
3270 targ
->to_close (quitting
);
3273 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
3277 target_attach (char *args
, int from_tty
)
3279 struct target_ops
*t
;
3281 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3283 if (t
->to_attach
!= NULL
)
3285 t
->to_attach (t
, args
, from_tty
);
3287 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3293 internal_error (__FILE__
, __LINE__
,
3294 _("could not find a target to attach"));
3298 target_thread_alive (ptid_t ptid
)
3300 struct target_ops
*t
;
3302 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3304 if (t
->to_thread_alive
!= NULL
)
3308 retval
= t
->to_thread_alive (t
, ptid
);
3310 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3311 PIDGET (ptid
), retval
);
3321 target_find_new_threads (void)
3323 struct target_ops
*t
;
3325 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3327 if (t
->to_find_new_threads
!= NULL
)
3329 t
->to_find_new_threads (t
);
3331 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3339 target_stop (ptid_t ptid
)
3343 warning (_("May not interrupt or stop the target, ignoring attempt"));
3347 (*current_target
.to_stop
) (ptid
);
3351 debug_to_post_attach (int pid
)
3353 debug_target
.to_post_attach (pid
);
3355 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3358 /* Return a pretty printed form of target_waitstatus.
3359 Space for the result is malloc'd, caller must free. */
3362 target_waitstatus_to_string (const struct target_waitstatus
*ws
)
3364 const char *kind_str
= "status->kind = ";
3368 case TARGET_WAITKIND_EXITED
:
3369 return xstrprintf ("%sexited, status = %d",
3370 kind_str
, ws
->value
.integer
);
3371 case TARGET_WAITKIND_STOPPED
:
3372 return xstrprintf ("%sstopped, signal = %s",
3373 kind_str
, target_signal_to_name (ws
->value
.sig
));
3374 case TARGET_WAITKIND_SIGNALLED
:
3375 return xstrprintf ("%ssignalled, signal = %s",
3376 kind_str
, target_signal_to_name (ws
->value
.sig
));
3377 case TARGET_WAITKIND_LOADED
:
3378 return xstrprintf ("%sloaded", kind_str
);
3379 case TARGET_WAITKIND_FORKED
:
3380 return xstrprintf ("%sforked", kind_str
);
3381 case TARGET_WAITKIND_VFORKED
:
3382 return xstrprintf ("%svforked", kind_str
);
3383 case TARGET_WAITKIND_EXECD
:
3384 return xstrprintf ("%sexecd", kind_str
);
3385 case TARGET_WAITKIND_SYSCALL_ENTRY
:
3386 return xstrprintf ("%sentered syscall", kind_str
);
3387 case TARGET_WAITKIND_SYSCALL_RETURN
:
3388 return xstrprintf ("%sexited syscall", kind_str
);
3389 case TARGET_WAITKIND_SPURIOUS
:
3390 return xstrprintf ("%sspurious", kind_str
);
3391 case TARGET_WAITKIND_IGNORE
:
3392 return xstrprintf ("%signore", kind_str
);
3393 case TARGET_WAITKIND_NO_HISTORY
:
3394 return xstrprintf ("%sno-history", kind_str
);
3396 return xstrprintf ("%sunknown???", kind_str
);
3401 debug_print_register (const char * func
,
3402 struct regcache
*regcache
, int regno
)
3404 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3406 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3407 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3408 && gdbarch_register_name (gdbarch
, regno
) != NULL
3409 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3410 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3411 gdbarch_register_name (gdbarch
, regno
));
3413 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3414 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3416 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3417 int i
, size
= register_size (gdbarch
, regno
);
3418 unsigned char buf
[MAX_REGISTER_SIZE
];
3420 regcache_raw_collect (regcache
, regno
, buf
);
3421 fprintf_unfiltered (gdb_stdlog
, " = ");
3422 for (i
= 0; i
< size
; i
++)
3424 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3426 if (size
<= sizeof (LONGEST
))
3428 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
3430 fprintf_unfiltered (gdb_stdlog
, " %s %s",
3431 core_addr_to_string_nz (val
), plongest (val
));
3434 fprintf_unfiltered (gdb_stdlog
, "\n");
3438 target_fetch_registers (struct regcache
*regcache
, int regno
)
3440 struct target_ops
*t
;
3442 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3444 if (t
->to_fetch_registers
!= NULL
)
3446 t
->to_fetch_registers (t
, regcache
, regno
);
3448 debug_print_register ("target_fetch_registers", regcache
, regno
);
3455 target_store_registers (struct regcache
*regcache
, int regno
)
3457 struct target_ops
*t
;
3459 if (!may_write_registers
)
3460 error (_("Writing to registers is not allowed (regno %d)"), regno
);
3462 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3464 if (t
->to_store_registers
!= NULL
)
3466 t
->to_store_registers (t
, regcache
, regno
);
3469 debug_print_register ("target_store_registers", regcache
, regno
);
3479 target_core_of_thread (ptid_t ptid
)
3481 struct target_ops
*t
;
3483 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3485 if (t
->to_core_of_thread
!= NULL
)
3487 int retval
= t
->to_core_of_thread (t
, ptid
);
3490 fprintf_unfiltered (gdb_stdlog
,
3491 "target_core_of_thread (%d) = %d\n",
3492 PIDGET (ptid
), retval
);
3501 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3503 struct target_ops
*t
;
3505 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3507 if (t
->to_verify_memory
!= NULL
)
3509 int retval
= t
->to_verify_memory (t
, data
, memaddr
, size
);
3512 fprintf_unfiltered (gdb_stdlog
,
3513 "target_verify_memory (%s, %s) = %d\n",
3514 paddress (target_gdbarch
, memaddr
),
3524 /* The documentation for this function is in its prototype declaration in
3528 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3530 struct target_ops
*t
;
3532 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3533 if (t
->to_insert_mask_watchpoint
!= NULL
)
3537 ret
= t
->to_insert_mask_watchpoint (t
, addr
, mask
, rw
);
3540 fprintf_unfiltered (gdb_stdlog
, "\
3541 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
3542 core_addr_to_string (addr
),
3543 core_addr_to_string (mask
), rw
, ret
);
3551 /* The documentation for this function is in its prototype declaration in
3555 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3557 struct target_ops
*t
;
3559 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3560 if (t
->to_remove_mask_watchpoint
!= NULL
)
3564 ret
= t
->to_remove_mask_watchpoint (t
, addr
, mask
, rw
);
3567 fprintf_unfiltered (gdb_stdlog
, "\
3568 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
3569 core_addr_to_string (addr
),
3570 core_addr_to_string (mask
), rw
, ret
);
3578 /* The documentation for this function is in its prototype declaration
3582 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
3584 struct target_ops
*t
;
3586 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3587 if (t
->to_masked_watch_num_registers
!= NULL
)
3588 return t
->to_masked_watch_num_registers (t
, addr
, mask
);
3593 /* The documentation for this function is in its prototype declaration
3597 target_ranged_break_num_registers (void)
3599 struct target_ops
*t
;
3601 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3602 if (t
->to_ranged_break_num_registers
!= NULL
)
3603 return t
->to_ranged_break_num_registers (t
);
3609 debug_to_prepare_to_store (struct regcache
*regcache
)
3611 debug_target
.to_prepare_to_store (regcache
);
3613 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
3617 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
3618 int write
, struct mem_attrib
*attrib
,
3619 struct target_ops
*target
)
3623 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
3626 fprintf_unfiltered (gdb_stdlog
,
3627 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
3628 paddress (target_gdbarch
, memaddr
), len
,
3629 write
? "write" : "read", retval
);
3635 fputs_unfiltered (", bytes =", gdb_stdlog
);
3636 for (i
= 0; i
< retval
; i
++)
3638 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
3640 if (targetdebug
< 2 && i
> 0)
3642 fprintf_unfiltered (gdb_stdlog
, " ...");
3645 fprintf_unfiltered (gdb_stdlog
, "\n");
3648 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
3652 fputc_unfiltered ('\n', gdb_stdlog
);
3658 debug_to_files_info (struct target_ops
*target
)
3660 debug_target
.to_files_info (target
);
3662 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
3666 debug_to_insert_breakpoint (struct gdbarch
*gdbarch
,
3667 struct bp_target_info
*bp_tgt
)
3671 retval
= debug_target
.to_insert_breakpoint (gdbarch
, bp_tgt
);
3673 fprintf_unfiltered (gdb_stdlog
,
3674 "target_insert_breakpoint (%s, xxx) = %ld\n",
3675 core_addr_to_string (bp_tgt
->placed_address
),
3676 (unsigned long) retval
);
3681 debug_to_remove_breakpoint (struct gdbarch
*gdbarch
,
3682 struct bp_target_info
*bp_tgt
)
3686 retval
= debug_target
.to_remove_breakpoint (gdbarch
, bp_tgt
);
3688 fprintf_unfiltered (gdb_stdlog
,
3689 "target_remove_breakpoint (%s, xxx) = %ld\n",
3690 core_addr_to_string (bp_tgt
->placed_address
),
3691 (unsigned long) retval
);
3696 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
3700 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
3702 fprintf_unfiltered (gdb_stdlog
,
3703 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
3704 (unsigned long) type
,
3705 (unsigned long) cnt
,
3706 (unsigned long) from_tty
,
3707 (unsigned long) retval
);
3712 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3716 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
3718 fprintf_unfiltered (gdb_stdlog
,
3719 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
3720 core_addr_to_string (addr
), (unsigned long) len
,
3721 core_addr_to_string (retval
));
3726 debug_to_can_accel_watchpoint_condition (CORE_ADDR addr
, int len
, int rw
,
3727 struct expression
*cond
)
3731 retval
= debug_target
.to_can_accel_watchpoint_condition (addr
, len
,
3734 fprintf_unfiltered (gdb_stdlog
,
3735 "target_can_accel_watchpoint_condition "
3736 "(%s, %d, %d, %s) = %ld\n",
3737 core_addr_to_string (addr
), len
, rw
,
3738 host_address_to_string (cond
), (unsigned long) retval
);
3743 debug_to_stopped_by_watchpoint (void)
3747 retval
= debug_target
.to_stopped_by_watchpoint ();
3749 fprintf_unfiltered (gdb_stdlog
,
3750 "target_stopped_by_watchpoint () = %ld\n",
3751 (unsigned long) retval
);
3756 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
3760 retval
= debug_target
.to_stopped_data_address (target
, addr
);
3762 fprintf_unfiltered (gdb_stdlog
,
3763 "target_stopped_data_address ([%s]) = %ld\n",
3764 core_addr_to_string (*addr
),
3765 (unsigned long)retval
);
3770 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
3772 CORE_ADDR start
, int length
)
3776 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
3779 fprintf_filtered (gdb_stdlog
,
3780 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
3781 core_addr_to_string (addr
), core_addr_to_string (start
),
3787 debug_to_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
3788 struct bp_target_info
*bp_tgt
)
3792 retval
= debug_target
.to_insert_hw_breakpoint (gdbarch
, bp_tgt
);
3794 fprintf_unfiltered (gdb_stdlog
,
3795 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
3796 core_addr_to_string (bp_tgt
->placed_address
),
3797 (unsigned long) retval
);
3802 debug_to_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
3803 struct bp_target_info
*bp_tgt
)
3807 retval
= debug_target
.to_remove_hw_breakpoint (gdbarch
, bp_tgt
);
3809 fprintf_unfiltered (gdb_stdlog
,
3810 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
3811 core_addr_to_string (bp_tgt
->placed_address
),
3812 (unsigned long) retval
);
3817 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
3818 struct expression
*cond
)
3822 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
, cond
);
3824 fprintf_unfiltered (gdb_stdlog
,
3825 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
3826 core_addr_to_string (addr
), len
, type
,
3827 host_address_to_string (cond
), (unsigned long) retval
);
3832 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
3833 struct expression
*cond
)
3837 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
, cond
);
3839 fprintf_unfiltered (gdb_stdlog
,
3840 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
3841 core_addr_to_string (addr
), len
, type
,
3842 host_address_to_string (cond
), (unsigned long) retval
);
3847 debug_to_terminal_init (void)
3849 debug_target
.to_terminal_init ();
3851 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
3855 debug_to_terminal_inferior (void)
3857 debug_target
.to_terminal_inferior ();
3859 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
3863 debug_to_terminal_ours_for_output (void)
3865 debug_target
.to_terminal_ours_for_output ();
3867 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
3871 debug_to_terminal_ours (void)
3873 debug_target
.to_terminal_ours ();
3875 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
3879 debug_to_terminal_save_ours (void)
3881 debug_target
.to_terminal_save_ours ();
3883 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
3887 debug_to_terminal_info (char *arg
, int from_tty
)
3889 debug_target
.to_terminal_info (arg
, from_tty
);
3891 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
3896 debug_to_load (char *args
, int from_tty
)
3898 debug_target
.to_load (args
, from_tty
);
3900 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
3904 debug_to_post_startup_inferior (ptid_t ptid
)
3906 debug_target
.to_post_startup_inferior (ptid
);
3908 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
3913 debug_to_insert_fork_catchpoint (int pid
)
3917 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
3919 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
3926 debug_to_remove_fork_catchpoint (int pid
)
3930 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
3932 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
3939 debug_to_insert_vfork_catchpoint (int pid
)
3943 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
3945 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
3952 debug_to_remove_vfork_catchpoint (int pid
)
3956 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
3958 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
3965 debug_to_insert_exec_catchpoint (int pid
)
3969 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
3971 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
3978 debug_to_remove_exec_catchpoint (int pid
)
3982 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
3984 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
3991 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
3995 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
3997 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
3998 pid
, wait_status
, *exit_status
, has_exited
);
4004 debug_to_can_run (void)
4008 retval
= debug_target
.to_can_run ();
4010 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4015 static struct gdbarch
*
4016 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4018 struct gdbarch
*retval
;
4020 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4022 fprintf_unfiltered (gdb_stdlog
,
4023 "target_thread_architecture (%s) = %s [%s]\n",
4024 target_pid_to_str (ptid
),
4025 host_address_to_string (retval
),
4026 gdbarch_bfd_arch_info (retval
)->printable_name
);
4031 debug_to_stop (ptid_t ptid
)
4033 debug_target
.to_stop (ptid
);
4035 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4036 target_pid_to_str (ptid
));
4040 debug_to_rcmd (char *command
,
4041 struct ui_file
*outbuf
)
4043 debug_target
.to_rcmd (command
, outbuf
);
4044 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4048 debug_to_pid_to_exec_file (int pid
)
4052 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
4054 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
4061 setup_target_debug (void)
4063 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
4065 current_target
.to_open
= debug_to_open
;
4066 current_target
.to_post_attach
= debug_to_post_attach
;
4067 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
4068 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
4069 current_target
.to_files_info
= debug_to_files_info
;
4070 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
4071 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
4072 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
4073 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
4074 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
4075 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
4076 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
4077 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
4078 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
4079 current_target
.to_watchpoint_addr_within_range
4080 = debug_to_watchpoint_addr_within_range
;
4081 current_target
.to_region_ok_for_hw_watchpoint
4082 = debug_to_region_ok_for_hw_watchpoint
;
4083 current_target
.to_can_accel_watchpoint_condition
4084 = debug_to_can_accel_watchpoint_condition
;
4085 current_target
.to_terminal_init
= debug_to_terminal_init
;
4086 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
4087 current_target
.to_terminal_ours_for_output
4088 = debug_to_terminal_ours_for_output
;
4089 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
4090 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
4091 current_target
.to_terminal_info
= debug_to_terminal_info
;
4092 current_target
.to_load
= debug_to_load
;
4093 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
4094 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
4095 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
4096 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
4097 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
4098 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
4099 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
4100 current_target
.to_has_exited
= debug_to_has_exited
;
4101 current_target
.to_can_run
= debug_to_can_run
;
4102 current_target
.to_stop
= debug_to_stop
;
4103 current_target
.to_rcmd
= debug_to_rcmd
;
4104 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
4105 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
4109 static char targ_desc
[] =
4110 "Names of targets and files being debugged.\nShows the entire \
4111 stack of targets currently in use (including the exec-file,\n\
4112 core-file, and process, if any), as well as the symbol file name.";
4115 do_monitor_command (char *cmd
,
4118 if ((current_target
.to_rcmd
4119 == (void (*) (char *, struct ui_file
*)) tcomplain
)
4120 || (current_target
.to_rcmd
== debug_to_rcmd
4121 && (debug_target
.to_rcmd
4122 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
4123 error (_("\"monitor\" command not supported by this target."));
4124 target_rcmd (cmd
, gdb_stdtarg
);
4127 /* Print the name of each layers of our target stack. */
4130 maintenance_print_target_stack (char *cmd
, int from_tty
)
4132 struct target_ops
*t
;
4134 printf_filtered (_("The current target stack is:\n"));
4136 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
4138 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
4142 /* Controls if async mode is permitted. */
4143 int target_async_permitted
= 0;
4145 /* The set command writes to this variable. If the inferior is
4146 executing, linux_nat_async_permitted is *not* updated. */
4147 static int target_async_permitted_1
= 0;
4150 set_maintenance_target_async_permitted (char *args
, int from_tty
,
4151 struct cmd_list_element
*c
)
4153 if (have_live_inferiors ())
4155 target_async_permitted_1
= target_async_permitted
;
4156 error (_("Cannot change this setting while the inferior is running."));
4159 target_async_permitted
= target_async_permitted_1
;
4163 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
4164 struct cmd_list_element
*c
,
4167 fprintf_filtered (file
,
4168 _("Controlling the inferior in "
4169 "asynchronous mode is %s.\n"), value
);
4172 /* Temporary copies of permission settings. */
4174 static int may_write_registers_1
= 1;
4175 static int may_write_memory_1
= 1;
4176 static int may_insert_breakpoints_1
= 1;
4177 static int may_insert_tracepoints_1
= 1;
4178 static int may_insert_fast_tracepoints_1
= 1;
4179 static int may_stop_1
= 1;
4181 /* Make the user-set values match the real values again. */
4184 update_target_permissions (void)
4186 may_write_registers_1
= may_write_registers
;
4187 may_write_memory_1
= may_write_memory
;
4188 may_insert_breakpoints_1
= may_insert_breakpoints
;
4189 may_insert_tracepoints_1
= may_insert_tracepoints
;
4190 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
4191 may_stop_1
= may_stop
;
4194 /* The one function handles (most of) the permission flags in the same
4198 set_target_permissions (char *args
, int from_tty
,
4199 struct cmd_list_element
*c
)
4201 if (target_has_execution
)
4203 update_target_permissions ();
4204 error (_("Cannot change this setting while the inferior is running."));
4207 /* Make the real values match the user-changed values. */
4208 may_write_registers
= may_write_registers_1
;
4209 may_insert_breakpoints
= may_insert_breakpoints_1
;
4210 may_insert_tracepoints
= may_insert_tracepoints_1
;
4211 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
4212 may_stop
= may_stop_1
;
4213 update_observer_mode ();
4216 /* Set memory write permission independently of observer mode. */
4219 set_write_memory_permission (char *args
, int from_tty
,
4220 struct cmd_list_element
*c
)
4222 /* Make the real values match the user-changed values. */
4223 may_write_memory
= may_write_memory_1
;
4224 update_observer_mode ();
4229 initialize_targets (void)
4231 init_dummy_target ();
4232 push_target (&dummy_target
);
4234 add_info ("target", target_info
, targ_desc
);
4235 add_info ("files", target_info
, targ_desc
);
4237 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
4238 Set target debugging."), _("\
4239 Show target debugging."), _("\
4240 When non-zero, target debugging is enabled. Higher numbers are more\n\
4241 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
4245 &setdebuglist
, &showdebuglist
);
4247 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
4248 &trust_readonly
, _("\
4249 Set mode for reading from readonly sections."), _("\
4250 Show mode for reading from readonly sections."), _("\
4251 When this mode is on, memory reads from readonly sections (such as .text)\n\
4252 will be read from the object file instead of from the target. This will\n\
4253 result in significant performance improvement for remote targets."),
4255 show_trust_readonly
,
4256 &setlist
, &showlist
);
4258 add_com ("monitor", class_obscure
, do_monitor_command
,
4259 _("Send a command to the remote monitor (remote targets only)."));
4261 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
4262 _("Print the name of each layer of the internal target stack."),
4263 &maintenanceprintlist
);
4265 add_setshow_boolean_cmd ("target-async", no_class
,
4266 &target_async_permitted_1
, _("\
4267 Set whether gdb controls the inferior in asynchronous mode."), _("\
4268 Show whether gdb controls the inferior in asynchronous mode."), _("\
4269 Tells gdb whether to control the inferior in asynchronous mode."),
4270 set_maintenance_target_async_permitted
,
4271 show_maintenance_target_async_permitted
,
4275 add_setshow_boolean_cmd ("stack-cache", class_support
,
4276 &stack_cache_enabled_p_1
, _("\
4277 Set cache use for stack access."), _("\
4278 Show cache use for stack access."), _("\
4279 When on, use the data cache for all stack access, regardless of any\n\
4280 configured memory regions. This improves remote performance significantly.\n\
4281 By default, caching for stack access is on."),
4282 set_stack_cache_enabled_p
,
4283 show_stack_cache_enabled_p
,
4284 &setlist
, &showlist
);
4286 add_setshow_boolean_cmd ("may-write-registers", class_support
,
4287 &may_write_registers_1
, _("\
4288 Set permission to write into registers."), _("\
4289 Show permission to write into registers."), _("\
4290 When this permission is on, GDB may write into the target's registers.\n\
4291 Otherwise, any sort of write attempt will result in an error."),
4292 set_target_permissions
, NULL
,
4293 &setlist
, &showlist
);
4295 add_setshow_boolean_cmd ("may-write-memory", class_support
,
4296 &may_write_memory_1
, _("\
4297 Set permission to write into target memory."), _("\
4298 Show permission to write into target memory."), _("\
4299 When this permission is on, GDB may write into the target's memory.\n\
4300 Otherwise, any sort of write attempt will result in an error."),
4301 set_write_memory_permission
, NULL
,
4302 &setlist
, &showlist
);
4304 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
4305 &may_insert_breakpoints_1
, _("\
4306 Set permission to insert breakpoints in the target."), _("\
4307 Show permission to insert breakpoints in the target."), _("\
4308 When this permission is on, GDB may insert breakpoints in the program.\n\
4309 Otherwise, any sort of insertion attempt will result in an error."),
4310 set_target_permissions
, NULL
,
4311 &setlist
, &showlist
);
4313 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
4314 &may_insert_tracepoints_1
, _("\
4315 Set permission to insert tracepoints in the target."), _("\
4316 Show permission to insert tracepoints in the target."), _("\
4317 When this permission is on, GDB may insert tracepoints in the program.\n\
4318 Otherwise, any sort of insertion attempt will result in an error."),
4319 set_target_permissions
, NULL
,
4320 &setlist
, &showlist
);
4322 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
4323 &may_insert_fast_tracepoints_1
, _("\
4324 Set permission to insert fast tracepoints in the target."), _("\
4325 Show permission to insert fast tracepoints in the target."), _("\
4326 When this permission is on, GDB may insert fast tracepoints.\n\
4327 Otherwise, any sort of insertion attempt will result in an error."),
4328 set_target_permissions
, NULL
,
4329 &setlist
, &showlist
);
4331 add_setshow_boolean_cmd ("may-interrupt", class_support
,
4333 Set permission to interrupt or signal the target."), _("\
4334 Show permission to interrupt or signal the target."), _("\
4335 When this permission is on, GDB may interrupt/stop the target's execution.\n\
4336 Otherwise, any attempt to interrupt or stop will be ignored."),
4337 set_target_permissions
, NULL
,
4338 &setlist
, &showlist
);
4341 target_dcache
= dcache_init ();