1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "target-dcache.h"
36 #include "gdb_assert.h"
38 #include "exceptions.h"
39 #include "target-descriptions.h"
40 #include "gdbthread.h"
43 #include "inline-frame.h"
44 #include "tracepoint.h"
45 #include "gdb/fileio.h"
49 static void target_info (char *, int);
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
*, 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 void tcomplain (void) ATTRIBUTE_NORETURN
;
78 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
80 static int return_zero (void);
82 void target_ignore (void);
84 static void target_command (char *, int);
86 static struct target_ops
*find_default_run_target (char *);
88 static target_xfer_partial_ftype default_xfer_partial
;
90 static struct gdbarch
*default_thread_architecture (struct target_ops
*ops
,
93 static int dummy_find_memory_regions (struct target_ops
*self
,
94 find_memory_region_ftype ignore1
,
97 static char *dummy_make_corefile_notes (struct target_ops
*self
,
98 bfd
*ignore1
, int *ignore2
);
100 static char *default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
);
102 static int find_default_can_async_p (struct target_ops
*ignore
);
104 static int find_default_is_async_p (struct target_ops
*ignore
);
106 static enum exec_direction_kind default_execution_direction
107 (struct target_ops
*self
);
109 #include "target-delegates.c"
111 static void init_dummy_target (void);
113 static struct target_ops debug_target
;
115 static void debug_to_open (char *, int);
117 static void debug_to_prepare_to_store (struct target_ops
*self
,
120 static void debug_to_files_info (struct target_ops
*);
122 static int debug_to_insert_breakpoint (struct target_ops
*, struct gdbarch
*,
123 struct bp_target_info
*);
125 static int debug_to_remove_breakpoint (struct target_ops
*, struct gdbarch
*,
126 struct bp_target_info
*);
128 static int debug_to_can_use_hw_breakpoint (struct target_ops
*self
,
131 static int debug_to_insert_hw_breakpoint (struct target_ops
*self
,
133 struct bp_target_info
*);
135 static int debug_to_remove_hw_breakpoint (struct target_ops
*self
,
137 struct bp_target_info
*);
139 static int debug_to_insert_watchpoint (struct target_ops
*self
,
141 struct expression
*);
143 static int debug_to_remove_watchpoint (struct target_ops
*self
,
145 struct expression
*);
147 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
149 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
150 CORE_ADDR
, CORE_ADDR
, int);
152 static int debug_to_region_ok_for_hw_watchpoint (struct target_ops
*self
,
155 static int debug_to_can_accel_watchpoint_condition (struct target_ops
*self
,
157 struct expression
*);
159 static void debug_to_terminal_init (struct target_ops
*self
);
161 static void debug_to_terminal_inferior (struct target_ops
*self
);
163 static void debug_to_terminal_ours_for_output (struct target_ops
*self
);
165 static void debug_to_terminal_save_ours (struct target_ops
*self
);
167 static void debug_to_terminal_ours (struct target_ops
*self
);
169 static void debug_to_load (struct target_ops
*self
, char *, int);
171 static int debug_to_can_run (struct target_ops
*self
);
173 static void debug_to_stop (struct target_ops
*self
, ptid_t
);
175 /* Pointer to array of target architecture structures; the size of the
176 array; the current index into the array; the allocated size of the
178 struct target_ops
**target_structs
;
179 unsigned target_struct_size
;
180 unsigned target_struct_allocsize
;
181 #define DEFAULT_ALLOCSIZE 10
183 /* The initial current target, so that there is always a semi-valid
186 static struct target_ops dummy_target
;
188 /* Top of target stack. */
190 static struct target_ops
*target_stack
;
192 /* The target structure we are currently using to talk to a process
193 or file or whatever "inferior" we have. */
195 struct target_ops current_target
;
197 /* Command list for target. */
199 static struct cmd_list_element
*targetlist
= NULL
;
201 /* Nonzero if we should trust readonly sections from the
202 executable when reading memory. */
204 static int trust_readonly
= 0;
206 /* Nonzero if we should show true memory content including
207 memory breakpoint inserted by gdb. */
209 static int show_memory_breakpoints
= 0;
211 /* These globals control whether GDB attempts to perform these
212 operations; they are useful for targets that need to prevent
213 inadvertant disruption, such as in non-stop mode. */
215 int may_write_registers
= 1;
217 int may_write_memory
= 1;
219 int may_insert_breakpoints
= 1;
221 int may_insert_tracepoints
= 1;
223 int may_insert_fast_tracepoints
= 1;
227 /* Non-zero if we want to see trace of target level stuff. */
229 static unsigned int targetdebug
= 0;
231 show_targetdebug (struct ui_file
*file
, int from_tty
,
232 struct cmd_list_element
*c
, const char *value
)
234 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
237 static void setup_target_debug (void);
239 /* The user just typed 'target' without the name of a target. */
242 target_command (char *arg
, int from_tty
)
244 fputs_filtered ("Argument required (target name). Try `help target'\n",
248 /* Default target_has_* methods for process_stratum targets. */
251 default_child_has_all_memory (struct target_ops
*ops
)
253 /* If no inferior selected, then we can't read memory here. */
254 if (ptid_equal (inferior_ptid
, null_ptid
))
261 default_child_has_memory (struct target_ops
*ops
)
263 /* If no inferior selected, then we can't read memory here. */
264 if (ptid_equal (inferior_ptid
, null_ptid
))
271 default_child_has_stack (struct target_ops
*ops
)
273 /* If no inferior selected, there's no stack. */
274 if (ptid_equal (inferior_ptid
, null_ptid
))
281 default_child_has_registers (struct target_ops
*ops
)
283 /* Can't read registers from no inferior. */
284 if (ptid_equal (inferior_ptid
, null_ptid
))
291 default_child_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
293 /* If there's no thread selected, then we can't make it run through
295 if (ptid_equal (the_ptid
, null_ptid
))
303 target_has_all_memory_1 (void)
305 struct target_ops
*t
;
307 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
308 if (t
->to_has_all_memory (t
))
315 target_has_memory_1 (void)
317 struct target_ops
*t
;
319 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
320 if (t
->to_has_memory (t
))
327 target_has_stack_1 (void)
329 struct target_ops
*t
;
331 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
332 if (t
->to_has_stack (t
))
339 target_has_registers_1 (void)
341 struct target_ops
*t
;
343 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
344 if (t
->to_has_registers (t
))
351 target_has_execution_1 (ptid_t the_ptid
)
353 struct target_ops
*t
;
355 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
356 if (t
->to_has_execution (t
, the_ptid
))
363 target_has_execution_current (void)
365 return target_has_execution_1 (inferior_ptid
);
368 /* Complete initialization of T. This ensures that various fields in
369 T are set, if needed by the target implementation. */
372 complete_target_initialization (struct target_ops
*t
)
374 /* Provide default values for all "must have" methods. */
375 if (t
->to_xfer_partial
== NULL
)
376 t
->to_xfer_partial
= default_xfer_partial
;
378 if (t
->to_has_all_memory
== NULL
)
379 t
->to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
381 if (t
->to_has_memory
== NULL
)
382 t
->to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
384 if (t
->to_has_stack
== NULL
)
385 t
->to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
387 if (t
->to_has_registers
== NULL
)
388 t
->to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
390 if (t
->to_has_execution
== NULL
)
391 t
->to_has_execution
= (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
393 install_delegators (t
);
396 /* Add possible target architecture T to the list and add a new
397 command 'target T->to_shortname'. Set COMPLETER as the command's
398 completer if not NULL. */
401 add_target_with_completer (struct target_ops
*t
,
402 completer_ftype
*completer
)
404 struct cmd_list_element
*c
;
406 complete_target_initialization (t
);
410 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
411 target_structs
= (struct target_ops
**) xmalloc
412 (target_struct_allocsize
* sizeof (*target_structs
));
414 if (target_struct_size
>= target_struct_allocsize
)
416 target_struct_allocsize
*= 2;
417 target_structs
= (struct target_ops
**)
418 xrealloc ((char *) target_structs
,
419 target_struct_allocsize
* sizeof (*target_structs
));
421 target_structs
[target_struct_size
++] = t
;
423 if (targetlist
== NULL
)
424 add_prefix_cmd ("target", class_run
, target_command
, _("\
425 Connect to a target machine or process.\n\
426 The first argument is the type or protocol of the target machine.\n\
427 Remaining arguments are interpreted by the target protocol. For more\n\
428 information on the arguments for a particular protocol, type\n\
429 `help target ' followed by the protocol name."),
430 &targetlist
, "target ", 0, &cmdlist
);
431 c
= add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
,
433 if (completer
!= NULL
)
434 set_cmd_completer (c
, completer
);
437 /* Add a possible target architecture to the list. */
440 add_target (struct target_ops
*t
)
442 add_target_with_completer (t
, NULL
);
448 add_deprecated_target_alias (struct target_ops
*t
, char *alias
)
450 struct cmd_list_element
*c
;
453 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
455 c
= add_cmd (alias
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
456 alt
= xstrprintf ("target %s", t
->to_shortname
);
457 deprecate_cmd (c
, alt
);
471 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
473 current_target
.to_kill (¤t_target
);
477 target_load (char *arg
, int from_tty
)
479 target_dcache_invalidate ();
480 (*current_target
.to_load
) (¤t_target
, arg
, from_tty
);
484 target_create_inferior (char *exec_file
, char *args
,
485 char **env
, int from_tty
)
487 struct target_ops
*t
;
489 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
491 if (t
->to_create_inferior
!= NULL
)
493 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
495 fprintf_unfiltered (gdb_stdlog
,
496 "target_create_inferior (%s, %s, xxx, %d)\n",
497 exec_file
, args
, from_tty
);
502 internal_error (__FILE__
, __LINE__
,
503 _("could not find a target to create inferior"));
507 target_terminal_inferior (void)
509 /* A background resume (``run&'') should leave GDB in control of the
510 terminal. Use target_can_async_p, not target_is_async_p, since at
511 this point the target is not async yet. However, if sync_execution
512 is not set, we know it will become async prior to resume. */
513 if (target_can_async_p () && !sync_execution
)
516 /* If GDB is resuming the inferior in the foreground, install
517 inferior's terminal modes. */
518 (*current_target
.to_terminal_inferior
) (¤t_target
);
522 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
523 struct target_ops
*t
)
525 errno
= EIO
; /* Can't read/write this location. */
526 return 0; /* No bytes handled. */
532 error (_("You can't do that when your target is `%s'"),
533 current_target
.to_shortname
);
539 error (_("You can't do that without a process to debug."));
543 default_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
545 printf_unfiltered (_("No saved terminal information.\n"));
548 /* A default implementation for the to_get_ada_task_ptid target method.
550 This function builds the PTID by using both LWP and TID as part of
551 the PTID lwp and tid elements. The pid used is the pid of the
555 default_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long tid
)
557 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
560 static enum exec_direction_kind
561 default_execution_direction (struct target_ops
*self
)
563 if (!target_can_execute_reverse
)
565 else if (!target_can_async_p ())
568 gdb_assert_not_reached ("\
569 to_execution_direction must be implemented for reverse async");
572 /* Go through the target stack from top to bottom, copying over zero
573 entries in current_target, then filling in still empty entries. In
574 effect, we are doing class inheritance through the pushed target
577 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
578 is currently implemented, is that it discards any knowledge of
579 which target an inherited method originally belonged to.
580 Consequently, new new target methods should instead explicitly and
581 locally search the target stack for the target that can handle the
585 update_current_target (void)
587 struct target_ops
*t
;
589 /* First, reset current's contents. */
590 memset (¤t_target
, 0, sizeof (current_target
));
592 /* Install the delegators. */
593 install_delegators (¤t_target
);
595 current_target
.to_stratum
= target_stack
->to_stratum
;
597 #define INHERIT(FIELD, TARGET) \
598 if (!current_target.FIELD) \
599 current_target.FIELD = (TARGET)->FIELD
601 /* Do not add any new INHERITs here. Instead, use the delegation
602 mechanism provided by make-target-delegates. */
603 for (t
= target_stack
; t
; t
= t
->beneath
)
605 INHERIT (to_shortname
, t
);
606 INHERIT (to_longname
, t
);
608 INHERIT (to_attach_no_wait
, t
);
609 INHERIT (deprecated_xfer_memory
, t
);
610 INHERIT (to_have_steppable_watchpoint
, t
);
611 INHERIT (to_have_continuable_watchpoint
, t
);
612 INHERIT (to_has_thread_control
, t
);
613 INHERIT (to_magic
, t
);
617 /* Clean up a target struct so it no longer has any zero pointers in
618 it. Do not add any new de_faults here. Instead, use the
619 delegation mechanism provided by make-target-delegates. */
621 #define de_fault(field, value) \
622 if (!current_target.field) \
623 current_target.field = value
626 (void (*) (char *, int))
629 (void (*) (struct target_ops
*))
631 de_fault (deprecated_xfer_memory
,
632 (int (*) (CORE_ADDR
, gdb_byte
*, int, int,
633 struct mem_attrib
*, struct target_ops
*))
638 /* Finally, position the target-stack beneath the squashed
639 "current_target". That way code looking for a non-inherited
640 target method can quickly and simply find it. */
641 current_target
.beneath
= target_stack
;
644 setup_target_debug ();
647 /* Push a new target type into the stack of the existing target accessors,
648 possibly superseding some of the existing accessors.
650 Rather than allow an empty stack, we always have the dummy target at
651 the bottom stratum, so we can call the function vectors without
655 push_target (struct target_ops
*t
)
657 struct target_ops
**cur
;
659 /* Check magic number. If wrong, it probably means someone changed
660 the struct definition, but not all the places that initialize one. */
661 if (t
->to_magic
!= OPS_MAGIC
)
663 fprintf_unfiltered (gdb_stderr
,
664 "Magic number of %s target struct wrong\n",
666 internal_error (__FILE__
, __LINE__
,
667 _("failed internal consistency check"));
670 /* Find the proper stratum to install this target in. */
671 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
673 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
677 /* If there's already targets at this stratum, remove them. */
678 /* FIXME: cagney/2003-10-15: I think this should be popping all
679 targets to CUR, and not just those at this stratum level. */
680 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
682 /* There's already something at this stratum level. Close it,
683 and un-hook it from the stack. */
684 struct target_ops
*tmp
= (*cur
);
686 (*cur
) = (*cur
)->beneath
;
691 /* We have removed all targets in our stratum, now add the new one. */
695 update_current_target ();
698 /* Remove a target_ops vector from the stack, wherever it may be.
699 Return how many times it was removed (0 or 1). */
702 unpush_target (struct target_ops
*t
)
704 struct target_ops
**cur
;
705 struct target_ops
*tmp
;
707 if (t
->to_stratum
== dummy_stratum
)
708 internal_error (__FILE__
, __LINE__
,
709 _("Attempt to unpush the dummy target"));
711 /* Look for the specified target. Note that we assume that a target
712 can only occur once in the target stack. */
714 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
720 /* If we don't find target_ops, quit. Only open targets should be
725 /* Unchain the target. */
727 (*cur
) = (*cur
)->beneath
;
730 update_current_target ();
732 /* Finally close the target. Note we do this after unchaining, so
733 any target method calls from within the target_close
734 implementation don't end up in T anymore. */
741 pop_all_targets_above (enum strata above_stratum
)
743 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
745 if (!unpush_target (target_stack
))
747 fprintf_unfiltered (gdb_stderr
,
748 "pop_all_targets couldn't find target %s\n",
749 target_stack
->to_shortname
);
750 internal_error (__FILE__
, __LINE__
,
751 _("failed internal consistency check"));
758 pop_all_targets (void)
760 pop_all_targets_above (dummy_stratum
);
763 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
766 target_is_pushed (struct target_ops
*t
)
768 struct target_ops
**cur
;
770 /* Check magic number. If wrong, it probably means someone changed
771 the struct definition, but not all the places that initialize one. */
772 if (t
->to_magic
!= OPS_MAGIC
)
774 fprintf_unfiltered (gdb_stderr
,
775 "Magic number of %s target struct wrong\n",
777 internal_error (__FILE__
, __LINE__
,
778 _("failed internal consistency check"));
781 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
788 /* Using the objfile specified in OBJFILE, find the address for the
789 current thread's thread-local storage with offset OFFSET. */
791 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
793 volatile CORE_ADDR addr
= 0;
794 struct target_ops
*target
;
796 for (target
= current_target
.beneath
;
798 target
= target
->beneath
)
800 if (target
->to_get_thread_local_address
!= NULL
)
805 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
807 ptid_t ptid
= inferior_ptid
;
808 volatile struct gdb_exception ex
;
810 TRY_CATCH (ex
, RETURN_MASK_ALL
)
814 /* Fetch the load module address for this objfile. */
815 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch (),
817 /* If it's 0, throw the appropriate exception. */
819 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
820 _("TLS load module not found"));
822 addr
= target
->to_get_thread_local_address (target
, ptid
,
825 /* If an error occurred, print TLS related messages here. Otherwise,
826 throw the error to some higher catcher. */
829 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
833 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
834 error (_("Cannot find thread-local variables "
835 "in this thread library."));
837 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
838 if (objfile_is_library
)
839 error (_("Cannot find shared library `%s' in dynamic"
840 " linker's load module list"), objfile_name (objfile
));
842 error (_("Cannot find executable file `%s' in dynamic"
843 " linker's load module list"), objfile_name (objfile
));
845 case TLS_NOT_ALLOCATED_YET_ERROR
:
846 if (objfile_is_library
)
847 error (_("The inferior has not yet allocated storage for"
848 " thread-local variables in\n"
849 "the shared library `%s'\n"
851 objfile_name (objfile
), target_pid_to_str (ptid
));
853 error (_("The inferior has not yet allocated storage for"
854 " thread-local variables in\n"
855 "the executable `%s'\n"
857 objfile_name (objfile
), target_pid_to_str (ptid
));
859 case TLS_GENERIC_ERROR
:
860 if (objfile_is_library
)
861 error (_("Cannot find thread-local storage for %s, "
862 "shared library %s:\n%s"),
863 target_pid_to_str (ptid
),
864 objfile_name (objfile
), ex
.message
);
866 error (_("Cannot find thread-local storage for %s, "
867 "executable file %s:\n%s"),
868 target_pid_to_str (ptid
),
869 objfile_name (objfile
), ex
.message
);
872 throw_exception (ex
);
877 /* It wouldn't be wrong here to try a gdbarch method, too; finding
878 TLS is an ABI-specific thing. But we don't do that yet. */
880 error (_("Cannot find thread-local variables on this target"));
886 target_xfer_status_to_string (enum target_xfer_status err
)
888 #define CASE(X) case X: return #X
891 CASE(TARGET_XFER_E_IO
);
892 CASE(TARGET_XFER_E_UNAVAILABLE
);
901 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
903 /* target_read_string -- read a null terminated string, up to LEN bytes,
904 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
905 Set *STRING to a pointer to malloc'd memory containing the data; the caller
906 is responsible for freeing it. Return the number of bytes successfully
910 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
916 int buffer_allocated
;
918 unsigned int nbytes_read
= 0;
922 /* Small for testing. */
923 buffer_allocated
= 4;
924 buffer
= xmalloc (buffer_allocated
);
929 tlen
= MIN (len
, 4 - (memaddr
& 3));
930 offset
= memaddr
& 3;
932 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
935 /* The transfer request might have crossed the boundary to an
936 unallocated region of memory. Retry the transfer, requesting
940 errcode
= target_read_memory (memaddr
, buf
, 1);
945 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
949 bytes
= bufptr
- buffer
;
950 buffer_allocated
*= 2;
951 buffer
= xrealloc (buffer
, buffer_allocated
);
952 bufptr
= buffer
+ bytes
;
955 for (i
= 0; i
< tlen
; i
++)
957 *bufptr
++ = buf
[i
+ offset
];
958 if (buf
[i
+ offset
] == '\000')
960 nbytes_read
+= i
+ 1;
976 struct target_section_table
*
977 target_get_section_table (struct target_ops
*target
)
980 fprintf_unfiltered (gdb_stdlog
, "target_get_section_table ()\n");
982 return (*target
->to_get_section_table
) (target
);
985 /* Find a section containing ADDR. */
987 struct target_section
*
988 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
990 struct target_section_table
*table
= target_get_section_table (target
);
991 struct target_section
*secp
;
996 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
998 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1004 /* Read memory from the live target, even if currently inspecting a
1005 traceframe. The return is the same as that of target_read. */
1007 static enum target_xfer_status
1008 target_read_live_memory (enum target_object object
,
1009 ULONGEST memaddr
, gdb_byte
*myaddr
, ULONGEST len
,
1010 ULONGEST
*xfered_len
)
1012 enum target_xfer_status ret
;
1013 struct cleanup
*cleanup
;
1015 /* Switch momentarily out of tfind mode so to access live memory.
1016 Note that this must not clear global state, such as the frame
1017 cache, which must still remain valid for the previous traceframe.
1018 We may be _building_ the frame cache at this point. */
1019 cleanup
= make_cleanup_restore_traceframe_number ();
1020 set_traceframe_number (-1);
1022 ret
= target_xfer_partial (current_target
.beneath
, object
, NULL
,
1023 myaddr
, NULL
, memaddr
, len
, xfered_len
);
1025 do_cleanups (cleanup
);
1029 /* Using the set of read-only target sections of OPS, read live
1030 read-only memory. Note that the actual reads start from the
1031 top-most target again.
1033 For interface/parameters/return description see target.h,
1036 static enum target_xfer_status
1037 memory_xfer_live_readonly_partial (struct target_ops
*ops
,
1038 enum target_object object
,
1039 gdb_byte
*readbuf
, ULONGEST memaddr
,
1040 ULONGEST len
, ULONGEST
*xfered_len
)
1042 struct target_section
*secp
;
1043 struct target_section_table
*table
;
1045 secp
= target_section_by_addr (ops
, memaddr
);
1047 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1048 secp
->the_bfd_section
)
1051 struct target_section
*p
;
1052 ULONGEST memend
= memaddr
+ len
;
1054 table
= target_get_section_table (ops
);
1056 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1058 if (memaddr
>= p
->addr
)
1060 if (memend
<= p
->endaddr
)
1062 /* Entire transfer is within this section. */
1063 return target_read_live_memory (object
, memaddr
,
1064 readbuf
, len
, xfered_len
);
1066 else if (memaddr
>= p
->endaddr
)
1068 /* This section ends before the transfer starts. */
1073 /* This section overlaps the transfer. Just do half. */
1074 len
= p
->endaddr
- memaddr
;
1075 return target_read_live_memory (object
, memaddr
,
1076 readbuf
, len
, xfered_len
);
1082 return TARGET_XFER_EOF
;
1085 /* Read memory from more than one valid target. A core file, for
1086 instance, could have some of memory but delegate other bits to
1087 the target below it. So, we must manually try all targets. */
1089 static enum target_xfer_status
1090 raw_memory_xfer_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
1091 const gdb_byte
*writebuf
, ULONGEST memaddr
, LONGEST len
,
1092 ULONGEST
*xfered_len
)
1094 enum target_xfer_status res
;
1098 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1099 readbuf
, writebuf
, memaddr
, len
,
1101 if (res
== TARGET_XFER_OK
)
1104 /* Stop if the target reports that the memory is not available. */
1105 if (res
== TARGET_XFER_E_UNAVAILABLE
)
1108 /* We want to continue past core files to executables, but not
1109 past a running target's memory. */
1110 if (ops
->to_has_all_memory (ops
))
1115 while (ops
!= NULL
);
1120 /* Perform a partial memory transfer.
1121 For docs see target.h, to_xfer_partial. */
1123 static enum target_xfer_status
1124 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
1125 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
1126 ULONGEST len
, ULONGEST
*xfered_len
)
1128 enum target_xfer_status res
;
1130 struct mem_region
*region
;
1131 struct inferior
*inf
;
1133 /* For accesses to unmapped overlay sections, read directly from
1134 files. Must do this first, as MEMADDR may need adjustment. */
1135 if (readbuf
!= NULL
&& overlay_debugging
)
1137 struct obj_section
*section
= find_pc_overlay (memaddr
);
1139 if (pc_in_unmapped_range (memaddr
, section
))
1141 struct target_section_table
*table
1142 = target_get_section_table (ops
);
1143 const char *section_name
= section
->the_bfd_section
->name
;
1145 memaddr
= overlay_mapped_address (memaddr
, section
);
1146 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1147 memaddr
, len
, xfered_len
,
1149 table
->sections_end
,
1154 /* Try the executable files, if "trust-readonly-sections" is set. */
1155 if (readbuf
!= NULL
&& trust_readonly
)
1157 struct target_section
*secp
;
1158 struct target_section_table
*table
;
1160 secp
= target_section_by_addr (ops
, memaddr
);
1162 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1163 secp
->the_bfd_section
)
1166 table
= target_get_section_table (ops
);
1167 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1168 memaddr
, len
, xfered_len
,
1170 table
->sections_end
,
1175 /* If reading unavailable memory in the context of traceframes, and
1176 this address falls within a read-only section, fallback to
1177 reading from live memory. */
1178 if (readbuf
!= NULL
&& get_traceframe_number () != -1)
1180 VEC(mem_range_s
) *available
;
1182 /* If we fail to get the set of available memory, then the
1183 target does not support querying traceframe info, and so we
1184 attempt reading from the traceframe anyway (assuming the
1185 target implements the old QTro packet then). */
1186 if (traceframe_available_memory (&available
, memaddr
, len
))
1188 struct cleanup
*old_chain
;
1190 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
1192 if (VEC_empty (mem_range_s
, available
)
1193 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
1195 /* Don't read into the traceframe's available
1197 if (!VEC_empty (mem_range_s
, available
))
1199 LONGEST oldlen
= len
;
1201 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
1202 gdb_assert (len
<= oldlen
);
1205 do_cleanups (old_chain
);
1207 /* This goes through the topmost target again. */
1208 res
= memory_xfer_live_readonly_partial (ops
, object
,
1211 if (res
== TARGET_XFER_OK
)
1212 return TARGET_XFER_OK
;
1215 /* No use trying further, we know some memory starting
1216 at MEMADDR isn't available. */
1218 return TARGET_XFER_E_UNAVAILABLE
;
1222 /* Don't try to read more than how much is available, in
1223 case the target implements the deprecated QTro packet to
1224 cater for older GDBs (the target's knowledge of read-only
1225 sections may be outdated by now). */
1226 len
= VEC_index (mem_range_s
, available
, 0)->length
;
1228 do_cleanups (old_chain
);
1232 /* Try GDB's internal data cache. */
1233 region
= lookup_mem_region (memaddr
);
1234 /* region->hi == 0 means there's no upper bound. */
1235 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1238 reg_len
= region
->hi
- memaddr
;
1240 switch (region
->attrib
.mode
)
1243 if (writebuf
!= NULL
)
1244 return TARGET_XFER_E_IO
;
1248 if (readbuf
!= NULL
)
1249 return TARGET_XFER_E_IO
;
1253 /* We only support writing to flash during "load" for now. */
1254 if (writebuf
!= NULL
)
1255 error (_("Writing to flash memory forbidden in this context"));
1259 return TARGET_XFER_E_IO
;
1262 if (!ptid_equal (inferior_ptid
, null_ptid
))
1263 inf
= find_inferior_pid (ptid_get_pid (inferior_ptid
));
1268 /* The dcache reads whole cache lines; that doesn't play well
1269 with reading from a trace buffer, because reading outside of
1270 the collected memory range fails. */
1271 && get_traceframe_number () == -1
1272 && (region
->attrib
.cache
1273 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1274 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1276 DCACHE
*dcache
= target_dcache_get_or_init ();
1279 if (readbuf
!= NULL
)
1280 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, readbuf
, reg_len
, 0);
1282 /* FIXME drow/2006-08-09: If we're going to preserve const
1283 correctness dcache_xfer_memory should take readbuf and
1285 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, (void *) writebuf
,
1288 return TARGET_XFER_E_IO
;
1291 *xfered_len
= (ULONGEST
) l
;
1292 return TARGET_XFER_OK
;
1296 /* If none of those methods found the memory we wanted, fall back
1297 to a target partial transfer. Normally a single call to
1298 to_xfer_partial is enough; if it doesn't recognize an object
1299 it will call the to_xfer_partial of the next target down.
1300 But for memory this won't do. Memory is the only target
1301 object which can be read from more than one valid target.
1302 A core file, for instance, could have some of memory but
1303 delegate other bits to the target below it. So, we must
1304 manually try all targets. */
1306 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
,
1309 /* Make sure the cache gets updated no matter what - if we are writing
1310 to the stack. Even if this write is not tagged as such, we still need
1311 to update the cache. */
1313 if (res
== TARGET_XFER_OK
1316 && target_dcache_init_p ()
1317 && !region
->attrib
.cache
1318 && ((stack_cache_enabled_p () && object
!= TARGET_OBJECT_STACK_MEMORY
)
1319 || (code_cache_enabled_p () && object
!= TARGET_OBJECT_CODE_MEMORY
)))
1321 DCACHE
*dcache
= target_dcache_get ();
1323 dcache_update (dcache
, memaddr
, (void *) writebuf
, reg_len
);
1326 /* If we still haven't got anything, return the last error. We
1331 /* Perform a partial memory transfer. For docs see target.h,
1334 static enum target_xfer_status
1335 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1336 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1337 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1339 enum target_xfer_status res
;
1341 /* Zero length requests are ok and require no work. */
1343 return TARGET_XFER_EOF
;
1345 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1346 breakpoint insns, thus hiding out from higher layers whether
1347 there are software breakpoints inserted in the code stream. */
1348 if (readbuf
!= NULL
)
1350 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
,
1353 if (res
== TARGET_XFER_OK
&& !show_memory_breakpoints
)
1354 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, res
);
1359 struct cleanup
*old_chain
;
1361 /* A large write request is likely to be partially satisfied
1362 by memory_xfer_partial_1. We will continually malloc
1363 and free a copy of the entire write request for breakpoint
1364 shadow handling even though we only end up writing a small
1365 subset of it. Cap writes to 4KB to mitigate this. */
1366 len
= min (4096, len
);
1368 buf
= xmalloc (len
);
1369 old_chain
= make_cleanup (xfree
, buf
);
1370 memcpy (buf
, writebuf
, len
);
1372 breakpoint_xfer_memory (NULL
, buf
, writebuf
, memaddr
, len
);
1373 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
, memaddr
, len
,
1376 do_cleanups (old_chain
);
1383 restore_show_memory_breakpoints (void *arg
)
1385 show_memory_breakpoints
= (uintptr_t) arg
;
1389 make_show_memory_breakpoints_cleanup (int show
)
1391 int current
= show_memory_breakpoints
;
1393 show_memory_breakpoints
= show
;
1394 return make_cleanup (restore_show_memory_breakpoints
,
1395 (void *) (uintptr_t) current
);
1398 /* For docs see target.h, to_xfer_partial. */
1400 enum target_xfer_status
1401 target_xfer_partial (struct target_ops
*ops
,
1402 enum target_object object
, const char *annex
,
1403 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1404 ULONGEST offset
, ULONGEST len
,
1405 ULONGEST
*xfered_len
)
1407 enum target_xfer_status retval
;
1409 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1411 /* Transfer is done when LEN is zero. */
1413 return TARGET_XFER_EOF
;
1415 if (writebuf
&& !may_write_memory
)
1416 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1417 core_addr_to_string_nz (offset
), plongest (len
));
1421 /* If this is a memory transfer, let the memory-specific code
1422 have a look at it instead. Memory transfers are more
1424 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1425 || object
== TARGET_OBJECT_CODE_MEMORY
)
1426 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1427 writebuf
, offset
, len
, xfered_len
);
1428 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1430 /* Request the normal memory object from other layers. */
1431 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
,
1435 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
,
1436 writebuf
, offset
, len
, xfered_len
);
1440 const unsigned char *myaddr
= NULL
;
1442 fprintf_unfiltered (gdb_stdlog
,
1443 "%s:target_xfer_partial "
1444 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1447 (annex
? annex
: "(null)"),
1448 host_address_to_string (readbuf
),
1449 host_address_to_string (writebuf
),
1450 core_addr_to_string_nz (offset
),
1451 pulongest (len
), retval
,
1452 pulongest (*xfered_len
));
1458 if (retval
== TARGET_XFER_OK
&& myaddr
!= NULL
)
1462 fputs_unfiltered (", bytes =", gdb_stdlog
);
1463 for (i
= 0; i
< *xfered_len
; i
++)
1465 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1467 if (targetdebug
< 2 && i
> 0)
1469 fprintf_unfiltered (gdb_stdlog
, " ...");
1472 fprintf_unfiltered (gdb_stdlog
, "\n");
1475 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1479 fputc_unfiltered ('\n', gdb_stdlog
);
1482 /* Check implementations of to_xfer_partial update *XFERED_LEN
1483 properly. Do assertion after printing debug messages, so that we
1484 can find more clues on assertion failure from debugging messages. */
1485 if (retval
== TARGET_XFER_OK
|| retval
== TARGET_XFER_E_UNAVAILABLE
)
1486 gdb_assert (*xfered_len
> 0);
1491 /* Read LEN bytes of target memory at address MEMADDR, placing the
1492 results in GDB's memory at MYADDR. Returns either 0 for success or
1493 TARGET_XFER_E_IO if any error occurs.
1495 If an error occurs, no guarantee is made about the contents of the data at
1496 MYADDR. In particular, the caller should not depend upon partial reads
1497 filling the buffer with good data. There is no way for the caller to know
1498 how much good data might have been transfered anyway. Callers that can
1499 deal with partial reads should call target_read (which will retry until
1500 it makes no progress, and then return how much was transferred). */
1503 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1505 /* Dispatch to the topmost target, not the flattened current_target.
1506 Memory accesses check target->to_has_(all_)memory, and the
1507 flattened target doesn't inherit those. */
1508 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1509 myaddr
, memaddr
, len
) == len
)
1512 return TARGET_XFER_E_IO
;
1515 /* Like target_read_memory, but specify explicitly that this is a read
1516 from the target's raw memory. That is, this read bypasses the
1517 dcache, breakpoint shadowing, etc. */
1520 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1522 /* See comment in target_read_memory about why the request starts at
1523 current_target.beneath. */
1524 if (target_read (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1525 myaddr
, memaddr
, len
) == len
)
1528 return TARGET_XFER_E_IO
;
1531 /* Like target_read_memory, but specify explicitly that this is a read from
1532 the target's stack. This may trigger different cache behavior. */
1535 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1537 /* See comment in target_read_memory about why the request starts at
1538 current_target.beneath. */
1539 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1540 myaddr
, memaddr
, len
) == len
)
1543 return TARGET_XFER_E_IO
;
1546 /* Like target_read_memory, but specify explicitly that this is a read from
1547 the target's code. This may trigger different cache behavior. */
1550 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1552 /* See comment in target_read_memory about why the request starts at
1553 current_target.beneath. */
1554 if (target_read (current_target
.beneath
, TARGET_OBJECT_CODE_MEMORY
, NULL
,
1555 myaddr
, memaddr
, len
) == len
)
1558 return TARGET_XFER_E_IO
;
1561 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1562 Returns either 0 for success or TARGET_XFER_E_IO if any
1563 error occurs. If an error occurs, no guarantee is made about how
1564 much data got written. Callers that can deal with partial writes
1565 should call target_write. */
1568 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1570 /* See comment in target_read_memory about why the request starts at
1571 current_target.beneath. */
1572 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1573 myaddr
, memaddr
, len
) == len
)
1576 return TARGET_XFER_E_IO
;
1579 /* Write LEN bytes from MYADDR to target raw memory at address
1580 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1581 if any error occurs. If an error occurs, no guarantee is made
1582 about how much data got written. Callers that can deal with
1583 partial writes should call target_write. */
1586 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1588 /* See comment in target_read_memory about why the request starts at
1589 current_target.beneath. */
1590 if (target_write (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1591 myaddr
, memaddr
, len
) == len
)
1594 return TARGET_XFER_E_IO
;
1597 /* Fetch the target's memory map. */
1600 target_memory_map (void)
1602 VEC(mem_region_s
) *result
;
1603 struct mem_region
*last_one
, *this_one
;
1605 struct target_ops
*t
;
1608 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1610 result
= current_target
.to_memory_map (¤t_target
);
1614 qsort (VEC_address (mem_region_s
, result
),
1615 VEC_length (mem_region_s
, result
),
1616 sizeof (struct mem_region
), mem_region_cmp
);
1618 /* Check that regions do not overlap. Simultaneously assign
1619 a numbering for the "mem" commands to use to refer to
1622 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1624 this_one
->number
= ix
;
1626 if (last_one
&& last_one
->hi
> this_one
->lo
)
1628 warning (_("Overlapping regions in memory map: ignoring"));
1629 VEC_free (mem_region_s
, result
);
1632 last_one
= this_one
;
1639 target_flash_erase (ULONGEST address
, LONGEST length
)
1642 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1643 hex_string (address
), phex (length
, 0));
1644 current_target
.to_flash_erase (¤t_target
, address
, length
);
1648 target_flash_done (void)
1651 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1652 current_target
.to_flash_done (¤t_target
);
1656 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1657 struct cmd_list_element
*c
, const char *value
)
1659 fprintf_filtered (file
,
1660 _("Mode for reading from readonly sections is %s.\n"),
1664 /* More generic transfers. */
1666 static enum target_xfer_status
1667 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1668 const char *annex
, gdb_byte
*readbuf
,
1669 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
1670 ULONGEST
*xfered_len
)
1672 if (object
== TARGET_OBJECT_MEMORY
1673 && ops
->deprecated_xfer_memory
!= NULL
)
1674 /* If available, fall back to the target's
1675 "deprecated_xfer_memory" method. */
1680 if (writebuf
!= NULL
)
1682 void *buffer
= xmalloc (len
);
1683 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1685 memcpy (buffer
, writebuf
, len
);
1686 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1687 1/*write*/, NULL
, ops
);
1688 do_cleanups (cleanup
);
1690 if (readbuf
!= NULL
)
1691 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1692 0/*read*/, NULL
, ops
);
1695 *xfered_len
= (ULONGEST
) xfered
;
1696 return TARGET_XFER_E_IO
;
1698 else if (xfered
== 0 && errno
== 0)
1699 /* "deprecated_xfer_memory" uses 0, cross checked against
1700 ERRNO as one indication of an error. */
1701 return TARGET_XFER_EOF
;
1703 return TARGET_XFER_E_IO
;
1707 gdb_assert (ops
->beneath
!= NULL
);
1708 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1709 readbuf
, writebuf
, offset
, len
,
1714 /* Target vector read/write partial wrapper functions. */
1716 static enum target_xfer_status
1717 target_read_partial (struct target_ops
*ops
,
1718 enum target_object object
,
1719 const char *annex
, gdb_byte
*buf
,
1720 ULONGEST offset
, ULONGEST len
,
1721 ULONGEST
*xfered_len
)
1723 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
,
1727 static enum target_xfer_status
1728 target_write_partial (struct target_ops
*ops
,
1729 enum target_object object
,
1730 const char *annex
, const gdb_byte
*buf
,
1731 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
1733 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
,
1737 /* Wrappers to perform the full transfer. */
1739 /* For docs on target_read see target.h. */
1742 target_read (struct target_ops
*ops
,
1743 enum target_object object
,
1744 const char *annex
, gdb_byte
*buf
,
1745 ULONGEST offset
, LONGEST len
)
1749 while (xfered
< len
)
1751 ULONGEST xfered_len
;
1752 enum target_xfer_status status
;
1754 status
= target_read_partial (ops
, object
, annex
,
1755 (gdb_byte
*) buf
+ xfered
,
1756 offset
+ xfered
, len
- xfered
,
1759 /* Call an observer, notifying them of the xfer progress? */
1760 if (status
== TARGET_XFER_EOF
)
1762 else if (status
== TARGET_XFER_OK
)
1764 xfered
+= xfered_len
;
1774 /* Assuming that the entire [begin, end) range of memory cannot be
1775 read, try to read whatever subrange is possible to read.
1777 The function returns, in RESULT, either zero or one memory block.
1778 If there's a readable subrange at the beginning, it is completely
1779 read and returned. Any further readable subrange will not be read.
1780 Otherwise, if there's a readable subrange at the end, it will be
1781 completely read and returned. Any readable subranges before it
1782 (obviously, not starting at the beginning), will be ignored. In
1783 other cases -- either no readable subrange, or readable subrange(s)
1784 that is neither at the beginning, or end, nothing is returned.
1786 The purpose of this function is to handle a read across a boundary
1787 of accessible memory in a case when memory map is not available.
1788 The above restrictions are fine for this case, but will give
1789 incorrect results if the memory is 'patchy'. However, supporting
1790 'patchy' memory would require trying to read every single byte,
1791 and it seems unacceptable solution. Explicit memory map is
1792 recommended for this case -- and target_read_memory_robust will
1793 take care of reading multiple ranges then. */
1796 read_whatever_is_readable (struct target_ops
*ops
,
1797 ULONGEST begin
, ULONGEST end
,
1798 VEC(memory_read_result_s
) **result
)
1800 gdb_byte
*buf
= xmalloc (end
- begin
);
1801 ULONGEST current_begin
= begin
;
1802 ULONGEST current_end
= end
;
1804 memory_read_result_s r
;
1805 ULONGEST xfered_len
;
1807 /* If we previously failed to read 1 byte, nothing can be done here. */
1808 if (end
- begin
<= 1)
1814 /* Check that either first or the last byte is readable, and give up
1815 if not. This heuristic is meant to permit reading accessible memory
1816 at the boundary of accessible region. */
1817 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1818 buf
, begin
, 1, &xfered_len
) == TARGET_XFER_OK
)
1823 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1824 buf
+ (end
-begin
) - 1, end
- 1, 1,
1825 &xfered_len
) == TARGET_XFER_OK
)
1836 /* Loop invariant is that the [current_begin, current_end) was previously
1837 found to be not readable as a whole.
1839 Note loop condition -- if the range has 1 byte, we can't divide the range
1840 so there's no point trying further. */
1841 while (current_end
- current_begin
> 1)
1843 ULONGEST first_half_begin
, first_half_end
;
1844 ULONGEST second_half_begin
, second_half_end
;
1846 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
1850 first_half_begin
= current_begin
;
1851 first_half_end
= middle
;
1852 second_half_begin
= middle
;
1853 second_half_end
= current_end
;
1857 first_half_begin
= middle
;
1858 first_half_end
= current_end
;
1859 second_half_begin
= current_begin
;
1860 second_half_end
= middle
;
1863 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1864 buf
+ (first_half_begin
- begin
),
1866 first_half_end
- first_half_begin
);
1868 if (xfer
== first_half_end
- first_half_begin
)
1870 /* This half reads up fine. So, the error must be in the
1872 current_begin
= second_half_begin
;
1873 current_end
= second_half_end
;
1877 /* This half is not readable. Because we've tried one byte, we
1878 know some part of this half if actually redable. Go to the next
1879 iteration to divide again and try to read.
1881 We don't handle the other half, because this function only tries
1882 to read a single readable subrange. */
1883 current_begin
= first_half_begin
;
1884 current_end
= first_half_end
;
1890 /* The [begin, current_begin) range has been read. */
1892 r
.end
= current_begin
;
1897 /* The [current_end, end) range has been read. */
1898 LONGEST rlen
= end
- current_end
;
1900 r
.data
= xmalloc (rlen
);
1901 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
1902 r
.begin
= current_end
;
1906 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
1910 free_memory_read_result_vector (void *x
)
1912 VEC(memory_read_result_s
) *v
= x
;
1913 memory_read_result_s
*current
;
1916 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
1918 xfree (current
->data
);
1920 VEC_free (memory_read_result_s
, v
);
1923 VEC(memory_read_result_s
) *
1924 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
1926 VEC(memory_read_result_s
) *result
= 0;
1929 while (xfered
< len
)
1931 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
1934 /* If there is no explicit region, a fake one should be created. */
1935 gdb_assert (region
);
1937 if (region
->hi
== 0)
1938 rlen
= len
- xfered
;
1940 rlen
= region
->hi
- offset
;
1942 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
1944 /* Cannot read this region. Note that we can end up here only
1945 if the region is explicitly marked inaccessible, or
1946 'inaccessible-by-default' is in effect. */
1951 LONGEST to_read
= min (len
- xfered
, rlen
);
1952 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
1954 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1955 (gdb_byte
*) buffer
,
1956 offset
+ xfered
, to_read
);
1957 /* Call an observer, notifying them of the xfer progress? */
1960 /* Got an error reading full chunk. See if maybe we can read
1963 read_whatever_is_readable (ops
, offset
+ xfered
,
1964 offset
+ xfered
+ to_read
, &result
);
1969 struct memory_read_result r
;
1971 r
.begin
= offset
+ xfered
;
1972 r
.end
= r
.begin
+ xfer
;
1973 VEC_safe_push (memory_read_result_s
, result
, &r
);
1983 /* An alternative to target_write with progress callbacks. */
1986 target_write_with_progress (struct target_ops
*ops
,
1987 enum target_object object
,
1988 const char *annex
, const gdb_byte
*buf
,
1989 ULONGEST offset
, LONGEST len
,
1990 void (*progress
) (ULONGEST
, void *), void *baton
)
1994 /* Give the progress callback a chance to set up. */
1996 (*progress
) (0, baton
);
1998 while (xfered
< len
)
2000 ULONGEST xfered_len
;
2001 enum target_xfer_status status
;
2003 status
= target_write_partial (ops
, object
, annex
,
2004 (gdb_byte
*) buf
+ xfered
,
2005 offset
+ xfered
, len
- xfered
,
2008 if (status
== TARGET_XFER_EOF
)
2010 if (TARGET_XFER_STATUS_ERROR_P (status
))
2013 gdb_assert (status
== TARGET_XFER_OK
);
2015 (*progress
) (xfered_len
, baton
);
2017 xfered
+= xfered_len
;
2023 /* For docs on target_write see target.h. */
2026 target_write (struct target_ops
*ops
,
2027 enum target_object object
,
2028 const char *annex
, const gdb_byte
*buf
,
2029 ULONGEST offset
, LONGEST len
)
2031 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2035 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2036 the size of the transferred data. PADDING additional bytes are
2037 available in *BUF_P. This is a helper function for
2038 target_read_alloc; see the declaration of that function for more
2042 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2043 const char *annex
, gdb_byte
**buf_p
, int padding
)
2045 size_t buf_alloc
, buf_pos
;
2048 /* This function does not have a length parameter; it reads the
2049 entire OBJECT). Also, it doesn't support objects fetched partly
2050 from one target and partly from another (in a different stratum,
2051 e.g. a core file and an executable). Both reasons make it
2052 unsuitable for reading memory. */
2053 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2055 /* Start by reading up to 4K at a time. The target will throttle
2056 this number down if necessary. */
2058 buf
= xmalloc (buf_alloc
);
2062 ULONGEST xfered_len
;
2063 enum target_xfer_status status
;
2065 status
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2066 buf_pos
, buf_alloc
- buf_pos
- padding
,
2069 if (status
== TARGET_XFER_EOF
)
2071 /* Read all there was. */
2078 else if (status
!= TARGET_XFER_OK
)
2080 /* An error occurred. */
2082 return TARGET_XFER_E_IO
;
2085 buf_pos
+= xfered_len
;
2087 /* If the buffer is filling up, expand it. */
2088 if (buf_alloc
< buf_pos
* 2)
2091 buf
= xrealloc (buf
, buf_alloc
);
2098 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2099 the size of the transferred data. See the declaration in "target.h"
2100 function for more information about the return value. */
2103 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2104 const char *annex
, gdb_byte
**buf_p
)
2106 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2109 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2110 returned as a string, allocated using xmalloc. If an error occurs
2111 or the transfer is unsupported, NULL is returned. Empty objects
2112 are returned as allocated but empty strings. A warning is issued
2113 if the result contains any embedded NUL bytes. */
2116 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2121 LONGEST i
, transferred
;
2123 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2124 bufstr
= (char *) buffer
;
2126 if (transferred
< 0)
2129 if (transferred
== 0)
2130 return xstrdup ("");
2132 bufstr
[transferred
] = 0;
2134 /* Check for embedded NUL bytes; but allow trailing NULs. */
2135 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2138 warning (_("target object %d, annex %s, "
2139 "contained unexpected null characters"),
2140 (int) object
, annex
? annex
: "(none)");
2147 /* Memory transfer methods. */
2150 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2153 /* This method is used to read from an alternate, non-current
2154 target. This read must bypass the overlay support (as symbols
2155 don't match this target), and GDB's internal cache (wrong cache
2156 for this target). */
2157 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2159 memory_error (TARGET_XFER_E_IO
, addr
);
2163 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2164 int len
, enum bfd_endian byte_order
)
2166 gdb_byte buf
[sizeof (ULONGEST
)];
2168 gdb_assert (len
<= sizeof (buf
));
2169 get_target_memory (ops
, addr
, buf
, len
);
2170 return extract_unsigned_integer (buf
, len
, byte_order
);
2176 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2177 struct bp_target_info
*bp_tgt
)
2179 if (!may_insert_breakpoints
)
2181 warning (_("May not insert breakpoints"));
2185 return current_target
.to_insert_breakpoint (¤t_target
,
2192 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2193 struct bp_target_info
*bp_tgt
)
2195 /* This is kind of a weird case to handle, but the permission might
2196 have been changed after breakpoints were inserted - in which case
2197 we should just take the user literally and assume that any
2198 breakpoints should be left in place. */
2199 if (!may_insert_breakpoints
)
2201 warning (_("May not remove breakpoints"));
2205 return current_target
.to_remove_breakpoint (¤t_target
,
2210 target_info (char *args
, int from_tty
)
2212 struct target_ops
*t
;
2213 int has_all_mem
= 0;
2215 if (symfile_objfile
!= NULL
)
2216 printf_unfiltered (_("Symbols from \"%s\".\n"),
2217 objfile_name (symfile_objfile
));
2219 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2221 if (!(*t
->to_has_memory
) (t
))
2224 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2227 printf_unfiltered (_("\tWhile running this, "
2228 "GDB does not access memory from...\n"));
2229 printf_unfiltered ("%s:\n", t
->to_longname
);
2230 (t
->to_files_info
) (t
);
2231 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2235 /* This function is called before any new inferior is created, e.g.
2236 by running a program, attaching, or connecting to a target.
2237 It cleans up any state from previous invocations which might
2238 change between runs. This is a subset of what target_preopen
2239 resets (things which might change between targets). */
2242 target_pre_inferior (int from_tty
)
2244 /* Clear out solib state. Otherwise the solib state of the previous
2245 inferior might have survived and is entirely wrong for the new
2246 target. This has been observed on GNU/Linux using glibc 2.3. How
2258 Cannot access memory at address 0xdeadbeef
2261 /* In some OSs, the shared library list is the same/global/shared
2262 across inferiors. If code is shared between processes, so are
2263 memory regions and features. */
2264 if (!gdbarch_has_global_solist (target_gdbarch ()))
2266 no_shared_libraries (NULL
, from_tty
);
2268 invalidate_target_mem_regions ();
2270 target_clear_description ();
2273 agent_capability_invalidate ();
2276 /* Callback for iterate_over_inferiors. Gets rid of the given
2280 dispose_inferior (struct inferior
*inf
, void *args
)
2282 struct thread_info
*thread
;
2284 thread
= any_thread_of_process (inf
->pid
);
2287 switch_to_thread (thread
->ptid
);
2289 /* Core inferiors actually should be detached, not killed. */
2290 if (target_has_execution
)
2293 target_detach (NULL
, 0);
2299 /* This is to be called by the open routine before it does
2303 target_preopen (int from_tty
)
2307 if (have_inferiors ())
2310 || !have_live_inferiors ()
2311 || query (_("A program is being debugged already. Kill it? ")))
2312 iterate_over_inferiors (dispose_inferior
, NULL
);
2314 error (_("Program not killed."));
2317 /* Calling target_kill may remove the target from the stack. But if
2318 it doesn't (which seems like a win for UDI), remove it now. */
2319 /* Leave the exec target, though. The user may be switching from a
2320 live process to a core of the same program. */
2321 pop_all_targets_above (file_stratum
);
2323 target_pre_inferior (from_tty
);
2326 /* Detach a target after doing deferred register stores. */
2329 target_detach (const char *args
, int from_tty
)
2331 struct target_ops
* t
;
2333 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2334 /* Don't remove global breakpoints here. They're removed on
2335 disconnection from the target. */
2338 /* If we're in breakpoints-always-inserted mode, have to remove
2339 them before detaching. */
2340 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2342 prepare_for_detach ();
2344 current_target
.to_detach (¤t_target
, args
, from_tty
);
2346 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2351 target_disconnect (char *args
, int from_tty
)
2353 /* If we're in breakpoints-always-inserted mode or if breakpoints
2354 are global across processes, we have to remove them before
2356 remove_breakpoints ();
2359 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2361 current_target
.to_disconnect (¤t_target
, args
, from_tty
);
2365 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2367 struct target_ops
*t
;
2368 ptid_t retval
= (current_target
.to_wait
) (¤t_target
, ptid
,
2373 char *status_string
;
2374 char *options_string
;
2376 status_string
= target_waitstatus_to_string (status
);
2377 options_string
= target_options_to_string (options
);
2378 fprintf_unfiltered (gdb_stdlog
,
2379 "target_wait (%d, status, options={%s})"
2381 ptid_get_pid (ptid
), options_string
,
2382 ptid_get_pid (retval
), status_string
);
2383 xfree (status_string
);
2384 xfree (options_string
);
2391 target_pid_to_str (ptid_t ptid
)
2393 return (*current_target
.to_pid_to_str
) (¤t_target
, ptid
);
2397 target_thread_name (struct thread_info
*info
)
2399 return current_target
.to_thread_name (¤t_target
, info
);
2403 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2405 struct target_ops
*t
;
2407 target_dcache_invalidate ();
2409 current_target
.to_resume (¤t_target
, ptid
, step
, signal
);
2411 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2412 ptid_get_pid (ptid
),
2413 step
? "step" : "continue",
2414 gdb_signal_to_name (signal
));
2416 registers_changed_ptid (ptid
);
2417 set_executing (ptid
, 1);
2418 set_running (ptid
, 1);
2419 clear_inline_frame_state (ptid
);
2423 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2429 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2432 for (i
= 0; i
< numsigs
; i
++)
2433 if (pass_signals
[i
])
2434 fprintf_unfiltered (gdb_stdlog
, " %s",
2435 gdb_signal_to_name (i
));
2437 fprintf_unfiltered (gdb_stdlog
, " })\n");
2440 (*current_target
.to_pass_signals
) (¤t_target
, numsigs
, pass_signals
);
2444 target_program_signals (int numsigs
, unsigned char *program_signals
)
2450 fprintf_unfiltered (gdb_stdlog
, "target_program_signals (%d, {",
2453 for (i
= 0; i
< numsigs
; i
++)
2454 if (program_signals
[i
])
2455 fprintf_unfiltered (gdb_stdlog
, " %s",
2456 gdb_signal_to_name (i
));
2458 fprintf_unfiltered (gdb_stdlog
, " })\n");
2461 (*current_target
.to_program_signals
) (¤t_target
,
2462 numsigs
, program_signals
);
2466 default_follow_fork (struct target_ops
*self
, int follow_child
,
2469 /* Some target returned a fork event, but did not know how to follow it. */
2470 internal_error (__FILE__
, __LINE__
,
2471 _("could not find a target to follow fork"));
2474 /* Look through the list of possible targets for a target that can
2478 target_follow_fork (int follow_child
, int detach_fork
)
2480 int retval
= current_target
.to_follow_fork (¤t_target
,
2481 follow_child
, detach_fork
);
2484 fprintf_unfiltered (gdb_stdlog
,
2485 "target_follow_fork (%d, %d) = %d\n",
2486 follow_child
, detach_fork
, retval
);
2491 default_mourn_inferior (struct target_ops
*self
)
2493 internal_error (__FILE__
, __LINE__
,
2494 _("could not find a target to follow mourn inferior"));
2498 target_mourn_inferior (void)
2500 current_target
.to_mourn_inferior (¤t_target
);
2502 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2504 /* We no longer need to keep handles on any of the object files.
2505 Make sure to release them to avoid unnecessarily locking any
2506 of them while we're not actually debugging. */
2507 bfd_cache_close_all ();
2510 /* Look for a target which can describe architectural features, starting
2511 from TARGET. If we find one, return its description. */
2513 const struct target_desc
*
2514 target_read_description (struct target_ops
*target
)
2516 return target
->to_read_description (target
);
2519 /* This implements a basic search of memory, reading target memory and
2520 performing the search here (as opposed to performing the search in on the
2521 target side with, for example, gdbserver). */
2524 simple_search_memory (struct target_ops
*ops
,
2525 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2526 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2527 CORE_ADDR
*found_addrp
)
2529 /* NOTE: also defined in find.c testcase. */
2530 #define SEARCH_CHUNK_SIZE 16000
2531 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2532 /* Buffer to hold memory contents for searching. */
2533 gdb_byte
*search_buf
;
2534 unsigned search_buf_size
;
2535 struct cleanup
*old_cleanups
;
2537 search_buf_size
= chunk_size
+ pattern_len
- 1;
2539 /* No point in trying to allocate a buffer larger than the search space. */
2540 if (search_space_len
< search_buf_size
)
2541 search_buf_size
= search_space_len
;
2543 search_buf
= malloc (search_buf_size
);
2544 if (search_buf
== NULL
)
2545 error (_("Unable to allocate memory to perform the search."));
2546 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2548 /* Prime the search buffer. */
2550 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2551 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2553 warning (_("Unable to access %s bytes of target "
2554 "memory at %s, halting search."),
2555 pulongest (search_buf_size
), hex_string (start_addr
));
2556 do_cleanups (old_cleanups
);
2560 /* Perform the search.
2562 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2563 When we've scanned N bytes we copy the trailing bytes to the start and
2564 read in another N bytes. */
2566 while (search_space_len
>= pattern_len
)
2568 gdb_byte
*found_ptr
;
2569 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2571 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2572 pattern
, pattern_len
);
2574 if (found_ptr
!= NULL
)
2576 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2578 *found_addrp
= found_addr
;
2579 do_cleanups (old_cleanups
);
2583 /* Not found in this chunk, skip to next chunk. */
2585 /* Don't let search_space_len wrap here, it's unsigned. */
2586 if (search_space_len
>= chunk_size
)
2587 search_space_len
-= chunk_size
;
2589 search_space_len
= 0;
2591 if (search_space_len
>= pattern_len
)
2593 unsigned keep_len
= search_buf_size
- chunk_size
;
2594 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2597 /* Copy the trailing part of the previous iteration to the front
2598 of the buffer for the next iteration. */
2599 gdb_assert (keep_len
== pattern_len
- 1);
2600 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
2602 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
2604 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2605 search_buf
+ keep_len
, read_addr
,
2606 nr_to_read
) != nr_to_read
)
2608 warning (_("Unable to access %s bytes of target "
2609 "memory at %s, halting search."),
2610 plongest (nr_to_read
),
2611 hex_string (read_addr
));
2612 do_cleanups (old_cleanups
);
2616 start_addr
+= chunk_size
;
2622 do_cleanups (old_cleanups
);
2626 /* Default implementation of memory-searching. */
2629 default_search_memory (struct target_ops
*self
,
2630 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2631 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2632 CORE_ADDR
*found_addrp
)
2634 /* Start over from the top of the target stack. */
2635 return simple_search_memory (current_target
.beneath
,
2636 start_addr
, search_space_len
,
2637 pattern
, pattern_len
, found_addrp
);
2640 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2641 sequence of bytes in PATTERN with length PATTERN_LEN.
2643 The result is 1 if found, 0 if not found, and -1 if there was an error
2644 requiring halting of the search (e.g. memory read error).
2645 If the pattern is found the address is recorded in FOUND_ADDRP. */
2648 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2649 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2650 CORE_ADDR
*found_addrp
)
2655 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2656 hex_string (start_addr
));
2658 found
= current_target
.to_search_memory (¤t_target
, start_addr
,
2660 pattern
, pattern_len
, found_addrp
);
2663 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2668 /* Look through the currently pushed targets. If none of them will
2669 be able to restart the currently running process, issue an error
2673 target_require_runnable (void)
2675 struct target_ops
*t
;
2677 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2679 /* If this target knows how to create a new program, then
2680 assume we will still be able to after killing the current
2681 one. Either killing and mourning will not pop T, or else
2682 find_default_run_target will find it again. */
2683 if (t
->to_create_inferior
!= NULL
)
2686 /* Do not worry about thread_stratum targets that can not
2687 create inferiors. Assume they will be pushed again if
2688 necessary, and continue to the process_stratum. */
2689 if (t
->to_stratum
== thread_stratum
2690 || t
->to_stratum
== arch_stratum
)
2693 error (_("The \"%s\" target does not support \"run\". "
2694 "Try \"help target\" or \"continue\"."),
2698 /* This function is only called if the target is running. In that
2699 case there should have been a process_stratum target and it
2700 should either know how to create inferiors, or not... */
2701 internal_error (__FILE__
, __LINE__
, _("No targets found"));
2704 /* Look through the list of possible targets for a target that can
2705 execute a run or attach command without any other data. This is
2706 used to locate the default process stratum.
2708 If DO_MESG is not NULL, the result is always valid (error() is
2709 called for errors); else, return NULL on error. */
2711 static struct target_ops
*
2712 find_default_run_target (char *do_mesg
)
2714 struct target_ops
**t
;
2715 struct target_ops
*runable
= NULL
;
2720 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2723 if ((*t
)->to_can_run
!= delegate_can_run
&& target_can_run (*t
))
2733 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2742 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2744 struct target_ops
*t
;
2746 t
= find_default_run_target ("attach");
2747 (t
->to_attach
) (t
, args
, from_tty
);
2752 find_default_create_inferior (struct target_ops
*ops
,
2753 char *exec_file
, char *allargs
, char **env
,
2756 struct target_ops
*t
;
2758 t
= find_default_run_target ("run");
2759 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
2764 find_default_can_async_p (struct target_ops
*ignore
)
2766 struct target_ops
*t
;
2768 /* This may be called before the target is pushed on the stack;
2769 look for the default process stratum. If there's none, gdb isn't
2770 configured with a native debugger, and target remote isn't
2772 t
= find_default_run_target (NULL
);
2773 if (t
&& t
->to_can_async_p
!= delegate_can_async_p
)
2774 return (t
->to_can_async_p
) (t
);
2779 find_default_is_async_p (struct target_ops
*ignore
)
2781 struct target_ops
*t
;
2783 /* This may be called before the target is pushed on the stack;
2784 look for the default process stratum. If there's none, gdb isn't
2785 configured with a native debugger, and target remote isn't
2787 t
= find_default_run_target (NULL
);
2788 if (t
&& t
->to_is_async_p
!= delegate_is_async_p
)
2789 return (t
->to_is_async_p
) (t
);
2794 find_default_supports_non_stop (struct target_ops
*self
)
2796 struct target_ops
*t
;
2798 t
= find_default_run_target (NULL
);
2799 if (t
&& t
->to_supports_non_stop
)
2800 return (t
->to_supports_non_stop
) (t
);
2805 target_supports_non_stop (void)
2807 struct target_ops
*t
;
2809 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2810 if (t
->to_supports_non_stop
)
2811 return t
->to_supports_non_stop (t
);
2816 /* Implement the "info proc" command. */
2819 target_info_proc (char *args
, enum info_proc_what what
)
2821 struct target_ops
*t
;
2823 /* If we're already connected to something that can get us OS
2824 related data, use it. Otherwise, try using the native
2826 if (current_target
.to_stratum
>= process_stratum
)
2827 t
= current_target
.beneath
;
2829 t
= find_default_run_target (NULL
);
2831 for (; t
!= NULL
; t
= t
->beneath
)
2833 if (t
->to_info_proc
!= NULL
)
2835 t
->to_info_proc (t
, args
, what
);
2838 fprintf_unfiltered (gdb_stdlog
,
2839 "target_info_proc (\"%s\", %d)\n", args
, what
);
2849 find_default_supports_disable_randomization (struct target_ops
*self
)
2851 struct target_ops
*t
;
2853 t
= find_default_run_target (NULL
);
2854 if (t
&& t
->to_supports_disable_randomization
)
2855 return (t
->to_supports_disable_randomization
) (t
);
2860 target_supports_disable_randomization (void)
2862 struct target_ops
*t
;
2864 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2865 if (t
->to_supports_disable_randomization
)
2866 return t
->to_supports_disable_randomization (t
);
2872 target_get_osdata (const char *type
)
2874 struct target_ops
*t
;
2876 /* If we're already connected to something that can get us OS
2877 related data, use it. Otherwise, try using the native
2879 if (current_target
.to_stratum
>= process_stratum
)
2880 t
= current_target
.beneath
;
2882 t
= find_default_run_target ("get OS data");
2887 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
2890 /* Determine the current address space of thread PTID. */
2892 struct address_space
*
2893 target_thread_address_space (ptid_t ptid
)
2895 struct address_space
*aspace
;
2896 struct inferior
*inf
;
2897 struct target_ops
*t
;
2899 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2901 if (t
->to_thread_address_space
!= NULL
)
2903 aspace
= t
->to_thread_address_space (t
, ptid
);
2904 gdb_assert (aspace
);
2907 fprintf_unfiltered (gdb_stdlog
,
2908 "target_thread_address_space (%s) = %d\n",
2909 target_pid_to_str (ptid
),
2910 address_space_num (aspace
));
2915 /* Fall-back to the "main" address space of the inferior. */
2916 inf
= find_inferior_pid (ptid_get_pid (ptid
));
2918 if (inf
== NULL
|| inf
->aspace
== NULL
)
2919 internal_error (__FILE__
, __LINE__
,
2920 _("Can't determine the current "
2921 "address space of thread %s\n"),
2922 target_pid_to_str (ptid
));
2928 /* Target file operations. */
2930 static struct target_ops
*
2931 default_fileio_target (void)
2933 /* If we're already connected to something that can perform
2934 file I/O, use it. Otherwise, try using the native target. */
2935 if (current_target
.to_stratum
>= process_stratum
)
2936 return current_target
.beneath
;
2938 return find_default_run_target ("file I/O");
2941 /* Open FILENAME on the target, using FLAGS and MODE. Return a
2942 target file descriptor, or -1 if an error occurs (and set
2945 target_fileio_open (const char *filename
, int flags
, int mode
,
2948 struct target_ops
*t
;
2950 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2952 if (t
->to_fileio_open
!= NULL
)
2954 int fd
= t
->to_fileio_open (t
, filename
, flags
, mode
, target_errno
);
2957 fprintf_unfiltered (gdb_stdlog
,
2958 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
2959 filename
, flags
, mode
,
2960 fd
, fd
!= -1 ? 0 : *target_errno
);
2965 *target_errno
= FILEIO_ENOSYS
;
2969 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
2970 Return the number of bytes written, or -1 if an error occurs
2971 (and set *TARGET_ERRNO). */
2973 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
2974 ULONGEST offset
, int *target_errno
)
2976 struct target_ops
*t
;
2978 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2980 if (t
->to_fileio_pwrite
!= NULL
)
2982 int ret
= t
->to_fileio_pwrite (t
, fd
, write_buf
, len
, offset
,
2986 fprintf_unfiltered (gdb_stdlog
,
2987 "target_fileio_pwrite (%d,...,%d,%s) "
2989 fd
, len
, pulongest (offset
),
2990 ret
, ret
!= -1 ? 0 : *target_errno
);
2995 *target_errno
= FILEIO_ENOSYS
;
2999 /* Read up to LEN bytes FD on the target into READ_BUF.
3000 Return the number of bytes read, or -1 if an error occurs
3001 (and set *TARGET_ERRNO). */
3003 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
3004 ULONGEST offset
, int *target_errno
)
3006 struct target_ops
*t
;
3008 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3010 if (t
->to_fileio_pread
!= NULL
)
3012 int ret
= t
->to_fileio_pread (t
, fd
, read_buf
, len
, offset
,
3016 fprintf_unfiltered (gdb_stdlog
,
3017 "target_fileio_pread (%d,...,%d,%s) "
3019 fd
, len
, pulongest (offset
),
3020 ret
, ret
!= -1 ? 0 : *target_errno
);
3025 *target_errno
= FILEIO_ENOSYS
;
3029 /* Close FD on the target. Return 0, or -1 if an error occurs
3030 (and set *TARGET_ERRNO). */
3032 target_fileio_close (int fd
, int *target_errno
)
3034 struct target_ops
*t
;
3036 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3038 if (t
->to_fileio_close
!= NULL
)
3040 int ret
= t
->to_fileio_close (t
, fd
, target_errno
);
3043 fprintf_unfiltered (gdb_stdlog
,
3044 "target_fileio_close (%d) = %d (%d)\n",
3045 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
3050 *target_errno
= FILEIO_ENOSYS
;
3054 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3055 occurs (and set *TARGET_ERRNO). */
3057 target_fileio_unlink (const char *filename
, int *target_errno
)
3059 struct target_ops
*t
;
3061 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3063 if (t
->to_fileio_unlink
!= NULL
)
3065 int ret
= t
->to_fileio_unlink (t
, filename
, target_errno
);
3068 fprintf_unfiltered (gdb_stdlog
,
3069 "target_fileio_unlink (%s) = %d (%d)\n",
3070 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
3075 *target_errno
= FILEIO_ENOSYS
;
3079 /* Read value of symbolic link FILENAME on the target. Return a
3080 null-terminated string allocated via xmalloc, or NULL if an error
3081 occurs (and set *TARGET_ERRNO). */
3083 target_fileio_readlink (const char *filename
, int *target_errno
)
3085 struct target_ops
*t
;
3087 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3089 if (t
->to_fileio_readlink
!= NULL
)
3091 char *ret
= t
->to_fileio_readlink (t
, filename
, target_errno
);
3094 fprintf_unfiltered (gdb_stdlog
,
3095 "target_fileio_readlink (%s) = %s (%d)\n",
3096 filename
, ret
? ret
: "(nil)",
3097 ret
? 0 : *target_errno
);
3102 *target_errno
= FILEIO_ENOSYS
;
3107 target_fileio_close_cleanup (void *opaque
)
3109 int fd
= *(int *) opaque
;
3112 target_fileio_close (fd
, &target_errno
);
3115 /* Read target file FILENAME. Store the result in *BUF_P and
3116 return the size of the transferred data. PADDING additional bytes are
3117 available in *BUF_P. This is a helper function for
3118 target_fileio_read_alloc; see the declaration of that function for more
3122 target_fileio_read_alloc_1 (const char *filename
,
3123 gdb_byte
**buf_p
, int padding
)
3125 struct cleanup
*close_cleanup
;
3126 size_t buf_alloc
, buf_pos
;
3132 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
3136 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
3138 /* Start by reading up to 4K at a time. The target will throttle
3139 this number down if necessary. */
3141 buf
= xmalloc (buf_alloc
);
3145 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
3146 buf_alloc
- buf_pos
- padding
, buf_pos
,
3150 /* An error occurred. */
3151 do_cleanups (close_cleanup
);
3157 /* Read all there was. */
3158 do_cleanups (close_cleanup
);
3168 /* If the buffer is filling up, expand it. */
3169 if (buf_alloc
< buf_pos
* 2)
3172 buf
= xrealloc (buf
, buf_alloc
);
3179 /* Read target file FILENAME. Store the result in *BUF_P and return
3180 the size of the transferred data. See the declaration in "target.h"
3181 function for more information about the return value. */
3184 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
3186 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
3189 /* Read target file FILENAME. The result is NUL-terminated and
3190 returned as a string, allocated using xmalloc. If an error occurs
3191 or the transfer is unsupported, NULL is returned. Empty objects
3192 are returned as allocated but empty strings. A warning is issued
3193 if the result contains any embedded NUL bytes. */
3196 target_fileio_read_stralloc (const char *filename
)
3200 LONGEST i
, transferred
;
3202 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
3203 bufstr
= (char *) buffer
;
3205 if (transferred
< 0)
3208 if (transferred
== 0)
3209 return xstrdup ("");
3211 bufstr
[transferred
] = 0;
3213 /* Check for embedded NUL bytes; but allow trailing NULs. */
3214 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3217 warning (_("target file %s "
3218 "contained unexpected null characters"),
3228 default_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3229 CORE_ADDR addr
, int len
)
3231 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3235 default_watchpoint_addr_within_range (struct target_ops
*target
,
3237 CORE_ADDR start
, int length
)
3239 return addr
>= start
&& addr
< start
+ length
;
3242 static struct gdbarch
*
3243 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3245 return target_gdbarch ();
3255 * Find the next target down the stack from the specified target.
3259 find_target_beneath (struct target_ops
*t
)
3267 find_target_at (enum strata stratum
)
3269 struct target_ops
*t
;
3271 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3272 if (t
->to_stratum
== stratum
)
3279 /* The inferior process has died. Long live the inferior! */
3282 generic_mourn_inferior (void)
3286 ptid
= inferior_ptid
;
3287 inferior_ptid
= null_ptid
;
3289 /* Mark breakpoints uninserted in case something tries to delete a
3290 breakpoint while we delete the inferior's threads (which would
3291 fail, since the inferior is long gone). */
3292 mark_breakpoints_out ();
3294 if (!ptid_equal (ptid
, null_ptid
))
3296 int pid
= ptid_get_pid (ptid
);
3297 exit_inferior (pid
);
3300 /* Note this wipes step-resume breakpoints, so needs to be done
3301 after exit_inferior, which ends up referencing the step-resume
3302 breakpoints through clear_thread_inferior_resources. */
3303 breakpoint_init_inferior (inf_exited
);
3305 registers_changed ();
3307 reopen_exec_file ();
3308 reinit_frame_cache ();
3310 if (deprecated_detach_hook
)
3311 deprecated_detach_hook ();
3314 /* Convert a normal process ID to a string. Returns the string in a
3318 normal_pid_to_str (ptid_t ptid
)
3320 static char buf
[32];
3322 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3327 default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3329 return normal_pid_to_str (ptid
);
3332 /* Error-catcher for target_find_memory_regions. */
3334 dummy_find_memory_regions (struct target_ops
*self
,
3335 find_memory_region_ftype ignore1
, void *ignore2
)
3337 error (_("Command not implemented for this target."));
3341 /* Error-catcher for target_make_corefile_notes. */
3343 dummy_make_corefile_notes (struct target_ops
*self
,
3344 bfd
*ignore1
, int *ignore2
)
3346 error (_("Command not implemented for this target."));
3350 /* Set up the handful of non-empty slots needed by the dummy target
3354 init_dummy_target (void)
3356 dummy_target
.to_shortname
= "None";
3357 dummy_target
.to_longname
= "None";
3358 dummy_target
.to_doc
= "";
3359 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3360 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3361 dummy_target
.to_supports_disable_randomization
3362 = find_default_supports_disable_randomization
;
3363 dummy_target
.to_stratum
= dummy_stratum
;
3364 dummy_target
.to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
3365 dummy_target
.to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
3366 dummy_target
.to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
3367 dummy_target
.to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
3368 dummy_target
.to_has_execution
3369 = (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
3370 dummy_target
.to_magic
= OPS_MAGIC
;
3372 install_dummy_methods (&dummy_target
);
3376 debug_to_open (char *args
, int from_tty
)
3378 debug_target
.to_open (args
, from_tty
);
3380 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3384 target_close (struct target_ops
*targ
)
3386 gdb_assert (!target_is_pushed (targ
));
3388 if (targ
->to_xclose
!= NULL
)
3389 targ
->to_xclose (targ
);
3390 else if (targ
->to_close
!= NULL
)
3391 targ
->to_close (targ
);
3394 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3398 target_attach (char *args
, int from_tty
)
3400 current_target
.to_attach (¤t_target
, args
, from_tty
);
3402 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3407 target_thread_alive (ptid_t ptid
)
3411 retval
= current_target
.to_thread_alive (¤t_target
, ptid
);
3413 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3414 ptid_get_pid (ptid
), retval
);
3420 target_find_new_threads (void)
3422 current_target
.to_find_new_threads (¤t_target
);
3424 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3428 target_stop (ptid_t ptid
)
3432 warning (_("May not interrupt or stop the target, ignoring attempt"));
3436 (*current_target
.to_stop
) (¤t_target
, ptid
);
3440 debug_to_post_attach (struct target_ops
*self
, int pid
)
3442 debug_target
.to_post_attach (&debug_target
, pid
);
3444 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3447 /* Concatenate ELEM to LIST, a comma separate list, and return the
3448 result. The LIST incoming argument is released. */
3451 str_comma_list_concat_elem (char *list
, const char *elem
)
3454 return xstrdup (elem
);
3456 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3459 /* Helper for target_options_to_string. If OPT is present in
3460 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3461 Returns the new resulting string. OPT is removed from
3465 do_option (int *target_options
, char *ret
,
3466 int opt
, char *opt_str
)
3468 if ((*target_options
& opt
) != 0)
3470 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3471 *target_options
&= ~opt
;
3478 target_options_to_string (int target_options
)
3482 #define DO_TARG_OPTION(OPT) \
3483 ret = do_option (&target_options, ret, OPT, #OPT)
3485 DO_TARG_OPTION (TARGET_WNOHANG
);
3487 if (target_options
!= 0)
3488 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3496 debug_print_register (const char * func
,
3497 struct regcache
*regcache
, int regno
)
3499 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3501 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3502 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3503 && gdbarch_register_name (gdbarch
, regno
) != NULL
3504 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3505 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3506 gdbarch_register_name (gdbarch
, regno
));
3508 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3509 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3511 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3512 int i
, size
= register_size (gdbarch
, regno
);
3513 gdb_byte buf
[MAX_REGISTER_SIZE
];
3515 regcache_raw_collect (regcache
, regno
, buf
);
3516 fprintf_unfiltered (gdb_stdlog
, " = ");
3517 for (i
= 0; i
< size
; i
++)
3519 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3521 if (size
<= sizeof (LONGEST
))
3523 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
3525 fprintf_unfiltered (gdb_stdlog
, " %s %s",
3526 core_addr_to_string_nz (val
), plongest (val
));
3529 fprintf_unfiltered (gdb_stdlog
, "\n");
3533 target_fetch_registers (struct regcache
*regcache
, int regno
)
3535 current_target
.to_fetch_registers (¤t_target
, regcache
, regno
);
3537 debug_print_register ("target_fetch_registers", regcache
, regno
);
3541 target_store_registers (struct regcache
*regcache
, int regno
)
3543 struct target_ops
*t
;
3545 if (!may_write_registers
)
3546 error (_("Writing to registers is not allowed (regno %d)"), regno
);
3548 current_target
.to_store_registers (¤t_target
, regcache
, regno
);
3551 debug_print_register ("target_store_registers", regcache
, regno
);
3556 target_core_of_thread (ptid_t ptid
)
3558 int retval
= current_target
.to_core_of_thread (¤t_target
, ptid
);
3561 fprintf_unfiltered (gdb_stdlog
,
3562 "target_core_of_thread (%d) = %d\n",
3563 ptid_get_pid (ptid
), retval
);
3568 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3570 int retval
= current_target
.to_verify_memory (¤t_target
,
3571 data
, memaddr
, size
);
3574 fprintf_unfiltered (gdb_stdlog
,
3575 "target_verify_memory (%s, %s) = %d\n",
3576 paddress (target_gdbarch (), memaddr
),
3582 /* The documentation for this function is in its prototype declaration in
3586 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3590 ret
= current_target
.to_insert_mask_watchpoint (¤t_target
,
3594 fprintf_unfiltered (gdb_stdlog
, "\
3595 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
3596 core_addr_to_string (addr
),
3597 core_addr_to_string (mask
), rw
, ret
);
3602 /* The documentation for this function is in its prototype declaration in
3606 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3610 ret
= current_target
.to_remove_mask_watchpoint (¤t_target
,
3614 fprintf_unfiltered (gdb_stdlog
, "\
3615 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
3616 core_addr_to_string (addr
),
3617 core_addr_to_string (mask
), rw
, ret
);
3622 /* The documentation for this function is in its prototype declaration
3626 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
3628 return current_target
.to_masked_watch_num_registers (¤t_target
,
3632 /* The documentation for this function is in its prototype declaration
3636 target_ranged_break_num_registers (void)
3638 return current_target
.to_ranged_break_num_registers (¤t_target
);
3643 struct btrace_target_info
*
3644 target_enable_btrace (ptid_t ptid
)
3646 return current_target
.to_enable_btrace (¤t_target
, ptid
);
3652 target_disable_btrace (struct btrace_target_info
*btinfo
)
3654 current_target
.to_disable_btrace (¤t_target
, btinfo
);
3660 target_teardown_btrace (struct btrace_target_info
*btinfo
)
3662 current_target
.to_teardown_btrace (¤t_target
, btinfo
);
3668 target_read_btrace (VEC (btrace_block_s
) **btrace
,
3669 struct btrace_target_info
*btinfo
,
3670 enum btrace_read_type type
)
3672 return current_target
.to_read_btrace (¤t_target
, btrace
, btinfo
, type
);
3678 target_stop_recording (void)
3680 current_target
.to_stop_recording (¤t_target
);
3686 target_info_record (void)
3688 struct target_ops
*t
;
3690 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3691 if (t
->to_info_record
!= NULL
)
3693 t
->to_info_record (t
);
3703 target_save_record (const char *filename
)
3705 current_target
.to_save_record (¤t_target
, filename
);
3711 target_supports_delete_record (void)
3713 struct target_ops
*t
;
3715 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3716 if (t
->to_delete_record
!= NULL
)
3725 target_delete_record (void)
3727 current_target
.to_delete_record (¤t_target
);
3733 target_record_is_replaying (void)
3735 return current_target
.to_record_is_replaying (¤t_target
);
3741 target_goto_record_begin (void)
3743 current_target
.to_goto_record_begin (¤t_target
);
3749 target_goto_record_end (void)
3751 current_target
.to_goto_record_end (¤t_target
);
3757 target_goto_record (ULONGEST insn
)
3759 current_target
.to_goto_record (¤t_target
, insn
);
3765 target_insn_history (int size
, int flags
)
3767 current_target
.to_insn_history (¤t_target
, size
, flags
);
3773 target_insn_history_from (ULONGEST from
, int size
, int flags
)
3775 current_target
.to_insn_history_from (¤t_target
, from
, size
, flags
);
3781 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
3783 current_target
.to_insn_history_range (¤t_target
, begin
, end
, flags
);
3789 target_call_history (int size
, int flags
)
3791 current_target
.to_call_history (¤t_target
, size
, flags
);
3797 target_call_history_from (ULONGEST begin
, int size
, int flags
)
3799 current_target
.to_call_history_from (¤t_target
, begin
, size
, flags
);
3805 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
3807 current_target
.to_call_history_range (¤t_target
, begin
, end
, flags
);
3811 debug_to_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
3813 debug_target
.to_prepare_to_store (&debug_target
, regcache
);
3815 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
3820 const struct frame_unwind
*
3821 target_get_unwinder (void)
3823 struct target_ops
*t
;
3825 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3826 if (t
->to_get_unwinder
!= NULL
)
3827 return t
->to_get_unwinder
;
3834 const struct frame_unwind
*
3835 target_get_tailcall_unwinder (void)
3837 struct target_ops
*t
;
3839 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3840 if (t
->to_get_tailcall_unwinder
!= NULL
)
3841 return t
->to_get_tailcall_unwinder
;
3849 forward_target_decr_pc_after_break (struct target_ops
*ops
,
3850 struct gdbarch
*gdbarch
)
3852 for (; ops
!= NULL
; ops
= ops
->beneath
)
3853 if (ops
->to_decr_pc_after_break
!= NULL
)
3854 return ops
->to_decr_pc_after_break (ops
, gdbarch
);
3856 return gdbarch_decr_pc_after_break (gdbarch
);
3862 target_decr_pc_after_break (struct gdbarch
*gdbarch
)
3864 return forward_target_decr_pc_after_break (current_target
.beneath
, gdbarch
);
3868 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
3869 int write
, struct mem_attrib
*attrib
,
3870 struct target_ops
*target
)
3874 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
3877 fprintf_unfiltered (gdb_stdlog
,
3878 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
3879 paddress (target_gdbarch (), memaddr
), len
,
3880 write
? "write" : "read", retval
);
3886 fputs_unfiltered (", bytes =", gdb_stdlog
);
3887 for (i
= 0; i
< retval
; i
++)
3889 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
3891 if (targetdebug
< 2 && i
> 0)
3893 fprintf_unfiltered (gdb_stdlog
, " ...");
3896 fprintf_unfiltered (gdb_stdlog
, "\n");
3899 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
3903 fputc_unfiltered ('\n', gdb_stdlog
);
3909 debug_to_files_info (struct target_ops
*target
)
3911 debug_target
.to_files_info (target
);
3913 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
3917 debug_to_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
3918 struct bp_target_info
*bp_tgt
)
3922 retval
= debug_target
.to_insert_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
3924 fprintf_unfiltered (gdb_stdlog
,
3925 "target_insert_breakpoint (%s, xxx) = %ld\n",
3926 core_addr_to_string (bp_tgt
->placed_address
),
3927 (unsigned long) retval
);
3932 debug_to_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
3933 struct bp_target_info
*bp_tgt
)
3937 retval
= debug_target
.to_remove_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
3939 fprintf_unfiltered (gdb_stdlog
,
3940 "target_remove_breakpoint (%s, xxx) = %ld\n",
3941 core_addr_to_string (bp_tgt
->placed_address
),
3942 (unsigned long) retval
);
3947 debug_to_can_use_hw_breakpoint (struct target_ops
*self
,
3948 int type
, int cnt
, int from_tty
)
3952 retval
= debug_target
.to_can_use_hw_breakpoint (&debug_target
,
3953 type
, cnt
, from_tty
);
3955 fprintf_unfiltered (gdb_stdlog
,
3956 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
3957 (unsigned long) type
,
3958 (unsigned long) cnt
,
3959 (unsigned long) from_tty
,
3960 (unsigned long) retval
);
3965 debug_to_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3966 CORE_ADDR addr
, int len
)
3970 retval
= debug_target
.to_region_ok_for_hw_watchpoint (&debug_target
,
3973 fprintf_unfiltered (gdb_stdlog
,
3974 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
3975 core_addr_to_string (addr
), (unsigned long) len
,
3976 core_addr_to_string (retval
));
3981 debug_to_can_accel_watchpoint_condition (struct target_ops
*self
,
3982 CORE_ADDR addr
, int len
, int rw
,
3983 struct expression
*cond
)
3987 retval
= debug_target
.to_can_accel_watchpoint_condition (&debug_target
,
3991 fprintf_unfiltered (gdb_stdlog
,
3992 "target_can_accel_watchpoint_condition "
3993 "(%s, %d, %d, %s) = %ld\n",
3994 core_addr_to_string (addr
), len
, rw
,
3995 host_address_to_string (cond
), (unsigned long) retval
);
4000 debug_to_stopped_by_watchpoint (struct target_ops
*ops
)
4004 retval
= debug_target
.to_stopped_by_watchpoint (&debug_target
);
4006 fprintf_unfiltered (gdb_stdlog
,
4007 "target_stopped_by_watchpoint () = %ld\n",
4008 (unsigned long) retval
);
4013 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
4017 retval
= debug_target
.to_stopped_data_address (target
, addr
);
4019 fprintf_unfiltered (gdb_stdlog
,
4020 "target_stopped_data_address ([%s]) = %ld\n",
4021 core_addr_to_string (*addr
),
4022 (unsigned long)retval
);
4027 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
4029 CORE_ADDR start
, int length
)
4033 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
4036 fprintf_filtered (gdb_stdlog
,
4037 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4038 core_addr_to_string (addr
), core_addr_to_string (start
),
4044 debug_to_insert_hw_breakpoint (struct target_ops
*self
,
4045 struct gdbarch
*gdbarch
,
4046 struct bp_target_info
*bp_tgt
)
4050 retval
= debug_target
.to_insert_hw_breakpoint (&debug_target
,
4053 fprintf_unfiltered (gdb_stdlog
,
4054 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4055 core_addr_to_string (bp_tgt
->placed_address
),
4056 (unsigned long) retval
);
4061 debug_to_remove_hw_breakpoint (struct target_ops
*self
,
4062 struct gdbarch
*gdbarch
,
4063 struct bp_target_info
*bp_tgt
)
4067 retval
= debug_target
.to_remove_hw_breakpoint (&debug_target
,
4070 fprintf_unfiltered (gdb_stdlog
,
4071 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4072 core_addr_to_string (bp_tgt
->placed_address
),
4073 (unsigned long) retval
);
4078 debug_to_insert_watchpoint (struct target_ops
*self
,
4079 CORE_ADDR addr
, int len
, int type
,
4080 struct expression
*cond
)
4084 retval
= debug_target
.to_insert_watchpoint (&debug_target
,
4085 addr
, len
, type
, cond
);
4087 fprintf_unfiltered (gdb_stdlog
,
4088 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4089 core_addr_to_string (addr
), len
, type
,
4090 host_address_to_string (cond
), (unsigned long) retval
);
4095 debug_to_remove_watchpoint (struct target_ops
*self
,
4096 CORE_ADDR addr
, int len
, int type
,
4097 struct expression
*cond
)
4101 retval
= debug_target
.to_remove_watchpoint (&debug_target
,
4102 addr
, len
, type
, cond
);
4104 fprintf_unfiltered (gdb_stdlog
,
4105 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4106 core_addr_to_string (addr
), len
, type
,
4107 host_address_to_string (cond
), (unsigned long) retval
);
4112 debug_to_terminal_init (struct target_ops
*self
)
4114 debug_target
.to_terminal_init (&debug_target
);
4116 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
4120 debug_to_terminal_inferior (struct target_ops
*self
)
4122 debug_target
.to_terminal_inferior (&debug_target
);
4124 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
4128 debug_to_terminal_ours_for_output (struct target_ops
*self
)
4130 debug_target
.to_terminal_ours_for_output (&debug_target
);
4132 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
4136 debug_to_terminal_ours (struct target_ops
*self
)
4138 debug_target
.to_terminal_ours (&debug_target
);
4140 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
4144 debug_to_terminal_save_ours (struct target_ops
*self
)
4146 debug_target
.to_terminal_save_ours (&debug_target
);
4148 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
4152 debug_to_terminal_info (struct target_ops
*self
,
4153 const char *arg
, int from_tty
)
4155 debug_target
.to_terminal_info (&debug_target
, arg
, from_tty
);
4157 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
4162 debug_to_load (struct target_ops
*self
, char *args
, int from_tty
)
4164 debug_target
.to_load (&debug_target
, args
, from_tty
);
4166 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
4170 debug_to_post_startup_inferior (struct target_ops
*self
, ptid_t ptid
)
4172 debug_target
.to_post_startup_inferior (&debug_target
, ptid
);
4174 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
4175 ptid_get_pid (ptid
));
4179 debug_to_insert_fork_catchpoint (struct target_ops
*self
, int pid
)
4183 retval
= debug_target
.to_insert_fork_catchpoint (&debug_target
, pid
);
4185 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
4192 debug_to_remove_fork_catchpoint (struct target_ops
*self
, int pid
)
4196 retval
= debug_target
.to_remove_fork_catchpoint (&debug_target
, pid
);
4198 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
4205 debug_to_insert_vfork_catchpoint (struct target_ops
*self
, int pid
)
4209 retval
= debug_target
.to_insert_vfork_catchpoint (&debug_target
, pid
);
4211 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
4218 debug_to_remove_vfork_catchpoint (struct target_ops
*self
, int pid
)
4222 retval
= debug_target
.to_remove_vfork_catchpoint (&debug_target
, pid
);
4224 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
4231 debug_to_insert_exec_catchpoint (struct target_ops
*self
, int pid
)
4235 retval
= debug_target
.to_insert_exec_catchpoint (&debug_target
, pid
);
4237 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
4244 debug_to_remove_exec_catchpoint (struct target_ops
*self
, int pid
)
4248 retval
= debug_target
.to_remove_exec_catchpoint (&debug_target
, pid
);
4250 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
4257 debug_to_has_exited (struct target_ops
*self
,
4258 int pid
, int wait_status
, int *exit_status
)
4262 has_exited
= debug_target
.to_has_exited (&debug_target
,
4263 pid
, wait_status
, exit_status
);
4265 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
4266 pid
, wait_status
, *exit_status
, has_exited
);
4272 debug_to_can_run (struct target_ops
*self
)
4276 retval
= debug_target
.to_can_run (&debug_target
);
4278 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4283 static struct gdbarch
*
4284 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4286 struct gdbarch
*retval
;
4288 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4290 fprintf_unfiltered (gdb_stdlog
,
4291 "target_thread_architecture (%s) = %s [%s]\n",
4292 target_pid_to_str (ptid
),
4293 host_address_to_string (retval
),
4294 gdbarch_bfd_arch_info (retval
)->printable_name
);
4299 debug_to_stop (struct target_ops
*self
, ptid_t ptid
)
4301 debug_target
.to_stop (&debug_target
, ptid
);
4303 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4304 target_pid_to_str (ptid
));
4308 debug_to_rcmd (struct target_ops
*self
, char *command
,
4309 struct ui_file
*outbuf
)
4311 debug_target
.to_rcmd (&debug_target
, command
, outbuf
);
4312 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4316 debug_to_pid_to_exec_file (struct target_ops
*self
, int pid
)
4320 exec_file
= debug_target
.to_pid_to_exec_file (&debug_target
, pid
);
4322 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
4329 setup_target_debug (void)
4331 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
4333 current_target
.to_open
= debug_to_open
;
4334 current_target
.to_post_attach
= debug_to_post_attach
;
4335 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
4336 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
4337 current_target
.to_files_info
= debug_to_files_info
;
4338 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
4339 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
4340 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
4341 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
4342 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
4343 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
4344 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
4345 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
4346 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
4347 current_target
.to_watchpoint_addr_within_range
4348 = debug_to_watchpoint_addr_within_range
;
4349 current_target
.to_region_ok_for_hw_watchpoint
4350 = debug_to_region_ok_for_hw_watchpoint
;
4351 current_target
.to_can_accel_watchpoint_condition
4352 = debug_to_can_accel_watchpoint_condition
;
4353 current_target
.to_terminal_init
= debug_to_terminal_init
;
4354 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
4355 current_target
.to_terminal_ours_for_output
4356 = debug_to_terminal_ours_for_output
;
4357 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
4358 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
4359 current_target
.to_terminal_info
= debug_to_terminal_info
;
4360 current_target
.to_load
= debug_to_load
;
4361 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
4362 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
4363 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
4364 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
4365 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
4366 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
4367 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
4368 current_target
.to_has_exited
= debug_to_has_exited
;
4369 current_target
.to_can_run
= debug_to_can_run
;
4370 current_target
.to_stop
= debug_to_stop
;
4371 current_target
.to_rcmd
= debug_to_rcmd
;
4372 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
4373 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
4377 static char targ_desc
[] =
4378 "Names of targets and files being debugged.\nShows the entire \
4379 stack of targets currently in use (including the exec-file,\n\
4380 core-file, and process, if any), as well as the symbol file name.";
4383 default_rcmd (struct target_ops
*self
, char *command
, struct ui_file
*output
)
4385 error (_("\"monitor\" command not supported by this target."));
4389 do_monitor_command (char *cmd
,
4392 target_rcmd (cmd
, gdb_stdtarg
);
4395 /* Print the name of each layers of our target stack. */
4398 maintenance_print_target_stack (char *cmd
, int from_tty
)
4400 struct target_ops
*t
;
4402 printf_filtered (_("The current target stack is:\n"));
4404 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
4406 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
4410 /* Controls if async mode is permitted. */
4411 int target_async_permitted
= 0;
4413 /* The set command writes to this variable. If the inferior is
4414 executing, target_async_permitted is *not* updated. */
4415 static int target_async_permitted_1
= 0;
4418 set_target_async_command (char *args
, int from_tty
,
4419 struct cmd_list_element
*c
)
4421 if (have_live_inferiors ())
4423 target_async_permitted_1
= target_async_permitted
;
4424 error (_("Cannot change this setting while the inferior is running."));
4427 target_async_permitted
= target_async_permitted_1
;
4431 show_target_async_command (struct ui_file
*file
, int from_tty
,
4432 struct cmd_list_element
*c
,
4435 fprintf_filtered (file
,
4436 _("Controlling the inferior in "
4437 "asynchronous mode is %s.\n"), value
);
4440 /* Temporary copies of permission settings. */
4442 static int may_write_registers_1
= 1;
4443 static int may_write_memory_1
= 1;
4444 static int may_insert_breakpoints_1
= 1;
4445 static int may_insert_tracepoints_1
= 1;
4446 static int may_insert_fast_tracepoints_1
= 1;
4447 static int may_stop_1
= 1;
4449 /* Make the user-set values match the real values again. */
4452 update_target_permissions (void)
4454 may_write_registers_1
= may_write_registers
;
4455 may_write_memory_1
= may_write_memory
;
4456 may_insert_breakpoints_1
= may_insert_breakpoints
;
4457 may_insert_tracepoints_1
= may_insert_tracepoints
;
4458 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
4459 may_stop_1
= may_stop
;
4462 /* The one function handles (most of) the permission flags in the same
4466 set_target_permissions (char *args
, int from_tty
,
4467 struct cmd_list_element
*c
)
4469 if (target_has_execution
)
4471 update_target_permissions ();
4472 error (_("Cannot change this setting while the inferior is running."));
4475 /* Make the real values match the user-changed values. */
4476 may_write_registers
= may_write_registers_1
;
4477 may_insert_breakpoints
= may_insert_breakpoints_1
;
4478 may_insert_tracepoints
= may_insert_tracepoints_1
;
4479 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
4480 may_stop
= may_stop_1
;
4481 update_observer_mode ();
4484 /* Set memory write permission independently of observer mode. */
4487 set_write_memory_permission (char *args
, int from_tty
,
4488 struct cmd_list_element
*c
)
4490 /* Make the real values match the user-changed values. */
4491 may_write_memory
= may_write_memory_1
;
4492 update_observer_mode ();
4497 initialize_targets (void)
4499 init_dummy_target ();
4500 push_target (&dummy_target
);
4502 add_info ("target", target_info
, targ_desc
);
4503 add_info ("files", target_info
, targ_desc
);
4505 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
4506 Set target debugging."), _("\
4507 Show target debugging."), _("\
4508 When non-zero, target debugging is enabled. Higher numbers are more\n\
4509 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
4513 &setdebuglist
, &showdebuglist
);
4515 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
4516 &trust_readonly
, _("\
4517 Set mode for reading from readonly sections."), _("\
4518 Show mode for reading from readonly sections."), _("\
4519 When this mode is on, memory reads from readonly sections (such as .text)\n\
4520 will be read from the object file instead of from the target. This will\n\
4521 result in significant performance improvement for remote targets."),
4523 show_trust_readonly
,
4524 &setlist
, &showlist
);
4526 add_com ("monitor", class_obscure
, do_monitor_command
,
4527 _("Send a command to the remote monitor (remote targets only)."));
4529 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
4530 _("Print the name of each layer of the internal target stack."),
4531 &maintenanceprintlist
);
4533 add_setshow_boolean_cmd ("target-async", no_class
,
4534 &target_async_permitted_1
, _("\
4535 Set whether gdb controls the inferior in asynchronous mode."), _("\
4536 Show whether gdb controls the inferior in asynchronous mode."), _("\
4537 Tells gdb whether to control the inferior in asynchronous mode."),
4538 set_target_async_command
,
4539 show_target_async_command
,
4543 add_setshow_boolean_cmd ("may-write-registers", class_support
,
4544 &may_write_registers_1
, _("\
4545 Set permission to write into registers."), _("\
4546 Show permission to write into registers."), _("\
4547 When this permission is on, GDB may write into the target's registers.\n\
4548 Otherwise, any sort of write attempt will result in an error."),
4549 set_target_permissions
, NULL
,
4550 &setlist
, &showlist
);
4552 add_setshow_boolean_cmd ("may-write-memory", class_support
,
4553 &may_write_memory_1
, _("\
4554 Set permission to write into target memory."), _("\
4555 Show permission to write into target memory."), _("\
4556 When this permission is on, GDB may write into the target's memory.\n\
4557 Otherwise, any sort of write attempt will result in an error."),
4558 set_write_memory_permission
, NULL
,
4559 &setlist
, &showlist
);
4561 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
4562 &may_insert_breakpoints_1
, _("\
4563 Set permission to insert breakpoints in the target."), _("\
4564 Show permission to insert breakpoints in the target."), _("\
4565 When this permission is on, GDB may insert breakpoints in the program.\n\
4566 Otherwise, any sort of insertion attempt will result in an error."),
4567 set_target_permissions
, NULL
,
4568 &setlist
, &showlist
);
4570 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
4571 &may_insert_tracepoints_1
, _("\
4572 Set permission to insert tracepoints in the target."), _("\
4573 Show permission to insert tracepoints in the target."), _("\
4574 When this permission is on, GDB may insert tracepoints in the program.\n\
4575 Otherwise, any sort of insertion attempt will result in an error."),
4576 set_target_permissions
, NULL
,
4577 &setlist
, &showlist
);
4579 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
4580 &may_insert_fast_tracepoints_1
, _("\
4581 Set permission to insert fast tracepoints in the target."), _("\
4582 Show permission to insert fast tracepoints in the target."), _("\
4583 When this permission is on, GDB may insert fast tracepoints.\n\
4584 Otherwise, any sort of insertion attempt will result in an error."),
4585 set_target_permissions
, NULL
,
4586 &setlist
, &showlist
);
4588 add_setshow_boolean_cmd ("may-interrupt", class_support
,
4590 Set permission to interrupt or signal the target."), _("\
4591 Show permission to interrupt or signal the target."), _("\
4592 When this permission is on, GDB may interrupt/stop the target's execution.\n\
4593 Otherwise, any attempt to interrupt or stop will be ignored."),
4594 set_target_permissions
, NULL
,
4595 &setlist
, &showlist
);