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 (struct target_ops
*);
82 static int return_zero_has_execution (struct target_ops
*, ptid_t
);
84 void target_ignore (void);
86 static void target_command (char *, int);
88 static struct target_ops
*find_default_run_target (char *);
90 static target_xfer_partial_ftype default_xfer_partial
;
92 static struct gdbarch
*default_thread_architecture (struct target_ops
*ops
,
95 static int dummy_find_memory_regions (struct target_ops
*self
,
96 find_memory_region_ftype ignore1
,
99 static char *dummy_make_corefile_notes (struct target_ops
*self
,
100 bfd
*ignore1
, int *ignore2
);
102 static char *default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
);
104 static int find_default_can_async_p (struct target_ops
*ignore
);
106 static int find_default_is_async_p (struct target_ops
*ignore
);
108 static enum exec_direction_kind default_execution_direction
109 (struct target_ops
*self
);
111 static CORE_ADDR
default_target_decr_pc_after_break (struct target_ops
*ops
,
112 struct gdbarch
*gdbarch
);
114 #include "target-delegates.c"
116 static void init_dummy_target (void);
118 static struct target_ops debug_target
;
120 static void debug_to_open (char *, int);
122 static void debug_to_prepare_to_store (struct target_ops
*self
,
125 static void debug_to_files_info (struct target_ops
*);
127 static int debug_to_insert_breakpoint (struct target_ops
*, struct gdbarch
*,
128 struct bp_target_info
*);
130 static int debug_to_remove_breakpoint (struct target_ops
*, struct gdbarch
*,
131 struct bp_target_info
*);
133 static int debug_to_can_use_hw_breakpoint (struct target_ops
*self
,
136 static int debug_to_insert_hw_breakpoint (struct target_ops
*self
,
138 struct bp_target_info
*);
140 static int debug_to_remove_hw_breakpoint (struct target_ops
*self
,
142 struct bp_target_info
*);
144 static int debug_to_insert_watchpoint (struct target_ops
*self
,
146 struct expression
*);
148 static int debug_to_remove_watchpoint (struct target_ops
*self
,
150 struct expression
*);
152 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
154 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
155 CORE_ADDR
, CORE_ADDR
, int);
157 static int debug_to_region_ok_for_hw_watchpoint (struct target_ops
*self
,
160 static int debug_to_can_accel_watchpoint_condition (struct target_ops
*self
,
162 struct expression
*);
164 static void debug_to_terminal_init (struct target_ops
*self
);
166 static void debug_to_terminal_inferior (struct target_ops
*self
);
168 static void debug_to_terminal_ours_for_output (struct target_ops
*self
);
170 static void debug_to_terminal_save_ours (struct target_ops
*self
);
172 static void debug_to_terminal_ours (struct target_ops
*self
);
174 static void debug_to_load (struct target_ops
*self
, char *, int);
176 static int debug_to_can_run (struct target_ops
*self
);
178 static void debug_to_stop (struct target_ops
*self
, ptid_t
);
180 /* Pointer to array of target architecture structures; the size of the
181 array; the current index into the array; the allocated size of the
183 struct target_ops
**target_structs
;
184 unsigned target_struct_size
;
185 unsigned target_struct_allocsize
;
186 #define DEFAULT_ALLOCSIZE 10
188 /* The initial current target, so that there is always a semi-valid
191 static struct target_ops dummy_target
;
193 /* Top of target stack. */
195 static struct target_ops
*target_stack
;
197 /* The target structure we are currently using to talk to a process
198 or file or whatever "inferior" we have. */
200 struct target_ops current_target
;
202 /* Command list for target. */
204 static struct cmd_list_element
*targetlist
= NULL
;
206 /* Nonzero if we should trust readonly sections from the
207 executable when reading memory. */
209 static int trust_readonly
= 0;
211 /* Nonzero if we should show true memory content including
212 memory breakpoint inserted by gdb. */
214 static int show_memory_breakpoints
= 0;
216 /* These globals control whether GDB attempts to perform these
217 operations; they are useful for targets that need to prevent
218 inadvertant disruption, such as in non-stop mode. */
220 int may_write_registers
= 1;
222 int may_write_memory
= 1;
224 int may_insert_breakpoints
= 1;
226 int may_insert_tracepoints
= 1;
228 int may_insert_fast_tracepoints
= 1;
232 /* Non-zero if we want to see trace of target level stuff. */
234 static unsigned int targetdebug
= 0;
236 show_targetdebug (struct ui_file
*file
, int from_tty
,
237 struct cmd_list_element
*c
, const char *value
)
239 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
242 static void setup_target_debug (void);
244 /* The user just typed 'target' without the name of a target. */
247 target_command (char *arg
, int from_tty
)
249 fputs_filtered ("Argument required (target name). Try `help target'\n",
253 /* Default target_has_* methods for process_stratum targets. */
256 default_child_has_all_memory (struct target_ops
*ops
)
258 /* If no inferior selected, then we can't read memory here. */
259 if (ptid_equal (inferior_ptid
, null_ptid
))
266 default_child_has_memory (struct target_ops
*ops
)
268 /* If no inferior selected, then we can't read memory here. */
269 if (ptid_equal (inferior_ptid
, null_ptid
))
276 default_child_has_stack (struct target_ops
*ops
)
278 /* If no inferior selected, there's no stack. */
279 if (ptid_equal (inferior_ptid
, null_ptid
))
286 default_child_has_registers (struct target_ops
*ops
)
288 /* Can't read registers from no inferior. */
289 if (ptid_equal (inferior_ptid
, null_ptid
))
296 default_child_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
298 /* If there's no thread selected, then we can't make it run through
300 if (ptid_equal (the_ptid
, null_ptid
))
308 target_has_all_memory_1 (void)
310 struct target_ops
*t
;
312 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
313 if (t
->to_has_all_memory (t
))
320 target_has_memory_1 (void)
322 struct target_ops
*t
;
324 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
325 if (t
->to_has_memory (t
))
332 target_has_stack_1 (void)
334 struct target_ops
*t
;
336 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
337 if (t
->to_has_stack (t
))
344 target_has_registers_1 (void)
346 struct target_ops
*t
;
348 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
349 if (t
->to_has_registers (t
))
356 target_has_execution_1 (ptid_t the_ptid
)
358 struct target_ops
*t
;
360 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
361 if (t
->to_has_execution (t
, the_ptid
))
368 target_has_execution_current (void)
370 return target_has_execution_1 (inferior_ptid
);
373 /* Complete initialization of T. This ensures that various fields in
374 T are set, if needed by the target implementation. */
377 complete_target_initialization (struct target_ops
*t
)
379 /* Provide default values for all "must have" methods. */
380 if (t
->to_xfer_partial
== NULL
)
381 t
->to_xfer_partial
= default_xfer_partial
;
383 if (t
->to_has_all_memory
== NULL
)
384 t
->to_has_all_memory
= return_zero
;
386 if (t
->to_has_memory
== NULL
)
387 t
->to_has_memory
= return_zero
;
389 if (t
->to_has_stack
== NULL
)
390 t
->to_has_stack
= return_zero
;
392 if (t
->to_has_registers
== NULL
)
393 t
->to_has_registers
= return_zero
;
395 if (t
->to_has_execution
== NULL
)
396 t
->to_has_execution
= return_zero_has_execution
;
398 install_delegators (t
);
401 /* Add possible target architecture T to the list and add a new
402 command 'target T->to_shortname'. Set COMPLETER as the command's
403 completer if not NULL. */
406 add_target_with_completer (struct target_ops
*t
,
407 completer_ftype
*completer
)
409 struct cmd_list_element
*c
;
411 complete_target_initialization (t
);
415 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
416 target_structs
= (struct target_ops
**) xmalloc
417 (target_struct_allocsize
* sizeof (*target_structs
));
419 if (target_struct_size
>= target_struct_allocsize
)
421 target_struct_allocsize
*= 2;
422 target_structs
= (struct target_ops
**)
423 xrealloc ((char *) target_structs
,
424 target_struct_allocsize
* sizeof (*target_structs
));
426 target_structs
[target_struct_size
++] = t
;
428 if (targetlist
== NULL
)
429 add_prefix_cmd ("target", class_run
, target_command
, _("\
430 Connect to a target machine or process.\n\
431 The first argument is the type or protocol of the target machine.\n\
432 Remaining arguments are interpreted by the target protocol. For more\n\
433 information on the arguments for a particular protocol, type\n\
434 `help target ' followed by the protocol name."),
435 &targetlist
, "target ", 0, &cmdlist
);
436 c
= add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
,
438 if (completer
!= NULL
)
439 set_cmd_completer (c
, completer
);
442 /* Add a possible target architecture to the list. */
445 add_target (struct target_ops
*t
)
447 add_target_with_completer (t
, NULL
);
453 add_deprecated_target_alias (struct target_ops
*t
, char *alias
)
455 struct cmd_list_element
*c
;
458 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
460 c
= add_cmd (alias
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
461 alt
= xstrprintf ("target %s", t
->to_shortname
);
462 deprecate_cmd (c
, alt
);
476 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
478 current_target
.to_kill (¤t_target
);
482 target_load (char *arg
, int from_tty
)
484 target_dcache_invalidate ();
485 (*current_target
.to_load
) (¤t_target
, arg
, from_tty
);
489 target_create_inferior (char *exec_file
, char *args
,
490 char **env
, int from_tty
)
492 struct target_ops
*t
;
494 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
496 if (t
->to_create_inferior
!= NULL
)
498 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
500 fprintf_unfiltered (gdb_stdlog
,
501 "target_create_inferior (%s, %s, xxx, %d)\n",
502 exec_file
, args
, from_tty
);
507 internal_error (__FILE__
, __LINE__
,
508 _("could not find a target to create inferior"));
512 target_terminal_inferior (void)
514 /* A background resume (``run&'') should leave GDB in control of the
515 terminal. Use target_can_async_p, not target_is_async_p, since at
516 this point the target is not async yet. However, if sync_execution
517 is not set, we know it will become async prior to resume. */
518 if (target_can_async_p () && !sync_execution
)
521 /* If GDB is resuming the inferior in the foreground, install
522 inferior's terminal modes. */
523 (*current_target
.to_terminal_inferior
) (¤t_target
);
527 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
528 struct target_ops
*t
)
530 errno
= EIO
; /* Can't read/write this location. */
531 return 0; /* No bytes handled. */
537 error (_("You can't do that when your target is `%s'"),
538 current_target
.to_shortname
);
544 error (_("You can't do that without a process to debug."));
548 default_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
550 printf_unfiltered (_("No saved terminal information.\n"));
553 /* A default implementation for the to_get_ada_task_ptid target method.
555 This function builds the PTID by using both LWP and TID as part of
556 the PTID lwp and tid elements. The pid used is the pid of the
560 default_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long tid
)
562 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
565 static enum exec_direction_kind
566 default_execution_direction (struct target_ops
*self
)
568 if (!target_can_execute_reverse
)
570 else if (!target_can_async_p ())
573 gdb_assert_not_reached ("\
574 to_execution_direction must be implemented for reverse async");
577 /* Go through the target stack from top to bottom, copying over zero
578 entries in current_target, then filling in still empty entries. In
579 effect, we are doing class inheritance through the pushed target
582 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
583 is currently implemented, is that it discards any knowledge of
584 which target an inherited method originally belonged to.
585 Consequently, new new target methods should instead explicitly and
586 locally search the target stack for the target that can handle the
590 update_current_target (void)
592 struct target_ops
*t
;
594 /* First, reset current's contents. */
595 memset (¤t_target
, 0, sizeof (current_target
));
597 /* Install the delegators. */
598 install_delegators (¤t_target
);
600 current_target
.to_stratum
= target_stack
->to_stratum
;
602 #define INHERIT(FIELD, TARGET) \
603 if (!current_target.FIELD) \
604 current_target.FIELD = (TARGET)->FIELD
606 /* Do not add any new INHERITs here. Instead, use the delegation
607 mechanism provided by make-target-delegates. */
608 for (t
= target_stack
; t
; t
= t
->beneath
)
610 INHERIT (to_shortname
, t
);
611 INHERIT (to_longname
, t
);
612 INHERIT (to_attach_no_wait
, t
);
613 INHERIT (deprecated_xfer_memory
, t
);
614 INHERIT (to_have_steppable_watchpoint
, t
);
615 INHERIT (to_have_continuable_watchpoint
, t
);
616 INHERIT (to_has_thread_control
, t
);
620 /* Clean up a target struct so it no longer has any zero pointers in
621 it. Do not add any new de_faults here. Instead, use the
622 delegation mechanism provided by make-target-delegates. */
624 #define de_fault(field, value) \
625 if (!current_target.field) \
626 current_target.field = value
628 de_fault (deprecated_xfer_memory
,
629 (int (*) (CORE_ADDR
, gdb_byte
*, int, int,
630 struct mem_attrib
*, struct target_ops
*))
635 /* Finally, position the target-stack beneath the squashed
636 "current_target". That way code looking for a non-inherited
637 target method can quickly and simply find it. */
638 current_target
.beneath
= target_stack
;
641 setup_target_debug ();
644 /* Push a new target type into the stack of the existing target accessors,
645 possibly superseding some of the existing accessors.
647 Rather than allow an empty stack, we always have the dummy target at
648 the bottom stratum, so we can call the function vectors without
652 push_target (struct target_ops
*t
)
654 struct target_ops
**cur
;
656 /* Check magic number. If wrong, it probably means someone changed
657 the struct definition, but not all the places that initialize one. */
658 if (t
->to_magic
!= OPS_MAGIC
)
660 fprintf_unfiltered (gdb_stderr
,
661 "Magic number of %s target struct wrong\n",
663 internal_error (__FILE__
, __LINE__
,
664 _("failed internal consistency check"));
667 /* Find the proper stratum to install this target in. */
668 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
670 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
674 /* If there's already targets at this stratum, remove them. */
675 /* FIXME: cagney/2003-10-15: I think this should be popping all
676 targets to CUR, and not just those at this stratum level. */
677 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
679 /* There's already something at this stratum level. Close it,
680 and un-hook it from the stack. */
681 struct target_ops
*tmp
= (*cur
);
683 (*cur
) = (*cur
)->beneath
;
688 /* We have removed all targets in our stratum, now add the new one. */
692 update_current_target ();
695 /* Remove a target_ops vector from the stack, wherever it may be.
696 Return how many times it was removed (0 or 1). */
699 unpush_target (struct target_ops
*t
)
701 struct target_ops
**cur
;
702 struct target_ops
*tmp
;
704 if (t
->to_stratum
== dummy_stratum
)
705 internal_error (__FILE__
, __LINE__
,
706 _("Attempt to unpush the dummy target"));
708 /* Look for the specified target. Note that we assume that a target
709 can only occur once in the target stack. */
711 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
717 /* If we don't find target_ops, quit. Only open targets should be
722 /* Unchain the target. */
724 (*cur
) = (*cur
)->beneath
;
727 update_current_target ();
729 /* Finally close the target. Note we do this after unchaining, so
730 any target method calls from within the target_close
731 implementation don't end up in T anymore. */
738 pop_all_targets_above (enum strata above_stratum
)
740 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
742 if (!unpush_target (target_stack
))
744 fprintf_unfiltered (gdb_stderr
,
745 "pop_all_targets couldn't find target %s\n",
746 target_stack
->to_shortname
);
747 internal_error (__FILE__
, __LINE__
,
748 _("failed internal consistency check"));
755 pop_all_targets (void)
757 pop_all_targets_above (dummy_stratum
);
760 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
763 target_is_pushed (struct target_ops
*t
)
765 struct target_ops
**cur
;
767 /* Check magic number. If wrong, it probably means someone changed
768 the struct definition, but not all the places that initialize one. */
769 if (t
->to_magic
!= OPS_MAGIC
)
771 fprintf_unfiltered (gdb_stderr
,
772 "Magic number of %s target struct wrong\n",
774 internal_error (__FILE__
, __LINE__
,
775 _("failed internal consistency check"));
778 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
785 /* Using the objfile specified in OBJFILE, find the address for the
786 current thread's thread-local storage with offset OFFSET. */
788 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
790 volatile CORE_ADDR addr
= 0;
791 struct target_ops
*target
;
793 for (target
= current_target
.beneath
;
795 target
= target
->beneath
)
797 if (target
->to_get_thread_local_address
!= NULL
)
802 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
804 ptid_t ptid
= inferior_ptid
;
805 volatile struct gdb_exception ex
;
807 TRY_CATCH (ex
, RETURN_MASK_ALL
)
811 /* Fetch the load module address for this objfile. */
812 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch (),
814 /* If it's 0, throw the appropriate exception. */
816 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
817 _("TLS load module not found"));
819 addr
= target
->to_get_thread_local_address (target
, ptid
,
822 /* If an error occurred, print TLS related messages here. Otherwise,
823 throw the error to some higher catcher. */
826 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
830 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
831 error (_("Cannot find thread-local variables "
832 "in this thread library."));
834 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
835 if (objfile_is_library
)
836 error (_("Cannot find shared library `%s' in dynamic"
837 " linker's load module list"), objfile_name (objfile
));
839 error (_("Cannot find executable file `%s' in dynamic"
840 " linker's load module list"), objfile_name (objfile
));
842 case TLS_NOT_ALLOCATED_YET_ERROR
:
843 if (objfile_is_library
)
844 error (_("The inferior has not yet allocated storage for"
845 " thread-local variables in\n"
846 "the shared library `%s'\n"
848 objfile_name (objfile
), target_pid_to_str (ptid
));
850 error (_("The inferior has not yet allocated storage for"
851 " thread-local variables in\n"
852 "the executable `%s'\n"
854 objfile_name (objfile
), target_pid_to_str (ptid
));
856 case TLS_GENERIC_ERROR
:
857 if (objfile_is_library
)
858 error (_("Cannot find thread-local storage for %s, "
859 "shared library %s:\n%s"),
860 target_pid_to_str (ptid
),
861 objfile_name (objfile
), ex
.message
);
863 error (_("Cannot find thread-local storage for %s, "
864 "executable file %s:\n%s"),
865 target_pid_to_str (ptid
),
866 objfile_name (objfile
), ex
.message
);
869 throw_exception (ex
);
874 /* It wouldn't be wrong here to try a gdbarch method, too; finding
875 TLS is an ABI-specific thing. But we don't do that yet. */
877 error (_("Cannot find thread-local variables on this target"));
883 target_xfer_status_to_string (enum target_xfer_status err
)
885 #define CASE(X) case X: return #X
888 CASE(TARGET_XFER_E_IO
);
889 CASE(TARGET_XFER_E_UNAVAILABLE
);
898 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
900 /* target_read_string -- read a null terminated string, up to LEN bytes,
901 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
902 Set *STRING to a pointer to malloc'd memory containing the data; the caller
903 is responsible for freeing it. Return the number of bytes successfully
907 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
913 int buffer_allocated
;
915 unsigned int nbytes_read
= 0;
919 /* Small for testing. */
920 buffer_allocated
= 4;
921 buffer
= xmalloc (buffer_allocated
);
926 tlen
= MIN (len
, 4 - (memaddr
& 3));
927 offset
= memaddr
& 3;
929 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
932 /* The transfer request might have crossed the boundary to an
933 unallocated region of memory. Retry the transfer, requesting
937 errcode
= target_read_memory (memaddr
, buf
, 1);
942 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
946 bytes
= bufptr
- buffer
;
947 buffer_allocated
*= 2;
948 buffer
= xrealloc (buffer
, buffer_allocated
);
949 bufptr
= buffer
+ bytes
;
952 for (i
= 0; i
< tlen
; i
++)
954 *bufptr
++ = buf
[i
+ offset
];
955 if (buf
[i
+ offset
] == '\000')
957 nbytes_read
+= i
+ 1;
973 struct target_section_table
*
974 target_get_section_table (struct target_ops
*target
)
977 fprintf_unfiltered (gdb_stdlog
, "target_get_section_table ()\n");
979 return (*target
->to_get_section_table
) (target
);
982 /* Find a section containing ADDR. */
984 struct target_section
*
985 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
987 struct target_section_table
*table
= target_get_section_table (target
);
988 struct target_section
*secp
;
993 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
995 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1001 /* Read memory from the live target, even if currently inspecting a
1002 traceframe. The return is the same as that of target_read. */
1004 static enum target_xfer_status
1005 target_read_live_memory (enum target_object object
,
1006 ULONGEST memaddr
, gdb_byte
*myaddr
, ULONGEST len
,
1007 ULONGEST
*xfered_len
)
1009 enum target_xfer_status ret
;
1010 struct cleanup
*cleanup
;
1012 /* Switch momentarily out of tfind mode so to access live memory.
1013 Note that this must not clear global state, such as the frame
1014 cache, which must still remain valid for the previous traceframe.
1015 We may be _building_ the frame cache at this point. */
1016 cleanup
= make_cleanup_restore_traceframe_number ();
1017 set_traceframe_number (-1);
1019 ret
= target_xfer_partial (current_target
.beneath
, object
, NULL
,
1020 myaddr
, NULL
, memaddr
, len
, xfered_len
);
1022 do_cleanups (cleanup
);
1026 /* Using the set of read-only target sections of OPS, read live
1027 read-only memory. Note that the actual reads start from the
1028 top-most target again.
1030 For interface/parameters/return description see target.h,
1033 static enum target_xfer_status
1034 memory_xfer_live_readonly_partial (struct target_ops
*ops
,
1035 enum target_object object
,
1036 gdb_byte
*readbuf
, ULONGEST memaddr
,
1037 ULONGEST len
, ULONGEST
*xfered_len
)
1039 struct target_section
*secp
;
1040 struct target_section_table
*table
;
1042 secp
= target_section_by_addr (ops
, memaddr
);
1044 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1045 secp
->the_bfd_section
)
1048 struct target_section
*p
;
1049 ULONGEST memend
= memaddr
+ len
;
1051 table
= target_get_section_table (ops
);
1053 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1055 if (memaddr
>= p
->addr
)
1057 if (memend
<= p
->endaddr
)
1059 /* Entire transfer is within this section. */
1060 return target_read_live_memory (object
, memaddr
,
1061 readbuf
, len
, xfered_len
);
1063 else if (memaddr
>= p
->endaddr
)
1065 /* This section ends before the transfer starts. */
1070 /* This section overlaps the transfer. Just do half. */
1071 len
= p
->endaddr
- memaddr
;
1072 return target_read_live_memory (object
, memaddr
,
1073 readbuf
, len
, xfered_len
);
1079 return TARGET_XFER_EOF
;
1082 /* Read memory from more than one valid target. A core file, for
1083 instance, could have some of memory but delegate other bits to
1084 the target below it. So, we must manually try all targets. */
1086 static enum target_xfer_status
1087 raw_memory_xfer_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
1088 const gdb_byte
*writebuf
, ULONGEST memaddr
, LONGEST len
,
1089 ULONGEST
*xfered_len
)
1091 enum target_xfer_status res
;
1095 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1096 readbuf
, writebuf
, memaddr
, len
,
1098 if (res
== TARGET_XFER_OK
)
1101 /* Stop if the target reports that the memory is not available. */
1102 if (res
== TARGET_XFER_E_UNAVAILABLE
)
1105 /* We want to continue past core files to executables, but not
1106 past a running target's memory. */
1107 if (ops
->to_has_all_memory (ops
))
1112 while (ops
!= NULL
);
1117 /* Perform a partial memory transfer.
1118 For docs see target.h, to_xfer_partial. */
1120 static enum target_xfer_status
1121 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
1122 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
1123 ULONGEST len
, ULONGEST
*xfered_len
)
1125 enum target_xfer_status res
;
1127 struct mem_region
*region
;
1128 struct inferior
*inf
;
1130 /* For accesses to unmapped overlay sections, read directly from
1131 files. Must do this first, as MEMADDR may need adjustment. */
1132 if (readbuf
!= NULL
&& overlay_debugging
)
1134 struct obj_section
*section
= find_pc_overlay (memaddr
);
1136 if (pc_in_unmapped_range (memaddr
, section
))
1138 struct target_section_table
*table
1139 = target_get_section_table (ops
);
1140 const char *section_name
= section
->the_bfd_section
->name
;
1142 memaddr
= overlay_mapped_address (memaddr
, section
);
1143 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1144 memaddr
, len
, xfered_len
,
1146 table
->sections_end
,
1151 /* Try the executable files, if "trust-readonly-sections" is set. */
1152 if (readbuf
!= NULL
&& trust_readonly
)
1154 struct target_section
*secp
;
1155 struct target_section_table
*table
;
1157 secp
= target_section_by_addr (ops
, memaddr
);
1159 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1160 secp
->the_bfd_section
)
1163 table
= target_get_section_table (ops
);
1164 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1165 memaddr
, len
, xfered_len
,
1167 table
->sections_end
,
1172 /* If reading unavailable memory in the context of traceframes, and
1173 this address falls within a read-only section, fallback to
1174 reading from live memory. */
1175 if (readbuf
!= NULL
&& get_traceframe_number () != -1)
1177 VEC(mem_range_s
) *available
;
1179 /* If we fail to get the set of available memory, then the
1180 target does not support querying traceframe info, and so we
1181 attempt reading from the traceframe anyway (assuming the
1182 target implements the old QTro packet then). */
1183 if (traceframe_available_memory (&available
, memaddr
, len
))
1185 struct cleanup
*old_chain
;
1187 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
1189 if (VEC_empty (mem_range_s
, available
)
1190 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
1192 /* Don't read into the traceframe's available
1194 if (!VEC_empty (mem_range_s
, available
))
1196 LONGEST oldlen
= len
;
1198 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
1199 gdb_assert (len
<= oldlen
);
1202 do_cleanups (old_chain
);
1204 /* This goes through the topmost target again. */
1205 res
= memory_xfer_live_readonly_partial (ops
, object
,
1208 if (res
== TARGET_XFER_OK
)
1209 return TARGET_XFER_OK
;
1212 /* No use trying further, we know some memory starting
1213 at MEMADDR isn't available. */
1215 return TARGET_XFER_E_UNAVAILABLE
;
1219 /* Don't try to read more than how much is available, in
1220 case the target implements the deprecated QTro packet to
1221 cater for older GDBs (the target's knowledge of read-only
1222 sections may be outdated by now). */
1223 len
= VEC_index (mem_range_s
, available
, 0)->length
;
1225 do_cleanups (old_chain
);
1229 /* Try GDB's internal data cache. */
1230 region
= lookup_mem_region (memaddr
);
1231 /* region->hi == 0 means there's no upper bound. */
1232 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1235 reg_len
= region
->hi
- memaddr
;
1237 switch (region
->attrib
.mode
)
1240 if (writebuf
!= NULL
)
1241 return TARGET_XFER_E_IO
;
1245 if (readbuf
!= NULL
)
1246 return TARGET_XFER_E_IO
;
1250 /* We only support writing to flash during "load" for now. */
1251 if (writebuf
!= NULL
)
1252 error (_("Writing to flash memory forbidden in this context"));
1256 return TARGET_XFER_E_IO
;
1259 if (!ptid_equal (inferior_ptid
, null_ptid
))
1260 inf
= find_inferior_pid (ptid_get_pid (inferior_ptid
));
1265 /* The dcache reads whole cache lines; that doesn't play well
1266 with reading from a trace buffer, because reading outside of
1267 the collected memory range fails. */
1268 && get_traceframe_number () == -1
1269 && (region
->attrib
.cache
1270 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1271 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1273 DCACHE
*dcache
= target_dcache_get_or_init ();
1276 if (readbuf
!= NULL
)
1277 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, readbuf
, reg_len
, 0);
1279 /* FIXME drow/2006-08-09: If we're going to preserve const
1280 correctness dcache_xfer_memory should take readbuf and
1282 l
= dcache_xfer_memory (ops
, dcache
, memaddr
, (void *) writebuf
,
1285 return TARGET_XFER_E_IO
;
1288 *xfered_len
= (ULONGEST
) l
;
1289 return TARGET_XFER_OK
;
1293 /* If none of those methods found the memory we wanted, fall back
1294 to a target partial transfer. Normally a single call to
1295 to_xfer_partial is enough; if it doesn't recognize an object
1296 it will call the to_xfer_partial of the next target down.
1297 But for memory this won't do. Memory is the only target
1298 object which can be read from more than one valid target.
1299 A core file, for instance, could have some of memory but
1300 delegate other bits to the target below it. So, we must
1301 manually try all targets. */
1303 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
,
1306 /* Make sure the cache gets updated no matter what - if we are writing
1307 to the stack. Even if this write is not tagged as such, we still need
1308 to update the cache. */
1310 if (res
== TARGET_XFER_OK
1313 && target_dcache_init_p ()
1314 && !region
->attrib
.cache
1315 && ((stack_cache_enabled_p () && object
!= TARGET_OBJECT_STACK_MEMORY
)
1316 || (code_cache_enabled_p () && object
!= TARGET_OBJECT_CODE_MEMORY
)))
1318 DCACHE
*dcache
= target_dcache_get ();
1320 dcache_update (dcache
, memaddr
, (void *) writebuf
, reg_len
);
1323 /* If we still haven't got anything, return the last error. We
1328 /* Perform a partial memory transfer. For docs see target.h,
1331 static enum target_xfer_status
1332 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1333 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1334 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1336 enum target_xfer_status res
;
1338 /* Zero length requests are ok and require no work. */
1340 return TARGET_XFER_EOF
;
1342 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1343 breakpoint insns, thus hiding out from higher layers whether
1344 there are software breakpoints inserted in the code stream. */
1345 if (readbuf
!= NULL
)
1347 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
,
1350 if (res
== TARGET_XFER_OK
&& !show_memory_breakpoints
)
1351 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, res
);
1356 struct cleanup
*old_chain
;
1358 /* A large write request is likely to be partially satisfied
1359 by memory_xfer_partial_1. We will continually malloc
1360 and free a copy of the entire write request for breakpoint
1361 shadow handling even though we only end up writing a small
1362 subset of it. Cap writes to 4KB to mitigate this. */
1363 len
= min (4096, len
);
1365 buf
= xmalloc (len
);
1366 old_chain
= make_cleanup (xfree
, buf
);
1367 memcpy (buf
, writebuf
, len
);
1369 breakpoint_xfer_memory (NULL
, buf
, writebuf
, memaddr
, len
);
1370 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
, memaddr
, len
,
1373 do_cleanups (old_chain
);
1380 restore_show_memory_breakpoints (void *arg
)
1382 show_memory_breakpoints
= (uintptr_t) arg
;
1386 make_show_memory_breakpoints_cleanup (int show
)
1388 int current
= show_memory_breakpoints
;
1390 show_memory_breakpoints
= show
;
1391 return make_cleanup (restore_show_memory_breakpoints
,
1392 (void *) (uintptr_t) current
);
1395 /* For docs see target.h, to_xfer_partial. */
1397 enum target_xfer_status
1398 target_xfer_partial (struct target_ops
*ops
,
1399 enum target_object object
, const char *annex
,
1400 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1401 ULONGEST offset
, ULONGEST len
,
1402 ULONGEST
*xfered_len
)
1404 enum target_xfer_status retval
;
1406 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1408 /* Transfer is done when LEN is zero. */
1410 return TARGET_XFER_EOF
;
1412 if (writebuf
&& !may_write_memory
)
1413 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1414 core_addr_to_string_nz (offset
), plongest (len
));
1418 /* If this is a memory transfer, let the memory-specific code
1419 have a look at it instead. Memory transfers are more
1421 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1422 || object
== TARGET_OBJECT_CODE_MEMORY
)
1423 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1424 writebuf
, offset
, len
, xfered_len
);
1425 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1427 /* Request the normal memory object from other layers. */
1428 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
,
1432 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
,
1433 writebuf
, offset
, len
, xfered_len
);
1437 const unsigned char *myaddr
= NULL
;
1439 fprintf_unfiltered (gdb_stdlog
,
1440 "%s:target_xfer_partial "
1441 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1444 (annex
? annex
: "(null)"),
1445 host_address_to_string (readbuf
),
1446 host_address_to_string (writebuf
),
1447 core_addr_to_string_nz (offset
),
1448 pulongest (len
), retval
,
1449 pulongest (*xfered_len
));
1455 if (retval
== TARGET_XFER_OK
&& myaddr
!= NULL
)
1459 fputs_unfiltered (", bytes =", gdb_stdlog
);
1460 for (i
= 0; i
< *xfered_len
; i
++)
1462 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1464 if (targetdebug
< 2 && i
> 0)
1466 fprintf_unfiltered (gdb_stdlog
, " ...");
1469 fprintf_unfiltered (gdb_stdlog
, "\n");
1472 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1476 fputc_unfiltered ('\n', gdb_stdlog
);
1479 /* Check implementations of to_xfer_partial update *XFERED_LEN
1480 properly. Do assertion after printing debug messages, so that we
1481 can find more clues on assertion failure from debugging messages. */
1482 if (retval
== TARGET_XFER_OK
|| retval
== TARGET_XFER_E_UNAVAILABLE
)
1483 gdb_assert (*xfered_len
> 0);
1488 /* Read LEN bytes of target memory at address MEMADDR, placing the
1489 results in GDB's memory at MYADDR. Returns either 0 for success or
1490 TARGET_XFER_E_IO if any error occurs.
1492 If an error occurs, no guarantee is made about the contents of the data at
1493 MYADDR. In particular, the caller should not depend upon partial reads
1494 filling the buffer with good data. There is no way for the caller to know
1495 how much good data might have been transfered anyway. Callers that can
1496 deal with partial reads should call target_read (which will retry until
1497 it makes no progress, and then return how much was transferred). */
1500 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1502 /* Dispatch to the topmost target, not the flattened current_target.
1503 Memory accesses check target->to_has_(all_)memory, and the
1504 flattened target doesn't inherit those. */
1505 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1506 myaddr
, memaddr
, len
) == len
)
1509 return TARGET_XFER_E_IO
;
1512 /* Like target_read_memory, but specify explicitly that this is a read
1513 from the target's raw memory. That is, this read bypasses the
1514 dcache, breakpoint shadowing, etc. */
1517 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1519 /* See comment in target_read_memory about why the request starts at
1520 current_target.beneath. */
1521 if (target_read (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1522 myaddr
, memaddr
, len
) == len
)
1525 return TARGET_XFER_E_IO
;
1528 /* Like target_read_memory, but specify explicitly that this is a read from
1529 the target's stack. This may trigger different cache behavior. */
1532 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1534 /* See comment in target_read_memory about why the request starts at
1535 current_target.beneath. */
1536 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1537 myaddr
, memaddr
, len
) == len
)
1540 return TARGET_XFER_E_IO
;
1543 /* Like target_read_memory, but specify explicitly that this is a read from
1544 the target's code. This may trigger different cache behavior. */
1547 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1549 /* See comment in target_read_memory about why the request starts at
1550 current_target.beneath. */
1551 if (target_read (current_target
.beneath
, TARGET_OBJECT_CODE_MEMORY
, NULL
,
1552 myaddr
, memaddr
, len
) == len
)
1555 return TARGET_XFER_E_IO
;
1558 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1559 Returns either 0 for success or TARGET_XFER_E_IO if any
1560 error occurs. If an error occurs, no guarantee is made about how
1561 much data got written. Callers that can deal with partial writes
1562 should call target_write. */
1565 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1567 /* See comment in target_read_memory about why the request starts at
1568 current_target.beneath. */
1569 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1570 myaddr
, memaddr
, len
) == len
)
1573 return TARGET_XFER_E_IO
;
1576 /* Write LEN bytes from MYADDR to target raw memory at address
1577 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1578 if any error occurs. If an error occurs, no guarantee is made
1579 about how much data got written. Callers that can deal with
1580 partial writes should call target_write. */
1583 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1585 /* See comment in target_read_memory about why the request starts at
1586 current_target.beneath. */
1587 if (target_write (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1588 myaddr
, memaddr
, len
) == len
)
1591 return TARGET_XFER_E_IO
;
1594 /* Fetch the target's memory map. */
1597 target_memory_map (void)
1599 VEC(mem_region_s
) *result
;
1600 struct mem_region
*last_one
, *this_one
;
1602 struct target_ops
*t
;
1605 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1607 result
= current_target
.to_memory_map (¤t_target
);
1611 qsort (VEC_address (mem_region_s
, result
),
1612 VEC_length (mem_region_s
, result
),
1613 sizeof (struct mem_region
), mem_region_cmp
);
1615 /* Check that regions do not overlap. Simultaneously assign
1616 a numbering for the "mem" commands to use to refer to
1619 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1621 this_one
->number
= ix
;
1623 if (last_one
&& last_one
->hi
> this_one
->lo
)
1625 warning (_("Overlapping regions in memory map: ignoring"));
1626 VEC_free (mem_region_s
, result
);
1629 last_one
= this_one
;
1636 target_flash_erase (ULONGEST address
, LONGEST length
)
1639 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1640 hex_string (address
), phex (length
, 0));
1641 current_target
.to_flash_erase (¤t_target
, address
, length
);
1645 target_flash_done (void)
1648 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1649 current_target
.to_flash_done (¤t_target
);
1653 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1654 struct cmd_list_element
*c
, const char *value
)
1656 fprintf_filtered (file
,
1657 _("Mode for reading from readonly sections is %s.\n"),
1661 /* More generic transfers. */
1663 static enum target_xfer_status
1664 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1665 const char *annex
, gdb_byte
*readbuf
,
1666 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
1667 ULONGEST
*xfered_len
)
1669 if (object
== TARGET_OBJECT_MEMORY
1670 && ops
->deprecated_xfer_memory
!= NULL
)
1671 /* If available, fall back to the target's
1672 "deprecated_xfer_memory" method. */
1677 if (writebuf
!= NULL
)
1679 void *buffer
= xmalloc (len
);
1680 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1682 memcpy (buffer
, writebuf
, len
);
1683 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1684 1/*write*/, NULL
, ops
);
1685 do_cleanups (cleanup
);
1687 if (readbuf
!= NULL
)
1688 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1689 0/*read*/, NULL
, ops
);
1692 *xfered_len
= (ULONGEST
) xfered
;
1693 return TARGET_XFER_E_IO
;
1695 else if (xfered
== 0 && errno
== 0)
1696 /* "deprecated_xfer_memory" uses 0, cross checked against
1697 ERRNO as one indication of an error. */
1698 return TARGET_XFER_EOF
;
1700 return TARGET_XFER_E_IO
;
1704 gdb_assert (ops
->beneath
!= NULL
);
1705 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1706 readbuf
, writebuf
, offset
, len
,
1711 /* Target vector read/write partial wrapper functions. */
1713 static enum target_xfer_status
1714 target_read_partial (struct target_ops
*ops
,
1715 enum target_object object
,
1716 const char *annex
, gdb_byte
*buf
,
1717 ULONGEST offset
, ULONGEST len
,
1718 ULONGEST
*xfered_len
)
1720 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
,
1724 static enum target_xfer_status
1725 target_write_partial (struct target_ops
*ops
,
1726 enum target_object object
,
1727 const char *annex
, const gdb_byte
*buf
,
1728 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
1730 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
,
1734 /* Wrappers to perform the full transfer. */
1736 /* For docs on target_read see target.h. */
1739 target_read (struct target_ops
*ops
,
1740 enum target_object object
,
1741 const char *annex
, gdb_byte
*buf
,
1742 ULONGEST offset
, LONGEST len
)
1746 while (xfered
< len
)
1748 ULONGEST xfered_len
;
1749 enum target_xfer_status status
;
1751 status
= target_read_partial (ops
, object
, annex
,
1752 (gdb_byte
*) buf
+ xfered
,
1753 offset
+ xfered
, len
- xfered
,
1756 /* Call an observer, notifying them of the xfer progress? */
1757 if (status
== TARGET_XFER_EOF
)
1759 else if (status
== TARGET_XFER_OK
)
1761 xfered
+= xfered_len
;
1771 /* Assuming that the entire [begin, end) range of memory cannot be
1772 read, try to read whatever subrange is possible to read.
1774 The function returns, in RESULT, either zero or one memory block.
1775 If there's a readable subrange at the beginning, it is completely
1776 read and returned. Any further readable subrange will not be read.
1777 Otherwise, if there's a readable subrange at the end, it will be
1778 completely read and returned. Any readable subranges before it
1779 (obviously, not starting at the beginning), will be ignored. In
1780 other cases -- either no readable subrange, or readable subrange(s)
1781 that is neither at the beginning, or end, nothing is returned.
1783 The purpose of this function is to handle a read across a boundary
1784 of accessible memory in a case when memory map is not available.
1785 The above restrictions are fine for this case, but will give
1786 incorrect results if the memory is 'patchy'. However, supporting
1787 'patchy' memory would require trying to read every single byte,
1788 and it seems unacceptable solution. Explicit memory map is
1789 recommended for this case -- and target_read_memory_robust will
1790 take care of reading multiple ranges then. */
1793 read_whatever_is_readable (struct target_ops
*ops
,
1794 ULONGEST begin
, ULONGEST end
,
1795 VEC(memory_read_result_s
) **result
)
1797 gdb_byte
*buf
= xmalloc (end
- begin
);
1798 ULONGEST current_begin
= begin
;
1799 ULONGEST current_end
= end
;
1801 memory_read_result_s r
;
1802 ULONGEST xfered_len
;
1804 /* If we previously failed to read 1 byte, nothing can be done here. */
1805 if (end
- begin
<= 1)
1811 /* Check that either first or the last byte is readable, and give up
1812 if not. This heuristic is meant to permit reading accessible memory
1813 at the boundary of accessible region. */
1814 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1815 buf
, begin
, 1, &xfered_len
) == TARGET_XFER_OK
)
1820 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1821 buf
+ (end
-begin
) - 1, end
- 1, 1,
1822 &xfered_len
) == TARGET_XFER_OK
)
1833 /* Loop invariant is that the [current_begin, current_end) was previously
1834 found to be not readable as a whole.
1836 Note loop condition -- if the range has 1 byte, we can't divide the range
1837 so there's no point trying further. */
1838 while (current_end
- current_begin
> 1)
1840 ULONGEST first_half_begin
, first_half_end
;
1841 ULONGEST second_half_begin
, second_half_end
;
1843 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
1847 first_half_begin
= current_begin
;
1848 first_half_end
= middle
;
1849 second_half_begin
= middle
;
1850 second_half_end
= current_end
;
1854 first_half_begin
= middle
;
1855 first_half_end
= current_end
;
1856 second_half_begin
= current_begin
;
1857 second_half_end
= middle
;
1860 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1861 buf
+ (first_half_begin
- begin
),
1863 first_half_end
- first_half_begin
);
1865 if (xfer
== first_half_end
- first_half_begin
)
1867 /* This half reads up fine. So, the error must be in the
1869 current_begin
= second_half_begin
;
1870 current_end
= second_half_end
;
1874 /* This half is not readable. Because we've tried one byte, we
1875 know some part of this half if actually redable. Go to the next
1876 iteration to divide again and try to read.
1878 We don't handle the other half, because this function only tries
1879 to read a single readable subrange. */
1880 current_begin
= first_half_begin
;
1881 current_end
= first_half_end
;
1887 /* The [begin, current_begin) range has been read. */
1889 r
.end
= current_begin
;
1894 /* The [current_end, end) range has been read. */
1895 LONGEST rlen
= end
- current_end
;
1897 r
.data
= xmalloc (rlen
);
1898 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
1899 r
.begin
= current_end
;
1903 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
1907 free_memory_read_result_vector (void *x
)
1909 VEC(memory_read_result_s
) *v
= x
;
1910 memory_read_result_s
*current
;
1913 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
1915 xfree (current
->data
);
1917 VEC_free (memory_read_result_s
, v
);
1920 VEC(memory_read_result_s
) *
1921 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
1923 VEC(memory_read_result_s
) *result
= 0;
1926 while (xfered
< len
)
1928 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
1931 /* If there is no explicit region, a fake one should be created. */
1932 gdb_assert (region
);
1934 if (region
->hi
== 0)
1935 rlen
= len
- xfered
;
1937 rlen
= region
->hi
- offset
;
1939 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
1941 /* Cannot read this region. Note that we can end up here only
1942 if the region is explicitly marked inaccessible, or
1943 'inaccessible-by-default' is in effect. */
1948 LONGEST to_read
= min (len
- xfered
, rlen
);
1949 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
1951 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1952 (gdb_byte
*) buffer
,
1953 offset
+ xfered
, to_read
);
1954 /* Call an observer, notifying them of the xfer progress? */
1957 /* Got an error reading full chunk. See if maybe we can read
1960 read_whatever_is_readable (ops
, offset
+ xfered
,
1961 offset
+ xfered
+ to_read
, &result
);
1966 struct memory_read_result r
;
1968 r
.begin
= offset
+ xfered
;
1969 r
.end
= r
.begin
+ xfer
;
1970 VEC_safe_push (memory_read_result_s
, result
, &r
);
1980 /* An alternative to target_write with progress callbacks. */
1983 target_write_with_progress (struct target_ops
*ops
,
1984 enum target_object object
,
1985 const char *annex
, const gdb_byte
*buf
,
1986 ULONGEST offset
, LONGEST len
,
1987 void (*progress
) (ULONGEST
, void *), void *baton
)
1991 /* Give the progress callback a chance to set up. */
1993 (*progress
) (0, baton
);
1995 while (xfered
< len
)
1997 ULONGEST xfered_len
;
1998 enum target_xfer_status status
;
2000 status
= target_write_partial (ops
, object
, annex
,
2001 (gdb_byte
*) buf
+ xfered
,
2002 offset
+ xfered
, len
- xfered
,
2005 if (status
== TARGET_XFER_EOF
)
2007 if (TARGET_XFER_STATUS_ERROR_P (status
))
2010 gdb_assert (status
== TARGET_XFER_OK
);
2012 (*progress
) (xfered_len
, baton
);
2014 xfered
+= xfered_len
;
2020 /* For docs on target_write see target.h. */
2023 target_write (struct target_ops
*ops
,
2024 enum target_object object
,
2025 const char *annex
, const gdb_byte
*buf
,
2026 ULONGEST offset
, LONGEST len
)
2028 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2032 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2033 the size of the transferred data. PADDING additional bytes are
2034 available in *BUF_P. This is a helper function for
2035 target_read_alloc; see the declaration of that function for more
2039 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2040 const char *annex
, gdb_byte
**buf_p
, int padding
)
2042 size_t buf_alloc
, buf_pos
;
2045 /* This function does not have a length parameter; it reads the
2046 entire OBJECT). Also, it doesn't support objects fetched partly
2047 from one target and partly from another (in a different stratum,
2048 e.g. a core file and an executable). Both reasons make it
2049 unsuitable for reading memory. */
2050 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2052 /* Start by reading up to 4K at a time. The target will throttle
2053 this number down if necessary. */
2055 buf
= xmalloc (buf_alloc
);
2059 ULONGEST xfered_len
;
2060 enum target_xfer_status status
;
2062 status
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2063 buf_pos
, buf_alloc
- buf_pos
- padding
,
2066 if (status
== TARGET_XFER_EOF
)
2068 /* Read all there was. */
2075 else if (status
!= TARGET_XFER_OK
)
2077 /* An error occurred. */
2079 return TARGET_XFER_E_IO
;
2082 buf_pos
+= xfered_len
;
2084 /* If the buffer is filling up, expand it. */
2085 if (buf_alloc
< buf_pos
* 2)
2088 buf
= xrealloc (buf
, buf_alloc
);
2095 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2096 the size of the transferred data. See the declaration in "target.h"
2097 function for more information about the return value. */
2100 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2101 const char *annex
, gdb_byte
**buf_p
)
2103 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2106 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2107 returned as a string, allocated using xmalloc. If an error occurs
2108 or the transfer is unsupported, NULL is returned. Empty objects
2109 are returned as allocated but empty strings. A warning is issued
2110 if the result contains any embedded NUL bytes. */
2113 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2118 LONGEST i
, transferred
;
2120 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2121 bufstr
= (char *) buffer
;
2123 if (transferred
< 0)
2126 if (transferred
== 0)
2127 return xstrdup ("");
2129 bufstr
[transferred
] = 0;
2131 /* Check for embedded NUL bytes; but allow trailing NULs. */
2132 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2135 warning (_("target object %d, annex %s, "
2136 "contained unexpected null characters"),
2137 (int) object
, annex
? annex
: "(none)");
2144 /* Memory transfer methods. */
2147 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2150 /* This method is used to read from an alternate, non-current
2151 target. This read must bypass the overlay support (as symbols
2152 don't match this target), and GDB's internal cache (wrong cache
2153 for this target). */
2154 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2156 memory_error (TARGET_XFER_E_IO
, addr
);
2160 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2161 int len
, enum bfd_endian byte_order
)
2163 gdb_byte buf
[sizeof (ULONGEST
)];
2165 gdb_assert (len
<= sizeof (buf
));
2166 get_target_memory (ops
, addr
, buf
, len
);
2167 return extract_unsigned_integer (buf
, len
, byte_order
);
2173 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2174 struct bp_target_info
*bp_tgt
)
2176 if (!may_insert_breakpoints
)
2178 warning (_("May not insert breakpoints"));
2182 return current_target
.to_insert_breakpoint (¤t_target
,
2189 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2190 struct bp_target_info
*bp_tgt
)
2192 /* This is kind of a weird case to handle, but the permission might
2193 have been changed after breakpoints were inserted - in which case
2194 we should just take the user literally and assume that any
2195 breakpoints should be left in place. */
2196 if (!may_insert_breakpoints
)
2198 warning (_("May not remove breakpoints"));
2202 return current_target
.to_remove_breakpoint (¤t_target
,
2207 target_info (char *args
, int from_tty
)
2209 struct target_ops
*t
;
2210 int has_all_mem
= 0;
2212 if (symfile_objfile
!= NULL
)
2213 printf_unfiltered (_("Symbols from \"%s\".\n"),
2214 objfile_name (symfile_objfile
));
2216 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2218 if (!(*t
->to_has_memory
) (t
))
2221 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2224 printf_unfiltered (_("\tWhile running this, "
2225 "GDB does not access memory from...\n"));
2226 printf_unfiltered ("%s:\n", t
->to_longname
);
2227 (t
->to_files_info
) (t
);
2228 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2232 /* This function is called before any new inferior is created, e.g.
2233 by running a program, attaching, or connecting to a target.
2234 It cleans up any state from previous invocations which might
2235 change between runs. This is a subset of what target_preopen
2236 resets (things which might change between targets). */
2239 target_pre_inferior (int from_tty
)
2241 /* Clear out solib state. Otherwise the solib state of the previous
2242 inferior might have survived and is entirely wrong for the new
2243 target. This has been observed on GNU/Linux using glibc 2.3. How
2255 Cannot access memory at address 0xdeadbeef
2258 /* In some OSs, the shared library list is the same/global/shared
2259 across inferiors. If code is shared between processes, so are
2260 memory regions and features. */
2261 if (!gdbarch_has_global_solist (target_gdbarch ()))
2263 no_shared_libraries (NULL
, from_tty
);
2265 invalidate_target_mem_regions ();
2267 target_clear_description ();
2270 agent_capability_invalidate ();
2273 /* Callback for iterate_over_inferiors. Gets rid of the given
2277 dispose_inferior (struct inferior
*inf
, void *args
)
2279 struct thread_info
*thread
;
2281 thread
= any_thread_of_process (inf
->pid
);
2284 switch_to_thread (thread
->ptid
);
2286 /* Core inferiors actually should be detached, not killed. */
2287 if (target_has_execution
)
2290 target_detach (NULL
, 0);
2296 /* This is to be called by the open routine before it does
2300 target_preopen (int from_tty
)
2304 if (have_inferiors ())
2307 || !have_live_inferiors ()
2308 || query (_("A program is being debugged already. Kill it? ")))
2309 iterate_over_inferiors (dispose_inferior
, NULL
);
2311 error (_("Program not killed."));
2314 /* Calling target_kill may remove the target from the stack. But if
2315 it doesn't (which seems like a win for UDI), remove it now. */
2316 /* Leave the exec target, though. The user may be switching from a
2317 live process to a core of the same program. */
2318 pop_all_targets_above (file_stratum
);
2320 target_pre_inferior (from_tty
);
2323 /* Detach a target after doing deferred register stores. */
2326 target_detach (const char *args
, int from_tty
)
2328 struct target_ops
* t
;
2330 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2331 /* Don't remove global breakpoints here. They're removed on
2332 disconnection from the target. */
2335 /* If we're in breakpoints-always-inserted mode, have to remove
2336 them before detaching. */
2337 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2339 prepare_for_detach ();
2341 current_target
.to_detach (¤t_target
, args
, from_tty
);
2343 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2348 target_disconnect (char *args
, int from_tty
)
2350 /* If we're in breakpoints-always-inserted mode or if breakpoints
2351 are global across processes, we have to remove them before
2353 remove_breakpoints ();
2356 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2358 current_target
.to_disconnect (¤t_target
, args
, from_tty
);
2362 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2364 struct target_ops
*t
;
2365 ptid_t retval
= (current_target
.to_wait
) (¤t_target
, ptid
,
2370 char *status_string
;
2371 char *options_string
;
2373 status_string
= target_waitstatus_to_string (status
);
2374 options_string
= target_options_to_string (options
);
2375 fprintf_unfiltered (gdb_stdlog
,
2376 "target_wait (%d, status, options={%s})"
2378 ptid_get_pid (ptid
), options_string
,
2379 ptid_get_pid (retval
), status_string
);
2380 xfree (status_string
);
2381 xfree (options_string
);
2388 target_pid_to_str (ptid_t ptid
)
2390 return (*current_target
.to_pid_to_str
) (¤t_target
, ptid
);
2394 target_thread_name (struct thread_info
*info
)
2396 return current_target
.to_thread_name (¤t_target
, info
);
2400 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2402 struct target_ops
*t
;
2404 target_dcache_invalidate ();
2406 current_target
.to_resume (¤t_target
, ptid
, step
, signal
);
2408 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2409 ptid_get_pid (ptid
),
2410 step
? "step" : "continue",
2411 gdb_signal_to_name (signal
));
2413 registers_changed_ptid (ptid
);
2414 set_executing (ptid
, 1);
2415 set_running (ptid
, 1);
2416 clear_inline_frame_state (ptid
);
2420 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2426 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2429 for (i
= 0; i
< numsigs
; i
++)
2430 if (pass_signals
[i
])
2431 fprintf_unfiltered (gdb_stdlog
, " %s",
2432 gdb_signal_to_name (i
));
2434 fprintf_unfiltered (gdb_stdlog
, " })\n");
2437 (*current_target
.to_pass_signals
) (¤t_target
, numsigs
, pass_signals
);
2441 target_program_signals (int numsigs
, unsigned char *program_signals
)
2447 fprintf_unfiltered (gdb_stdlog
, "target_program_signals (%d, {",
2450 for (i
= 0; i
< numsigs
; i
++)
2451 if (program_signals
[i
])
2452 fprintf_unfiltered (gdb_stdlog
, " %s",
2453 gdb_signal_to_name (i
));
2455 fprintf_unfiltered (gdb_stdlog
, " })\n");
2458 (*current_target
.to_program_signals
) (¤t_target
,
2459 numsigs
, program_signals
);
2463 default_follow_fork (struct target_ops
*self
, int follow_child
,
2466 /* Some target returned a fork event, but did not know how to follow it. */
2467 internal_error (__FILE__
, __LINE__
,
2468 _("could not find a target to follow fork"));
2471 /* Look through the list of possible targets for a target that can
2475 target_follow_fork (int follow_child
, int detach_fork
)
2477 int retval
= current_target
.to_follow_fork (¤t_target
,
2478 follow_child
, detach_fork
);
2481 fprintf_unfiltered (gdb_stdlog
,
2482 "target_follow_fork (%d, %d) = %d\n",
2483 follow_child
, detach_fork
, retval
);
2488 default_mourn_inferior (struct target_ops
*self
)
2490 internal_error (__FILE__
, __LINE__
,
2491 _("could not find a target to follow mourn inferior"));
2495 target_mourn_inferior (void)
2497 current_target
.to_mourn_inferior (¤t_target
);
2499 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2501 /* We no longer need to keep handles on any of the object files.
2502 Make sure to release them to avoid unnecessarily locking any
2503 of them while we're not actually debugging. */
2504 bfd_cache_close_all ();
2507 /* Look for a target which can describe architectural features, starting
2508 from TARGET. If we find one, return its description. */
2510 const struct target_desc
*
2511 target_read_description (struct target_ops
*target
)
2513 return target
->to_read_description (target
);
2516 /* This implements a basic search of memory, reading target memory and
2517 performing the search here (as opposed to performing the search in on the
2518 target side with, for example, gdbserver). */
2521 simple_search_memory (struct target_ops
*ops
,
2522 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2523 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2524 CORE_ADDR
*found_addrp
)
2526 /* NOTE: also defined in find.c testcase. */
2527 #define SEARCH_CHUNK_SIZE 16000
2528 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2529 /* Buffer to hold memory contents for searching. */
2530 gdb_byte
*search_buf
;
2531 unsigned search_buf_size
;
2532 struct cleanup
*old_cleanups
;
2534 search_buf_size
= chunk_size
+ pattern_len
- 1;
2536 /* No point in trying to allocate a buffer larger than the search space. */
2537 if (search_space_len
< search_buf_size
)
2538 search_buf_size
= search_space_len
;
2540 search_buf
= malloc (search_buf_size
);
2541 if (search_buf
== NULL
)
2542 error (_("Unable to allocate memory to perform the search."));
2543 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2545 /* Prime the search buffer. */
2547 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2548 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2550 warning (_("Unable to access %s bytes of target "
2551 "memory at %s, halting search."),
2552 pulongest (search_buf_size
), hex_string (start_addr
));
2553 do_cleanups (old_cleanups
);
2557 /* Perform the search.
2559 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2560 When we've scanned N bytes we copy the trailing bytes to the start and
2561 read in another N bytes. */
2563 while (search_space_len
>= pattern_len
)
2565 gdb_byte
*found_ptr
;
2566 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2568 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2569 pattern
, pattern_len
);
2571 if (found_ptr
!= NULL
)
2573 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2575 *found_addrp
= found_addr
;
2576 do_cleanups (old_cleanups
);
2580 /* Not found in this chunk, skip to next chunk. */
2582 /* Don't let search_space_len wrap here, it's unsigned. */
2583 if (search_space_len
>= chunk_size
)
2584 search_space_len
-= chunk_size
;
2586 search_space_len
= 0;
2588 if (search_space_len
>= pattern_len
)
2590 unsigned keep_len
= search_buf_size
- chunk_size
;
2591 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2594 /* Copy the trailing part of the previous iteration to the front
2595 of the buffer for the next iteration. */
2596 gdb_assert (keep_len
== pattern_len
- 1);
2597 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
2599 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
2601 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2602 search_buf
+ keep_len
, read_addr
,
2603 nr_to_read
) != nr_to_read
)
2605 warning (_("Unable to access %s bytes of target "
2606 "memory at %s, halting search."),
2607 plongest (nr_to_read
),
2608 hex_string (read_addr
));
2609 do_cleanups (old_cleanups
);
2613 start_addr
+= chunk_size
;
2619 do_cleanups (old_cleanups
);
2623 /* Default implementation of memory-searching. */
2626 default_search_memory (struct target_ops
*self
,
2627 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2628 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2629 CORE_ADDR
*found_addrp
)
2631 /* Start over from the top of the target stack. */
2632 return simple_search_memory (current_target
.beneath
,
2633 start_addr
, search_space_len
,
2634 pattern
, pattern_len
, found_addrp
);
2637 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2638 sequence of bytes in PATTERN with length PATTERN_LEN.
2640 The result is 1 if found, 0 if not found, and -1 if there was an error
2641 requiring halting of the search (e.g. memory read error).
2642 If the pattern is found the address is recorded in FOUND_ADDRP. */
2645 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2646 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2647 CORE_ADDR
*found_addrp
)
2652 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2653 hex_string (start_addr
));
2655 found
= current_target
.to_search_memory (¤t_target
, start_addr
,
2657 pattern
, pattern_len
, found_addrp
);
2660 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2665 /* Look through the currently pushed targets. If none of them will
2666 be able to restart the currently running process, issue an error
2670 target_require_runnable (void)
2672 struct target_ops
*t
;
2674 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2676 /* If this target knows how to create a new program, then
2677 assume we will still be able to after killing the current
2678 one. Either killing and mourning will not pop T, or else
2679 find_default_run_target will find it again. */
2680 if (t
->to_create_inferior
!= NULL
)
2683 /* Do not worry about thread_stratum targets that can not
2684 create inferiors. Assume they will be pushed again if
2685 necessary, and continue to the process_stratum. */
2686 if (t
->to_stratum
== thread_stratum
2687 || t
->to_stratum
== arch_stratum
)
2690 error (_("The \"%s\" target does not support \"run\". "
2691 "Try \"help target\" or \"continue\"."),
2695 /* This function is only called if the target is running. In that
2696 case there should have been a process_stratum target and it
2697 should either know how to create inferiors, or not... */
2698 internal_error (__FILE__
, __LINE__
, _("No targets found"));
2701 /* Look through the list of possible targets for a target that can
2702 execute a run or attach command without any other data. This is
2703 used to locate the default process stratum.
2705 If DO_MESG is not NULL, the result is always valid (error() is
2706 called for errors); else, return NULL on error. */
2708 static struct target_ops
*
2709 find_default_run_target (char *do_mesg
)
2711 struct target_ops
**t
;
2712 struct target_ops
*runable
= NULL
;
2717 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2720 if ((*t
)->to_can_run
!= delegate_can_run
&& target_can_run (*t
))
2730 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2739 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2741 struct target_ops
*t
;
2743 t
= find_default_run_target ("attach");
2744 (t
->to_attach
) (t
, args
, from_tty
);
2749 find_default_create_inferior (struct target_ops
*ops
,
2750 char *exec_file
, char *allargs
, char **env
,
2753 struct target_ops
*t
;
2755 t
= find_default_run_target ("run");
2756 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
2761 find_default_can_async_p (struct target_ops
*ignore
)
2763 struct target_ops
*t
;
2765 /* This may be called before the target is pushed on the stack;
2766 look for the default process stratum. If there's none, gdb isn't
2767 configured with a native debugger, and target remote isn't
2769 t
= find_default_run_target (NULL
);
2770 if (t
&& t
->to_can_async_p
!= delegate_can_async_p
)
2771 return (t
->to_can_async_p
) (t
);
2776 find_default_is_async_p (struct target_ops
*ignore
)
2778 struct target_ops
*t
;
2780 /* This may be called before the target is pushed on the stack;
2781 look for the default process stratum. If there's none, gdb isn't
2782 configured with a native debugger, and target remote isn't
2784 t
= find_default_run_target (NULL
);
2785 if (t
&& t
->to_is_async_p
!= delegate_is_async_p
)
2786 return (t
->to_is_async_p
) (t
);
2791 find_default_supports_non_stop (struct target_ops
*self
)
2793 struct target_ops
*t
;
2795 t
= find_default_run_target (NULL
);
2796 if (t
&& t
->to_supports_non_stop
)
2797 return (t
->to_supports_non_stop
) (t
);
2802 target_supports_non_stop (void)
2804 struct target_ops
*t
;
2806 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2807 if (t
->to_supports_non_stop
)
2808 return t
->to_supports_non_stop (t
);
2813 /* Implement the "info proc" command. */
2816 target_info_proc (char *args
, enum info_proc_what what
)
2818 struct target_ops
*t
;
2820 /* If we're already connected to something that can get us OS
2821 related data, use it. Otherwise, try using the native
2823 if (current_target
.to_stratum
>= process_stratum
)
2824 t
= current_target
.beneath
;
2826 t
= find_default_run_target (NULL
);
2828 for (; t
!= NULL
; t
= t
->beneath
)
2830 if (t
->to_info_proc
!= NULL
)
2832 t
->to_info_proc (t
, args
, what
);
2835 fprintf_unfiltered (gdb_stdlog
,
2836 "target_info_proc (\"%s\", %d)\n", args
, what
);
2846 find_default_supports_disable_randomization (struct target_ops
*self
)
2848 struct target_ops
*t
;
2850 t
= find_default_run_target (NULL
);
2851 if (t
&& t
->to_supports_disable_randomization
)
2852 return (t
->to_supports_disable_randomization
) (t
);
2857 target_supports_disable_randomization (void)
2859 struct target_ops
*t
;
2861 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2862 if (t
->to_supports_disable_randomization
)
2863 return t
->to_supports_disable_randomization (t
);
2869 target_get_osdata (const char *type
)
2871 struct target_ops
*t
;
2873 /* If we're already connected to something that can get us OS
2874 related data, use it. Otherwise, try using the native
2876 if (current_target
.to_stratum
>= process_stratum
)
2877 t
= current_target
.beneath
;
2879 t
= find_default_run_target ("get OS data");
2884 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
2887 /* Determine the current address space of thread PTID. */
2889 struct address_space
*
2890 target_thread_address_space (ptid_t ptid
)
2892 struct address_space
*aspace
;
2893 struct inferior
*inf
;
2894 struct target_ops
*t
;
2896 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2898 if (t
->to_thread_address_space
!= NULL
)
2900 aspace
= t
->to_thread_address_space (t
, ptid
);
2901 gdb_assert (aspace
);
2904 fprintf_unfiltered (gdb_stdlog
,
2905 "target_thread_address_space (%s) = %d\n",
2906 target_pid_to_str (ptid
),
2907 address_space_num (aspace
));
2912 /* Fall-back to the "main" address space of the inferior. */
2913 inf
= find_inferior_pid (ptid_get_pid (ptid
));
2915 if (inf
== NULL
|| inf
->aspace
== NULL
)
2916 internal_error (__FILE__
, __LINE__
,
2917 _("Can't determine the current "
2918 "address space of thread %s\n"),
2919 target_pid_to_str (ptid
));
2925 /* Target file operations. */
2927 static struct target_ops
*
2928 default_fileio_target (void)
2930 /* If we're already connected to something that can perform
2931 file I/O, use it. Otherwise, try using the native target. */
2932 if (current_target
.to_stratum
>= process_stratum
)
2933 return current_target
.beneath
;
2935 return find_default_run_target ("file I/O");
2938 /* Open FILENAME on the target, using FLAGS and MODE. Return a
2939 target file descriptor, or -1 if an error occurs (and set
2942 target_fileio_open (const char *filename
, int flags
, int mode
,
2945 struct target_ops
*t
;
2947 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2949 if (t
->to_fileio_open
!= NULL
)
2951 int fd
= t
->to_fileio_open (t
, filename
, flags
, mode
, target_errno
);
2954 fprintf_unfiltered (gdb_stdlog
,
2955 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
2956 filename
, flags
, mode
,
2957 fd
, fd
!= -1 ? 0 : *target_errno
);
2962 *target_errno
= FILEIO_ENOSYS
;
2966 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
2967 Return the number of bytes written, or -1 if an error occurs
2968 (and set *TARGET_ERRNO). */
2970 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
2971 ULONGEST offset
, int *target_errno
)
2973 struct target_ops
*t
;
2975 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
2977 if (t
->to_fileio_pwrite
!= NULL
)
2979 int ret
= t
->to_fileio_pwrite (t
, fd
, write_buf
, len
, offset
,
2983 fprintf_unfiltered (gdb_stdlog
,
2984 "target_fileio_pwrite (%d,...,%d,%s) "
2986 fd
, len
, pulongest (offset
),
2987 ret
, ret
!= -1 ? 0 : *target_errno
);
2992 *target_errno
= FILEIO_ENOSYS
;
2996 /* Read up to LEN bytes FD on the target into READ_BUF.
2997 Return the number of bytes read, or -1 if an error occurs
2998 (and set *TARGET_ERRNO). */
3000 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
3001 ULONGEST offset
, int *target_errno
)
3003 struct target_ops
*t
;
3005 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3007 if (t
->to_fileio_pread
!= NULL
)
3009 int ret
= t
->to_fileio_pread (t
, fd
, read_buf
, len
, offset
,
3013 fprintf_unfiltered (gdb_stdlog
,
3014 "target_fileio_pread (%d,...,%d,%s) "
3016 fd
, len
, pulongest (offset
),
3017 ret
, ret
!= -1 ? 0 : *target_errno
);
3022 *target_errno
= FILEIO_ENOSYS
;
3026 /* Close FD on the target. Return 0, or -1 if an error occurs
3027 (and set *TARGET_ERRNO). */
3029 target_fileio_close (int fd
, int *target_errno
)
3031 struct target_ops
*t
;
3033 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3035 if (t
->to_fileio_close
!= NULL
)
3037 int ret
= t
->to_fileio_close (t
, fd
, target_errno
);
3040 fprintf_unfiltered (gdb_stdlog
,
3041 "target_fileio_close (%d) = %d (%d)\n",
3042 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
3047 *target_errno
= FILEIO_ENOSYS
;
3051 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3052 occurs (and set *TARGET_ERRNO). */
3054 target_fileio_unlink (const char *filename
, int *target_errno
)
3056 struct target_ops
*t
;
3058 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3060 if (t
->to_fileio_unlink
!= NULL
)
3062 int ret
= t
->to_fileio_unlink (t
, filename
, target_errno
);
3065 fprintf_unfiltered (gdb_stdlog
,
3066 "target_fileio_unlink (%s) = %d (%d)\n",
3067 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
3072 *target_errno
= FILEIO_ENOSYS
;
3076 /* Read value of symbolic link FILENAME on the target. Return a
3077 null-terminated string allocated via xmalloc, or NULL if an error
3078 occurs (and set *TARGET_ERRNO). */
3080 target_fileio_readlink (const char *filename
, int *target_errno
)
3082 struct target_ops
*t
;
3084 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3086 if (t
->to_fileio_readlink
!= NULL
)
3088 char *ret
= t
->to_fileio_readlink (t
, filename
, target_errno
);
3091 fprintf_unfiltered (gdb_stdlog
,
3092 "target_fileio_readlink (%s) = %s (%d)\n",
3093 filename
, ret
? ret
: "(nil)",
3094 ret
? 0 : *target_errno
);
3099 *target_errno
= FILEIO_ENOSYS
;
3104 target_fileio_close_cleanup (void *opaque
)
3106 int fd
= *(int *) opaque
;
3109 target_fileio_close (fd
, &target_errno
);
3112 /* Read target file FILENAME. Store the result in *BUF_P and
3113 return the size of the transferred data. PADDING additional bytes are
3114 available in *BUF_P. This is a helper function for
3115 target_fileio_read_alloc; see the declaration of that function for more
3119 target_fileio_read_alloc_1 (const char *filename
,
3120 gdb_byte
**buf_p
, int padding
)
3122 struct cleanup
*close_cleanup
;
3123 size_t buf_alloc
, buf_pos
;
3129 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
3133 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
3135 /* Start by reading up to 4K at a time. The target will throttle
3136 this number down if necessary. */
3138 buf
= xmalloc (buf_alloc
);
3142 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
3143 buf_alloc
- buf_pos
- padding
, buf_pos
,
3147 /* An error occurred. */
3148 do_cleanups (close_cleanup
);
3154 /* Read all there was. */
3155 do_cleanups (close_cleanup
);
3165 /* If the buffer is filling up, expand it. */
3166 if (buf_alloc
< buf_pos
* 2)
3169 buf
= xrealloc (buf
, buf_alloc
);
3176 /* Read target file FILENAME. Store the result in *BUF_P and return
3177 the size of the transferred data. See the declaration in "target.h"
3178 function for more information about the return value. */
3181 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
3183 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
3186 /* Read target file FILENAME. The result is NUL-terminated and
3187 returned as a string, allocated using xmalloc. If an error occurs
3188 or the transfer is unsupported, NULL is returned. Empty objects
3189 are returned as allocated but empty strings. A warning is issued
3190 if the result contains any embedded NUL bytes. */
3193 target_fileio_read_stralloc (const char *filename
)
3197 LONGEST i
, transferred
;
3199 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
3200 bufstr
= (char *) buffer
;
3202 if (transferred
< 0)
3205 if (transferred
== 0)
3206 return xstrdup ("");
3208 bufstr
[transferred
] = 0;
3210 /* Check for embedded NUL bytes; but allow trailing NULs. */
3211 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3214 warning (_("target file %s "
3215 "contained unexpected null characters"),
3225 default_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3226 CORE_ADDR addr
, int len
)
3228 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3232 default_watchpoint_addr_within_range (struct target_ops
*target
,
3234 CORE_ADDR start
, int length
)
3236 return addr
>= start
&& addr
< start
+ length
;
3239 static struct gdbarch
*
3240 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3242 return target_gdbarch ();
3246 return_zero (struct target_ops
*ignore
)
3252 return_zero_has_execution (struct target_ops
*ignore
, ptid_t ignore2
)
3258 * Find the next target down the stack from the specified target.
3262 find_target_beneath (struct target_ops
*t
)
3270 find_target_at (enum strata stratum
)
3272 struct target_ops
*t
;
3274 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3275 if (t
->to_stratum
== stratum
)
3282 /* The inferior process has died. Long live the inferior! */
3285 generic_mourn_inferior (void)
3289 ptid
= inferior_ptid
;
3290 inferior_ptid
= null_ptid
;
3292 /* Mark breakpoints uninserted in case something tries to delete a
3293 breakpoint while we delete the inferior's threads (which would
3294 fail, since the inferior is long gone). */
3295 mark_breakpoints_out ();
3297 if (!ptid_equal (ptid
, null_ptid
))
3299 int pid
= ptid_get_pid (ptid
);
3300 exit_inferior (pid
);
3303 /* Note this wipes step-resume breakpoints, so needs to be done
3304 after exit_inferior, which ends up referencing the step-resume
3305 breakpoints through clear_thread_inferior_resources. */
3306 breakpoint_init_inferior (inf_exited
);
3308 registers_changed ();
3310 reopen_exec_file ();
3311 reinit_frame_cache ();
3313 if (deprecated_detach_hook
)
3314 deprecated_detach_hook ();
3317 /* Convert a normal process ID to a string. Returns the string in a
3321 normal_pid_to_str (ptid_t ptid
)
3323 static char buf
[32];
3325 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3330 default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3332 return normal_pid_to_str (ptid
);
3335 /* Error-catcher for target_find_memory_regions. */
3337 dummy_find_memory_regions (struct target_ops
*self
,
3338 find_memory_region_ftype ignore1
, void *ignore2
)
3340 error (_("Command not implemented for this target."));
3344 /* Error-catcher for target_make_corefile_notes. */
3346 dummy_make_corefile_notes (struct target_ops
*self
,
3347 bfd
*ignore1
, int *ignore2
)
3349 error (_("Command not implemented for this target."));
3353 /* Set up the handful of non-empty slots needed by the dummy target
3357 init_dummy_target (void)
3359 dummy_target
.to_shortname
= "None";
3360 dummy_target
.to_longname
= "None";
3361 dummy_target
.to_doc
= "";
3362 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3363 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3364 dummy_target
.to_supports_disable_randomization
3365 = find_default_supports_disable_randomization
;
3366 dummy_target
.to_stratum
= dummy_stratum
;
3367 dummy_target
.to_has_all_memory
= return_zero
;
3368 dummy_target
.to_has_memory
= return_zero
;
3369 dummy_target
.to_has_stack
= return_zero
;
3370 dummy_target
.to_has_registers
= return_zero
;
3371 dummy_target
.to_has_execution
= return_zero_has_execution
;
3372 dummy_target
.to_magic
= OPS_MAGIC
;
3374 install_dummy_methods (&dummy_target
);
3378 debug_to_open (char *args
, int from_tty
)
3380 debug_target
.to_open (args
, from_tty
);
3382 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3386 target_close (struct target_ops
*targ
)
3388 gdb_assert (!target_is_pushed (targ
));
3390 if (targ
->to_xclose
!= NULL
)
3391 targ
->to_xclose (targ
);
3392 else if (targ
->to_close
!= NULL
)
3393 targ
->to_close (targ
);
3396 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3400 target_attach (char *args
, int from_tty
)
3402 current_target
.to_attach (¤t_target
, args
, from_tty
);
3404 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3409 target_thread_alive (ptid_t ptid
)
3413 retval
= current_target
.to_thread_alive (¤t_target
, ptid
);
3415 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3416 ptid_get_pid (ptid
), retval
);
3422 target_find_new_threads (void)
3424 current_target
.to_find_new_threads (¤t_target
);
3426 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3430 target_stop (ptid_t ptid
)
3434 warning (_("May not interrupt or stop the target, ignoring attempt"));
3438 (*current_target
.to_stop
) (¤t_target
, ptid
);
3442 debug_to_post_attach (struct target_ops
*self
, int pid
)
3444 debug_target
.to_post_attach (&debug_target
, pid
);
3446 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3449 /* Concatenate ELEM to LIST, a comma separate list, and return the
3450 result. The LIST incoming argument is released. */
3453 str_comma_list_concat_elem (char *list
, const char *elem
)
3456 return xstrdup (elem
);
3458 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3461 /* Helper for target_options_to_string. If OPT is present in
3462 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3463 Returns the new resulting string. OPT is removed from
3467 do_option (int *target_options
, char *ret
,
3468 int opt
, char *opt_str
)
3470 if ((*target_options
& opt
) != 0)
3472 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3473 *target_options
&= ~opt
;
3480 target_options_to_string (int target_options
)
3484 #define DO_TARG_OPTION(OPT) \
3485 ret = do_option (&target_options, ret, OPT, #OPT)
3487 DO_TARG_OPTION (TARGET_WNOHANG
);
3489 if (target_options
!= 0)
3490 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3498 debug_print_register (const char * func
,
3499 struct regcache
*regcache
, int regno
)
3501 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3503 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3504 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3505 && gdbarch_register_name (gdbarch
, regno
) != NULL
3506 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3507 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3508 gdbarch_register_name (gdbarch
, regno
));
3510 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3511 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3513 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3514 int i
, size
= register_size (gdbarch
, regno
);
3515 gdb_byte buf
[MAX_REGISTER_SIZE
];
3517 regcache_raw_collect (regcache
, regno
, buf
);
3518 fprintf_unfiltered (gdb_stdlog
, " = ");
3519 for (i
= 0; i
< size
; i
++)
3521 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3523 if (size
<= sizeof (LONGEST
))
3525 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
3527 fprintf_unfiltered (gdb_stdlog
, " %s %s",
3528 core_addr_to_string_nz (val
), plongest (val
));
3531 fprintf_unfiltered (gdb_stdlog
, "\n");
3535 target_fetch_registers (struct regcache
*regcache
, int regno
)
3537 current_target
.to_fetch_registers (¤t_target
, regcache
, regno
);
3539 debug_print_register ("target_fetch_registers", regcache
, regno
);
3543 target_store_registers (struct regcache
*regcache
, int regno
)
3545 struct target_ops
*t
;
3547 if (!may_write_registers
)
3548 error (_("Writing to registers is not allowed (regno %d)"), regno
);
3550 current_target
.to_store_registers (¤t_target
, regcache
, regno
);
3553 debug_print_register ("target_store_registers", regcache
, regno
);
3558 target_core_of_thread (ptid_t ptid
)
3560 int retval
= current_target
.to_core_of_thread (¤t_target
, ptid
);
3563 fprintf_unfiltered (gdb_stdlog
,
3564 "target_core_of_thread (%d) = %d\n",
3565 ptid_get_pid (ptid
), retval
);
3570 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3572 int retval
= current_target
.to_verify_memory (¤t_target
,
3573 data
, memaddr
, size
);
3576 fprintf_unfiltered (gdb_stdlog
,
3577 "target_verify_memory (%s, %s) = %d\n",
3578 paddress (target_gdbarch (), memaddr
),
3584 /* The documentation for this function is in its prototype declaration in
3588 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3592 ret
= current_target
.to_insert_mask_watchpoint (¤t_target
,
3596 fprintf_unfiltered (gdb_stdlog
, "\
3597 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
3598 core_addr_to_string (addr
),
3599 core_addr_to_string (mask
), rw
, ret
);
3604 /* The documentation for this function is in its prototype declaration in
3608 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3612 ret
= current_target
.to_remove_mask_watchpoint (¤t_target
,
3616 fprintf_unfiltered (gdb_stdlog
, "\
3617 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
3618 core_addr_to_string (addr
),
3619 core_addr_to_string (mask
), rw
, ret
);
3624 /* The documentation for this function is in its prototype declaration
3628 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
3630 return current_target
.to_masked_watch_num_registers (¤t_target
,
3634 /* The documentation for this function is in its prototype declaration
3638 target_ranged_break_num_registers (void)
3640 return current_target
.to_ranged_break_num_registers (¤t_target
);
3645 struct btrace_target_info
*
3646 target_enable_btrace (ptid_t ptid
)
3648 return current_target
.to_enable_btrace (¤t_target
, ptid
);
3654 target_disable_btrace (struct btrace_target_info
*btinfo
)
3656 current_target
.to_disable_btrace (¤t_target
, btinfo
);
3662 target_teardown_btrace (struct btrace_target_info
*btinfo
)
3664 current_target
.to_teardown_btrace (¤t_target
, btinfo
);
3670 target_read_btrace (VEC (btrace_block_s
) **btrace
,
3671 struct btrace_target_info
*btinfo
,
3672 enum btrace_read_type type
)
3674 return current_target
.to_read_btrace (¤t_target
, btrace
, btinfo
, type
);
3680 target_stop_recording (void)
3682 current_target
.to_stop_recording (¤t_target
);
3688 target_info_record (void)
3690 struct target_ops
*t
;
3692 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3693 if (t
->to_info_record
!= NULL
)
3695 t
->to_info_record (t
);
3705 target_save_record (const char *filename
)
3707 current_target
.to_save_record (¤t_target
, filename
);
3713 target_supports_delete_record (void)
3715 struct target_ops
*t
;
3717 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3718 if (t
->to_delete_record
!= NULL
)
3727 target_delete_record (void)
3729 current_target
.to_delete_record (¤t_target
);
3735 target_record_is_replaying (void)
3737 return current_target
.to_record_is_replaying (¤t_target
);
3743 target_goto_record_begin (void)
3745 current_target
.to_goto_record_begin (¤t_target
);
3751 target_goto_record_end (void)
3753 current_target
.to_goto_record_end (¤t_target
);
3759 target_goto_record (ULONGEST insn
)
3761 current_target
.to_goto_record (¤t_target
, insn
);
3767 target_insn_history (int size
, int flags
)
3769 current_target
.to_insn_history (¤t_target
, size
, flags
);
3775 target_insn_history_from (ULONGEST from
, int size
, int flags
)
3777 current_target
.to_insn_history_from (¤t_target
, from
, size
, flags
);
3783 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
3785 current_target
.to_insn_history_range (¤t_target
, begin
, end
, flags
);
3791 target_call_history (int size
, int flags
)
3793 current_target
.to_call_history (¤t_target
, size
, flags
);
3799 target_call_history_from (ULONGEST begin
, int size
, int flags
)
3801 current_target
.to_call_history_from (¤t_target
, begin
, size
, flags
);
3807 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
3809 current_target
.to_call_history_range (¤t_target
, begin
, end
, flags
);
3813 debug_to_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
3815 debug_target
.to_prepare_to_store (&debug_target
, regcache
);
3817 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
3822 const struct frame_unwind
*
3823 target_get_unwinder (void)
3825 struct target_ops
*t
;
3827 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3828 if (t
->to_get_unwinder
!= NULL
)
3829 return t
->to_get_unwinder
;
3836 const struct frame_unwind
*
3837 target_get_tailcall_unwinder (void)
3839 struct target_ops
*t
;
3841 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3842 if (t
->to_get_tailcall_unwinder
!= NULL
)
3843 return t
->to_get_tailcall_unwinder
;
3848 /* Default implementation of to_decr_pc_after_break. */
3851 default_target_decr_pc_after_break (struct target_ops
*ops
,
3852 struct gdbarch
*gdbarch
)
3854 return gdbarch_decr_pc_after_break (gdbarch
);
3860 target_decr_pc_after_break (struct gdbarch
*gdbarch
)
3862 return current_target
.to_decr_pc_after_break (¤t_target
, gdbarch
);
3866 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
3867 int write
, struct mem_attrib
*attrib
,
3868 struct target_ops
*target
)
3872 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
3875 fprintf_unfiltered (gdb_stdlog
,
3876 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
3877 paddress (target_gdbarch (), memaddr
), len
,
3878 write
? "write" : "read", retval
);
3884 fputs_unfiltered (", bytes =", gdb_stdlog
);
3885 for (i
= 0; i
< retval
; i
++)
3887 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
3889 if (targetdebug
< 2 && i
> 0)
3891 fprintf_unfiltered (gdb_stdlog
, " ...");
3894 fprintf_unfiltered (gdb_stdlog
, "\n");
3897 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
3901 fputc_unfiltered ('\n', gdb_stdlog
);
3907 debug_to_files_info (struct target_ops
*target
)
3909 debug_target
.to_files_info (target
);
3911 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
3915 debug_to_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
3916 struct bp_target_info
*bp_tgt
)
3920 retval
= debug_target
.to_insert_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
3922 fprintf_unfiltered (gdb_stdlog
,
3923 "target_insert_breakpoint (%s, xxx) = %ld\n",
3924 core_addr_to_string (bp_tgt
->placed_address
),
3925 (unsigned long) retval
);
3930 debug_to_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
3931 struct bp_target_info
*bp_tgt
)
3935 retval
= debug_target
.to_remove_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
3937 fprintf_unfiltered (gdb_stdlog
,
3938 "target_remove_breakpoint (%s, xxx) = %ld\n",
3939 core_addr_to_string (bp_tgt
->placed_address
),
3940 (unsigned long) retval
);
3945 debug_to_can_use_hw_breakpoint (struct target_ops
*self
,
3946 int type
, int cnt
, int from_tty
)
3950 retval
= debug_target
.to_can_use_hw_breakpoint (&debug_target
,
3951 type
, cnt
, from_tty
);
3953 fprintf_unfiltered (gdb_stdlog
,
3954 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
3955 (unsigned long) type
,
3956 (unsigned long) cnt
,
3957 (unsigned long) from_tty
,
3958 (unsigned long) retval
);
3963 debug_to_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3964 CORE_ADDR addr
, int len
)
3968 retval
= debug_target
.to_region_ok_for_hw_watchpoint (&debug_target
,
3971 fprintf_unfiltered (gdb_stdlog
,
3972 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
3973 core_addr_to_string (addr
), (unsigned long) len
,
3974 core_addr_to_string (retval
));
3979 debug_to_can_accel_watchpoint_condition (struct target_ops
*self
,
3980 CORE_ADDR addr
, int len
, int rw
,
3981 struct expression
*cond
)
3985 retval
= debug_target
.to_can_accel_watchpoint_condition (&debug_target
,
3989 fprintf_unfiltered (gdb_stdlog
,
3990 "target_can_accel_watchpoint_condition "
3991 "(%s, %d, %d, %s) = %ld\n",
3992 core_addr_to_string (addr
), len
, rw
,
3993 host_address_to_string (cond
), (unsigned long) retval
);
3998 debug_to_stopped_by_watchpoint (struct target_ops
*ops
)
4002 retval
= debug_target
.to_stopped_by_watchpoint (&debug_target
);
4004 fprintf_unfiltered (gdb_stdlog
,
4005 "target_stopped_by_watchpoint () = %ld\n",
4006 (unsigned long) retval
);
4011 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
4015 retval
= debug_target
.to_stopped_data_address (target
, addr
);
4017 fprintf_unfiltered (gdb_stdlog
,
4018 "target_stopped_data_address ([%s]) = %ld\n",
4019 core_addr_to_string (*addr
),
4020 (unsigned long)retval
);
4025 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
4027 CORE_ADDR start
, int length
)
4031 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
4034 fprintf_filtered (gdb_stdlog
,
4035 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4036 core_addr_to_string (addr
), core_addr_to_string (start
),
4042 debug_to_insert_hw_breakpoint (struct target_ops
*self
,
4043 struct gdbarch
*gdbarch
,
4044 struct bp_target_info
*bp_tgt
)
4048 retval
= debug_target
.to_insert_hw_breakpoint (&debug_target
,
4051 fprintf_unfiltered (gdb_stdlog
,
4052 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4053 core_addr_to_string (bp_tgt
->placed_address
),
4054 (unsigned long) retval
);
4059 debug_to_remove_hw_breakpoint (struct target_ops
*self
,
4060 struct gdbarch
*gdbarch
,
4061 struct bp_target_info
*bp_tgt
)
4065 retval
= debug_target
.to_remove_hw_breakpoint (&debug_target
,
4068 fprintf_unfiltered (gdb_stdlog
,
4069 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4070 core_addr_to_string (bp_tgt
->placed_address
),
4071 (unsigned long) retval
);
4076 debug_to_insert_watchpoint (struct target_ops
*self
,
4077 CORE_ADDR addr
, int len
, int type
,
4078 struct expression
*cond
)
4082 retval
= debug_target
.to_insert_watchpoint (&debug_target
,
4083 addr
, len
, type
, cond
);
4085 fprintf_unfiltered (gdb_stdlog
,
4086 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4087 core_addr_to_string (addr
), len
, type
,
4088 host_address_to_string (cond
), (unsigned long) retval
);
4093 debug_to_remove_watchpoint (struct target_ops
*self
,
4094 CORE_ADDR addr
, int len
, int type
,
4095 struct expression
*cond
)
4099 retval
= debug_target
.to_remove_watchpoint (&debug_target
,
4100 addr
, len
, type
, cond
);
4102 fprintf_unfiltered (gdb_stdlog
,
4103 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4104 core_addr_to_string (addr
), len
, type
,
4105 host_address_to_string (cond
), (unsigned long) retval
);
4110 debug_to_terminal_init (struct target_ops
*self
)
4112 debug_target
.to_terminal_init (&debug_target
);
4114 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
4118 debug_to_terminal_inferior (struct target_ops
*self
)
4120 debug_target
.to_terminal_inferior (&debug_target
);
4122 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
4126 debug_to_terminal_ours_for_output (struct target_ops
*self
)
4128 debug_target
.to_terminal_ours_for_output (&debug_target
);
4130 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
4134 debug_to_terminal_ours (struct target_ops
*self
)
4136 debug_target
.to_terminal_ours (&debug_target
);
4138 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
4142 debug_to_terminal_save_ours (struct target_ops
*self
)
4144 debug_target
.to_terminal_save_ours (&debug_target
);
4146 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
4150 debug_to_terminal_info (struct target_ops
*self
,
4151 const char *arg
, int from_tty
)
4153 debug_target
.to_terminal_info (&debug_target
, arg
, from_tty
);
4155 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
4160 debug_to_load (struct target_ops
*self
, char *args
, int from_tty
)
4162 debug_target
.to_load (&debug_target
, args
, from_tty
);
4164 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
4168 debug_to_post_startup_inferior (struct target_ops
*self
, ptid_t ptid
)
4170 debug_target
.to_post_startup_inferior (&debug_target
, ptid
);
4172 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
4173 ptid_get_pid (ptid
));
4177 debug_to_insert_fork_catchpoint (struct target_ops
*self
, int pid
)
4181 retval
= debug_target
.to_insert_fork_catchpoint (&debug_target
, pid
);
4183 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
4190 debug_to_remove_fork_catchpoint (struct target_ops
*self
, int pid
)
4194 retval
= debug_target
.to_remove_fork_catchpoint (&debug_target
, pid
);
4196 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
4203 debug_to_insert_vfork_catchpoint (struct target_ops
*self
, int pid
)
4207 retval
= debug_target
.to_insert_vfork_catchpoint (&debug_target
, pid
);
4209 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
4216 debug_to_remove_vfork_catchpoint (struct target_ops
*self
, int pid
)
4220 retval
= debug_target
.to_remove_vfork_catchpoint (&debug_target
, pid
);
4222 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
4229 debug_to_insert_exec_catchpoint (struct target_ops
*self
, int pid
)
4233 retval
= debug_target
.to_insert_exec_catchpoint (&debug_target
, pid
);
4235 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
4242 debug_to_remove_exec_catchpoint (struct target_ops
*self
, int pid
)
4246 retval
= debug_target
.to_remove_exec_catchpoint (&debug_target
, pid
);
4248 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
4255 debug_to_has_exited (struct target_ops
*self
,
4256 int pid
, int wait_status
, int *exit_status
)
4260 has_exited
= debug_target
.to_has_exited (&debug_target
,
4261 pid
, wait_status
, exit_status
);
4263 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
4264 pid
, wait_status
, *exit_status
, has_exited
);
4270 debug_to_can_run (struct target_ops
*self
)
4274 retval
= debug_target
.to_can_run (&debug_target
);
4276 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4281 static struct gdbarch
*
4282 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4284 struct gdbarch
*retval
;
4286 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4288 fprintf_unfiltered (gdb_stdlog
,
4289 "target_thread_architecture (%s) = %s [%s]\n",
4290 target_pid_to_str (ptid
),
4291 host_address_to_string (retval
),
4292 gdbarch_bfd_arch_info (retval
)->printable_name
);
4297 debug_to_stop (struct target_ops
*self
, ptid_t ptid
)
4299 debug_target
.to_stop (&debug_target
, ptid
);
4301 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4302 target_pid_to_str (ptid
));
4306 debug_to_rcmd (struct target_ops
*self
, char *command
,
4307 struct ui_file
*outbuf
)
4309 debug_target
.to_rcmd (&debug_target
, command
, outbuf
);
4310 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4314 debug_to_pid_to_exec_file (struct target_ops
*self
, int pid
)
4318 exec_file
= debug_target
.to_pid_to_exec_file (&debug_target
, pid
);
4320 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
4327 setup_target_debug (void)
4329 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
4331 current_target
.to_open
= debug_to_open
;
4332 current_target
.to_post_attach
= debug_to_post_attach
;
4333 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
4334 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
4335 current_target
.to_files_info
= debug_to_files_info
;
4336 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
4337 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
4338 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
4339 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
4340 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
4341 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
4342 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
4343 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
4344 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
4345 current_target
.to_watchpoint_addr_within_range
4346 = debug_to_watchpoint_addr_within_range
;
4347 current_target
.to_region_ok_for_hw_watchpoint
4348 = debug_to_region_ok_for_hw_watchpoint
;
4349 current_target
.to_can_accel_watchpoint_condition
4350 = debug_to_can_accel_watchpoint_condition
;
4351 current_target
.to_terminal_init
= debug_to_terminal_init
;
4352 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
4353 current_target
.to_terminal_ours_for_output
4354 = debug_to_terminal_ours_for_output
;
4355 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
4356 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
4357 current_target
.to_terminal_info
= debug_to_terminal_info
;
4358 current_target
.to_load
= debug_to_load
;
4359 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
4360 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
4361 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
4362 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
4363 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
4364 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
4365 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
4366 current_target
.to_has_exited
= debug_to_has_exited
;
4367 current_target
.to_can_run
= debug_to_can_run
;
4368 current_target
.to_stop
= debug_to_stop
;
4369 current_target
.to_rcmd
= debug_to_rcmd
;
4370 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
4371 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
4375 static char targ_desc
[] =
4376 "Names of targets and files being debugged.\nShows the entire \
4377 stack of targets currently in use (including the exec-file,\n\
4378 core-file, and process, if any), as well as the symbol file name.";
4381 default_rcmd (struct target_ops
*self
, char *command
, struct ui_file
*output
)
4383 error (_("\"monitor\" command not supported by this target."));
4387 do_monitor_command (char *cmd
,
4390 target_rcmd (cmd
, gdb_stdtarg
);
4393 /* Print the name of each layers of our target stack. */
4396 maintenance_print_target_stack (char *cmd
, int from_tty
)
4398 struct target_ops
*t
;
4400 printf_filtered (_("The current target stack is:\n"));
4402 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
4404 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
4408 /* Controls if async mode is permitted. */
4409 int target_async_permitted
= 0;
4411 /* The set command writes to this variable. If the inferior is
4412 executing, target_async_permitted is *not* updated. */
4413 static int target_async_permitted_1
= 0;
4416 set_target_async_command (char *args
, int from_tty
,
4417 struct cmd_list_element
*c
)
4419 if (have_live_inferiors ())
4421 target_async_permitted_1
= target_async_permitted
;
4422 error (_("Cannot change this setting while the inferior is running."));
4425 target_async_permitted
= target_async_permitted_1
;
4429 show_target_async_command (struct ui_file
*file
, int from_tty
,
4430 struct cmd_list_element
*c
,
4433 fprintf_filtered (file
,
4434 _("Controlling the inferior in "
4435 "asynchronous mode is %s.\n"), value
);
4438 /* Temporary copies of permission settings. */
4440 static int may_write_registers_1
= 1;
4441 static int may_write_memory_1
= 1;
4442 static int may_insert_breakpoints_1
= 1;
4443 static int may_insert_tracepoints_1
= 1;
4444 static int may_insert_fast_tracepoints_1
= 1;
4445 static int may_stop_1
= 1;
4447 /* Make the user-set values match the real values again. */
4450 update_target_permissions (void)
4452 may_write_registers_1
= may_write_registers
;
4453 may_write_memory_1
= may_write_memory
;
4454 may_insert_breakpoints_1
= may_insert_breakpoints
;
4455 may_insert_tracepoints_1
= may_insert_tracepoints
;
4456 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
4457 may_stop_1
= may_stop
;
4460 /* The one function handles (most of) the permission flags in the same
4464 set_target_permissions (char *args
, int from_tty
,
4465 struct cmd_list_element
*c
)
4467 if (target_has_execution
)
4469 update_target_permissions ();
4470 error (_("Cannot change this setting while the inferior is running."));
4473 /* Make the real values match the user-changed values. */
4474 may_write_registers
= may_write_registers_1
;
4475 may_insert_breakpoints
= may_insert_breakpoints_1
;
4476 may_insert_tracepoints
= may_insert_tracepoints_1
;
4477 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
4478 may_stop
= may_stop_1
;
4479 update_observer_mode ();
4482 /* Set memory write permission independently of observer mode. */
4485 set_write_memory_permission (char *args
, int from_tty
,
4486 struct cmd_list_element
*c
)
4488 /* Make the real values match the user-changed values. */
4489 may_write_memory
= may_write_memory_1
;
4490 update_observer_mode ();
4495 initialize_targets (void)
4497 init_dummy_target ();
4498 push_target (&dummy_target
);
4500 add_info ("target", target_info
, targ_desc
);
4501 add_info ("files", target_info
, targ_desc
);
4503 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
4504 Set target debugging."), _("\
4505 Show target debugging."), _("\
4506 When non-zero, target debugging is enabled. Higher numbers are more\n\
4507 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
4511 &setdebuglist
, &showdebuglist
);
4513 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
4514 &trust_readonly
, _("\
4515 Set mode for reading from readonly sections."), _("\
4516 Show mode for reading from readonly sections."), _("\
4517 When this mode is on, memory reads from readonly sections (such as .text)\n\
4518 will be read from the object file instead of from the target. This will\n\
4519 result in significant performance improvement for remote targets."),
4521 show_trust_readonly
,
4522 &setlist
, &showlist
);
4524 add_com ("monitor", class_obscure
, do_monitor_command
,
4525 _("Send a command to the remote monitor (remote targets only)."));
4527 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
4528 _("Print the name of each layer of the internal target stack."),
4529 &maintenanceprintlist
);
4531 add_setshow_boolean_cmd ("target-async", no_class
,
4532 &target_async_permitted_1
, _("\
4533 Set whether gdb controls the inferior in asynchronous mode."), _("\
4534 Show whether gdb controls the inferior in asynchronous mode."), _("\
4535 Tells gdb whether to control the inferior in asynchronous mode."),
4536 set_target_async_command
,
4537 show_target_async_command
,
4541 add_setshow_boolean_cmd ("may-write-registers", class_support
,
4542 &may_write_registers_1
, _("\
4543 Set permission to write into registers."), _("\
4544 Show permission to write into registers."), _("\
4545 When this permission is on, GDB may write into the target's registers.\n\
4546 Otherwise, any sort of write attempt will result in an error."),
4547 set_target_permissions
, NULL
,
4548 &setlist
, &showlist
);
4550 add_setshow_boolean_cmd ("may-write-memory", class_support
,
4551 &may_write_memory_1
, _("\
4552 Set permission to write into target memory."), _("\
4553 Show permission to write into target memory."), _("\
4554 When this permission is on, GDB may write into the target's memory.\n\
4555 Otherwise, any sort of write attempt will result in an error."),
4556 set_write_memory_permission
, NULL
,
4557 &setlist
, &showlist
);
4559 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
4560 &may_insert_breakpoints_1
, _("\
4561 Set permission to insert breakpoints in the target."), _("\
4562 Show permission to insert breakpoints in the target."), _("\
4563 When this permission is on, GDB may insert breakpoints in the program.\n\
4564 Otherwise, any sort of insertion attempt will result in an error."),
4565 set_target_permissions
, NULL
,
4566 &setlist
, &showlist
);
4568 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
4569 &may_insert_tracepoints_1
, _("\
4570 Set permission to insert tracepoints in the target."), _("\
4571 Show permission to insert tracepoints in the target."), _("\
4572 When this permission is on, GDB may insert tracepoints in the program.\n\
4573 Otherwise, any sort of insertion attempt will result in an error."),
4574 set_target_permissions
, NULL
,
4575 &setlist
, &showlist
);
4577 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
4578 &may_insert_fast_tracepoints_1
, _("\
4579 Set permission to insert fast tracepoints in the target."), _("\
4580 Show permission to insert fast tracepoints in the target."), _("\
4581 When this permission is on, GDB may insert fast tracepoints.\n\
4582 Otherwise, any sort of insertion attempt will result in an error."),
4583 set_target_permissions
, NULL
,
4584 &setlist
, &showlist
);
4586 add_setshow_boolean_cmd ("may-interrupt", class_support
,
4588 Set permission to interrupt or signal the target."), _("\
4589 Show permission to interrupt or signal the target."), _("\
4590 When this permission is on, GDB may interrupt/stop the target's execution.\n\
4591 Otherwise, any attempt to interrupt or stop will be ignored."),
4592 set_target_permissions
, NULL
,
4593 &setlist
, &showlist
);