1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "target-dcache.h"
36 #include "target-descriptions.h"
37 #include "gdbthread.h"
40 #include "inline-frame.h"
41 #include "tracepoint.h"
42 #include "gdb/fileio.h"
45 #include "target-debug.h"
47 static void target_info (char *, int);
49 static void generic_tls_error (void) ATTRIBUTE_NORETURN
;
51 static void default_terminal_info (struct target_ops
*, const char *, int);
53 static int default_watchpoint_addr_within_range (struct target_ops
*,
54 CORE_ADDR
, CORE_ADDR
, int);
56 static int default_region_ok_for_hw_watchpoint (struct target_ops
*,
59 static void default_rcmd (struct target_ops
*, const char *, struct ui_file
*);
61 static ptid_t
default_get_ada_task_ptid (struct target_ops
*self
,
64 static int default_follow_fork (struct target_ops
*self
, int follow_child
,
67 static void default_mourn_inferior (struct target_ops
*self
);
69 static int default_search_memory (struct target_ops
*ops
,
71 ULONGEST search_space_len
,
72 const gdb_byte
*pattern
,
74 CORE_ADDR
*found_addrp
);
76 static int default_verify_memory (struct target_ops
*self
,
78 CORE_ADDR memaddr
, ULONGEST size
);
80 static struct address_space
*default_thread_address_space
81 (struct target_ops
*self
, ptid_t ptid
);
83 static void tcomplain (void) ATTRIBUTE_NORETURN
;
85 static int return_zero (struct target_ops
*);
87 static int return_zero_has_execution (struct target_ops
*, ptid_t
);
89 static void target_command (char *, int);
91 static struct target_ops
*find_default_run_target (char *);
93 static struct gdbarch
*default_thread_architecture (struct target_ops
*ops
,
96 static int dummy_find_memory_regions (struct target_ops
*self
,
97 find_memory_region_ftype ignore1
,
100 static char *dummy_make_corefile_notes (struct target_ops
*self
,
101 bfd
*ignore1
, int *ignore2
);
103 static char *default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
);
105 static enum exec_direction_kind default_execution_direction
106 (struct target_ops
*self
);
108 static CORE_ADDR
default_target_decr_pc_after_break (struct target_ops
*ops
,
109 struct gdbarch
*gdbarch
);
111 static struct target_ops debug_target
;
113 #include "target-delegates.c"
115 static void init_dummy_target (void);
117 static void update_current_target (void);
119 /* Vector of existing target structures. */
120 typedef struct target_ops
*target_ops_p
;
121 DEF_VEC_P (target_ops_p
);
122 static VEC (target_ops_p
) *target_structs
;
124 /* The initial current target, so that there is always a semi-valid
127 static struct target_ops dummy_target
;
129 /* Top of target stack. */
131 static struct target_ops
*target_stack
;
133 /* The target structure we are currently using to talk to a process
134 or file or whatever "inferior" we have. */
136 struct target_ops current_target
;
138 /* Command list for target. */
140 static struct cmd_list_element
*targetlist
= NULL
;
142 /* Nonzero if we should trust readonly sections from the
143 executable when reading memory. */
145 static int trust_readonly
= 0;
147 /* Nonzero if we should show true memory content including
148 memory breakpoint inserted by gdb. */
150 static int show_memory_breakpoints
= 0;
152 /* These globals control whether GDB attempts to perform these
153 operations; they are useful for targets that need to prevent
154 inadvertant disruption, such as in non-stop mode. */
156 int may_write_registers
= 1;
158 int may_write_memory
= 1;
160 int may_insert_breakpoints
= 1;
162 int may_insert_tracepoints
= 1;
164 int may_insert_fast_tracepoints
= 1;
168 /* Non-zero if we want to see trace of target level stuff. */
170 static unsigned int targetdebug
= 0;
173 set_targetdebug (char *args
, int from_tty
, struct cmd_list_element
*c
)
175 update_current_target ();
179 show_targetdebug (struct ui_file
*file
, int from_tty
,
180 struct cmd_list_element
*c
, const char *value
)
182 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
185 static void setup_target_debug (void);
187 /* The user just typed 'target' without the name of a target. */
190 target_command (char *arg
, int from_tty
)
192 fputs_filtered ("Argument required (target name). Try `help target'\n",
196 /* Default target_has_* methods for process_stratum targets. */
199 default_child_has_all_memory (struct target_ops
*ops
)
201 /* If no inferior selected, then we can't read memory here. */
202 if (ptid_equal (inferior_ptid
, null_ptid
))
209 default_child_has_memory (struct target_ops
*ops
)
211 /* If no inferior selected, then we can't read memory here. */
212 if (ptid_equal (inferior_ptid
, null_ptid
))
219 default_child_has_stack (struct target_ops
*ops
)
221 /* If no inferior selected, there's no stack. */
222 if (ptid_equal (inferior_ptid
, null_ptid
))
229 default_child_has_registers (struct target_ops
*ops
)
231 /* Can't read registers from no inferior. */
232 if (ptid_equal (inferior_ptid
, null_ptid
))
239 default_child_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
241 /* If there's no thread selected, then we can't make it run through
243 if (ptid_equal (the_ptid
, null_ptid
))
251 target_has_all_memory_1 (void)
253 struct target_ops
*t
;
255 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
256 if (t
->to_has_all_memory (t
))
263 target_has_memory_1 (void)
265 struct target_ops
*t
;
267 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
268 if (t
->to_has_memory (t
))
275 target_has_stack_1 (void)
277 struct target_ops
*t
;
279 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
280 if (t
->to_has_stack (t
))
287 target_has_registers_1 (void)
289 struct target_ops
*t
;
291 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
292 if (t
->to_has_registers (t
))
299 target_has_execution_1 (ptid_t the_ptid
)
301 struct target_ops
*t
;
303 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
304 if (t
->to_has_execution (t
, the_ptid
))
311 target_has_execution_current (void)
313 return target_has_execution_1 (inferior_ptid
);
316 /* Complete initialization of T. This ensures that various fields in
317 T are set, if needed by the target implementation. */
320 complete_target_initialization (struct target_ops
*t
)
322 /* Provide default values for all "must have" methods. */
324 if (t
->to_has_all_memory
== NULL
)
325 t
->to_has_all_memory
= return_zero
;
327 if (t
->to_has_memory
== NULL
)
328 t
->to_has_memory
= return_zero
;
330 if (t
->to_has_stack
== NULL
)
331 t
->to_has_stack
= return_zero
;
333 if (t
->to_has_registers
== NULL
)
334 t
->to_has_registers
= return_zero
;
336 if (t
->to_has_execution
== NULL
)
337 t
->to_has_execution
= return_zero_has_execution
;
339 /* These methods can be called on an unpushed target and so require
340 a default implementation if the target might plausibly be the
341 default run target. */
342 gdb_assert (t
->to_can_run
== NULL
|| (t
->to_can_async_p
!= NULL
343 && t
->to_supports_non_stop
!= NULL
));
345 install_delegators (t
);
348 /* This is used to implement the various target commands. */
351 open_target (char *args
, int from_tty
, struct cmd_list_element
*command
)
353 struct target_ops
*ops
= get_cmd_context (command
);
356 fprintf_unfiltered (gdb_stdlog
, "-> %s->to_open (...)\n",
359 ops
->to_open (args
, from_tty
);
362 fprintf_unfiltered (gdb_stdlog
, "<- %s->to_open (%s, %d)\n",
363 ops
->to_shortname
, args
, from_tty
);
366 /* Add possible target architecture T to the list and add a new
367 command 'target T->to_shortname'. Set COMPLETER as the command's
368 completer if not NULL. */
371 add_target_with_completer (struct target_ops
*t
,
372 completer_ftype
*completer
)
374 struct cmd_list_element
*c
;
376 complete_target_initialization (t
);
378 VEC_safe_push (target_ops_p
, target_structs
, t
);
380 if (targetlist
== NULL
)
381 add_prefix_cmd ("target", class_run
, target_command
, _("\
382 Connect to a target machine or process.\n\
383 The first argument is the type or protocol of the target machine.\n\
384 Remaining arguments are interpreted by the target protocol. For more\n\
385 information on the arguments for a particular protocol, type\n\
386 `help target ' followed by the protocol name."),
387 &targetlist
, "target ", 0, &cmdlist
);
388 c
= add_cmd (t
->to_shortname
, no_class
, NULL
, t
->to_doc
, &targetlist
);
389 set_cmd_sfunc (c
, open_target
);
390 set_cmd_context (c
, t
);
391 if (completer
!= NULL
)
392 set_cmd_completer (c
, completer
);
395 /* Add a possible target architecture to the list. */
398 add_target (struct target_ops
*t
)
400 add_target_with_completer (t
, NULL
);
406 add_deprecated_target_alias (struct target_ops
*t
, char *alias
)
408 struct cmd_list_element
*c
;
411 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
413 c
= add_cmd (alias
, no_class
, NULL
, t
->to_doc
, &targetlist
);
414 set_cmd_sfunc (c
, open_target
);
415 set_cmd_context (c
, t
);
416 alt
= xstrprintf ("target %s", t
->to_shortname
);
417 deprecate_cmd (c
, alt
);
425 current_target
.to_kill (¤t_target
);
429 target_load (const char *arg
, int from_tty
)
431 target_dcache_invalidate ();
432 (*current_target
.to_load
) (¤t_target
, arg
, from_tty
);
435 /* Possible terminal states. */
439 /* The inferior's terminal settings are in effect. */
440 terminal_is_inferior
= 0,
442 /* Some of our terminal settings are in effect, enough to get
444 terminal_is_ours_for_output
= 1,
446 /* Our terminal settings are in effect, for output and input. */
450 static enum terminal_state terminal_state
;
455 target_terminal_init (void)
457 (*current_target
.to_terminal_init
) (¤t_target
);
459 terminal_state
= terminal_is_ours
;
465 target_terminal_inferior (void)
467 /* A background resume (``run&'') should leave GDB in control of the
468 terminal. Use target_can_async_p, not target_is_async_p, since at
469 this point the target is not async yet. However, if sync_execution
470 is not set, we know it will become async prior to resume. */
471 if (target_can_async_p () && !sync_execution
)
474 if (terminal_state
== terminal_is_inferior
)
477 /* If GDB is resuming the inferior in the foreground, install
478 inferior's terminal modes. */
479 (*current_target
.to_terminal_inferior
) (¤t_target
);
480 terminal_state
= terminal_is_inferior
;
486 target_terminal_ours (void)
488 if (terminal_state
== terminal_is_ours
)
491 (*current_target
.to_terminal_ours
) (¤t_target
);
492 terminal_state
= terminal_is_ours
;
498 target_terminal_ours_for_output (void)
500 if (terminal_state
!= terminal_is_inferior
)
502 (*current_target
.to_terminal_ours_for_output
) (¤t_target
);
503 terminal_state
= terminal_is_ours_for_output
;
509 target_supports_terminal_ours (void)
511 struct target_ops
*t
;
513 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
515 if (t
->to_terminal_ours
!= delegate_terminal_ours
516 && t
->to_terminal_ours
!= tdefault_terminal_ours
)
526 error (_("You can't do that when your target is `%s'"),
527 current_target
.to_shortname
);
533 error (_("You can't do that without a process to debug."));
537 default_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
539 printf_unfiltered (_("No saved terminal information.\n"));
542 /* A default implementation for the to_get_ada_task_ptid target method.
544 This function builds the PTID by using both LWP and TID as part of
545 the PTID lwp and tid elements. The pid used is the pid of the
549 default_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long tid
)
551 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
554 static enum exec_direction_kind
555 default_execution_direction (struct target_ops
*self
)
557 if (!target_can_execute_reverse
)
559 else if (!target_can_async_p ())
562 gdb_assert_not_reached ("\
563 to_execution_direction must be implemented for reverse async");
566 /* Go through the target stack from top to bottom, copying over zero
567 entries in current_target, then filling in still empty entries. In
568 effect, we are doing class inheritance through the pushed target
571 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
572 is currently implemented, is that it discards any knowledge of
573 which target an inherited method originally belonged to.
574 Consequently, new new target methods should instead explicitly and
575 locally search the target stack for the target that can handle the
579 update_current_target (void)
581 struct target_ops
*t
;
583 /* First, reset current's contents. */
584 memset (¤t_target
, 0, sizeof (current_target
));
586 /* Install the delegators. */
587 install_delegators (¤t_target
);
589 current_target
.to_stratum
= target_stack
->to_stratum
;
591 #define INHERIT(FIELD, TARGET) \
592 if (!current_target.FIELD) \
593 current_target.FIELD = (TARGET)->FIELD
595 /* Do not add any new INHERITs here. Instead, use the delegation
596 mechanism provided by make-target-delegates. */
597 for (t
= target_stack
; t
; t
= t
->beneath
)
599 INHERIT (to_shortname
, t
);
600 INHERIT (to_longname
, t
);
601 INHERIT (to_attach_no_wait
, t
);
602 INHERIT (to_have_steppable_watchpoint
, t
);
603 INHERIT (to_have_continuable_watchpoint
, t
);
604 INHERIT (to_has_thread_control
, t
);
608 /* Finally, position the target-stack beneath the squashed
609 "current_target". That way code looking for a non-inherited
610 target method can quickly and simply find it. */
611 current_target
.beneath
= target_stack
;
614 setup_target_debug ();
617 /* Push a new target type into the stack of the existing target accessors,
618 possibly superseding some of the existing accessors.
620 Rather than allow an empty stack, we always have the dummy target at
621 the bottom stratum, so we can call the function vectors without
625 push_target (struct target_ops
*t
)
627 struct target_ops
**cur
;
629 /* Check magic number. If wrong, it probably means someone changed
630 the struct definition, but not all the places that initialize one. */
631 if (t
->to_magic
!= OPS_MAGIC
)
633 fprintf_unfiltered (gdb_stderr
,
634 "Magic number of %s target struct wrong\n",
636 internal_error (__FILE__
, __LINE__
,
637 _("failed internal consistency check"));
640 /* Find the proper stratum to install this target in. */
641 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
643 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
647 /* If there's already targets at this stratum, remove them. */
648 /* FIXME: cagney/2003-10-15: I think this should be popping all
649 targets to CUR, and not just those at this stratum level. */
650 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
652 /* There's already something at this stratum level. Close it,
653 and un-hook it from the stack. */
654 struct target_ops
*tmp
= (*cur
);
656 (*cur
) = (*cur
)->beneath
;
661 /* We have removed all targets in our stratum, now add the new one. */
665 update_current_target ();
668 /* Remove a target_ops vector from the stack, wherever it may be.
669 Return how many times it was removed (0 or 1). */
672 unpush_target (struct target_ops
*t
)
674 struct target_ops
**cur
;
675 struct target_ops
*tmp
;
677 if (t
->to_stratum
== dummy_stratum
)
678 internal_error (__FILE__
, __LINE__
,
679 _("Attempt to unpush the dummy target"));
681 /* Look for the specified target. Note that we assume that a target
682 can only occur once in the target stack. */
684 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
690 /* If we don't find target_ops, quit. Only open targets should be
695 /* Unchain the target. */
697 (*cur
) = (*cur
)->beneath
;
700 update_current_target ();
702 /* Finally close the target. Note we do this after unchaining, so
703 any target method calls from within the target_close
704 implementation don't end up in T anymore. */
711 pop_all_targets_above (enum strata above_stratum
)
713 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
715 if (!unpush_target (target_stack
))
717 fprintf_unfiltered (gdb_stderr
,
718 "pop_all_targets couldn't find target %s\n",
719 target_stack
->to_shortname
);
720 internal_error (__FILE__
, __LINE__
,
721 _("failed internal consistency check"));
728 pop_all_targets (void)
730 pop_all_targets_above (dummy_stratum
);
733 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
736 target_is_pushed (struct target_ops
*t
)
738 struct target_ops
*cur
;
740 /* Check magic number. If wrong, it probably means someone changed
741 the struct definition, but not all the places that initialize one. */
742 if (t
->to_magic
!= OPS_MAGIC
)
744 fprintf_unfiltered (gdb_stderr
,
745 "Magic number of %s target struct wrong\n",
747 internal_error (__FILE__
, __LINE__
,
748 _("failed internal consistency check"));
751 for (cur
= target_stack
; cur
!= NULL
; cur
= cur
->beneath
)
758 /* Default implementation of to_get_thread_local_address. */
761 generic_tls_error (void)
763 throw_error (TLS_GENERIC_ERROR
,
764 _("Cannot find thread-local variables on this target"));
767 /* Using the objfile specified in OBJFILE, find the address for the
768 current thread's thread-local storage with offset OFFSET. */
770 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
772 volatile CORE_ADDR addr
= 0;
773 struct target_ops
*target
= ¤t_target
;
775 if (gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
777 ptid_t ptid
= inferior_ptid
;
778 volatile struct gdb_exception ex
;
780 TRY_CATCH (ex
, RETURN_MASK_ALL
)
784 /* Fetch the load module address for this objfile. */
785 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch (),
788 addr
= target
->to_get_thread_local_address (target
, ptid
,
791 /* If an error occurred, print TLS related messages here. Otherwise,
792 throw the error to some higher catcher. */
795 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
799 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
800 error (_("Cannot find thread-local variables "
801 "in this thread library."));
803 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
804 if (objfile_is_library
)
805 error (_("Cannot find shared library `%s' in dynamic"
806 " linker's load module list"), objfile_name (objfile
));
808 error (_("Cannot find executable file `%s' in dynamic"
809 " linker's load module list"), objfile_name (objfile
));
811 case TLS_NOT_ALLOCATED_YET_ERROR
:
812 if (objfile_is_library
)
813 error (_("The inferior has not yet allocated storage for"
814 " thread-local variables in\n"
815 "the shared library `%s'\n"
817 objfile_name (objfile
), target_pid_to_str (ptid
));
819 error (_("The inferior has not yet allocated storage for"
820 " thread-local variables in\n"
821 "the executable `%s'\n"
823 objfile_name (objfile
), target_pid_to_str (ptid
));
825 case TLS_GENERIC_ERROR
:
826 if (objfile_is_library
)
827 error (_("Cannot find thread-local storage for %s, "
828 "shared library %s:\n%s"),
829 target_pid_to_str (ptid
),
830 objfile_name (objfile
), ex
.message
);
832 error (_("Cannot find thread-local storage for %s, "
833 "executable file %s:\n%s"),
834 target_pid_to_str (ptid
),
835 objfile_name (objfile
), ex
.message
);
838 throw_exception (ex
);
843 /* It wouldn't be wrong here to try a gdbarch method, too; finding
844 TLS is an ABI-specific thing. But we don't do that yet. */
846 error (_("Cannot find thread-local variables on this target"));
852 target_xfer_status_to_string (enum target_xfer_status status
)
854 #define CASE(X) case X: return #X
857 CASE(TARGET_XFER_E_IO
);
858 CASE(TARGET_XFER_UNAVAILABLE
);
867 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
869 /* target_read_string -- read a null terminated string, up to LEN bytes,
870 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
871 Set *STRING to a pointer to malloc'd memory containing the data; the caller
872 is responsible for freeing it. Return the number of bytes successfully
876 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
882 int buffer_allocated
;
884 unsigned int nbytes_read
= 0;
888 /* Small for testing. */
889 buffer_allocated
= 4;
890 buffer
= xmalloc (buffer_allocated
);
895 tlen
= MIN (len
, 4 - (memaddr
& 3));
896 offset
= memaddr
& 3;
898 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
901 /* The transfer request might have crossed the boundary to an
902 unallocated region of memory. Retry the transfer, requesting
906 errcode
= target_read_memory (memaddr
, buf
, 1);
911 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
915 bytes
= bufptr
- buffer
;
916 buffer_allocated
*= 2;
917 buffer
= xrealloc (buffer
, buffer_allocated
);
918 bufptr
= buffer
+ bytes
;
921 for (i
= 0; i
< tlen
; i
++)
923 *bufptr
++ = buf
[i
+ offset
];
924 if (buf
[i
+ offset
] == '\000')
926 nbytes_read
+= i
+ 1;
942 struct target_section_table
*
943 target_get_section_table (struct target_ops
*target
)
945 return (*target
->to_get_section_table
) (target
);
948 /* Find a section containing ADDR. */
950 struct target_section
*
951 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
953 struct target_section_table
*table
= target_get_section_table (target
);
954 struct target_section
*secp
;
959 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
961 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
968 /* Helper for the memory xfer routines. Checks the attributes of the
969 memory region of MEMADDR against the read or write being attempted.
970 If the access is permitted returns true, otherwise returns false.
971 REGION_P is an optional output parameter. If not-NULL, it is
972 filled with a pointer to the memory region of MEMADDR. REG_LEN
973 returns LEN trimmed to the end of the region. This is how much the
974 caller can continue requesting, if the access is permitted. A
975 single xfer request must not straddle memory region boundaries. */
978 memory_xfer_check_region (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
979 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*reg_len
,
980 struct mem_region
**region_p
)
982 struct mem_region
*region
;
984 region
= lookup_mem_region (memaddr
);
986 if (region_p
!= NULL
)
989 switch (region
->attrib
.mode
)
992 if (writebuf
!= NULL
)
1002 /* We only support writing to flash during "load" for now. */
1003 if (writebuf
!= NULL
)
1004 error (_("Writing to flash memory forbidden in this context"));
1011 /* region->hi == 0 means there's no upper bound. */
1012 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1015 *reg_len
= region
->hi
- memaddr
;
1020 /* Read memory from more than one valid target. A core file, for
1021 instance, could have some of memory but delegate other bits to
1022 the target below it. So, we must manually try all targets. */
1024 static enum target_xfer_status
1025 raw_memory_xfer_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
1026 const gdb_byte
*writebuf
, ULONGEST memaddr
, LONGEST len
,
1027 ULONGEST
*xfered_len
)
1029 enum target_xfer_status res
;
1033 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1034 readbuf
, writebuf
, memaddr
, len
,
1036 if (res
== TARGET_XFER_OK
)
1039 /* Stop if the target reports that the memory is not available. */
1040 if (res
== TARGET_XFER_UNAVAILABLE
)
1043 /* We want to continue past core files to executables, but not
1044 past a running target's memory. */
1045 if (ops
->to_has_all_memory (ops
))
1050 while (ops
!= NULL
);
1052 /* The cache works at the raw memory level. Make sure the cache
1053 gets updated with raw contents no matter what kind of memory
1054 object was originally being written. Note we do write-through
1055 first, so that if it fails, we don't write to the cache contents
1056 that never made it to the target. */
1057 if (writebuf
!= NULL
1058 && !ptid_equal (inferior_ptid
, null_ptid
)
1059 && target_dcache_init_p ()
1060 && (stack_cache_enabled_p () || code_cache_enabled_p ()))
1062 DCACHE
*dcache
= target_dcache_get ();
1064 /* Note that writing to an area of memory which wasn't present
1065 in the cache doesn't cause it to be loaded in. */
1066 dcache_update (dcache
, res
, memaddr
, writebuf
, *xfered_len
);
1072 /* Perform a partial memory transfer.
1073 For docs see target.h, to_xfer_partial. */
1075 static enum target_xfer_status
1076 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
1077 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
1078 ULONGEST len
, ULONGEST
*xfered_len
)
1080 enum target_xfer_status res
;
1082 struct mem_region
*region
;
1083 struct inferior
*inf
;
1085 /* For accesses to unmapped overlay sections, read directly from
1086 files. Must do this first, as MEMADDR may need adjustment. */
1087 if (readbuf
!= NULL
&& overlay_debugging
)
1089 struct obj_section
*section
= find_pc_overlay (memaddr
);
1091 if (pc_in_unmapped_range (memaddr
, section
))
1093 struct target_section_table
*table
1094 = target_get_section_table (ops
);
1095 const char *section_name
= section
->the_bfd_section
->name
;
1097 memaddr
= overlay_mapped_address (memaddr
, section
);
1098 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1099 memaddr
, len
, xfered_len
,
1101 table
->sections_end
,
1106 /* Try the executable files, if "trust-readonly-sections" is set. */
1107 if (readbuf
!= NULL
&& trust_readonly
)
1109 struct target_section
*secp
;
1110 struct target_section_table
*table
;
1112 secp
= target_section_by_addr (ops
, memaddr
);
1114 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1115 secp
->the_bfd_section
)
1118 table
= target_get_section_table (ops
);
1119 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1120 memaddr
, len
, xfered_len
,
1122 table
->sections_end
,
1127 /* Try GDB's internal data cache. */
1129 if (!memory_xfer_check_region (readbuf
, writebuf
, memaddr
, len
, ®_len
,
1131 return TARGET_XFER_E_IO
;
1133 if (!ptid_equal (inferior_ptid
, null_ptid
))
1134 inf
= find_inferior_pid (ptid_get_pid (inferior_ptid
));
1140 /* The dcache reads whole cache lines; that doesn't play well
1141 with reading from a trace buffer, because reading outside of
1142 the collected memory range fails. */
1143 && get_traceframe_number () == -1
1144 && (region
->attrib
.cache
1145 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1146 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1148 DCACHE
*dcache
= target_dcache_get_or_init ();
1150 return dcache_read_memory_partial (ops
, dcache
, memaddr
, readbuf
,
1151 reg_len
, xfered_len
);
1154 /* If none of those methods found the memory we wanted, fall back
1155 to a target partial transfer. Normally a single call to
1156 to_xfer_partial is enough; if it doesn't recognize an object
1157 it will call the to_xfer_partial of the next target down.
1158 But for memory this won't do. Memory is the only target
1159 object which can be read from more than one valid target.
1160 A core file, for instance, could have some of memory but
1161 delegate other bits to the target below it. So, we must
1162 manually try all targets. */
1164 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
,
1167 /* If we still haven't got anything, return the last error. We
1172 /* Perform a partial memory transfer. For docs see target.h,
1175 static enum target_xfer_status
1176 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1177 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1178 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1180 enum target_xfer_status res
;
1182 /* Zero length requests are ok and require no work. */
1184 return TARGET_XFER_EOF
;
1186 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1187 breakpoint insns, thus hiding out from higher layers whether
1188 there are software breakpoints inserted in the code stream. */
1189 if (readbuf
!= NULL
)
1191 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
,
1194 if (res
== TARGET_XFER_OK
&& !show_memory_breakpoints
)
1195 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, *xfered_len
);
1200 struct cleanup
*old_chain
;
1202 /* A large write request is likely to be partially satisfied
1203 by memory_xfer_partial_1. We will continually malloc
1204 and free a copy of the entire write request for breakpoint
1205 shadow handling even though we only end up writing a small
1206 subset of it. Cap writes to 4KB to mitigate this. */
1207 len
= min (4096, len
);
1209 buf
= xmalloc (len
);
1210 old_chain
= make_cleanup (xfree
, buf
);
1211 memcpy (buf
, writebuf
, len
);
1213 breakpoint_xfer_memory (NULL
, buf
, writebuf
, memaddr
, len
);
1214 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
, memaddr
, len
,
1217 do_cleanups (old_chain
);
1224 restore_show_memory_breakpoints (void *arg
)
1226 show_memory_breakpoints
= (uintptr_t) arg
;
1230 make_show_memory_breakpoints_cleanup (int show
)
1232 int current
= show_memory_breakpoints
;
1234 show_memory_breakpoints
= show
;
1235 return make_cleanup (restore_show_memory_breakpoints
,
1236 (void *) (uintptr_t) current
);
1239 /* For docs see target.h, to_xfer_partial. */
1241 enum target_xfer_status
1242 target_xfer_partial (struct target_ops
*ops
,
1243 enum target_object object
, const char *annex
,
1244 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1245 ULONGEST offset
, ULONGEST len
,
1246 ULONGEST
*xfered_len
)
1248 enum target_xfer_status retval
;
1250 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1252 /* Transfer is done when LEN is zero. */
1254 return TARGET_XFER_EOF
;
1256 if (writebuf
&& !may_write_memory
)
1257 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1258 core_addr_to_string_nz (offset
), plongest (len
));
1262 /* If this is a memory transfer, let the memory-specific code
1263 have a look at it instead. Memory transfers are more
1265 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1266 || object
== TARGET_OBJECT_CODE_MEMORY
)
1267 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1268 writebuf
, offset
, len
, xfered_len
);
1269 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1271 /* Skip/avoid accessing the target if the memory region
1272 attributes block the access. Check this here instead of in
1273 raw_memory_xfer_partial as otherwise we'd end up checking
1274 this twice in the case of the memory_xfer_partial path is
1275 taken; once before checking the dcache, and another in the
1276 tail call to raw_memory_xfer_partial. */
1277 if (!memory_xfer_check_region (readbuf
, writebuf
, offset
, len
, &len
,
1279 return TARGET_XFER_E_IO
;
1281 /* Request the normal memory object from other layers. */
1282 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
,
1286 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
,
1287 writebuf
, offset
, len
, xfered_len
);
1291 const unsigned char *myaddr
= NULL
;
1293 fprintf_unfiltered (gdb_stdlog
,
1294 "%s:target_xfer_partial "
1295 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1298 (annex
? annex
: "(null)"),
1299 host_address_to_string (readbuf
),
1300 host_address_to_string (writebuf
),
1301 core_addr_to_string_nz (offset
),
1302 pulongest (len
), retval
,
1303 pulongest (*xfered_len
));
1309 if (retval
== TARGET_XFER_OK
&& myaddr
!= NULL
)
1313 fputs_unfiltered (", bytes =", gdb_stdlog
);
1314 for (i
= 0; i
< *xfered_len
; i
++)
1316 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1318 if (targetdebug
< 2 && i
> 0)
1320 fprintf_unfiltered (gdb_stdlog
, " ...");
1323 fprintf_unfiltered (gdb_stdlog
, "\n");
1326 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1330 fputc_unfiltered ('\n', gdb_stdlog
);
1333 /* Check implementations of to_xfer_partial update *XFERED_LEN
1334 properly. Do assertion after printing debug messages, so that we
1335 can find more clues on assertion failure from debugging messages. */
1336 if (retval
== TARGET_XFER_OK
|| retval
== TARGET_XFER_UNAVAILABLE
)
1337 gdb_assert (*xfered_len
> 0);
1342 /* Read LEN bytes of target memory at address MEMADDR, placing the
1343 results in GDB's memory at MYADDR. Returns either 0 for success or
1344 TARGET_XFER_E_IO if any error occurs.
1346 If an error occurs, no guarantee is made about the contents of the data at
1347 MYADDR. In particular, the caller should not depend upon partial reads
1348 filling the buffer with good data. There is no way for the caller to know
1349 how much good data might have been transfered anyway. Callers that can
1350 deal with partial reads should call target_read (which will retry until
1351 it makes no progress, and then return how much was transferred). */
1354 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1356 /* Dispatch to the topmost target, not the flattened current_target.
1357 Memory accesses check target->to_has_(all_)memory, and the
1358 flattened target doesn't inherit those. */
1359 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1360 myaddr
, memaddr
, len
) == len
)
1363 return TARGET_XFER_E_IO
;
1366 /* See target/target.h. */
1369 target_read_uint32 (CORE_ADDR memaddr
, uint32_t *result
)
1374 r
= target_read_memory (memaddr
, buf
, sizeof buf
);
1377 *result
= extract_unsigned_integer (buf
, sizeof buf
,
1378 gdbarch_byte_order (target_gdbarch ()));
1382 /* Like target_read_memory, but specify explicitly that this is a read
1383 from the target's raw memory. That is, this read bypasses the
1384 dcache, breakpoint shadowing, etc. */
1387 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1389 /* See comment in target_read_memory about why the request starts at
1390 current_target.beneath. */
1391 if (target_read (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1392 myaddr
, memaddr
, len
) == len
)
1395 return TARGET_XFER_E_IO
;
1398 /* Like target_read_memory, but specify explicitly that this is a read from
1399 the target's stack. This may trigger different cache behavior. */
1402 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1404 /* See comment in target_read_memory about why the request starts at
1405 current_target.beneath. */
1406 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1407 myaddr
, memaddr
, len
) == len
)
1410 return TARGET_XFER_E_IO
;
1413 /* Like target_read_memory, but specify explicitly that this is a read from
1414 the target's code. This may trigger different cache behavior. */
1417 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1419 /* See comment in target_read_memory about why the request starts at
1420 current_target.beneath. */
1421 if (target_read (current_target
.beneath
, TARGET_OBJECT_CODE_MEMORY
, NULL
,
1422 myaddr
, memaddr
, len
) == len
)
1425 return TARGET_XFER_E_IO
;
1428 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1429 Returns either 0 for success or TARGET_XFER_E_IO if any
1430 error occurs. If an error occurs, no guarantee is made about how
1431 much data got written. Callers that can deal with partial writes
1432 should call target_write. */
1435 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1437 /* See comment in target_read_memory about why the request starts at
1438 current_target.beneath. */
1439 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1440 myaddr
, memaddr
, len
) == len
)
1443 return TARGET_XFER_E_IO
;
1446 /* Write LEN bytes from MYADDR to target raw memory at address
1447 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1448 if any error occurs. If an error occurs, no guarantee is made
1449 about how much data got written. Callers that can deal with
1450 partial writes should call target_write. */
1453 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1455 /* See comment in target_read_memory about why the request starts at
1456 current_target.beneath. */
1457 if (target_write (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1458 myaddr
, memaddr
, len
) == len
)
1461 return TARGET_XFER_E_IO
;
1464 /* Fetch the target's memory map. */
1467 target_memory_map (void)
1469 VEC(mem_region_s
) *result
;
1470 struct mem_region
*last_one
, *this_one
;
1472 struct target_ops
*t
;
1474 result
= current_target
.to_memory_map (¤t_target
);
1478 qsort (VEC_address (mem_region_s
, result
),
1479 VEC_length (mem_region_s
, result
),
1480 sizeof (struct mem_region
), mem_region_cmp
);
1482 /* Check that regions do not overlap. Simultaneously assign
1483 a numbering for the "mem" commands to use to refer to
1486 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1488 this_one
->number
= ix
;
1490 if (last_one
&& last_one
->hi
> this_one
->lo
)
1492 warning (_("Overlapping regions in memory map: ignoring"));
1493 VEC_free (mem_region_s
, result
);
1496 last_one
= this_one
;
1503 target_flash_erase (ULONGEST address
, LONGEST length
)
1505 current_target
.to_flash_erase (¤t_target
, address
, length
);
1509 target_flash_done (void)
1511 current_target
.to_flash_done (¤t_target
);
1515 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1516 struct cmd_list_element
*c
, const char *value
)
1518 fprintf_filtered (file
,
1519 _("Mode for reading from readonly sections is %s.\n"),
1523 /* Target vector read/write partial wrapper functions. */
1525 static enum target_xfer_status
1526 target_read_partial (struct target_ops
*ops
,
1527 enum target_object object
,
1528 const char *annex
, gdb_byte
*buf
,
1529 ULONGEST offset
, ULONGEST len
,
1530 ULONGEST
*xfered_len
)
1532 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
,
1536 static enum target_xfer_status
1537 target_write_partial (struct target_ops
*ops
,
1538 enum target_object object
,
1539 const char *annex
, const gdb_byte
*buf
,
1540 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
1542 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
,
1546 /* Wrappers to perform the full transfer. */
1548 /* For docs on target_read see target.h. */
1551 target_read (struct target_ops
*ops
,
1552 enum target_object object
,
1553 const char *annex
, gdb_byte
*buf
,
1554 ULONGEST offset
, LONGEST len
)
1558 while (xfered
< len
)
1560 ULONGEST xfered_len
;
1561 enum target_xfer_status status
;
1563 status
= target_read_partial (ops
, object
, annex
,
1564 (gdb_byte
*) buf
+ xfered
,
1565 offset
+ xfered
, len
- xfered
,
1568 /* Call an observer, notifying them of the xfer progress? */
1569 if (status
== TARGET_XFER_EOF
)
1571 else if (status
== TARGET_XFER_OK
)
1573 xfered
+= xfered_len
;
1583 /* Assuming that the entire [begin, end) range of memory cannot be
1584 read, try to read whatever subrange is possible to read.
1586 The function returns, in RESULT, either zero or one memory block.
1587 If there's a readable subrange at the beginning, it is completely
1588 read and returned. Any further readable subrange will not be read.
1589 Otherwise, if there's a readable subrange at the end, it will be
1590 completely read and returned. Any readable subranges before it
1591 (obviously, not starting at the beginning), will be ignored. In
1592 other cases -- either no readable subrange, or readable subrange(s)
1593 that is neither at the beginning, or end, nothing is returned.
1595 The purpose of this function is to handle a read across a boundary
1596 of accessible memory in a case when memory map is not available.
1597 The above restrictions are fine for this case, but will give
1598 incorrect results if the memory is 'patchy'. However, supporting
1599 'patchy' memory would require trying to read every single byte,
1600 and it seems unacceptable solution. Explicit memory map is
1601 recommended for this case -- and target_read_memory_robust will
1602 take care of reading multiple ranges then. */
1605 read_whatever_is_readable (struct target_ops
*ops
,
1606 ULONGEST begin
, ULONGEST end
,
1607 VEC(memory_read_result_s
) **result
)
1609 gdb_byte
*buf
= xmalloc (end
- begin
);
1610 ULONGEST current_begin
= begin
;
1611 ULONGEST current_end
= end
;
1613 memory_read_result_s r
;
1614 ULONGEST xfered_len
;
1616 /* If we previously failed to read 1 byte, nothing can be done here. */
1617 if (end
- begin
<= 1)
1623 /* Check that either first or the last byte is readable, and give up
1624 if not. This heuristic is meant to permit reading accessible memory
1625 at the boundary of accessible region. */
1626 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1627 buf
, begin
, 1, &xfered_len
) == TARGET_XFER_OK
)
1632 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1633 buf
+ (end
-begin
) - 1, end
- 1, 1,
1634 &xfered_len
) == TARGET_XFER_OK
)
1645 /* Loop invariant is that the [current_begin, current_end) was previously
1646 found to be not readable as a whole.
1648 Note loop condition -- if the range has 1 byte, we can't divide the range
1649 so there's no point trying further. */
1650 while (current_end
- current_begin
> 1)
1652 ULONGEST first_half_begin
, first_half_end
;
1653 ULONGEST second_half_begin
, second_half_end
;
1655 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
1659 first_half_begin
= current_begin
;
1660 first_half_end
= middle
;
1661 second_half_begin
= middle
;
1662 second_half_end
= current_end
;
1666 first_half_begin
= middle
;
1667 first_half_end
= current_end
;
1668 second_half_begin
= current_begin
;
1669 second_half_end
= middle
;
1672 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1673 buf
+ (first_half_begin
- begin
),
1675 first_half_end
- first_half_begin
);
1677 if (xfer
== first_half_end
- first_half_begin
)
1679 /* This half reads up fine. So, the error must be in the
1681 current_begin
= second_half_begin
;
1682 current_end
= second_half_end
;
1686 /* This half is not readable. Because we've tried one byte, we
1687 know some part of this half if actually redable. Go to the next
1688 iteration to divide again and try to read.
1690 We don't handle the other half, because this function only tries
1691 to read a single readable subrange. */
1692 current_begin
= first_half_begin
;
1693 current_end
= first_half_end
;
1699 /* The [begin, current_begin) range has been read. */
1701 r
.end
= current_begin
;
1706 /* The [current_end, end) range has been read. */
1707 LONGEST rlen
= end
- current_end
;
1709 r
.data
= xmalloc (rlen
);
1710 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
1711 r
.begin
= current_end
;
1715 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
1719 free_memory_read_result_vector (void *x
)
1721 VEC(memory_read_result_s
) *v
= x
;
1722 memory_read_result_s
*current
;
1725 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
1727 xfree (current
->data
);
1729 VEC_free (memory_read_result_s
, v
);
1732 VEC(memory_read_result_s
) *
1733 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
1735 VEC(memory_read_result_s
) *result
= 0;
1738 while (xfered
< len
)
1740 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
1743 /* If there is no explicit region, a fake one should be created. */
1744 gdb_assert (region
);
1746 if (region
->hi
== 0)
1747 rlen
= len
- xfered
;
1749 rlen
= region
->hi
- offset
;
1751 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
1753 /* Cannot read this region. Note that we can end up here only
1754 if the region is explicitly marked inaccessible, or
1755 'inaccessible-by-default' is in effect. */
1760 LONGEST to_read
= min (len
- xfered
, rlen
);
1761 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
1763 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1764 (gdb_byte
*) buffer
,
1765 offset
+ xfered
, to_read
);
1766 /* Call an observer, notifying them of the xfer progress? */
1769 /* Got an error reading full chunk. See if maybe we can read
1772 read_whatever_is_readable (ops
, offset
+ xfered
,
1773 offset
+ xfered
+ to_read
, &result
);
1778 struct memory_read_result r
;
1780 r
.begin
= offset
+ xfered
;
1781 r
.end
= r
.begin
+ xfer
;
1782 VEC_safe_push (memory_read_result_s
, result
, &r
);
1792 /* An alternative to target_write with progress callbacks. */
1795 target_write_with_progress (struct target_ops
*ops
,
1796 enum target_object object
,
1797 const char *annex
, const gdb_byte
*buf
,
1798 ULONGEST offset
, LONGEST len
,
1799 void (*progress
) (ULONGEST
, void *), void *baton
)
1803 /* Give the progress callback a chance to set up. */
1805 (*progress
) (0, baton
);
1807 while (xfered
< len
)
1809 ULONGEST xfered_len
;
1810 enum target_xfer_status status
;
1812 status
= target_write_partial (ops
, object
, annex
,
1813 (gdb_byte
*) buf
+ xfered
,
1814 offset
+ xfered
, len
- xfered
,
1817 if (status
!= TARGET_XFER_OK
)
1818 return status
== TARGET_XFER_EOF
? xfered
: -1;
1821 (*progress
) (xfered_len
, baton
);
1823 xfered
+= xfered_len
;
1829 /* For docs on target_write see target.h. */
1832 target_write (struct target_ops
*ops
,
1833 enum target_object object
,
1834 const char *annex
, const gdb_byte
*buf
,
1835 ULONGEST offset
, LONGEST len
)
1837 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1841 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1842 the size of the transferred data. PADDING additional bytes are
1843 available in *BUF_P. This is a helper function for
1844 target_read_alloc; see the declaration of that function for more
1848 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1849 const char *annex
, gdb_byte
**buf_p
, int padding
)
1851 size_t buf_alloc
, buf_pos
;
1854 /* This function does not have a length parameter; it reads the
1855 entire OBJECT). Also, it doesn't support objects fetched partly
1856 from one target and partly from another (in a different stratum,
1857 e.g. a core file and an executable). Both reasons make it
1858 unsuitable for reading memory. */
1859 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1861 /* Start by reading up to 4K at a time. The target will throttle
1862 this number down if necessary. */
1864 buf
= xmalloc (buf_alloc
);
1868 ULONGEST xfered_len
;
1869 enum target_xfer_status status
;
1871 status
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1872 buf_pos
, buf_alloc
- buf_pos
- padding
,
1875 if (status
== TARGET_XFER_EOF
)
1877 /* Read all there was. */
1884 else if (status
!= TARGET_XFER_OK
)
1886 /* An error occurred. */
1888 return TARGET_XFER_E_IO
;
1891 buf_pos
+= xfered_len
;
1893 /* If the buffer is filling up, expand it. */
1894 if (buf_alloc
< buf_pos
* 2)
1897 buf
= xrealloc (buf
, buf_alloc
);
1904 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1905 the size of the transferred data. See the declaration in "target.h"
1906 function for more information about the return value. */
1909 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1910 const char *annex
, gdb_byte
**buf_p
)
1912 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1915 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1916 returned as a string, allocated using xmalloc. If an error occurs
1917 or the transfer is unsupported, NULL is returned. Empty objects
1918 are returned as allocated but empty strings. A warning is issued
1919 if the result contains any embedded NUL bytes. */
1922 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1927 LONGEST i
, transferred
;
1929 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1930 bufstr
= (char *) buffer
;
1932 if (transferred
< 0)
1935 if (transferred
== 0)
1936 return xstrdup ("");
1938 bufstr
[transferred
] = 0;
1940 /* Check for embedded NUL bytes; but allow trailing NULs. */
1941 for (i
= strlen (bufstr
); i
< transferred
; i
++)
1944 warning (_("target object %d, annex %s, "
1945 "contained unexpected null characters"),
1946 (int) object
, annex
? annex
: "(none)");
1953 /* Memory transfer methods. */
1956 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1959 /* This method is used to read from an alternate, non-current
1960 target. This read must bypass the overlay support (as symbols
1961 don't match this target), and GDB's internal cache (wrong cache
1962 for this target). */
1963 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
1965 memory_error (TARGET_XFER_E_IO
, addr
);
1969 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
1970 int len
, enum bfd_endian byte_order
)
1972 gdb_byte buf
[sizeof (ULONGEST
)];
1974 gdb_assert (len
<= sizeof (buf
));
1975 get_target_memory (ops
, addr
, buf
, len
);
1976 return extract_unsigned_integer (buf
, len
, byte_order
);
1982 target_insert_breakpoint (struct gdbarch
*gdbarch
,
1983 struct bp_target_info
*bp_tgt
)
1985 if (!may_insert_breakpoints
)
1987 warning (_("May not insert breakpoints"));
1991 return current_target
.to_insert_breakpoint (¤t_target
,
1998 target_remove_breakpoint (struct gdbarch
*gdbarch
,
1999 struct bp_target_info
*bp_tgt
)
2001 /* This is kind of a weird case to handle, but the permission might
2002 have been changed after breakpoints were inserted - in which case
2003 we should just take the user literally and assume that any
2004 breakpoints should be left in place. */
2005 if (!may_insert_breakpoints
)
2007 warning (_("May not remove breakpoints"));
2011 return current_target
.to_remove_breakpoint (¤t_target
,
2016 target_info (char *args
, int from_tty
)
2018 struct target_ops
*t
;
2019 int has_all_mem
= 0;
2021 if (symfile_objfile
!= NULL
)
2022 printf_unfiltered (_("Symbols from \"%s\".\n"),
2023 objfile_name (symfile_objfile
));
2025 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2027 if (!(*t
->to_has_memory
) (t
))
2030 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2033 printf_unfiltered (_("\tWhile running this, "
2034 "GDB does not access memory from...\n"));
2035 printf_unfiltered ("%s:\n", t
->to_longname
);
2036 (t
->to_files_info
) (t
);
2037 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2041 /* This function is called before any new inferior is created, e.g.
2042 by running a program, attaching, or connecting to a target.
2043 It cleans up any state from previous invocations which might
2044 change between runs. This is a subset of what target_preopen
2045 resets (things which might change between targets). */
2048 target_pre_inferior (int from_tty
)
2050 /* Clear out solib state. Otherwise the solib state of the previous
2051 inferior might have survived and is entirely wrong for the new
2052 target. This has been observed on GNU/Linux using glibc 2.3. How
2064 Cannot access memory at address 0xdeadbeef
2067 /* In some OSs, the shared library list is the same/global/shared
2068 across inferiors. If code is shared between processes, so are
2069 memory regions and features. */
2070 if (!gdbarch_has_global_solist (target_gdbarch ()))
2072 no_shared_libraries (NULL
, from_tty
);
2074 invalidate_target_mem_regions ();
2076 target_clear_description ();
2079 agent_capability_invalidate ();
2082 /* Callback for iterate_over_inferiors. Gets rid of the given
2086 dispose_inferior (struct inferior
*inf
, void *args
)
2088 struct thread_info
*thread
;
2090 thread
= any_thread_of_process (inf
->pid
);
2093 switch_to_thread (thread
->ptid
);
2095 /* Core inferiors actually should be detached, not killed. */
2096 if (target_has_execution
)
2099 target_detach (NULL
, 0);
2105 /* This is to be called by the open routine before it does
2109 target_preopen (int from_tty
)
2113 if (have_inferiors ())
2116 || !have_live_inferiors ()
2117 || query (_("A program is being debugged already. Kill it? ")))
2118 iterate_over_inferiors (dispose_inferior
, NULL
);
2120 error (_("Program not killed."));
2123 /* Calling target_kill may remove the target from the stack. But if
2124 it doesn't (which seems like a win for UDI), remove it now. */
2125 /* Leave the exec target, though. The user may be switching from a
2126 live process to a core of the same program. */
2127 pop_all_targets_above (file_stratum
);
2129 target_pre_inferior (from_tty
);
2132 /* Detach a target after doing deferred register stores. */
2135 target_detach (const char *args
, int from_tty
)
2137 struct target_ops
* t
;
2139 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2140 /* Don't remove global breakpoints here. They're removed on
2141 disconnection from the target. */
2144 /* If we're in breakpoints-always-inserted mode, have to remove
2145 them before detaching. */
2146 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2148 prepare_for_detach ();
2150 current_target
.to_detach (¤t_target
, args
, from_tty
);
2154 target_disconnect (const char *args
, int from_tty
)
2156 /* If we're in breakpoints-always-inserted mode or if breakpoints
2157 are global across processes, we have to remove them before
2159 remove_breakpoints ();
2161 current_target
.to_disconnect (¤t_target
, args
, from_tty
);
2165 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2167 return (current_target
.to_wait
) (¤t_target
, ptid
, status
, options
);
2171 target_pid_to_str (ptid_t ptid
)
2173 return (*current_target
.to_pid_to_str
) (¤t_target
, ptid
);
2177 target_thread_name (struct thread_info
*info
)
2179 return current_target
.to_thread_name (¤t_target
, info
);
2183 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2185 struct target_ops
*t
;
2187 target_dcache_invalidate ();
2189 current_target
.to_resume (¤t_target
, ptid
, step
, signal
);
2191 registers_changed_ptid (ptid
);
2192 /* We only set the internal executing state here. The user/frontend
2193 running state is set at a higher level. */
2194 set_executing (ptid
, 1);
2195 clear_inline_frame_state (ptid
);
2199 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2201 (*current_target
.to_pass_signals
) (¤t_target
, numsigs
, pass_signals
);
2205 target_program_signals (int numsigs
, unsigned char *program_signals
)
2207 (*current_target
.to_program_signals
) (¤t_target
,
2208 numsigs
, program_signals
);
2212 default_follow_fork (struct target_ops
*self
, int follow_child
,
2215 /* Some target returned a fork event, but did not know how to follow it. */
2216 internal_error (__FILE__
, __LINE__
,
2217 _("could not find a target to follow fork"));
2220 /* Look through the list of possible targets for a target that can
2224 target_follow_fork (int follow_child
, int detach_fork
)
2226 return current_target
.to_follow_fork (¤t_target
,
2227 follow_child
, detach_fork
);
2231 default_mourn_inferior (struct target_ops
*self
)
2233 internal_error (__FILE__
, __LINE__
,
2234 _("could not find a target to follow mourn inferior"));
2238 target_mourn_inferior (void)
2240 current_target
.to_mourn_inferior (¤t_target
);
2242 /* We no longer need to keep handles on any of the object files.
2243 Make sure to release them to avoid unnecessarily locking any
2244 of them while we're not actually debugging. */
2245 bfd_cache_close_all ();
2248 /* Look for a target which can describe architectural features, starting
2249 from TARGET. If we find one, return its description. */
2251 const struct target_desc
*
2252 target_read_description (struct target_ops
*target
)
2254 return target
->to_read_description (target
);
2257 /* This implements a basic search of memory, reading target memory and
2258 performing the search here (as opposed to performing the search in on the
2259 target side with, for example, gdbserver). */
2262 simple_search_memory (struct target_ops
*ops
,
2263 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2264 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2265 CORE_ADDR
*found_addrp
)
2267 /* NOTE: also defined in find.c testcase. */
2268 #define SEARCH_CHUNK_SIZE 16000
2269 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2270 /* Buffer to hold memory contents for searching. */
2271 gdb_byte
*search_buf
;
2272 unsigned search_buf_size
;
2273 struct cleanup
*old_cleanups
;
2275 search_buf_size
= chunk_size
+ pattern_len
- 1;
2277 /* No point in trying to allocate a buffer larger than the search space. */
2278 if (search_space_len
< search_buf_size
)
2279 search_buf_size
= search_space_len
;
2281 search_buf
= malloc (search_buf_size
);
2282 if (search_buf
== NULL
)
2283 error (_("Unable to allocate memory to perform the search."));
2284 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2286 /* Prime the search buffer. */
2288 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2289 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2291 warning (_("Unable to access %s bytes of target "
2292 "memory at %s, halting search."),
2293 pulongest (search_buf_size
), hex_string (start_addr
));
2294 do_cleanups (old_cleanups
);
2298 /* Perform the search.
2300 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2301 When we've scanned N bytes we copy the trailing bytes to the start and
2302 read in another N bytes. */
2304 while (search_space_len
>= pattern_len
)
2306 gdb_byte
*found_ptr
;
2307 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2309 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2310 pattern
, pattern_len
);
2312 if (found_ptr
!= NULL
)
2314 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2316 *found_addrp
= found_addr
;
2317 do_cleanups (old_cleanups
);
2321 /* Not found in this chunk, skip to next chunk. */
2323 /* Don't let search_space_len wrap here, it's unsigned. */
2324 if (search_space_len
>= chunk_size
)
2325 search_space_len
-= chunk_size
;
2327 search_space_len
= 0;
2329 if (search_space_len
>= pattern_len
)
2331 unsigned keep_len
= search_buf_size
- chunk_size
;
2332 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2335 /* Copy the trailing part of the previous iteration to the front
2336 of the buffer for the next iteration. */
2337 gdb_assert (keep_len
== pattern_len
- 1);
2338 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
2340 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
2342 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2343 search_buf
+ keep_len
, read_addr
,
2344 nr_to_read
) != nr_to_read
)
2346 warning (_("Unable to access %s bytes of target "
2347 "memory at %s, halting search."),
2348 plongest (nr_to_read
),
2349 hex_string (read_addr
));
2350 do_cleanups (old_cleanups
);
2354 start_addr
+= chunk_size
;
2360 do_cleanups (old_cleanups
);
2364 /* Default implementation of memory-searching. */
2367 default_search_memory (struct target_ops
*self
,
2368 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2369 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2370 CORE_ADDR
*found_addrp
)
2372 /* Start over from the top of the target stack. */
2373 return simple_search_memory (current_target
.beneath
,
2374 start_addr
, search_space_len
,
2375 pattern
, pattern_len
, found_addrp
);
2378 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2379 sequence of bytes in PATTERN with length PATTERN_LEN.
2381 The result is 1 if found, 0 if not found, and -1 if there was an error
2382 requiring halting of the search (e.g. memory read error).
2383 If the pattern is found the address is recorded in FOUND_ADDRP. */
2386 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2387 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2388 CORE_ADDR
*found_addrp
)
2390 return current_target
.to_search_memory (¤t_target
, start_addr
,
2392 pattern
, pattern_len
, found_addrp
);
2395 /* Look through the currently pushed targets. If none of them will
2396 be able to restart the currently running process, issue an error
2400 target_require_runnable (void)
2402 struct target_ops
*t
;
2404 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2406 /* If this target knows how to create a new program, then
2407 assume we will still be able to after killing the current
2408 one. Either killing and mourning will not pop T, or else
2409 find_default_run_target will find it again. */
2410 if (t
->to_create_inferior
!= NULL
)
2413 /* Do not worry about targets at certain strata that can not
2414 create inferiors. Assume they will be pushed again if
2415 necessary, and continue to the process_stratum. */
2416 if (t
->to_stratum
== thread_stratum
2417 || t
->to_stratum
== record_stratum
2418 || t
->to_stratum
== arch_stratum
)
2421 error (_("The \"%s\" target does not support \"run\". "
2422 "Try \"help target\" or \"continue\"."),
2426 /* This function is only called if the target is running. In that
2427 case there should have been a process_stratum target and it
2428 should either know how to create inferiors, or not... */
2429 internal_error (__FILE__
, __LINE__
, _("No targets found"));
2432 /* Whether GDB is allowed to fall back to the default run target for
2433 "run", "attach", etc. when no target is connected yet. */
2434 static int auto_connect_native_target
= 1;
2437 show_auto_connect_native_target (struct ui_file
*file
, int from_tty
,
2438 struct cmd_list_element
*c
, const char *value
)
2440 fprintf_filtered (file
,
2441 _("Whether GDB may automatically connect to the "
2442 "native target is %s.\n"),
2446 /* Look through the list of possible targets for a target that can
2447 execute a run or attach command without any other data. This is
2448 used to locate the default process stratum.
2450 If DO_MESG is not NULL, the result is always valid (error() is
2451 called for errors); else, return NULL on error. */
2453 static struct target_ops
*
2454 find_default_run_target (char *do_mesg
)
2456 struct target_ops
*runable
= NULL
;
2458 if (auto_connect_native_target
)
2460 struct target_ops
*t
;
2464 for (i
= 0; VEC_iterate (target_ops_p
, target_structs
, i
, t
); ++i
)
2466 if (t
->to_can_run
!= delegate_can_run
&& target_can_run (t
))
2477 if (runable
== NULL
)
2480 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2491 find_attach_target (void)
2493 struct target_ops
*t
;
2495 /* If a target on the current stack can attach, use it. */
2496 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2498 if (t
->to_attach
!= NULL
)
2502 /* Otherwise, use the default run target for attaching. */
2504 t
= find_default_run_target ("attach");
2512 find_run_target (void)
2514 struct target_ops
*t
;
2516 /* If a target on the current stack can attach, use it. */
2517 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2519 if (t
->to_create_inferior
!= NULL
)
2523 /* Otherwise, use the default run target. */
2525 t
= find_default_run_target ("run");
2530 /* Implement the "info proc" command. */
2533 target_info_proc (const char *args
, enum info_proc_what what
)
2535 struct target_ops
*t
;
2537 /* If we're already connected to something that can get us OS
2538 related data, use it. Otherwise, try using the native
2540 if (current_target
.to_stratum
>= process_stratum
)
2541 t
= current_target
.beneath
;
2543 t
= find_default_run_target (NULL
);
2545 for (; t
!= NULL
; t
= t
->beneath
)
2547 if (t
->to_info_proc
!= NULL
)
2549 t
->to_info_proc (t
, args
, what
);
2552 fprintf_unfiltered (gdb_stdlog
,
2553 "target_info_proc (\"%s\", %d)\n", args
, what
);
2563 find_default_supports_disable_randomization (struct target_ops
*self
)
2565 struct target_ops
*t
;
2567 t
= find_default_run_target (NULL
);
2568 if (t
&& t
->to_supports_disable_randomization
)
2569 return (t
->to_supports_disable_randomization
) (t
);
2574 target_supports_disable_randomization (void)
2576 struct target_ops
*t
;
2578 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2579 if (t
->to_supports_disable_randomization
)
2580 return t
->to_supports_disable_randomization (t
);
2586 target_get_osdata (const char *type
)
2588 struct target_ops
*t
;
2590 /* If we're already connected to something that can get us OS
2591 related data, use it. Otherwise, try using the native
2593 if (current_target
.to_stratum
>= process_stratum
)
2594 t
= current_target
.beneath
;
2596 t
= find_default_run_target ("get OS data");
2601 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
2604 static struct address_space
*
2605 default_thread_address_space (struct target_ops
*self
, ptid_t ptid
)
2607 struct inferior
*inf
;
2609 /* Fall-back to the "main" address space of the inferior. */
2610 inf
= find_inferior_pid (ptid_get_pid (ptid
));
2612 if (inf
== NULL
|| inf
->aspace
== NULL
)
2613 internal_error (__FILE__
, __LINE__
,
2614 _("Can't determine the current "
2615 "address space of thread %s\n"),
2616 target_pid_to_str (ptid
));
2621 /* Determine the current address space of thread PTID. */
2623 struct address_space
*
2624 target_thread_address_space (ptid_t ptid
)
2626 struct address_space
*aspace
;
2628 aspace
= current_target
.to_thread_address_space (¤t_target
, ptid
);
2629 gdb_assert (aspace
!= NULL
);
2635 /* Target file operations. */
2637 static struct target_ops
*
2638 default_fileio_target (void)
2640 /* If we're already connected to something that can perform
2641 file I/O, use it. Otherwise, try using the native target. */
2642 if (current_target
.to_stratum
>= process_stratum
)
2643 return current_target
.beneath
;
2645 return find_default_run_target ("file I/O");
2648 /* Open FILENAME on the target, using FLAGS and MODE. Return a
2649 target file descriptor, or -1 if an error occurs (and set
2652 target_fileio_open (const char *filename
, int flags
, int mode
,
2655 struct target_ops
*t
;
2657 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2659 if (t
->to_fileio_open
!= NULL
)
2661 int fd
= t
->to_fileio_open (t
, filename
, flags
, mode
, target_errno
);
2664 fprintf_unfiltered (gdb_stdlog
,
2665 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
2666 filename
, flags
, mode
,
2667 fd
, fd
!= -1 ? 0 : *target_errno
);
2672 *target_errno
= FILEIO_ENOSYS
;
2676 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
2677 Return the number of bytes written, or -1 if an error occurs
2678 (and set *TARGET_ERRNO). */
2680 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
2681 ULONGEST offset
, int *target_errno
)
2683 struct target_ops
*t
;
2685 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2687 if (t
->to_fileio_pwrite
!= NULL
)
2689 int ret
= t
->to_fileio_pwrite (t
, fd
, write_buf
, len
, offset
,
2693 fprintf_unfiltered (gdb_stdlog
,
2694 "target_fileio_pwrite (%d,...,%d,%s) "
2696 fd
, len
, pulongest (offset
),
2697 ret
, ret
!= -1 ? 0 : *target_errno
);
2702 *target_errno
= FILEIO_ENOSYS
;
2706 /* Read up to LEN bytes FD on the target into READ_BUF.
2707 Return the number of bytes read, or -1 if an error occurs
2708 (and set *TARGET_ERRNO). */
2710 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
2711 ULONGEST offset
, int *target_errno
)
2713 struct target_ops
*t
;
2715 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2717 if (t
->to_fileio_pread
!= NULL
)
2719 int ret
= t
->to_fileio_pread (t
, fd
, read_buf
, len
, offset
,
2723 fprintf_unfiltered (gdb_stdlog
,
2724 "target_fileio_pread (%d,...,%d,%s) "
2726 fd
, len
, pulongest (offset
),
2727 ret
, ret
!= -1 ? 0 : *target_errno
);
2732 *target_errno
= FILEIO_ENOSYS
;
2736 /* Close FD on the target. Return 0, or -1 if an error occurs
2737 (and set *TARGET_ERRNO). */
2739 target_fileio_close (int fd
, int *target_errno
)
2741 struct target_ops
*t
;
2743 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2745 if (t
->to_fileio_close
!= NULL
)
2747 int ret
= t
->to_fileio_close (t
, fd
, target_errno
);
2750 fprintf_unfiltered (gdb_stdlog
,
2751 "target_fileio_close (%d) = %d (%d)\n",
2752 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
2757 *target_errno
= FILEIO_ENOSYS
;
2761 /* Unlink FILENAME on the target. Return 0, or -1 if an error
2762 occurs (and set *TARGET_ERRNO). */
2764 target_fileio_unlink (const char *filename
, int *target_errno
)
2766 struct target_ops
*t
;
2768 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2770 if (t
->to_fileio_unlink
!= NULL
)
2772 int ret
= t
->to_fileio_unlink (t
, filename
, target_errno
);
2775 fprintf_unfiltered (gdb_stdlog
,
2776 "target_fileio_unlink (%s) = %d (%d)\n",
2777 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
2782 *target_errno
= FILEIO_ENOSYS
;
2786 /* Read value of symbolic link FILENAME on the target. Return a
2787 null-terminated string allocated via xmalloc, or NULL if an error
2788 occurs (and set *TARGET_ERRNO). */
2790 target_fileio_readlink (const char *filename
, int *target_errno
)
2792 struct target_ops
*t
;
2794 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2796 if (t
->to_fileio_readlink
!= NULL
)
2798 char *ret
= t
->to_fileio_readlink (t
, filename
, target_errno
);
2801 fprintf_unfiltered (gdb_stdlog
,
2802 "target_fileio_readlink (%s) = %s (%d)\n",
2803 filename
, ret
? ret
: "(nil)",
2804 ret
? 0 : *target_errno
);
2809 *target_errno
= FILEIO_ENOSYS
;
2814 target_fileio_close_cleanup (void *opaque
)
2816 int fd
= *(int *) opaque
;
2819 target_fileio_close (fd
, &target_errno
);
2822 /* Read target file FILENAME. Store the result in *BUF_P and
2823 return the size of the transferred data. PADDING additional bytes are
2824 available in *BUF_P. This is a helper function for
2825 target_fileio_read_alloc; see the declaration of that function for more
2829 target_fileio_read_alloc_1 (const char *filename
,
2830 gdb_byte
**buf_p
, int padding
)
2832 struct cleanup
*close_cleanup
;
2833 size_t buf_alloc
, buf_pos
;
2839 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
2843 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
2845 /* Start by reading up to 4K at a time. The target will throttle
2846 this number down if necessary. */
2848 buf
= xmalloc (buf_alloc
);
2852 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
2853 buf_alloc
- buf_pos
- padding
, buf_pos
,
2857 /* An error occurred. */
2858 do_cleanups (close_cleanup
);
2864 /* Read all there was. */
2865 do_cleanups (close_cleanup
);
2875 /* If the buffer is filling up, expand it. */
2876 if (buf_alloc
< buf_pos
* 2)
2879 buf
= xrealloc (buf
, buf_alloc
);
2886 /* Read target file FILENAME. Store the result in *BUF_P and return
2887 the size of the transferred data. See the declaration in "target.h"
2888 function for more information about the return value. */
2891 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
2893 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
2896 /* Read target file FILENAME. The result is NUL-terminated and
2897 returned as a string, allocated using xmalloc. If an error occurs
2898 or the transfer is unsupported, NULL is returned. Empty objects
2899 are returned as allocated but empty strings. A warning is issued
2900 if the result contains any embedded NUL bytes. */
2903 target_fileio_read_stralloc (const char *filename
)
2907 LONGEST i
, transferred
;
2909 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
2910 bufstr
= (char *) buffer
;
2912 if (transferred
< 0)
2915 if (transferred
== 0)
2916 return xstrdup ("");
2918 bufstr
[transferred
] = 0;
2920 /* Check for embedded NUL bytes; but allow trailing NULs. */
2921 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2924 warning (_("target file %s "
2925 "contained unexpected null characters"),
2935 default_region_ok_for_hw_watchpoint (struct target_ops
*self
,
2936 CORE_ADDR addr
, int len
)
2938 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
2942 default_watchpoint_addr_within_range (struct target_ops
*target
,
2944 CORE_ADDR start
, int length
)
2946 return addr
>= start
&& addr
< start
+ length
;
2949 static struct gdbarch
*
2950 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
2952 return target_gdbarch ();
2956 return_zero (struct target_ops
*ignore
)
2962 return_zero_has_execution (struct target_ops
*ignore
, ptid_t ignore2
)
2968 * Find the next target down the stack from the specified target.
2972 find_target_beneath (struct target_ops
*t
)
2980 find_target_at (enum strata stratum
)
2982 struct target_ops
*t
;
2984 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2985 if (t
->to_stratum
== stratum
)
2992 /* The inferior process has died. Long live the inferior! */
2995 generic_mourn_inferior (void)
2999 ptid
= inferior_ptid
;
3000 inferior_ptid
= null_ptid
;
3002 /* Mark breakpoints uninserted in case something tries to delete a
3003 breakpoint while we delete the inferior's threads (which would
3004 fail, since the inferior is long gone). */
3005 mark_breakpoints_out ();
3007 if (!ptid_equal (ptid
, null_ptid
))
3009 int pid
= ptid_get_pid (ptid
);
3010 exit_inferior (pid
);
3013 /* Note this wipes step-resume breakpoints, so needs to be done
3014 after exit_inferior, which ends up referencing the step-resume
3015 breakpoints through clear_thread_inferior_resources. */
3016 breakpoint_init_inferior (inf_exited
);
3018 registers_changed ();
3020 reopen_exec_file ();
3021 reinit_frame_cache ();
3023 if (deprecated_detach_hook
)
3024 deprecated_detach_hook ();
3027 /* Convert a normal process ID to a string. Returns the string in a
3031 normal_pid_to_str (ptid_t ptid
)
3033 static char buf
[32];
3035 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3040 default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3042 return normal_pid_to_str (ptid
);
3045 /* Error-catcher for target_find_memory_regions. */
3047 dummy_find_memory_regions (struct target_ops
*self
,
3048 find_memory_region_ftype ignore1
, void *ignore2
)
3050 error (_("Command not implemented for this target."));
3054 /* Error-catcher for target_make_corefile_notes. */
3056 dummy_make_corefile_notes (struct target_ops
*self
,
3057 bfd
*ignore1
, int *ignore2
)
3059 error (_("Command not implemented for this target."));
3063 /* Set up the handful of non-empty slots needed by the dummy target
3067 init_dummy_target (void)
3069 dummy_target
.to_shortname
= "None";
3070 dummy_target
.to_longname
= "None";
3071 dummy_target
.to_doc
= "";
3072 dummy_target
.to_supports_disable_randomization
3073 = find_default_supports_disable_randomization
;
3074 dummy_target
.to_stratum
= dummy_stratum
;
3075 dummy_target
.to_has_all_memory
= return_zero
;
3076 dummy_target
.to_has_memory
= return_zero
;
3077 dummy_target
.to_has_stack
= return_zero
;
3078 dummy_target
.to_has_registers
= return_zero
;
3079 dummy_target
.to_has_execution
= return_zero_has_execution
;
3080 dummy_target
.to_magic
= OPS_MAGIC
;
3082 install_dummy_methods (&dummy_target
);
3087 target_close (struct target_ops
*targ
)
3089 gdb_assert (!target_is_pushed (targ
));
3091 if (targ
->to_xclose
!= NULL
)
3092 targ
->to_xclose (targ
);
3093 else if (targ
->to_close
!= NULL
)
3094 targ
->to_close (targ
);
3097 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3101 target_thread_alive (ptid_t ptid
)
3103 return current_target
.to_thread_alive (¤t_target
, ptid
);
3107 target_update_thread_list (void)
3109 current_target
.to_update_thread_list (¤t_target
);
3113 target_stop (ptid_t ptid
)
3117 warning (_("May not interrupt or stop the target, ignoring attempt"));
3121 (*current_target
.to_stop
) (¤t_target
, ptid
);
3124 /* See target/target.h. */
3127 target_stop_and_wait (ptid_t ptid
)
3129 struct target_waitstatus status
;
3130 int was_non_stop
= non_stop
;
3135 memset (&status
, 0, sizeof (status
));
3136 target_wait (ptid
, &status
, 0);
3138 non_stop
= was_non_stop
;
3141 /* See target/target.h. */
3144 target_continue_no_signal (ptid_t ptid
)
3146 target_resume (ptid
, 0, GDB_SIGNAL_0
);
3149 /* Concatenate ELEM to LIST, a comma separate list, and return the
3150 result. The LIST incoming argument is released. */
3153 str_comma_list_concat_elem (char *list
, const char *elem
)
3156 return xstrdup (elem
);
3158 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3161 /* Helper for target_options_to_string. If OPT is present in
3162 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3163 Returns the new resulting string. OPT is removed from
3167 do_option (int *target_options
, char *ret
,
3168 int opt
, char *opt_str
)
3170 if ((*target_options
& opt
) != 0)
3172 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3173 *target_options
&= ~opt
;
3180 target_options_to_string (int target_options
)
3184 #define DO_TARG_OPTION(OPT) \
3185 ret = do_option (&target_options, ret, OPT, #OPT)
3187 DO_TARG_OPTION (TARGET_WNOHANG
);
3189 if (target_options
!= 0)
3190 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3198 debug_print_register (const char * func
,
3199 struct regcache
*regcache
, int regno
)
3201 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3203 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3204 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3205 && gdbarch_register_name (gdbarch
, regno
) != NULL
3206 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3207 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3208 gdbarch_register_name (gdbarch
, regno
));
3210 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3211 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3213 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3214 int i
, size
= register_size (gdbarch
, regno
);
3215 gdb_byte buf
[MAX_REGISTER_SIZE
];
3217 regcache_raw_collect (regcache
, regno
, buf
);
3218 fprintf_unfiltered (gdb_stdlog
, " = ");
3219 for (i
= 0; i
< size
; i
++)
3221 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3223 if (size
<= sizeof (LONGEST
))
3225 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
3227 fprintf_unfiltered (gdb_stdlog
, " %s %s",
3228 core_addr_to_string_nz (val
), plongest (val
));
3231 fprintf_unfiltered (gdb_stdlog
, "\n");
3235 target_fetch_registers (struct regcache
*regcache
, int regno
)
3237 current_target
.to_fetch_registers (¤t_target
, regcache
, regno
);
3239 debug_print_register ("target_fetch_registers", regcache
, regno
);
3243 target_store_registers (struct regcache
*regcache
, int regno
)
3245 struct target_ops
*t
;
3247 if (!may_write_registers
)
3248 error (_("Writing to registers is not allowed (regno %d)"), regno
);
3250 current_target
.to_store_registers (¤t_target
, regcache
, regno
);
3253 debug_print_register ("target_store_registers", regcache
, regno
);
3258 target_core_of_thread (ptid_t ptid
)
3260 return current_target
.to_core_of_thread (¤t_target
, ptid
);
3264 simple_verify_memory (struct target_ops
*ops
,
3265 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
3267 LONGEST total_xfered
= 0;
3269 while (total_xfered
< size
)
3271 ULONGEST xfered_len
;
3272 enum target_xfer_status status
;
3274 ULONGEST howmuch
= min (sizeof (buf
), size
- total_xfered
);
3276 status
= target_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
3277 buf
, NULL
, lma
+ total_xfered
, howmuch
,
3279 if (status
== TARGET_XFER_OK
3280 && memcmp (data
+ total_xfered
, buf
, xfered_len
) == 0)
3282 total_xfered
+= xfered_len
;
3291 /* Default implementation of memory verification. */
3294 default_verify_memory (struct target_ops
*self
,
3295 const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3297 /* Start over from the top of the target stack. */
3298 return simple_verify_memory (current_target
.beneath
,
3299 data
, memaddr
, size
);
3303 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3305 return current_target
.to_verify_memory (¤t_target
,
3306 data
, memaddr
, size
);
3309 /* The documentation for this function is in its prototype declaration in
3313 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3315 return current_target
.to_insert_mask_watchpoint (¤t_target
,
3319 /* The documentation for this function is in its prototype declaration in
3323 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3325 return current_target
.to_remove_mask_watchpoint (¤t_target
,
3329 /* The documentation for this function is in its prototype declaration
3333 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
3335 return current_target
.to_masked_watch_num_registers (¤t_target
,
3339 /* The documentation for this function is in its prototype declaration
3343 target_ranged_break_num_registers (void)
3345 return current_target
.to_ranged_break_num_registers (¤t_target
);
3350 struct btrace_target_info
*
3351 target_enable_btrace (ptid_t ptid
)
3353 return current_target
.to_enable_btrace (¤t_target
, ptid
);
3359 target_disable_btrace (struct btrace_target_info
*btinfo
)
3361 current_target
.to_disable_btrace (¤t_target
, btinfo
);
3367 target_teardown_btrace (struct btrace_target_info
*btinfo
)
3369 current_target
.to_teardown_btrace (¤t_target
, btinfo
);
3375 target_read_btrace (VEC (btrace_block_s
) **btrace
,
3376 struct btrace_target_info
*btinfo
,
3377 enum btrace_read_type type
)
3379 return current_target
.to_read_btrace (¤t_target
, btrace
, btinfo
, type
);
3385 target_stop_recording (void)
3387 current_target
.to_stop_recording (¤t_target
);
3393 target_save_record (const char *filename
)
3395 current_target
.to_save_record (¤t_target
, filename
);
3401 target_supports_delete_record (void)
3403 struct target_ops
*t
;
3405 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3406 if (t
->to_delete_record
!= delegate_delete_record
3407 && t
->to_delete_record
!= tdefault_delete_record
)
3416 target_delete_record (void)
3418 current_target
.to_delete_record (¤t_target
);
3424 target_record_is_replaying (void)
3426 return current_target
.to_record_is_replaying (¤t_target
);
3432 target_goto_record_begin (void)
3434 current_target
.to_goto_record_begin (¤t_target
);
3440 target_goto_record_end (void)
3442 current_target
.to_goto_record_end (¤t_target
);
3448 target_goto_record (ULONGEST insn
)
3450 current_target
.to_goto_record (¤t_target
, insn
);
3456 target_insn_history (int size
, int flags
)
3458 current_target
.to_insn_history (¤t_target
, size
, flags
);
3464 target_insn_history_from (ULONGEST from
, int size
, int flags
)
3466 current_target
.to_insn_history_from (¤t_target
, from
, size
, flags
);
3472 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
3474 current_target
.to_insn_history_range (¤t_target
, begin
, end
, flags
);
3480 target_call_history (int size
, int flags
)
3482 current_target
.to_call_history (¤t_target
, size
, flags
);
3488 target_call_history_from (ULONGEST begin
, int size
, int flags
)
3490 current_target
.to_call_history_from (¤t_target
, begin
, size
, flags
);
3496 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
3498 current_target
.to_call_history_range (¤t_target
, begin
, end
, flags
);
3503 const struct frame_unwind
*
3504 target_get_unwinder (void)
3506 return current_target
.to_get_unwinder (¤t_target
);
3511 const struct frame_unwind
*
3512 target_get_tailcall_unwinder (void)
3514 return current_target
.to_get_tailcall_unwinder (¤t_target
);
3517 /* Default implementation of to_decr_pc_after_break. */
3520 default_target_decr_pc_after_break (struct target_ops
*ops
,
3521 struct gdbarch
*gdbarch
)
3523 return gdbarch_decr_pc_after_break (gdbarch
);
3529 target_decr_pc_after_break (struct gdbarch
*gdbarch
)
3531 return current_target
.to_decr_pc_after_break (¤t_target
, gdbarch
);
3537 target_prepare_to_generate_core (void)
3539 current_target
.to_prepare_to_generate_core (¤t_target
);
3545 target_done_generating_core (void)
3547 current_target
.to_done_generating_core (¤t_target
);
3551 setup_target_debug (void)
3553 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3555 init_debug_target (¤t_target
);
3559 static char targ_desc
[] =
3560 "Names of targets and files being debugged.\nShows the entire \
3561 stack of targets currently in use (including the exec-file,\n\
3562 core-file, and process, if any), as well as the symbol file name.";
3565 default_rcmd (struct target_ops
*self
, const char *command
,
3566 struct ui_file
*output
)
3568 error (_("\"monitor\" command not supported by this target."));
3572 do_monitor_command (char *cmd
,
3575 target_rcmd (cmd
, gdb_stdtarg
);
3578 /* Print the name of each layers of our target stack. */
3581 maintenance_print_target_stack (char *cmd
, int from_tty
)
3583 struct target_ops
*t
;
3585 printf_filtered (_("The current target stack is:\n"));
3587 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3589 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3593 /* Controls if targets can report that they can/are async. This is
3594 just for maintainers to use when debugging gdb. */
3595 int target_async_permitted
= 1;
3597 /* The set command writes to this variable. If the inferior is
3598 executing, target_async_permitted is *not* updated. */
3599 static int target_async_permitted_1
= 1;
3602 maint_set_target_async_command (char *args
, int from_tty
,
3603 struct cmd_list_element
*c
)
3605 if (have_live_inferiors ())
3607 target_async_permitted_1
= target_async_permitted
;
3608 error (_("Cannot change this setting while the inferior is running."));
3611 target_async_permitted
= target_async_permitted_1
;
3615 maint_show_target_async_command (struct ui_file
*file
, int from_tty
,
3616 struct cmd_list_element
*c
,
3619 fprintf_filtered (file
,
3620 _("Controlling the inferior in "
3621 "asynchronous mode is %s.\n"), value
);
3624 /* Temporary copies of permission settings. */
3626 static int may_write_registers_1
= 1;
3627 static int may_write_memory_1
= 1;
3628 static int may_insert_breakpoints_1
= 1;
3629 static int may_insert_tracepoints_1
= 1;
3630 static int may_insert_fast_tracepoints_1
= 1;
3631 static int may_stop_1
= 1;
3633 /* Make the user-set values match the real values again. */
3636 update_target_permissions (void)
3638 may_write_registers_1
= may_write_registers
;
3639 may_write_memory_1
= may_write_memory
;
3640 may_insert_breakpoints_1
= may_insert_breakpoints
;
3641 may_insert_tracepoints_1
= may_insert_tracepoints
;
3642 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
3643 may_stop_1
= may_stop
;
3646 /* The one function handles (most of) the permission flags in the same
3650 set_target_permissions (char *args
, int from_tty
,
3651 struct cmd_list_element
*c
)
3653 if (target_has_execution
)
3655 update_target_permissions ();
3656 error (_("Cannot change this setting while the inferior is running."));
3659 /* Make the real values match the user-changed values. */
3660 may_write_registers
= may_write_registers_1
;
3661 may_insert_breakpoints
= may_insert_breakpoints_1
;
3662 may_insert_tracepoints
= may_insert_tracepoints_1
;
3663 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
3664 may_stop
= may_stop_1
;
3665 update_observer_mode ();
3668 /* Set memory write permission independently of observer mode. */
3671 set_write_memory_permission (char *args
, int from_tty
,
3672 struct cmd_list_element
*c
)
3674 /* Make the real values match the user-changed values. */
3675 may_write_memory
= may_write_memory_1
;
3676 update_observer_mode ();
3681 initialize_targets (void)
3683 init_dummy_target ();
3684 push_target (&dummy_target
);
3686 add_info ("target", target_info
, targ_desc
);
3687 add_info ("files", target_info
, targ_desc
);
3689 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3690 Set target debugging."), _("\
3691 Show target debugging."), _("\
3692 When non-zero, target debugging is enabled. Higher numbers are more\n\
3696 &setdebuglist
, &showdebuglist
);
3698 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3699 &trust_readonly
, _("\
3700 Set mode for reading from readonly sections."), _("\
3701 Show mode for reading from readonly sections."), _("\
3702 When this mode is on, memory reads from readonly sections (such as .text)\n\
3703 will be read from the object file instead of from the target. This will\n\
3704 result in significant performance improvement for remote targets."),
3706 show_trust_readonly
,
3707 &setlist
, &showlist
);
3709 add_com ("monitor", class_obscure
, do_monitor_command
,
3710 _("Send a command to the remote monitor (remote targets only)."));
3712 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3713 _("Print the name of each layer of the internal target stack."),
3714 &maintenanceprintlist
);
3716 add_setshow_boolean_cmd ("target-async", no_class
,
3717 &target_async_permitted_1
, _("\
3718 Set whether gdb controls the inferior in asynchronous mode."), _("\
3719 Show whether gdb controls the inferior in asynchronous mode."), _("\
3720 Tells gdb whether to control the inferior in asynchronous mode."),
3721 maint_set_target_async_command
,
3722 maint_show_target_async_command
,
3723 &maintenance_set_cmdlist
,
3724 &maintenance_show_cmdlist
);
3726 add_setshow_boolean_cmd ("may-write-registers", class_support
,
3727 &may_write_registers_1
, _("\
3728 Set permission to write into registers."), _("\
3729 Show permission to write into registers."), _("\
3730 When this permission is on, GDB may write into the target's registers.\n\
3731 Otherwise, any sort of write attempt will result in an error."),
3732 set_target_permissions
, NULL
,
3733 &setlist
, &showlist
);
3735 add_setshow_boolean_cmd ("may-write-memory", class_support
,
3736 &may_write_memory_1
, _("\
3737 Set permission to write into target memory."), _("\
3738 Show permission to write into target memory."), _("\
3739 When this permission is on, GDB may write into the target's memory.\n\
3740 Otherwise, any sort of write attempt will result in an error."),
3741 set_write_memory_permission
, NULL
,
3742 &setlist
, &showlist
);
3744 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
3745 &may_insert_breakpoints_1
, _("\
3746 Set permission to insert breakpoints in the target."), _("\
3747 Show permission to insert breakpoints in the target."), _("\
3748 When this permission is on, GDB may insert breakpoints in the program.\n\
3749 Otherwise, any sort of insertion attempt will result in an error."),
3750 set_target_permissions
, NULL
,
3751 &setlist
, &showlist
);
3753 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
3754 &may_insert_tracepoints_1
, _("\
3755 Set permission to insert tracepoints in the target."), _("\
3756 Show permission to insert tracepoints in the target."), _("\
3757 When this permission is on, GDB may insert tracepoints in the program.\n\
3758 Otherwise, any sort of insertion attempt will result in an error."),
3759 set_target_permissions
, NULL
,
3760 &setlist
, &showlist
);
3762 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
3763 &may_insert_fast_tracepoints_1
, _("\
3764 Set permission to insert fast tracepoints in the target."), _("\
3765 Show permission to insert fast tracepoints in the target."), _("\
3766 When this permission is on, GDB may insert fast tracepoints.\n\
3767 Otherwise, any sort of insertion attempt will result in an error."),
3768 set_target_permissions
, NULL
,
3769 &setlist
, &showlist
);
3771 add_setshow_boolean_cmd ("may-interrupt", class_support
,
3773 Set permission to interrupt or signal the target."), _("\
3774 Show permission to interrupt or signal the target."), _("\
3775 When this permission is on, GDB may interrupt/stop the target's execution.\n\
3776 Otherwise, any attempt to interrupt or stop will be ignored."),
3777 set_target_permissions
, NULL
,
3778 &setlist
, &showlist
);
3780 add_setshow_boolean_cmd ("auto-connect-native-target", class_support
,
3781 &auto_connect_native_target
, _("\
3782 Set whether GDB may automatically connect to the native target."), _("\
3783 Show whether GDB may automatically connect to the native target."), _("\
3784 When on, and GDB is not connected to a target yet, GDB\n\
3785 attempts \"run\" and other commands with the native target."),
3786 NULL
, show_auto_connect_native_target
,
3787 &setlist
, &showlist
);