1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990-2019 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "target-dcache.h"
36 #include "target-descriptions.h"
37 #include "gdbthread.h"
40 #include "inline-frame.h"
41 #include "tracepoint.h"
42 #include "gdb/fileio.h"
43 #include "common/agent.h"
45 #include "target-debug.h"
47 #include "event-top.h"
49 #include "common/byte-vector.h"
51 #include <unordered_map>
53 static void generic_tls_error (void) ATTRIBUTE_NORETURN
;
55 static void default_terminal_info (struct target_ops
*, const char *, int);
57 static int default_watchpoint_addr_within_range (struct target_ops
*,
58 CORE_ADDR
, CORE_ADDR
, int);
60 static int default_region_ok_for_hw_watchpoint (struct target_ops
*,
63 static void default_rcmd (struct target_ops
*, const char *, struct ui_file
*);
65 static ptid_t
default_get_ada_task_ptid (struct target_ops
*self
,
68 static int default_follow_fork (struct target_ops
*self
, int follow_child
,
71 static void default_mourn_inferior (struct target_ops
*self
);
73 static int default_search_memory (struct target_ops
*ops
,
75 ULONGEST search_space_len
,
76 const gdb_byte
*pattern
,
78 CORE_ADDR
*found_addrp
);
80 static int default_verify_memory (struct target_ops
*self
,
82 CORE_ADDR memaddr
, ULONGEST size
);
84 static void tcomplain (void) ATTRIBUTE_NORETURN
;
86 static struct target_ops
*find_default_run_target (const char *);
88 static int dummy_find_memory_regions (struct target_ops
*self
,
89 find_memory_region_ftype ignore1
,
92 static char *dummy_make_corefile_notes (struct target_ops
*self
,
93 bfd
*ignore1
, int *ignore2
);
95 static const char *default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
);
97 static enum exec_direction_kind default_execution_direction
98 (struct target_ops
*self
);
100 /* Mapping between target_info objects (which have address identity)
101 and corresponding open/factory function/callback. Each add_target
102 call adds one entry to this map, and registers a "target
103 TARGET_NAME" command that when invoked calls the factory registered
104 here. The target_info object is associated with the command via
105 the command's context. */
106 static std::unordered_map
<const target_info
*, target_open_ftype
*>
109 /* The singleton debug target. */
111 static struct target_ops
*the_debug_target
;
113 /* The target stack. */
115 static target_stack g_target_stack
;
117 /* Top of target stack. */
118 /* The target structure we are currently using to talk to a process
119 or file or whatever "inferior" we have. */
122 current_top_target ()
124 return g_target_stack
.top ();
127 /* Command list for target. */
129 static struct cmd_list_element
*targetlist
= NULL
;
131 /* Nonzero if we should trust readonly sections from the
132 executable when reading memory. */
134 static int trust_readonly
= 0;
136 /* Nonzero if we should show true memory content including
137 memory breakpoint inserted by gdb. */
139 static int show_memory_breakpoints
= 0;
141 /* These globals control whether GDB attempts to perform these
142 operations; they are useful for targets that need to prevent
143 inadvertant disruption, such as in non-stop mode. */
145 int may_write_registers
= 1;
147 int may_write_memory
= 1;
149 int may_insert_breakpoints
= 1;
151 int may_insert_tracepoints
= 1;
153 int may_insert_fast_tracepoints
= 1;
157 /* Non-zero if we want to see trace of target level stuff. */
159 static unsigned int targetdebug
= 0;
162 set_targetdebug (const char *args
, int from_tty
, struct cmd_list_element
*c
)
165 push_target (the_debug_target
);
167 unpush_target (the_debug_target
);
171 show_targetdebug (struct ui_file
*file
, int from_tty
,
172 struct cmd_list_element
*c
, const char *value
)
174 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
177 /* The user just typed 'target' without the name of a target. */
180 target_command (const char *arg
, int from_tty
)
182 fputs_filtered ("Argument required (target name). Try `help target'\n",
187 target_has_all_memory_1 (void)
189 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
190 if (t
->has_all_memory ())
197 target_has_memory_1 (void)
199 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
200 if (t
->has_memory ())
207 target_has_stack_1 (void)
209 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
217 target_has_registers_1 (void)
219 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
220 if (t
->has_registers ())
227 target_has_execution_1 (ptid_t the_ptid
)
229 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
230 if (t
->has_execution (the_ptid
))
237 target_has_execution_current (void)
239 return target_has_execution_1 (inferior_ptid
);
242 /* This is used to implement the various target commands. */
245 open_target (const char *args
, int from_tty
, struct cmd_list_element
*command
)
247 auto *ti
= static_cast<target_info
*> (get_cmd_context (command
));
248 target_open_ftype
*func
= target_factories
[ti
];
251 fprintf_unfiltered (gdb_stdlog
, "-> %s->open (...)\n",
254 func (args
, from_tty
);
257 fprintf_unfiltered (gdb_stdlog
, "<- %s->open (%s, %d)\n",
258 ti
->shortname
, args
, from_tty
);
264 add_target (const target_info
&t
, target_open_ftype
*func
,
265 completer_ftype
*completer
)
267 struct cmd_list_element
*c
;
269 auto &func_slot
= target_factories
[&t
];
270 if (func_slot
!= nullptr)
271 internal_error (__FILE__
, __LINE__
,
272 _("target already added (\"%s\")."), t
.shortname
);
275 if (targetlist
== NULL
)
276 add_prefix_cmd ("target", class_run
, target_command
, _("\
277 Connect to a target machine or process.\n\
278 The first argument is the type or protocol of the target machine.\n\
279 Remaining arguments are interpreted by the target protocol. For more\n\
280 information on the arguments for a particular protocol, type\n\
281 `help target ' followed by the protocol name."),
282 &targetlist
, "target ", 0, &cmdlist
);
283 c
= add_cmd (t
.shortname
, no_class
, t
.doc
, &targetlist
);
284 set_cmd_context (c
, (void *) &t
);
285 set_cmd_sfunc (c
, open_target
);
286 if (completer
!= NULL
)
287 set_cmd_completer (c
, completer
);
293 add_deprecated_target_alias (const target_info
&tinfo
, const char *alias
)
295 struct cmd_list_element
*c
;
298 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
300 c
= add_cmd (alias
, no_class
, tinfo
.doc
, &targetlist
);
301 set_cmd_sfunc (c
, open_target
);
302 set_cmd_context (c
, (void *) &tinfo
);
303 alt
= xstrprintf ("target %s", tinfo
.shortname
);
304 deprecate_cmd (c
, alt
);
312 current_top_target ()->kill ();
316 target_load (const char *arg
, int from_tty
)
318 target_dcache_invalidate ();
319 current_top_target ()->load (arg
, from_tty
);
324 target_terminal_state
target_terminal::m_terminal_state
325 = target_terminal_state::is_ours
;
327 /* See target/target.h. */
330 target_terminal::init (void)
332 current_top_target ()->terminal_init ();
334 m_terminal_state
= target_terminal_state::is_ours
;
337 /* See target/target.h. */
340 target_terminal::inferior (void)
342 struct ui
*ui
= current_ui
;
344 /* A background resume (``run&'') should leave GDB in control of the
346 if (ui
->prompt_state
!= PROMPT_BLOCKED
)
349 /* Since we always run the inferior in the main console (unless "set
350 inferior-tty" is in effect), when some UI other than the main one
351 calls target_terminal::inferior, then we leave the main UI's
352 terminal settings as is. */
356 /* If GDB is resuming the inferior in the foreground, install
357 inferior's terminal modes. */
359 struct inferior
*inf
= current_inferior ();
361 if (inf
->terminal_state
!= target_terminal_state::is_inferior
)
363 current_top_target ()->terminal_inferior ();
364 inf
->terminal_state
= target_terminal_state::is_inferior
;
367 m_terminal_state
= target_terminal_state::is_inferior
;
369 /* If the user hit C-c before, pretend that it was hit right
371 if (check_quit_flag ())
372 target_pass_ctrlc ();
375 /* See target/target.h. */
378 target_terminal::restore_inferior (void)
380 struct ui
*ui
= current_ui
;
382 /* See target_terminal::inferior(). */
383 if (ui
->prompt_state
!= PROMPT_BLOCKED
|| ui
!= main_ui
)
386 /* Restore the terminal settings of inferiors that were in the
387 foreground but are now ours_for_output due to a temporary
388 target_target::ours_for_output() call. */
391 scoped_restore_current_inferior restore_inferior
;
393 for (::inferior
*inf
: all_inferiors ())
395 if (inf
->terminal_state
== target_terminal_state::is_ours_for_output
)
397 set_current_inferior (inf
);
398 current_top_target ()->terminal_inferior ();
399 inf
->terminal_state
= target_terminal_state::is_inferior
;
404 m_terminal_state
= target_terminal_state::is_inferior
;
406 /* If the user hit C-c before, pretend that it was hit right
408 if (check_quit_flag ())
409 target_pass_ctrlc ();
412 /* Switch terminal state to DESIRED_STATE, either is_ours, or
413 is_ours_for_output. */
416 target_terminal_is_ours_kind (target_terminal_state desired_state
)
418 scoped_restore_current_inferior restore_inferior
;
420 /* Must do this in two passes. First, have all inferiors save the
421 current terminal settings. Then, after all inferiors have add a
422 chance to safely save the terminal settings, restore GDB's
423 terminal settings. */
425 for (inferior
*inf
: all_inferiors ())
427 if (inf
->terminal_state
== target_terminal_state::is_inferior
)
429 set_current_inferior (inf
);
430 current_top_target ()->terminal_save_inferior ();
434 for (inferior
*inf
: all_inferiors ())
436 /* Note we don't check is_inferior here like above because we
437 need to handle 'is_ours_for_output -> is_ours' too. Careful
438 to never transition from 'is_ours' to 'is_ours_for_output',
440 if (inf
->terminal_state
!= target_terminal_state::is_ours
441 && inf
->terminal_state
!= desired_state
)
443 set_current_inferior (inf
);
444 if (desired_state
== target_terminal_state::is_ours
)
445 current_top_target ()->terminal_ours ();
446 else if (desired_state
== target_terminal_state::is_ours_for_output
)
447 current_top_target ()->terminal_ours_for_output ();
449 gdb_assert_not_reached ("unhandled desired state");
450 inf
->terminal_state
= desired_state
;
455 /* See target/target.h. */
458 target_terminal::ours ()
460 struct ui
*ui
= current_ui
;
462 /* See target_terminal::inferior. */
466 if (m_terminal_state
== target_terminal_state::is_ours
)
469 target_terminal_is_ours_kind (target_terminal_state::is_ours
);
470 m_terminal_state
= target_terminal_state::is_ours
;
473 /* See target/target.h. */
476 target_terminal::ours_for_output ()
478 struct ui
*ui
= current_ui
;
480 /* See target_terminal::inferior. */
484 if (!target_terminal::is_inferior ())
487 target_terminal_is_ours_kind (target_terminal_state::is_ours_for_output
);
488 target_terminal::m_terminal_state
= target_terminal_state::is_ours_for_output
;
491 /* See target/target.h. */
494 target_terminal::info (const char *arg
, int from_tty
)
496 current_top_target ()->terminal_info (arg
, from_tty
);
502 target_supports_terminal_ours (void)
504 /* This can be called before there is any target, so we must check
506 target_ops
*top
= current_top_target ();
510 return top
->supports_terminal_ours ();
516 error (_("You can't do that when your target is `%s'"),
517 current_top_target ()->shortname ());
523 error (_("You can't do that without a process to debug."));
527 default_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
529 printf_unfiltered (_("No saved terminal information.\n"));
532 /* A default implementation for the to_get_ada_task_ptid target method.
534 This function builds the PTID by using both LWP and TID as part of
535 the PTID lwp and tid elements. The pid used is the pid of the
539 default_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long tid
)
541 return ptid_t (inferior_ptid
.pid (), lwp
, tid
);
544 static enum exec_direction_kind
545 default_execution_direction (struct target_ops
*self
)
547 if (!target_can_execute_reverse
)
549 else if (!target_can_async_p ())
552 gdb_assert_not_reached ("\
553 to_execution_direction must be implemented for reverse async");
559 target_stack::push (target_ops
*t
)
561 /* If there's already a target at this stratum, remove it. */
562 strata stratum
= t
->stratum ();
564 if (m_stack
[stratum
] != NULL
)
566 target_ops
*prev
= m_stack
[stratum
];
567 m_stack
[stratum
] = NULL
;
571 /* Now add the new one. */
572 m_stack
[stratum
] = t
;
581 push_target (struct target_ops
*t
)
583 g_target_stack
.push (t
);
589 push_target (target_ops_up
&&t
)
591 g_target_stack
.push (t
.get ());
598 unpush_target (struct target_ops
*t
)
600 return g_target_stack
.unpush (t
);
606 target_stack::unpush (target_ops
*t
)
608 gdb_assert (t
!= NULL
);
610 strata stratum
= t
->stratum ();
612 if (stratum
== dummy_stratum
)
613 internal_error (__FILE__
, __LINE__
,
614 _("Attempt to unpush the dummy target"));
616 /* Look for the specified target. Note that a target can only occur
617 once in the target stack. */
619 if (m_stack
[stratum
] != t
)
621 /* If T wasn't pushed, quit. Only open targets should be
626 /* Unchain the target. */
627 m_stack
[stratum
] = NULL
;
629 if (m_top
== stratum
)
630 m_top
= t
->beneath ()->stratum ();
632 /* Finally close the target. Note we do this after unchaining, so
633 any target method calls from within the target_close
634 implementation don't end up in T anymore. */
640 /* Unpush TARGET and assert that it worked. */
643 unpush_target_and_assert (struct target_ops
*target
)
645 if (!unpush_target (target
))
647 fprintf_unfiltered (gdb_stderr
,
648 "pop_all_targets couldn't find target %s\n",
649 target
->shortname ());
650 internal_error (__FILE__
, __LINE__
,
651 _("failed internal consistency check"));
656 pop_all_targets_above (enum strata above_stratum
)
658 while ((int) (current_top_target ()->stratum ()) > (int) above_stratum
)
659 unpush_target_and_assert (current_top_target ());
665 pop_all_targets_at_and_above (enum strata stratum
)
667 while ((int) (current_top_target ()->stratum ()) >= (int) stratum
)
668 unpush_target_and_assert (current_top_target ());
672 pop_all_targets (void)
674 pop_all_targets_above (dummy_stratum
);
677 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
680 target_is_pushed (struct target_ops
*t
)
682 return g_target_stack
.is_pushed (t
);
685 /* Default implementation of to_get_thread_local_address. */
688 generic_tls_error (void)
690 throw_error (TLS_GENERIC_ERROR
,
691 _("Cannot find thread-local variables on this target"));
694 /* Using the objfile specified in OBJFILE, find the address for the
695 current thread's thread-local storage with offset OFFSET. */
697 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
699 volatile CORE_ADDR addr
= 0;
700 struct target_ops
*target
= current_top_target ();
702 if (gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
704 ptid_t ptid
= inferior_ptid
;
710 /* Fetch the load module address for this objfile. */
711 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch (),
714 addr
= target
->get_thread_local_address (ptid
, lm_addr
, offset
);
716 /* If an error occurred, print TLS related messages here. Otherwise,
717 throw the error to some higher catcher. */
718 CATCH (ex
, RETURN_MASK_ALL
)
720 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
724 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
725 error (_("Cannot find thread-local variables "
726 "in this thread library."));
728 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
729 if (objfile_is_library
)
730 error (_("Cannot find shared library `%s' in dynamic"
731 " linker's load module list"), objfile_name (objfile
));
733 error (_("Cannot find executable file `%s' in dynamic"
734 " linker's load module list"), objfile_name (objfile
));
736 case TLS_NOT_ALLOCATED_YET_ERROR
:
737 if (objfile_is_library
)
738 error (_("The inferior has not yet allocated storage for"
739 " thread-local variables in\n"
740 "the shared library `%s'\n"
742 objfile_name (objfile
), target_pid_to_str (ptid
));
744 error (_("The inferior has not yet allocated storage for"
745 " thread-local variables in\n"
746 "the executable `%s'\n"
748 objfile_name (objfile
), target_pid_to_str (ptid
));
750 case TLS_GENERIC_ERROR
:
751 if (objfile_is_library
)
752 error (_("Cannot find thread-local storage for %s, "
753 "shared library %s:\n%s"),
754 target_pid_to_str (ptid
),
755 objfile_name (objfile
), ex
.message
);
757 error (_("Cannot find thread-local storage for %s, "
758 "executable file %s:\n%s"),
759 target_pid_to_str (ptid
),
760 objfile_name (objfile
), ex
.message
);
763 throw_exception (ex
);
769 /* It wouldn't be wrong here to try a gdbarch method, too; finding
770 TLS is an ABI-specific thing. But we don't do that yet. */
772 error (_("Cannot find thread-local variables on this target"));
778 target_xfer_status_to_string (enum target_xfer_status status
)
780 #define CASE(X) case X: return #X
783 CASE(TARGET_XFER_E_IO
);
784 CASE(TARGET_XFER_UNAVAILABLE
);
793 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
795 /* target_read_string -- read a null terminated string, up to LEN bytes,
796 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
797 Set *STRING to a pointer to malloc'd memory containing the data; the caller
798 is responsible for freeing it. Return the number of bytes successfully
802 target_read_string (CORE_ADDR memaddr
, gdb::unique_xmalloc_ptr
<char> *string
,
803 int len
, int *errnop
)
809 int buffer_allocated
;
811 unsigned int nbytes_read
= 0;
815 /* Small for testing. */
816 buffer_allocated
= 4;
817 buffer
= (char *) xmalloc (buffer_allocated
);
822 tlen
= MIN (len
, 4 - (memaddr
& 3));
823 offset
= memaddr
& 3;
825 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
828 /* The transfer request might have crossed the boundary to an
829 unallocated region of memory. Retry the transfer, requesting
833 errcode
= target_read_memory (memaddr
, buf
, 1);
838 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
842 bytes
= bufptr
- buffer
;
843 buffer_allocated
*= 2;
844 buffer
= (char *) xrealloc (buffer
, buffer_allocated
);
845 bufptr
= buffer
+ bytes
;
848 for (i
= 0; i
< tlen
; i
++)
850 *bufptr
++ = buf
[i
+ offset
];
851 if (buf
[i
+ offset
] == '\000')
853 nbytes_read
+= i
+ 1;
863 string
->reset (buffer
);
869 struct target_section_table
*
870 target_get_section_table (struct target_ops
*target
)
872 return target
->get_section_table ();
875 /* Find a section containing ADDR. */
877 struct target_section
*
878 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
880 struct target_section_table
*table
= target_get_section_table (target
);
881 struct target_section
*secp
;
886 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
888 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
895 /* Helper for the memory xfer routines. Checks the attributes of the
896 memory region of MEMADDR against the read or write being attempted.
897 If the access is permitted returns true, otherwise returns false.
898 REGION_P is an optional output parameter. If not-NULL, it is
899 filled with a pointer to the memory region of MEMADDR. REG_LEN
900 returns LEN trimmed to the end of the region. This is how much the
901 caller can continue requesting, if the access is permitted. A
902 single xfer request must not straddle memory region boundaries. */
905 memory_xfer_check_region (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
906 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*reg_len
,
907 struct mem_region
**region_p
)
909 struct mem_region
*region
;
911 region
= lookup_mem_region (memaddr
);
913 if (region_p
!= NULL
)
916 switch (region
->attrib
.mode
)
919 if (writebuf
!= NULL
)
929 /* We only support writing to flash during "load" for now. */
930 if (writebuf
!= NULL
)
931 error (_("Writing to flash memory forbidden in this context"));
938 /* region->hi == 0 means there's no upper bound. */
939 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
942 *reg_len
= region
->hi
- memaddr
;
947 /* Read memory from more than one valid target. A core file, for
948 instance, could have some of memory but delegate other bits to
949 the target below it. So, we must manually try all targets. */
951 enum target_xfer_status
952 raw_memory_xfer_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
953 const gdb_byte
*writebuf
, ULONGEST memaddr
, LONGEST len
,
954 ULONGEST
*xfered_len
)
956 enum target_xfer_status res
;
960 res
= ops
->xfer_partial (TARGET_OBJECT_MEMORY
, NULL
,
961 readbuf
, writebuf
, memaddr
, len
,
963 if (res
== TARGET_XFER_OK
)
966 /* Stop if the target reports that the memory is not available. */
967 if (res
== TARGET_XFER_UNAVAILABLE
)
970 /* We want to continue past core files to executables, but not
971 past a running target's memory. */
972 if (ops
->has_all_memory ())
975 ops
= ops
->beneath ();
979 /* The cache works at the raw memory level. Make sure the cache
980 gets updated with raw contents no matter what kind of memory
981 object was originally being written. Note we do write-through
982 first, so that if it fails, we don't write to the cache contents
983 that never made it to the target. */
985 && inferior_ptid
!= null_ptid
986 && target_dcache_init_p ()
987 && (stack_cache_enabled_p () || code_cache_enabled_p ()))
989 DCACHE
*dcache
= target_dcache_get ();
991 /* Note that writing to an area of memory which wasn't present
992 in the cache doesn't cause it to be loaded in. */
993 dcache_update (dcache
, res
, memaddr
, writebuf
, *xfered_len
);
999 /* Perform a partial memory transfer.
1000 For docs see target.h, to_xfer_partial. */
1002 static enum target_xfer_status
1003 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
1004 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
1005 ULONGEST len
, ULONGEST
*xfered_len
)
1007 enum target_xfer_status res
;
1009 struct mem_region
*region
;
1010 struct inferior
*inf
;
1012 /* For accesses to unmapped overlay sections, read directly from
1013 files. Must do this first, as MEMADDR may need adjustment. */
1014 if (readbuf
!= NULL
&& overlay_debugging
)
1016 struct obj_section
*section
= find_pc_overlay (memaddr
);
1018 if (pc_in_unmapped_range (memaddr
, section
))
1020 struct target_section_table
*table
1021 = target_get_section_table (ops
);
1022 const char *section_name
= section
->the_bfd_section
->name
;
1024 memaddr
= overlay_mapped_address (memaddr
, section
);
1025 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1026 memaddr
, len
, xfered_len
,
1028 table
->sections_end
,
1033 /* Try the executable files, if "trust-readonly-sections" is set. */
1034 if (readbuf
!= NULL
&& trust_readonly
)
1036 struct target_section
*secp
;
1037 struct target_section_table
*table
;
1039 secp
= target_section_by_addr (ops
, memaddr
);
1041 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1042 secp
->the_bfd_section
)
1045 table
= target_get_section_table (ops
);
1046 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1047 memaddr
, len
, xfered_len
,
1049 table
->sections_end
,
1054 /* Try GDB's internal data cache. */
1056 if (!memory_xfer_check_region (readbuf
, writebuf
, memaddr
, len
, ®_len
,
1058 return TARGET_XFER_E_IO
;
1060 if (inferior_ptid
!= null_ptid
)
1061 inf
= current_inferior ();
1067 /* The dcache reads whole cache lines; that doesn't play well
1068 with reading from a trace buffer, because reading outside of
1069 the collected memory range fails. */
1070 && get_traceframe_number () == -1
1071 && (region
->attrib
.cache
1072 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1073 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1075 DCACHE
*dcache
= target_dcache_get_or_init ();
1077 return dcache_read_memory_partial (ops
, dcache
, memaddr
, readbuf
,
1078 reg_len
, xfered_len
);
1081 /* If none of those methods found the memory we wanted, fall back
1082 to a target partial transfer. Normally a single call to
1083 to_xfer_partial is enough; if it doesn't recognize an object
1084 it will call the to_xfer_partial of the next target down.
1085 But for memory this won't do. Memory is the only target
1086 object which can be read from more than one valid target.
1087 A core file, for instance, could have some of memory but
1088 delegate other bits to the target below it. So, we must
1089 manually try all targets. */
1091 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
,
1094 /* If we still haven't got anything, return the last error. We
1099 /* Perform a partial memory transfer. For docs see target.h,
1102 static enum target_xfer_status
1103 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1104 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1105 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1107 enum target_xfer_status res
;
1109 /* Zero length requests are ok and require no work. */
1111 return TARGET_XFER_EOF
;
1113 memaddr
= address_significant (target_gdbarch (), memaddr
);
1115 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1116 breakpoint insns, thus hiding out from higher layers whether
1117 there are software breakpoints inserted in the code stream. */
1118 if (readbuf
!= NULL
)
1120 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
,
1123 if (res
== TARGET_XFER_OK
&& !show_memory_breakpoints
)
1124 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, *xfered_len
);
1128 /* A large write request is likely to be partially satisfied
1129 by memory_xfer_partial_1. We will continually malloc
1130 and free a copy of the entire write request for breakpoint
1131 shadow handling even though we only end up writing a small
1132 subset of it. Cap writes to a limit specified by the target
1133 to mitigate this. */
1134 len
= std::min (ops
->get_memory_xfer_limit (), len
);
1136 gdb::byte_vector
buf (writebuf
, writebuf
+ len
);
1137 breakpoint_xfer_memory (NULL
, buf
.data (), writebuf
, memaddr
, len
);
1138 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
.data (), memaddr
, len
,
1145 scoped_restore_tmpl
<int>
1146 make_scoped_restore_show_memory_breakpoints (int show
)
1148 return make_scoped_restore (&show_memory_breakpoints
, show
);
1151 /* For docs see target.h, to_xfer_partial. */
1153 enum target_xfer_status
1154 target_xfer_partial (struct target_ops
*ops
,
1155 enum target_object object
, const char *annex
,
1156 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1157 ULONGEST offset
, ULONGEST len
,
1158 ULONGEST
*xfered_len
)
1160 enum target_xfer_status retval
;
1162 /* Transfer is done when LEN is zero. */
1164 return TARGET_XFER_EOF
;
1166 if (writebuf
&& !may_write_memory
)
1167 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1168 core_addr_to_string_nz (offset
), plongest (len
));
1172 /* If this is a memory transfer, let the memory-specific code
1173 have a look at it instead. Memory transfers are more
1175 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1176 || object
== TARGET_OBJECT_CODE_MEMORY
)
1177 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1178 writebuf
, offset
, len
, xfered_len
);
1179 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1181 /* Skip/avoid accessing the target if the memory region
1182 attributes block the access. Check this here instead of in
1183 raw_memory_xfer_partial as otherwise we'd end up checking
1184 this twice in the case of the memory_xfer_partial path is
1185 taken; once before checking the dcache, and another in the
1186 tail call to raw_memory_xfer_partial. */
1187 if (!memory_xfer_check_region (readbuf
, writebuf
, offset
, len
, &len
,
1189 return TARGET_XFER_E_IO
;
1191 /* Request the normal memory object from other layers. */
1192 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
,
1196 retval
= ops
->xfer_partial (object
, annex
, readbuf
,
1197 writebuf
, offset
, len
, xfered_len
);
1201 const unsigned char *myaddr
= NULL
;
1203 fprintf_unfiltered (gdb_stdlog
,
1204 "%s:target_xfer_partial "
1205 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1208 (annex
? annex
: "(null)"),
1209 host_address_to_string (readbuf
),
1210 host_address_to_string (writebuf
),
1211 core_addr_to_string_nz (offset
),
1212 pulongest (len
), retval
,
1213 pulongest (*xfered_len
));
1219 if (retval
== TARGET_XFER_OK
&& myaddr
!= NULL
)
1223 fputs_unfiltered (", bytes =", gdb_stdlog
);
1224 for (i
= 0; i
< *xfered_len
; i
++)
1226 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1228 if (targetdebug
< 2 && i
> 0)
1230 fprintf_unfiltered (gdb_stdlog
, " ...");
1233 fprintf_unfiltered (gdb_stdlog
, "\n");
1236 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1240 fputc_unfiltered ('\n', gdb_stdlog
);
1243 /* Check implementations of to_xfer_partial update *XFERED_LEN
1244 properly. Do assertion after printing debug messages, so that we
1245 can find more clues on assertion failure from debugging messages. */
1246 if (retval
== TARGET_XFER_OK
|| retval
== TARGET_XFER_UNAVAILABLE
)
1247 gdb_assert (*xfered_len
> 0);
1252 /* Read LEN bytes of target memory at address MEMADDR, placing the
1253 results in GDB's memory at MYADDR. Returns either 0 for success or
1254 -1 if any error occurs.
1256 If an error occurs, no guarantee is made about the contents of the data at
1257 MYADDR. In particular, the caller should not depend upon partial reads
1258 filling the buffer with good data. There is no way for the caller to know
1259 how much good data might have been transfered anyway. Callers that can
1260 deal with partial reads should call target_read (which will retry until
1261 it makes no progress, and then return how much was transferred). */
1264 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1266 if (target_read (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1267 myaddr
, memaddr
, len
) == len
)
1273 /* See target/target.h. */
1276 target_read_uint32 (CORE_ADDR memaddr
, uint32_t *result
)
1281 r
= target_read_memory (memaddr
, buf
, sizeof buf
);
1284 *result
= extract_unsigned_integer (buf
, sizeof buf
,
1285 gdbarch_byte_order (target_gdbarch ()));
1289 /* Like target_read_memory, but specify explicitly that this is a read
1290 from the target's raw memory. That is, this read bypasses the
1291 dcache, breakpoint shadowing, etc. */
1294 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1296 if (target_read (current_top_target (), TARGET_OBJECT_RAW_MEMORY
, NULL
,
1297 myaddr
, memaddr
, len
) == len
)
1303 /* Like target_read_memory, but specify explicitly that this is a read from
1304 the target's stack. This may trigger different cache behavior. */
1307 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1309 if (target_read (current_top_target (), TARGET_OBJECT_STACK_MEMORY
, NULL
,
1310 myaddr
, memaddr
, len
) == len
)
1316 /* Like target_read_memory, but specify explicitly that this is a read from
1317 the target's code. This may trigger different cache behavior. */
1320 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1322 if (target_read (current_top_target (), TARGET_OBJECT_CODE_MEMORY
, NULL
,
1323 myaddr
, memaddr
, len
) == len
)
1329 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1330 Returns either 0 for success or -1 if any error occurs. If an
1331 error occurs, no guarantee is made about how much data got written.
1332 Callers that can deal with partial writes should call
1336 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1338 if (target_write (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1339 myaddr
, memaddr
, len
) == len
)
1345 /* Write LEN bytes from MYADDR to target raw memory at address
1346 MEMADDR. Returns either 0 for success or -1 if any error occurs.
1347 If an error occurs, no guarantee is made about how much data got
1348 written. Callers that can deal with partial writes should call
1352 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1354 if (target_write (current_top_target (), TARGET_OBJECT_RAW_MEMORY
, NULL
,
1355 myaddr
, memaddr
, len
) == len
)
1361 /* Fetch the target's memory map. */
1363 std::vector
<mem_region
>
1364 target_memory_map (void)
1366 std::vector
<mem_region
> result
= current_top_target ()->memory_map ();
1367 if (result
.empty ())
1370 std::sort (result
.begin (), result
.end ());
1372 /* Check that regions do not overlap. Simultaneously assign
1373 a numbering for the "mem" commands to use to refer to
1375 mem_region
*last_one
= NULL
;
1376 for (size_t ix
= 0; ix
< result
.size (); ix
++)
1378 mem_region
*this_one
= &result
[ix
];
1379 this_one
->number
= ix
;
1381 if (last_one
!= NULL
&& last_one
->hi
> this_one
->lo
)
1383 warning (_("Overlapping regions in memory map: ignoring"));
1384 return std::vector
<mem_region
> ();
1387 last_one
= this_one
;
1394 target_flash_erase (ULONGEST address
, LONGEST length
)
1396 current_top_target ()->flash_erase (address
, length
);
1400 target_flash_done (void)
1402 current_top_target ()->flash_done ();
1406 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1407 struct cmd_list_element
*c
, const char *value
)
1409 fprintf_filtered (file
,
1410 _("Mode for reading from readonly sections is %s.\n"),
1414 /* Target vector read/write partial wrapper functions. */
1416 static enum target_xfer_status
1417 target_read_partial (struct target_ops
*ops
,
1418 enum target_object object
,
1419 const char *annex
, gdb_byte
*buf
,
1420 ULONGEST offset
, ULONGEST len
,
1421 ULONGEST
*xfered_len
)
1423 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
,
1427 static enum target_xfer_status
1428 target_write_partial (struct target_ops
*ops
,
1429 enum target_object object
,
1430 const char *annex
, const gdb_byte
*buf
,
1431 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
1433 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
,
1437 /* Wrappers to perform the full transfer. */
1439 /* For docs on target_read see target.h. */
1442 target_read (struct target_ops
*ops
,
1443 enum target_object object
,
1444 const char *annex
, gdb_byte
*buf
,
1445 ULONGEST offset
, LONGEST len
)
1447 LONGEST xfered_total
= 0;
1450 /* If we are reading from a memory object, find the length of an addressable
1451 unit for that architecture. */
1452 if (object
== TARGET_OBJECT_MEMORY
1453 || object
== TARGET_OBJECT_STACK_MEMORY
1454 || object
== TARGET_OBJECT_CODE_MEMORY
1455 || object
== TARGET_OBJECT_RAW_MEMORY
)
1456 unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
1458 while (xfered_total
< len
)
1460 ULONGEST xfered_partial
;
1461 enum target_xfer_status status
;
1463 status
= target_read_partial (ops
, object
, annex
,
1464 buf
+ xfered_total
* unit_size
,
1465 offset
+ xfered_total
, len
- xfered_total
,
1468 /* Call an observer, notifying them of the xfer progress? */
1469 if (status
== TARGET_XFER_EOF
)
1470 return xfered_total
;
1471 else if (status
== TARGET_XFER_OK
)
1473 xfered_total
+= xfered_partial
;
1477 return TARGET_XFER_E_IO
;
1483 /* Assuming that the entire [begin, end) range of memory cannot be
1484 read, try to read whatever subrange is possible to read.
1486 The function returns, in RESULT, either zero or one memory block.
1487 If there's a readable subrange at the beginning, it is completely
1488 read and returned. Any further readable subrange will not be read.
1489 Otherwise, if there's a readable subrange at the end, it will be
1490 completely read and returned. Any readable subranges before it
1491 (obviously, not starting at the beginning), will be ignored. In
1492 other cases -- either no readable subrange, or readable subrange(s)
1493 that is neither at the beginning, or end, nothing is returned.
1495 The purpose of this function is to handle a read across a boundary
1496 of accessible memory in a case when memory map is not available.
1497 The above restrictions are fine for this case, but will give
1498 incorrect results if the memory is 'patchy'. However, supporting
1499 'patchy' memory would require trying to read every single byte,
1500 and it seems unacceptable solution. Explicit memory map is
1501 recommended for this case -- and target_read_memory_robust will
1502 take care of reading multiple ranges then. */
1505 read_whatever_is_readable (struct target_ops
*ops
,
1506 const ULONGEST begin
, const ULONGEST end
,
1508 std::vector
<memory_read_result
> *result
)
1510 ULONGEST current_begin
= begin
;
1511 ULONGEST current_end
= end
;
1513 ULONGEST xfered_len
;
1515 /* If we previously failed to read 1 byte, nothing can be done here. */
1516 if (end
- begin
<= 1)
1519 gdb::unique_xmalloc_ptr
<gdb_byte
> buf ((gdb_byte
*) xmalloc (end
- begin
));
1521 /* Check that either first or the last byte is readable, and give up
1522 if not. This heuristic is meant to permit reading accessible memory
1523 at the boundary of accessible region. */
1524 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1525 buf
.get (), begin
, 1, &xfered_len
) == TARGET_XFER_OK
)
1530 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1531 buf
.get () + (end
- begin
) - 1, end
- 1, 1,
1532 &xfered_len
) == TARGET_XFER_OK
)
1540 /* Loop invariant is that the [current_begin, current_end) was previously
1541 found to be not readable as a whole.
1543 Note loop condition -- if the range has 1 byte, we can't divide the range
1544 so there's no point trying further. */
1545 while (current_end
- current_begin
> 1)
1547 ULONGEST first_half_begin
, first_half_end
;
1548 ULONGEST second_half_begin
, second_half_end
;
1550 ULONGEST middle
= current_begin
+ (current_end
- current_begin
) / 2;
1554 first_half_begin
= current_begin
;
1555 first_half_end
= middle
;
1556 second_half_begin
= middle
;
1557 second_half_end
= current_end
;
1561 first_half_begin
= middle
;
1562 first_half_end
= current_end
;
1563 second_half_begin
= current_begin
;
1564 second_half_end
= middle
;
1567 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1568 buf
.get () + (first_half_begin
- begin
) * unit_size
,
1570 first_half_end
- first_half_begin
);
1572 if (xfer
== first_half_end
- first_half_begin
)
1574 /* This half reads up fine. So, the error must be in the
1576 current_begin
= second_half_begin
;
1577 current_end
= second_half_end
;
1581 /* This half is not readable. Because we've tried one byte, we
1582 know some part of this half if actually readable. Go to the next
1583 iteration to divide again and try to read.
1585 We don't handle the other half, because this function only tries
1586 to read a single readable subrange. */
1587 current_begin
= first_half_begin
;
1588 current_end
= first_half_end
;
1594 /* The [begin, current_begin) range has been read. */
1595 result
->emplace_back (begin
, current_end
, std::move (buf
));
1599 /* The [current_end, end) range has been read. */
1600 LONGEST region_len
= end
- current_end
;
1602 gdb::unique_xmalloc_ptr
<gdb_byte
> data
1603 ((gdb_byte
*) xmalloc (region_len
* unit_size
));
1604 memcpy (data
.get (), buf
.get () + (current_end
- begin
) * unit_size
,
1605 region_len
* unit_size
);
1606 result
->emplace_back (current_end
, end
, std::move (data
));
1610 std::vector
<memory_read_result
>
1611 read_memory_robust (struct target_ops
*ops
,
1612 const ULONGEST offset
, const LONGEST len
)
1614 std::vector
<memory_read_result
> result
;
1615 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
1617 LONGEST xfered_total
= 0;
1618 while (xfered_total
< len
)
1620 struct mem_region
*region
= lookup_mem_region (offset
+ xfered_total
);
1623 /* If there is no explicit region, a fake one should be created. */
1624 gdb_assert (region
);
1626 if (region
->hi
== 0)
1627 region_len
= len
- xfered_total
;
1629 region_len
= region
->hi
- offset
;
1631 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
1633 /* Cannot read this region. Note that we can end up here only
1634 if the region is explicitly marked inaccessible, or
1635 'inaccessible-by-default' is in effect. */
1636 xfered_total
+= region_len
;
1640 LONGEST to_read
= std::min (len
- xfered_total
, region_len
);
1641 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
1642 ((gdb_byte
*) xmalloc (to_read
* unit_size
));
1644 LONGEST xfered_partial
=
1645 target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buffer
.get (),
1646 offset
+ xfered_total
, to_read
);
1647 /* Call an observer, notifying them of the xfer progress? */
1648 if (xfered_partial
<= 0)
1650 /* Got an error reading full chunk. See if maybe we can read
1652 read_whatever_is_readable (ops
, offset
+ xfered_total
,
1653 offset
+ xfered_total
+ to_read
,
1654 unit_size
, &result
);
1655 xfered_total
+= to_read
;
1659 result
.emplace_back (offset
+ xfered_total
,
1660 offset
+ xfered_total
+ xfered_partial
,
1661 std::move (buffer
));
1662 xfered_total
+= xfered_partial
;
1672 /* An alternative to target_write with progress callbacks. */
1675 target_write_with_progress (struct target_ops
*ops
,
1676 enum target_object object
,
1677 const char *annex
, const gdb_byte
*buf
,
1678 ULONGEST offset
, LONGEST len
,
1679 void (*progress
) (ULONGEST
, void *), void *baton
)
1681 LONGEST xfered_total
= 0;
1684 /* If we are writing to a memory object, find the length of an addressable
1685 unit for that architecture. */
1686 if (object
== TARGET_OBJECT_MEMORY
1687 || object
== TARGET_OBJECT_STACK_MEMORY
1688 || object
== TARGET_OBJECT_CODE_MEMORY
1689 || object
== TARGET_OBJECT_RAW_MEMORY
)
1690 unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
1692 /* Give the progress callback a chance to set up. */
1694 (*progress
) (0, baton
);
1696 while (xfered_total
< len
)
1698 ULONGEST xfered_partial
;
1699 enum target_xfer_status status
;
1701 status
= target_write_partial (ops
, object
, annex
,
1702 buf
+ xfered_total
* unit_size
,
1703 offset
+ xfered_total
, len
- xfered_total
,
1706 if (status
!= TARGET_XFER_OK
)
1707 return status
== TARGET_XFER_EOF
? xfered_total
: TARGET_XFER_E_IO
;
1710 (*progress
) (xfered_partial
, baton
);
1712 xfered_total
+= xfered_partial
;
1718 /* For docs on target_write see target.h. */
1721 target_write (struct target_ops
*ops
,
1722 enum target_object object
,
1723 const char *annex
, const gdb_byte
*buf
,
1724 ULONGEST offset
, LONGEST len
)
1726 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1730 /* Help for target_read_alloc and target_read_stralloc. See their comments
1733 template <typename T
>
1734 gdb::optional
<gdb::def_vector
<T
>>
1735 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1738 gdb::def_vector
<T
> buf
;
1740 const int chunk
= 4096;
1742 /* This function does not have a length parameter; it reads the
1743 entire OBJECT). Also, it doesn't support objects fetched partly
1744 from one target and partly from another (in a different stratum,
1745 e.g. a core file and an executable). Both reasons make it
1746 unsuitable for reading memory. */
1747 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1749 /* Start by reading up to 4K at a time. The target will throttle
1750 this number down if necessary. */
1753 ULONGEST xfered_len
;
1754 enum target_xfer_status status
;
1756 buf
.resize (buf_pos
+ chunk
);
1758 status
= target_read_partial (ops
, object
, annex
,
1759 (gdb_byte
*) &buf
[buf_pos
],
1763 if (status
== TARGET_XFER_EOF
)
1765 /* Read all there was. */
1766 buf
.resize (buf_pos
);
1769 else if (status
!= TARGET_XFER_OK
)
1771 /* An error occurred. */
1775 buf_pos
+= xfered_len
;
1783 gdb::optional
<gdb::byte_vector
>
1784 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1787 return target_read_alloc_1
<gdb_byte
> (ops
, object
, annex
);
1792 gdb::optional
<gdb::char_vector
>
1793 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1796 gdb::optional
<gdb::char_vector
> buf
1797 = target_read_alloc_1
<char> (ops
, object
, annex
);
1802 if (buf
->empty () || buf
->back () != '\0')
1803 buf
->push_back ('\0');
1805 /* Check for embedded NUL bytes; but allow trailing NULs. */
1806 for (auto it
= std::find (buf
->begin (), buf
->end (), '\0');
1807 it
!= buf
->end (); it
++)
1810 warning (_("target object %d, annex %s, "
1811 "contained unexpected null characters"),
1812 (int) object
, annex
? annex
: "(none)");
1819 /* Memory transfer methods. */
1822 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1825 /* This method is used to read from an alternate, non-current
1826 target. This read must bypass the overlay support (as symbols
1827 don't match this target), and GDB's internal cache (wrong cache
1828 for this target). */
1829 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
1831 memory_error (TARGET_XFER_E_IO
, addr
);
1835 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
1836 int len
, enum bfd_endian byte_order
)
1838 gdb_byte buf
[sizeof (ULONGEST
)];
1840 gdb_assert (len
<= sizeof (buf
));
1841 get_target_memory (ops
, addr
, buf
, len
);
1842 return extract_unsigned_integer (buf
, len
, byte_order
);
1848 target_insert_breakpoint (struct gdbarch
*gdbarch
,
1849 struct bp_target_info
*bp_tgt
)
1851 if (!may_insert_breakpoints
)
1853 warning (_("May not insert breakpoints"));
1857 return current_top_target ()->insert_breakpoint (gdbarch
, bp_tgt
);
1863 target_remove_breakpoint (struct gdbarch
*gdbarch
,
1864 struct bp_target_info
*bp_tgt
,
1865 enum remove_bp_reason reason
)
1867 /* This is kind of a weird case to handle, but the permission might
1868 have been changed after breakpoints were inserted - in which case
1869 we should just take the user literally and assume that any
1870 breakpoints should be left in place. */
1871 if (!may_insert_breakpoints
)
1873 warning (_("May not remove breakpoints"));
1877 return current_top_target ()->remove_breakpoint (gdbarch
, bp_tgt
, reason
);
1881 info_target_command (const char *args
, int from_tty
)
1883 int has_all_mem
= 0;
1885 if (symfile_objfile
!= NULL
)
1886 printf_unfiltered (_("Symbols from \"%s\".\n"),
1887 objfile_name (symfile_objfile
));
1889 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
1891 if (!t
->has_memory ())
1894 if ((int) (t
->stratum ()) <= (int) dummy_stratum
)
1897 printf_unfiltered (_("\tWhile running this, "
1898 "GDB does not access memory from...\n"));
1899 printf_unfiltered ("%s:\n", t
->longname ());
1901 has_all_mem
= t
->has_all_memory ();
1905 /* This function is called before any new inferior is created, e.g.
1906 by running a program, attaching, or connecting to a target.
1907 It cleans up any state from previous invocations which might
1908 change between runs. This is a subset of what target_preopen
1909 resets (things which might change between targets). */
1912 target_pre_inferior (int from_tty
)
1914 /* Clear out solib state. Otherwise the solib state of the previous
1915 inferior might have survived and is entirely wrong for the new
1916 target. This has been observed on GNU/Linux using glibc 2.3. How
1928 Cannot access memory at address 0xdeadbeef
1931 /* In some OSs, the shared library list is the same/global/shared
1932 across inferiors. If code is shared between processes, so are
1933 memory regions and features. */
1934 if (!gdbarch_has_global_solist (target_gdbarch ()))
1936 no_shared_libraries (NULL
, from_tty
);
1938 invalidate_target_mem_regions ();
1940 target_clear_description ();
1943 /* attach_flag may be set if the previous process associated with
1944 the inferior was attached to. */
1945 current_inferior ()->attach_flag
= 0;
1947 current_inferior ()->highest_thread_num
= 0;
1949 agent_capability_invalidate ();
1952 /* Callback for iterate_over_inferiors. Gets rid of the given
1956 dispose_inferior (struct inferior
*inf
, void *args
)
1958 /* Not all killed inferiors can, or will ever be, removed from the
1959 inferior list. Killed inferiors clearly don't need to be killed
1960 again, so, we're done. */
1964 thread_info
*thread
= any_thread_of_inferior (inf
);
1967 switch_to_thread (thread
);
1969 /* Core inferiors actually should be detached, not killed. */
1970 if (target_has_execution
)
1973 target_detach (inf
, 0);
1979 /* This is to be called by the open routine before it does
1983 target_preopen (int from_tty
)
1987 if (have_inferiors ())
1990 || !have_live_inferiors ()
1991 || query (_("A program is being debugged already. Kill it? ")))
1992 iterate_over_inferiors (dispose_inferior
, NULL
);
1994 error (_("Program not killed."));
1997 /* Calling target_kill may remove the target from the stack. But if
1998 it doesn't (which seems like a win for UDI), remove it now. */
1999 /* Leave the exec target, though. The user may be switching from a
2000 live process to a core of the same program. */
2001 pop_all_targets_above (file_stratum
);
2003 target_pre_inferior (from_tty
);
2009 target_detach (inferior
*inf
, int from_tty
)
2011 /* As long as some to_detach implementations rely on the current_inferior
2012 (either directly, or indirectly, like through target_gdbarch or by
2013 reading memory), INF needs to be the current inferior. When that
2014 requirement will become no longer true, then we can remove this
2016 gdb_assert (inf
== current_inferior ());
2018 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2019 /* Don't remove global breakpoints here. They're removed on
2020 disconnection from the target. */
2023 /* If we're in breakpoints-always-inserted mode, have to remove
2024 breakpoints before detaching. */
2025 remove_breakpoints_inf (current_inferior ());
2027 prepare_for_detach ();
2029 current_top_target ()->detach (inf
, from_tty
);
2031 /* After we have detached, clear the register cache for this inferior. */
2032 ptid_t pid_ptid
= ptid_t (inf
->pid
);
2034 registers_changed_ptid (pid_ptid
);
2036 /* We have to ensure we have no frame cache left. Normally,
2037 registers_changed_ptid (pid_ptid) calls reinit_frame_cache when
2038 inferior_ptid matches pid_ptid, but in our case, it does not
2039 call it, as inferior_ptid has been reset. */
2040 reinit_frame_cache ();
2044 target_disconnect (const char *args
, int from_tty
)
2046 /* If we're in breakpoints-always-inserted mode or if breakpoints
2047 are global across processes, we have to remove them before
2049 remove_breakpoints ();
2051 current_top_target ()->disconnect (args
, from_tty
);
2054 /* See target/target.h. */
2057 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2059 return current_top_target ()->wait (ptid
, status
, options
);
2065 default_target_wait (struct target_ops
*ops
,
2066 ptid_t ptid
, struct target_waitstatus
*status
,
2069 status
->kind
= TARGET_WAITKIND_IGNORE
;
2070 return minus_one_ptid
;
2074 target_pid_to_str (ptid_t ptid
)
2076 return current_top_target ()->pid_to_str (ptid
);
2080 target_thread_name (struct thread_info
*info
)
2082 return current_top_target ()->thread_name (info
);
2085 struct thread_info
*
2086 target_thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
2088 struct inferior
*inf
)
2090 return current_top_target ()->thread_handle_to_thread_info (thread_handle
,
2095 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2097 target_dcache_invalidate ();
2099 current_top_target ()->resume (ptid
, step
, signal
);
2101 registers_changed_ptid (ptid
);
2102 /* We only set the internal executing state here. The user/frontend
2103 running state is set at a higher level. This also clears the
2104 thread's stop_pc as side effect. */
2105 set_executing (ptid
, 1);
2106 clear_inline_frame_state (ptid
);
2109 /* If true, target_commit_resume is a nop. */
2110 static int defer_target_commit_resume
;
2115 target_commit_resume (void)
2117 if (defer_target_commit_resume
)
2120 current_top_target ()->commit_resume ();
2125 scoped_restore_tmpl
<int>
2126 make_scoped_defer_target_commit_resume ()
2128 return make_scoped_restore (&defer_target_commit_resume
, 1);
2132 target_pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2134 current_top_target ()->pass_signals (pass_signals
);
2138 target_program_signals (gdb::array_view
<const unsigned char> program_signals
)
2140 current_top_target ()->program_signals (program_signals
);
2144 default_follow_fork (struct target_ops
*self
, int follow_child
,
2147 /* Some target returned a fork event, but did not know how to follow it. */
2148 internal_error (__FILE__
, __LINE__
,
2149 _("could not find a target to follow fork"));
2152 /* Look through the list of possible targets for a target that can
2156 target_follow_fork (int follow_child
, int detach_fork
)
2158 return current_top_target ()->follow_fork (follow_child
, detach_fork
);
2161 /* Target wrapper for follow exec hook. */
2164 target_follow_exec (struct inferior
*inf
, char *execd_pathname
)
2166 current_top_target ()->follow_exec (inf
, execd_pathname
);
2170 default_mourn_inferior (struct target_ops
*self
)
2172 internal_error (__FILE__
, __LINE__
,
2173 _("could not find a target to follow mourn inferior"));
2177 target_mourn_inferior (ptid_t ptid
)
2179 gdb_assert (ptid
== inferior_ptid
);
2180 current_top_target ()->mourn_inferior ();
2182 /* We no longer need to keep handles on any of the object files.
2183 Make sure to release them to avoid unnecessarily locking any
2184 of them while we're not actually debugging. */
2185 bfd_cache_close_all ();
2188 /* Look for a target which can describe architectural features, starting
2189 from TARGET. If we find one, return its description. */
2191 const struct target_desc
*
2192 target_read_description (struct target_ops
*target
)
2194 return target
->read_description ();
2197 /* This implements a basic search of memory, reading target memory and
2198 performing the search here (as opposed to performing the search in on the
2199 target side with, for example, gdbserver). */
2202 simple_search_memory (struct target_ops
*ops
,
2203 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2204 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2205 CORE_ADDR
*found_addrp
)
2207 /* NOTE: also defined in find.c testcase. */
2208 #define SEARCH_CHUNK_SIZE 16000
2209 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2210 /* Buffer to hold memory contents for searching. */
2211 unsigned search_buf_size
;
2213 search_buf_size
= chunk_size
+ pattern_len
- 1;
2215 /* No point in trying to allocate a buffer larger than the search space. */
2216 if (search_space_len
< search_buf_size
)
2217 search_buf_size
= search_space_len
;
2219 gdb::byte_vector
search_buf (search_buf_size
);
2221 /* Prime the search buffer. */
2223 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2224 search_buf
.data (), start_addr
, search_buf_size
)
2227 warning (_("Unable to access %s bytes of target "
2228 "memory at %s, halting search."),
2229 pulongest (search_buf_size
), hex_string (start_addr
));
2233 /* Perform the search.
2235 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2236 When we've scanned N bytes we copy the trailing bytes to the start and
2237 read in another N bytes. */
2239 while (search_space_len
>= pattern_len
)
2241 gdb_byte
*found_ptr
;
2242 unsigned nr_search_bytes
2243 = std::min (search_space_len
, (ULONGEST
) search_buf_size
);
2245 found_ptr
= (gdb_byte
*) memmem (search_buf
.data (), nr_search_bytes
,
2246 pattern
, pattern_len
);
2248 if (found_ptr
!= NULL
)
2250 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
.data ());
2252 *found_addrp
= found_addr
;
2256 /* Not found in this chunk, skip to next chunk. */
2258 /* Don't let search_space_len wrap here, it's unsigned. */
2259 if (search_space_len
>= chunk_size
)
2260 search_space_len
-= chunk_size
;
2262 search_space_len
= 0;
2264 if (search_space_len
>= pattern_len
)
2266 unsigned keep_len
= search_buf_size
- chunk_size
;
2267 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2270 /* Copy the trailing part of the previous iteration to the front
2271 of the buffer for the next iteration. */
2272 gdb_assert (keep_len
== pattern_len
- 1);
2273 memcpy (&search_buf
[0], &search_buf
[chunk_size
], keep_len
);
2275 nr_to_read
= std::min (search_space_len
- keep_len
,
2276 (ULONGEST
) chunk_size
);
2278 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2279 &search_buf
[keep_len
], read_addr
,
2280 nr_to_read
) != nr_to_read
)
2282 warning (_("Unable to access %s bytes of target "
2283 "memory at %s, halting search."),
2284 plongest (nr_to_read
),
2285 hex_string (read_addr
));
2289 start_addr
+= chunk_size
;
2298 /* Default implementation of memory-searching. */
2301 default_search_memory (struct target_ops
*self
,
2302 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2303 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2304 CORE_ADDR
*found_addrp
)
2306 /* Start over from the top of the target stack. */
2307 return simple_search_memory (current_top_target (),
2308 start_addr
, search_space_len
,
2309 pattern
, pattern_len
, found_addrp
);
2312 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2313 sequence of bytes in PATTERN with length PATTERN_LEN.
2315 The result is 1 if found, 0 if not found, and -1 if there was an error
2316 requiring halting of the search (e.g. memory read error).
2317 If the pattern is found the address is recorded in FOUND_ADDRP. */
2320 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2321 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2322 CORE_ADDR
*found_addrp
)
2324 return current_top_target ()->search_memory (start_addr
, search_space_len
,
2325 pattern
, pattern_len
, found_addrp
);
2328 /* Look through the currently pushed targets. If none of them will
2329 be able to restart the currently running process, issue an error
2333 target_require_runnable (void)
2335 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
2337 /* If this target knows how to create a new program, then
2338 assume we will still be able to after killing the current
2339 one. Either killing and mourning will not pop T, or else
2340 find_default_run_target will find it again. */
2341 if (t
->can_create_inferior ())
2344 /* Do not worry about targets at certain strata that can not
2345 create inferiors. Assume they will be pushed again if
2346 necessary, and continue to the process_stratum. */
2347 if (t
->stratum () > process_stratum
)
2350 error (_("The \"%s\" target does not support \"run\". "
2351 "Try \"help target\" or \"continue\"."),
2355 /* This function is only called if the target is running. In that
2356 case there should have been a process_stratum target and it
2357 should either know how to create inferiors, or not... */
2358 internal_error (__FILE__
, __LINE__
, _("No targets found"));
2361 /* Whether GDB is allowed to fall back to the default run target for
2362 "run", "attach", etc. when no target is connected yet. */
2363 static int auto_connect_native_target
= 1;
2366 show_auto_connect_native_target (struct ui_file
*file
, int from_tty
,
2367 struct cmd_list_element
*c
, const char *value
)
2369 fprintf_filtered (file
,
2370 _("Whether GDB may automatically connect to the "
2371 "native target is %s.\n"),
2375 /* A pointer to the target that can respond to "run" or "attach".
2376 Native targets are always singletons and instantiated early at GDB
2378 static target_ops
*the_native_target
;
2383 set_native_target (target_ops
*target
)
2385 if (the_native_target
!= NULL
)
2386 internal_error (__FILE__
, __LINE__
,
2387 _("native target already set (\"%s\")."),
2388 the_native_target
->longname ());
2390 the_native_target
= target
;
2396 get_native_target ()
2398 return the_native_target
;
2401 /* Look through the list of possible targets for a target that can
2402 execute a run or attach command without any other data. This is
2403 used to locate the default process stratum.
2405 If DO_MESG is not NULL, the result is always valid (error() is
2406 called for errors); else, return NULL on error. */
2408 static struct target_ops
*
2409 find_default_run_target (const char *do_mesg
)
2411 if (auto_connect_native_target
&& the_native_target
!= NULL
)
2412 return the_native_target
;
2414 if (do_mesg
!= NULL
)
2415 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2422 find_attach_target (void)
2424 /* If a target on the current stack can attach, use it. */
2425 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
2427 if (t
->can_attach ())
2431 /* Otherwise, use the default run target for attaching. */
2432 return find_default_run_target ("attach");
2438 find_run_target (void)
2440 /* If a target on the current stack can run, use it. */
2441 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
2443 if (t
->can_create_inferior ())
2447 /* Otherwise, use the default run target. */
2448 return find_default_run_target ("run");
2452 target_ops::info_proc (const char *args
, enum info_proc_what what
)
2457 /* Implement the "info proc" command. */
2460 target_info_proc (const char *args
, enum info_proc_what what
)
2462 struct target_ops
*t
;
2464 /* If we're already connected to something that can get us OS
2465 related data, use it. Otherwise, try using the native
2467 t
= find_target_at (process_stratum
);
2469 t
= find_default_run_target (NULL
);
2471 for (; t
!= NULL
; t
= t
->beneath ())
2473 if (t
->info_proc (args
, what
))
2476 fprintf_unfiltered (gdb_stdlog
,
2477 "target_info_proc (\"%s\", %d)\n", args
, what
);
2487 find_default_supports_disable_randomization (struct target_ops
*self
)
2489 struct target_ops
*t
;
2491 t
= find_default_run_target (NULL
);
2493 return t
->supports_disable_randomization ();
2498 target_supports_disable_randomization (void)
2500 return current_top_target ()->supports_disable_randomization ();
2503 /* See target/target.h. */
2506 target_supports_multi_process (void)
2508 return current_top_target ()->supports_multi_process ();
2513 gdb::optional
<gdb::char_vector
>
2514 target_get_osdata (const char *type
)
2516 struct target_ops
*t
;
2518 /* If we're already connected to something that can get us OS
2519 related data, use it. Otherwise, try using the native
2521 t
= find_target_at (process_stratum
);
2523 t
= find_default_run_target ("get OS data");
2528 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
2532 /* Determine the current address space of thread PTID. */
2534 struct address_space
*
2535 target_thread_address_space (ptid_t ptid
)
2537 struct address_space
*aspace
;
2539 aspace
= current_top_target ()->thread_address_space (ptid
);
2540 gdb_assert (aspace
!= NULL
);
2548 target_ops::beneath () const
2550 return g_target_stack
.find_beneath (this);
2554 target_ops::close ()
2559 target_ops::can_attach ()
2565 target_ops::attach (const char *, int)
2567 gdb_assert_not_reached ("target_ops::attach called");
2571 target_ops::can_create_inferior ()
2577 target_ops::create_inferior (const char *, const std::string
&,
2580 gdb_assert_not_reached ("target_ops::create_inferior called");
2584 target_ops::can_run ()
2592 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
2601 /* Target file operations. */
2603 static struct target_ops
*
2604 default_fileio_target (void)
2606 struct target_ops
*t
;
2608 /* If we're already connected to something that can perform
2609 file I/O, use it. Otherwise, try using the native target. */
2610 t
= find_target_at (process_stratum
);
2613 return find_default_run_target ("file I/O");
2616 /* File handle for target file operations. */
2620 /* The target on which this file is open. NULL if the target is
2621 meanwhile closed while the handle is open. */
2624 /* The file descriptor on the target. */
2627 /* Check whether this fileio_fh_t represents a closed file. */
2630 return target_fd
< 0;
2634 /* Vector of currently open file handles. The value returned by
2635 target_fileio_open and passed as the FD argument to other
2636 target_fileio_* functions is an index into this vector. This
2637 vector's entries are never freed; instead, files are marked as
2638 closed, and the handle becomes available for reuse. */
2639 static std::vector
<fileio_fh_t
> fileio_fhandles
;
2641 /* Index into fileio_fhandles of the lowest handle that might be
2642 closed. This permits handle reuse without searching the whole
2643 list each time a new file is opened. */
2644 static int lowest_closed_fd
;
2646 /* Invalidate the target associated with open handles that were open
2647 on target TARG, since we're about to close (and maybe destroy) the
2648 target. The handles remain open from the client's perspective, but
2649 trying to do anything with them other than closing them will fail
2653 fileio_handles_invalidate_target (target_ops
*targ
)
2655 for (fileio_fh_t
&fh
: fileio_fhandles
)
2656 if (fh
.target
== targ
)
2660 /* Acquire a target fileio file descriptor. */
2663 acquire_fileio_fd (target_ops
*target
, int target_fd
)
2665 /* Search for closed handles to reuse. */
2666 for (; lowest_closed_fd
< fileio_fhandles
.size (); lowest_closed_fd
++)
2668 fileio_fh_t
&fh
= fileio_fhandles
[lowest_closed_fd
];
2670 if (fh
.is_closed ())
2674 /* Push a new handle if no closed handles were found. */
2675 if (lowest_closed_fd
== fileio_fhandles
.size ())
2676 fileio_fhandles
.push_back (fileio_fh_t
{target
, target_fd
});
2678 fileio_fhandles
[lowest_closed_fd
] = {target
, target_fd
};
2680 /* Should no longer be marked closed. */
2681 gdb_assert (!fileio_fhandles
[lowest_closed_fd
].is_closed ());
2683 /* Return its index, and start the next lookup at
2685 return lowest_closed_fd
++;
2688 /* Release a target fileio file descriptor. */
2691 release_fileio_fd (int fd
, fileio_fh_t
*fh
)
2694 lowest_closed_fd
= std::min (lowest_closed_fd
, fd
);
2697 /* Return a pointer to the fileio_fhandle_t corresponding to FD. */
2699 static fileio_fh_t
*
2700 fileio_fd_to_fh (int fd
)
2702 return &fileio_fhandles
[fd
];
2706 /* Default implementations of file i/o methods. We don't want these
2707 to delegate automatically, because we need to know which target
2708 supported the method, in order to call it directly from within
2709 pread/pwrite, etc. */
2712 target_ops::fileio_open (struct inferior
*inf
, const char *filename
,
2713 int flags
, int mode
, int warn_if_slow
,
2716 *target_errno
= FILEIO_ENOSYS
;
2721 target_ops::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
2722 ULONGEST offset
, int *target_errno
)
2724 *target_errno
= FILEIO_ENOSYS
;
2729 target_ops::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
2730 ULONGEST offset
, int *target_errno
)
2732 *target_errno
= FILEIO_ENOSYS
;
2737 target_ops::fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
)
2739 *target_errno
= FILEIO_ENOSYS
;
2744 target_ops::fileio_close (int fd
, int *target_errno
)
2746 *target_errno
= FILEIO_ENOSYS
;
2751 target_ops::fileio_unlink (struct inferior
*inf
, const char *filename
,
2754 *target_errno
= FILEIO_ENOSYS
;
2758 gdb::optional
<std::string
>
2759 target_ops::fileio_readlink (struct inferior
*inf
, const char *filename
,
2762 *target_errno
= FILEIO_ENOSYS
;
2766 /* Helper for target_fileio_open and
2767 target_fileio_open_warn_if_slow. */
2770 target_fileio_open_1 (struct inferior
*inf
, const char *filename
,
2771 int flags
, int mode
, int warn_if_slow
,
2774 for (target_ops
*t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath ())
2776 int fd
= t
->fileio_open (inf
, filename
, flags
, mode
,
2777 warn_if_slow
, target_errno
);
2779 if (fd
== -1 && *target_errno
== FILEIO_ENOSYS
)
2785 fd
= acquire_fileio_fd (t
, fd
);
2788 fprintf_unfiltered (gdb_stdlog
,
2789 "target_fileio_open (%d,%s,0x%x,0%o,%d)"
2791 inf
== NULL
? 0 : inf
->num
,
2792 filename
, flags
, mode
,
2794 fd
!= -1 ? 0 : *target_errno
);
2798 *target_errno
= FILEIO_ENOSYS
;
2805 target_fileio_open (struct inferior
*inf
, const char *filename
,
2806 int flags
, int mode
, int *target_errno
)
2808 return target_fileio_open_1 (inf
, filename
, flags
, mode
, 0,
2815 target_fileio_open_warn_if_slow (struct inferior
*inf
,
2816 const char *filename
,
2817 int flags
, int mode
, int *target_errno
)
2819 return target_fileio_open_1 (inf
, filename
, flags
, mode
, 1,
2826 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
2827 ULONGEST offset
, int *target_errno
)
2829 fileio_fh_t
*fh
= fileio_fd_to_fh (fd
);
2832 if (fh
->is_closed ())
2833 *target_errno
= EBADF
;
2834 else if (fh
->target
== NULL
)
2835 *target_errno
= EIO
;
2837 ret
= fh
->target
->fileio_pwrite (fh
->target_fd
, write_buf
,
2838 len
, offset
, target_errno
);
2841 fprintf_unfiltered (gdb_stdlog
,
2842 "target_fileio_pwrite (%d,...,%d,%s) "
2844 fd
, len
, pulongest (offset
),
2845 ret
, ret
!= -1 ? 0 : *target_errno
);
2852 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
2853 ULONGEST offset
, int *target_errno
)
2855 fileio_fh_t
*fh
= fileio_fd_to_fh (fd
);
2858 if (fh
->is_closed ())
2859 *target_errno
= EBADF
;
2860 else if (fh
->target
== NULL
)
2861 *target_errno
= EIO
;
2863 ret
= fh
->target
->fileio_pread (fh
->target_fd
, read_buf
,
2864 len
, offset
, target_errno
);
2867 fprintf_unfiltered (gdb_stdlog
,
2868 "target_fileio_pread (%d,...,%d,%s) "
2870 fd
, len
, pulongest (offset
),
2871 ret
, ret
!= -1 ? 0 : *target_errno
);
2878 target_fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
)
2880 fileio_fh_t
*fh
= fileio_fd_to_fh (fd
);
2883 if (fh
->is_closed ())
2884 *target_errno
= EBADF
;
2885 else if (fh
->target
== NULL
)
2886 *target_errno
= EIO
;
2888 ret
= fh
->target
->fileio_fstat (fh
->target_fd
, sb
, target_errno
);
2891 fprintf_unfiltered (gdb_stdlog
,
2892 "target_fileio_fstat (%d) = %d (%d)\n",
2893 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
2900 target_fileio_close (int fd
, int *target_errno
)
2902 fileio_fh_t
*fh
= fileio_fd_to_fh (fd
);
2905 if (fh
->is_closed ())
2906 *target_errno
= EBADF
;
2909 if (fh
->target
!= NULL
)
2910 ret
= fh
->target
->fileio_close (fh
->target_fd
,
2914 release_fileio_fd (fd
, fh
);
2918 fprintf_unfiltered (gdb_stdlog
,
2919 "target_fileio_close (%d) = %d (%d)\n",
2920 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
2927 target_fileio_unlink (struct inferior
*inf
, const char *filename
,
2930 for (target_ops
*t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath ())
2932 int ret
= t
->fileio_unlink (inf
, filename
, target_errno
);
2934 if (ret
== -1 && *target_errno
== FILEIO_ENOSYS
)
2938 fprintf_unfiltered (gdb_stdlog
,
2939 "target_fileio_unlink (%d,%s)"
2941 inf
== NULL
? 0 : inf
->num
, filename
,
2942 ret
, ret
!= -1 ? 0 : *target_errno
);
2946 *target_errno
= FILEIO_ENOSYS
;
2952 gdb::optional
<std::string
>
2953 target_fileio_readlink (struct inferior
*inf
, const char *filename
,
2956 for (target_ops
*t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath ())
2958 gdb::optional
<std::string
> ret
2959 = t
->fileio_readlink (inf
, filename
, target_errno
);
2961 if (!ret
.has_value () && *target_errno
== FILEIO_ENOSYS
)
2965 fprintf_unfiltered (gdb_stdlog
,
2966 "target_fileio_readlink (%d,%s)"
2968 inf
== NULL
? 0 : inf
->num
,
2969 filename
, ret
? ret
->c_str () : "(nil)",
2970 ret
? 0 : *target_errno
);
2974 *target_errno
= FILEIO_ENOSYS
;
2978 /* Like scoped_fd, but specific to target fileio. */
2980 class scoped_target_fd
2983 explicit scoped_target_fd (int fd
) noexcept
2988 ~scoped_target_fd ()
2994 target_fileio_close (m_fd
, &target_errno
);
2998 DISABLE_COPY_AND_ASSIGN (scoped_target_fd
);
3000 int get () const noexcept
3009 /* Read target file FILENAME, in the filesystem as seen by INF. If
3010 INF is NULL, use the filesystem seen by the debugger (GDB or, for
3011 remote targets, the remote stub). Store the result in *BUF_P and
3012 return the size of the transferred data. PADDING additional bytes
3013 are available in *BUF_P. This is a helper function for
3014 target_fileio_read_alloc; see the declaration of that function for
3015 more information. */
3018 target_fileio_read_alloc_1 (struct inferior
*inf
, const char *filename
,
3019 gdb_byte
**buf_p
, int padding
)
3021 size_t buf_alloc
, buf_pos
;
3026 scoped_target_fd
fd (target_fileio_open (inf
, filename
, FILEIO_O_RDONLY
,
3027 0700, &target_errno
));
3028 if (fd
.get () == -1)
3031 /* Start by reading up to 4K at a time. The target will throttle
3032 this number down if necessary. */
3034 buf
= (gdb_byte
*) xmalloc (buf_alloc
);
3038 n
= target_fileio_pread (fd
.get (), &buf
[buf_pos
],
3039 buf_alloc
- buf_pos
- padding
, buf_pos
,
3043 /* An error occurred. */
3049 /* Read all there was. */
3059 /* If the buffer is filling up, expand it. */
3060 if (buf_alloc
< buf_pos
* 2)
3063 buf
= (gdb_byte
*) xrealloc (buf
, buf_alloc
);
3073 target_fileio_read_alloc (struct inferior
*inf
, const char *filename
,
3076 return target_fileio_read_alloc_1 (inf
, filename
, buf_p
, 0);
3081 gdb::unique_xmalloc_ptr
<char>
3082 target_fileio_read_stralloc (struct inferior
*inf
, const char *filename
)
3086 LONGEST i
, transferred
;
3088 transferred
= target_fileio_read_alloc_1 (inf
, filename
, &buffer
, 1);
3089 bufstr
= (char *) buffer
;
3091 if (transferred
< 0)
3092 return gdb::unique_xmalloc_ptr
<char> (nullptr);
3094 if (transferred
== 0)
3095 return gdb::unique_xmalloc_ptr
<char> (xstrdup (""));
3097 bufstr
[transferred
] = 0;
3099 /* Check for embedded NUL bytes; but allow trailing NULs. */
3100 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3103 warning (_("target file %s "
3104 "contained unexpected null characters"),
3109 return gdb::unique_xmalloc_ptr
<char> (bufstr
);
3114 default_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3115 CORE_ADDR addr
, int len
)
3117 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3121 default_watchpoint_addr_within_range (struct target_ops
*target
,
3123 CORE_ADDR start
, int length
)
3125 return addr
>= start
&& addr
< start
+ length
;
3131 target_stack::find_beneath (const target_ops
*t
) const
3133 /* Look for a non-empty slot at stratum levels beneath T's. */
3134 for (int stratum
= t
->stratum () - 1; stratum
>= 0; --stratum
)
3135 if (m_stack
[stratum
] != NULL
)
3136 return m_stack
[stratum
];
3144 find_target_at (enum strata stratum
)
3146 return g_target_stack
.at (stratum
);
3154 target_announce_detach (int from_tty
)
3157 const char *exec_file
;
3162 exec_file
= get_exec_file (0);
3163 if (exec_file
== NULL
)
3166 pid
= inferior_ptid
.pid ();
3167 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
3168 target_pid_to_str (ptid_t (pid
)));
3171 /* The inferior process has died. Long live the inferior! */
3174 generic_mourn_inferior (void)
3176 inferior
*inf
= current_inferior ();
3178 inferior_ptid
= null_ptid
;
3180 /* Mark breakpoints uninserted in case something tries to delete a
3181 breakpoint while we delete the inferior's threads (which would
3182 fail, since the inferior is long gone). */
3183 mark_breakpoints_out ();
3186 exit_inferior (inf
);
3188 /* Note this wipes step-resume breakpoints, so needs to be done
3189 after exit_inferior, which ends up referencing the step-resume
3190 breakpoints through clear_thread_inferior_resources. */
3191 breakpoint_init_inferior (inf_exited
);
3193 registers_changed ();
3195 reopen_exec_file ();
3196 reinit_frame_cache ();
3198 if (deprecated_detach_hook
)
3199 deprecated_detach_hook ();
3202 /* Convert a normal process ID to a string. Returns the string in a
3206 normal_pid_to_str (ptid_t ptid
)
3208 static char buf
[32];
3210 xsnprintf (buf
, sizeof buf
, "process %d", ptid
.pid ());
3215 default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3217 return normal_pid_to_str (ptid
);
3220 /* Error-catcher for target_find_memory_regions. */
3222 dummy_find_memory_regions (struct target_ops
*self
,
3223 find_memory_region_ftype ignore1
, void *ignore2
)
3225 error (_("Command not implemented for this target."));
3229 /* Error-catcher for target_make_corefile_notes. */
3231 dummy_make_corefile_notes (struct target_ops
*self
,
3232 bfd
*ignore1
, int *ignore2
)
3234 error (_("Command not implemented for this target."));
3238 #include "target-delegates.c"
3240 /* The initial current target, so that there is always a semi-valid
3243 static dummy_target the_dummy_target
;
3245 static const target_info dummy_target_info
= {
3252 dummy_target::stratum () const
3254 return dummy_stratum
;
3258 debug_target::stratum () const
3260 return debug_stratum
;
3264 dummy_target::info () const
3266 return dummy_target_info
;
3270 debug_target::info () const
3272 return beneath ()->info ();
3278 target_close (struct target_ops
*targ
)
3280 gdb_assert (!target_is_pushed (targ
));
3282 fileio_handles_invalidate_target (targ
);
3287 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3291 target_thread_alive (ptid_t ptid
)
3293 return current_top_target ()->thread_alive (ptid
);
3297 target_update_thread_list (void)
3299 current_top_target ()->update_thread_list ();
3303 target_stop (ptid_t ptid
)
3307 warning (_("May not interrupt or stop the target, ignoring attempt"));
3311 current_top_target ()->stop (ptid
);
3319 warning (_("May not interrupt or stop the target, ignoring attempt"));
3323 current_top_target ()->interrupt ();
3329 target_pass_ctrlc (void)
3331 current_top_target ()->pass_ctrlc ();
3337 default_target_pass_ctrlc (struct target_ops
*ops
)
3339 target_interrupt ();
3342 /* See target/target.h. */
3345 target_stop_and_wait (ptid_t ptid
)
3347 struct target_waitstatus status
;
3348 int was_non_stop
= non_stop
;
3353 memset (&status
, 0, sizeof (status
));
3354 target_wait (ptid
, &status
, 0);
3356 non_stop
= was_non_stop
;
3359 /* See target/target.h. */
3362 target_continue_no_signal (ptid_t ptid
)
3364 target_resume (ptid
, 0, GDB_SIGNAL_0
);
3367 /* See target/target.h. */
3370 target_continue (ptid_t ptid
, enum gdb_signal signal
)
3372 target_resume (ptid
, 0, signal
);
3375 /* Concatenate ELEM to LIST, a comma-separated list. */
3378 str_comma_list_concat_elem (std::string
*list
, const char *elem
)
3380 if (!list
->empty ())
3381 list
->append (", ");
3383 list
->append (elem
);
3386 /* Helper for target_options_to_string. If OPT is present in
3387 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3388 OPT is removed from TARGET_OPTIONS. */
3391 do_option (int *target_options
, std::string
*ret
,
3392 int opt
, const char *opt_str
)
3394 if ((*target_options
& opt
) != 0)
3396 str_comma_list_concat_elem (ret
, opt_str
);
3397 *target_options
&= ~opt
;
3404 target_options_to_string (int target_options
)
3408 #define DO_TARG_OPTION(OPT) \
3409 do_option (&target_options, &ret, OPT, #OPT)
3411 DO_TARG_OPTION (TARGET_WNOHANG
);
3413 if (target_options
!= 0)
3414 str_comma_list_concat_elem (&ret
, "unknown???");
3420 target_fetch_registers (struct regcache
*regcache
, int regno
)
3422 current_top_target ()->fetch_registers (regcache
, regno
);
3424 regcache
->debug_print_register ("target_fetch_registers", regno
);
3428 target_store_registers (struct regcache
*regcache
, int regno
)
3430 if (!may_write_registers
)
3431 error (_("Writing to registers is not allowed (regno %d)"), regno
);
3433 current_top_target ()->store_registers (regcache
, regno
);
3436 regcache
->debug_print_register ("target_store_registers", regno
);
3441 target_core_of_thread (ptid_t ptid
)
3443 return current_top_target ()->core_of_thread (ptid
);
3447 simple_verify_memory (struct target_ops
*ops
,
3448 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
3450 LONGEST total_xfered
= 0;
3452 while (total_xfered
< size
)
3454 ULONGEST xfered_len
;
3455 enum target_xfer_status status
;
3457 ULONGEST howmuch
= std::min
<ULONGEST
> (sizeof (buf
), size
- total_xfered
);
3459 status
= target_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
3460 buf
, NULL
, lma
+ total_xfered
, howmuch
,
3462 if (status
== TARGET_XFER_OK
3463 && memcmp (data
+ total_xfered
, buf
, xfered_len
) == 0)
3465 total_xfered
+= xfered_len
;
3474 /* Default implementation of memory verification. */
3477 default_verify_memory (struct target_ops
*self
,
3478 const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3480 /* Start over from the top of the target stack. */
3481 return simple_verify_memory (current_top_target (),
3482 data
, memaddr
, size
);
3486 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3488 return current_top_target ()->verify_memory (data
, memaddr
, size
);
3491 /* The documentation for this function is in its prototype declaration in
3495 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
,
3496 enum target_hw_bp_type rw
)
3498 return current_top_target ()->insert_mask_watchpoint (addr
, mask
, rw
);
3501 /* The documentation for this function is in its prototype declaration in
3505 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
,
3506 enum target_hw_bp_type rw
)
3508 return current_top_target ()->remove_mask_watchpoint (addr
, mask
, rw
);
3511 /* The documentation for this function is in its prototype declaration
3515 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
3517 return current_top_target ()->masked_watch_num_registers (addr
, mask
);
3520 /* The documentation for this function is in its prototype declaration
3524 target_ranged_break_num_registers (void)
3526 return current_top_target ()->ranged_break_num_registers ();
3531 struct btrace_target_info
*
3532 target_enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
3534 return current_top_target ()->enable_btrace (ptid
, conf
);
3540 target_disable_btrace (struct btrace_target_info
*btinfo
)
3542 current_top_target ()->disable_btrace (btinfo
);
3548 target_teardown_btrace (struct btrace_target_info
*btinfo
)
3550 current_top_target ()->teardown_btrace (btinfo
);
3556 target_read_btrace (struct btrace_data
*btrace
,
3557 struct btrace_target_info
*btinfo
,
3558 enum btrace_read_type type
)
3560 return current_top_target ()->read_btrace (btrace
, btinfo
, type
);
3565 const struct btrace_config
*
3566 target_btrace_conf (const struct btrace_target_info
*btinfo
)
3568 return current_top_target ()->btrace_conf (btinfo
);
3574 target_stop_recording (void)
3576 current_top_target ()->stop_recording ();
3582 target_save_record (const char *filename
)
3584 current_top_target ()->save_record (filename
);
3590 target_supports_delete_record ()
3592 return current_top_target ()->supports_delete_record ();
3598 target_delete_record (void)
3600 current_top_target ()->delete_record ();
3606 target_record_method (ptid_t ptid
)
3608 return current_top_target ()->record_method (ptid
);
3614 target_record_is_replaying (ptid_t ptid
)
3616 return current_top_target ()->record_is_replaying (ptid
);
3622 target_record_will_replay (ptid_t ptid
, int dir
)
3624 return current_top_target ()->record_will_replay (ptid
, dir
);
3630 target_record_stop_replaying (void)
3632 current_top_target ()->record_stop_replaying ();
3638 target_goto_record_begin (void)
3640 current_top_target ()->goto_record_begin ();
3646 target_goto_record_end (void)
3648 current_top_target ()->goto_record_end ();
3654 target_goto_record (ULONGEST insn
)
3656 current_top_target ()->goto_record (insn
);
3662 target_insn_history (int size
, gdb_disassembly_flags flags
)
3664 current_top_target ()->insn_history (size
, flags
);
3670 target_insn_history_from (ULONGEST from
, int size
,
3671 gdb_disassembly_flags flags
)
3673 current_top_target ()->insn_history_from (from
, size
, flags
);
3679 target_insn_history_range (ULONGEST begin
, ULONGEST end
,
3680 gdb_disassembly_flags flags
)
3682 current_top_target ()->insn_history_range (begin
, end
, flags
);
3688 target_call_history (int size
, record_print_flags flags
)
3690 current_top_target ()->call_history (size
, flags
);
3696 target_call_history_from (ULONGEST begin
, int size
, record_print_flags flags
)
3698 current_top_target ()->call_history_from (begin
, size
, flags
);
3704 target_call_history_range (ULONGEST begin
, ULONGEST end
, record_print_flags flags
)
3706 current_top_target ()->call_history_range (begin
, end
, flags
);
3711 const struct frame_unwind
*
3712 target_get_unwinder (void)
3714 return current_top_target ()->get_unwinder ();
3719 const struct frame_unwind
*
3720 target_get_tailcall_unwinder (void)
3722 return current_top_target ()->get_tailcall_unwinder ();
3728 target_prepare_to_generate_core (void)
3730 current_top_target ()->prepare_to_generate_core ();
3736 target_done_generating_core (void)
3738 current_top_target ()->done_generating_core ();
3743 static char targ_desc
[] =
3744 "Names of targets and files being debugged.\nShows the entire \
3745 stack of targets currently in use (including the exec-file,\n\
3746 core-file, and process, if any), as well as the symbol file name.";
3749 default_rcmd (struct target_ops
*self
, const char *command
,
3750 struct ui_file
*output
)
3752 error (_("\"monitor\" command not supported by this target."));
3756 do_monitor_command (const char *cmd
, int from_tty
)
3758 target_rcmd (cmd
, gdb_stdtarg
);
3761 /* Erases all the memory regions marked as flash. CMD and FROM_TTY are
3765 flash_erase_command (const char *cmd
, int from_tty
)
3767 /* Used to communicate termination of flash operations to the target. */
3768 bool found_flash_region
= false;
3769 struct gdbarch
*gdbarch
= target_gdbarch ();
3771 std::vector
<mem_region
> mem_regions
= target_memory_map ();
3773 /* Iterate over all memory regions. */
3774 for (const mem_region
&m
: mem_regions
)
3776 /* Is this a flash memory region? */
3777 if (m
.attrib
.mode
== MEM_FLASH
)
3779 found_flash_region
= true;
3780 target_flash_erase (m
.lo
, m
.hi
- m
.lo
);
3782 ui_out_emit_tuple
tuple_emitter (current_uiout
, "erased-regions");
3784 current_uiout
->message (_("Erasing flash memory region at address "));
3785 current_uiout
->field_fmt ("address", "%s", paddress (gdbarch
, m
.lo
));
3786 current_uiout
->message (", size = ");
3787 current_uiout
->field_fmt ("size", "%s", hex_string (m
.hi
- m
.lo
));
3788 current_uiout
->message ("\n");
3792 /* Did we do any flash operations? If so, we need to finalize them. */
3793 if (found_flash_region
)
3794 target_flash_done ();
3796 current_uiout
->message (_("No flash memory regions found.\n"));
3799 /* Print the name of each layers of our target stack. */
3802 maintenance_print_target_stack (const char *cmd
, int from_tty
)
3804 printf_filtered (_("The current target stack is:\n"));
3806 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
3808 if (t
->stratum () == debug_stratum
)
3810 printf_filtered (" - %s (%s)\n", t
->shortname (), t
->longname ());
3817 target_async (int enable
)
3819 infrun_async (enable
);
3820 current_top_target ()->async (enable
);
3826 target_thread_events (int enable
)
3828 current_top_target ()->thread_events (enable
);
3831 /* Controls if targets can report that they can/are async. This is
3832 just for maintainers to use when debugging gdb. */
3833 int target_async_permitted
= 1;
3835 /* The set command writes to this variable. If the inferior is
3836 executing, target_async_permitted is *not* updated. */
3837 static int target_async_permitted_1
= 1;
3840 maint_set_target_async_command (const char *args
, int from_tty
,
3841 struct cmd_list_element
*c
)
3843 if (have_live_inferiors ())
3845 target_async_permitted_1
= target_async_permitted
;
3846 error (_("Cannot change this setting while the inferior is running."));
3849 target_async_permitted
= target_async_permitted_1
;
3853 maint_show_target_async_command (struct ui_file
*file
, int from_tty
,
3854 struct cmd_list_element
*c
,
3857 fprintf_filtered (file
,
3858 _("Controlling the inferior in "
3859 "asynchronous mode is %s.\n"), value
);
3862 /* Return true if the target operates in non-stop mode even with "set
3866 target_always_non_stop_p (void)
3868 return current_top_target ()->always_non_stop_p ();
3874 target_is_non_stop_p (void)
3877 || target_non_stop_enabled
== AUTO_BOOLEAN_TRUE
3878 || (target_non_stop_enabled
== AUTO_BOOLEAN_AUTO
3879 && target_always_non_stop_p ()));
3882 /* Controls if targets can report that they always run in non-stop
3883 mode. This is just for maintainers to use when debugging gdb. */
3884 enum auto_boolean target_non_stop_enabled
= AUTO_BOOLEAN_AUTO
;
3886 /* The set command writes to this variable. If the inferior is
3887 executing, target_non_stop_enabled is *not* updated. */
3888 static enum auto_boolean target_non_stop_enabled_1
= AUTO_BOOLEAN_AUTO
;
3890 /* Implementation of "maint set target-non-stop". */
3893 maint_set_target_non_stop_command (const char *args
, int from_tty
,
3894 struct cmd_list_element
*c
)
3896 if (have_live_inferiors ())
3898 target_non_stop_enabled_1
= target_non_stop_enabled
;
3899 error (_("Cannot change this setting while the inferior is running."));
3902 target_non_stop_enabled
= target_non_stop_enabled_1
;
3905 /* Implementation of "maint show target-non-stop". */
3908 maint_show_target_non_stop_command (struct ui_file
*file
, int from_tty
,
3909 struct cmd_list_element
*c
,
3912 if (target_non_stop_enabled
== AUTO_BOOLEAN_AUTO
)
3913 fprintf_filtered (file
,
3914 _("Whether the target is always in non-stop mode "
3915 "is %s (currently %s).\n"), value
,
3916 target_always_non_stop_p () ? "on" : "off");
3918 fprintf_filtered (file
,
3919 _("Whether the target is always in non-stop mode "
3920 "is %s.\n"), value
);
3923 /* Temporary copies of permission settings. */
3925 static int may_write_registers_1
= 1;
3926 static int may_write_memory_1
= 1;
3927 static int may_insert_breakpoints_1
= 1;
3928 static int may_insert_tracepoints_1
= 1;
3929 static int may_insert_fast_tracepoints_1
= 1;
3930 static int may_stop_1
= 1;
3932 /* Make the user-set values match the real values again. */
3935 update_target_permissions (void)
3937 may_write_registers_1
= may_write_registers
;
3938 may_write_memory_1
= may_write_memory
;
3939 may_insert_breakpoints_1
= may_insert_breakpoints
;
3940 may_insert_tracepoints_1
= may_insert_tracepoints
;
3941 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
3942 may_stop_1
= may_stop
;
3945 /* The one function handles (most of) the permission flags in the same
3949 set_target_permissions (const char *args
, int from_tty
,
3950 struct cmd_list_element
*c
)
3952 if (target_has_execution
)
3954 update_target_permissions ();
3955 error (_("Cannot change this setting while the inferior is running."));
3958 /* Make the real values match the user-changed values. */
3959 may_write_registers
= may_write_registers_1
;
3960 may_insert_breakpoints
= may_insert_breakpoints_1
;
3961 may_insert_tracepoints
= may_insert_tracepoints_1
;
3962 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
3963 may_stop
= may_stop_1
;
3964 update_observer_mode ();
3967 /* Set memory write permission independently of observer mode. */
3970 set_write_memory_permission (const char *args
, int from_tty
,
3971 struct cmd_list_element
*c
)
3973 /* Make the real values match the user-changed values. */
3974 may_write_memory
= may_write_memory_1
;
3975 update_observer_mode ();
3979 initialize_targets (void)
3981 push_target (&the_dummy_target
);
3983 the_debug_target
= new debug_target ();
3985 add_info ("target", info_target_command
, targ_desc
);
3986 add_info ("files", info_target_command
, targ_desc
);
3988 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3989 Set target debugging."), _("\
3990 Show target debugging."), _("\
3991 When non-zero, target debugging is enabled. Higher numbers are more\n\
3995 &setdebuglist
, &showdebuglist
);
3997 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3998 &trust_readonly
, _("\
3999 Set mode for reading from readonly sections."), _("\
4000 Show mode for reading from readonly sections."), _("\
4001 When this mode is on, memory reads from readonly sections (such as .text)\n\
4002 will be read from the object file instead of from the target. This will\n\
4003 result in significant performance improvement for remote targets."),
4005 show_trust_readonly
,
4006 &setlist
, &showlist
);
4008 add_com ("monitor", class_obscure
, do_monitor_command
,
4009 _("Send a command to the remote monitor (remote targets only)."));
4011 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
4012 _("Print the name of each layer of the internal target stack."),
4013 &maintenanceprintlist
);
4015 add_setshow_boolean_cmd ("target-async", no_class
,
4016 &target_async_permitted_1
, _("\
4017 Set whether gdb controls the inferior in asynchronous mode."), _("\
4018 Show whether gdb controls the inferior in asynchronous mode."), _("\
4019 Tells gdb whether to control the inferior in asynchronous mode."),
4020 maint_set_target_async_command
,
4021 maint_show_target_async_command
,
4022 &maintenance_set_cmdlist
,
4023 &maintenance_show_cmdlist
);
4025 add_setshow_auto_boolean_cmd ("target-non-stop", no_class
,
4026 &target_non_stop_enabled_1
, _("\
4027 Set whether gdb always controls the inferior in non-stop mode."), _("\
4028 Show whether gdb always controls the inferior in non-stop mode."), _("\
4029 Tells gdb whether to control the inferior in non-stop mode."),
4030 maint_set_target_non_stop_command
,
4031 maint_show_target_non_stop_command
,
4032 &maintenance_set_cmdlist
,
4033 &maintenance_show_cmdlist
);
4035 add_setshow_boolean_cmd ("may-write-registers", class_support
,
4036 &may_write_registers_1
, _("\
4037 Set permission to write into registers."), _("\
4038 Show permission to write into registers."), _("\
4039 When this permission is on, GDB may write into the target's registers.\n\
4040 Otherwise, any sort of write attempt will result in an error."),
4041 set_target_permissions
, NULL
,
4042 &setlist
, &showlist
);
4044 add_setshow_boolean_cmd ("may-write-memory", class_support
,
4045 &may_write_memory_1
, _("\
4046 Set permission to write into target memory."), _("\
4047 Show permission to write into target memory."), _("\
4048 When this permission is on, GDB may write into the target's memory.\n\
4049 Otherwise, any sort of write attempt will result in an error."),
4050 set_write_memory_permission
, NULL
,
4051 &setlist
, &showlist
);
4053 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
4054 &may_insert_breakpoints_1
, _("\
4055 Set permission to insert breakpoints in the target."), _("\
4056 Show permission to insert breakpoints in the target."), _("\
4057 When this permission is on, GDB may insert breakpoints in the program.\n\
4058 Otherwise, any sort of insertion attempt will result in an error."),
4059 set_target_permissions
, NULL
,
4060 &setlist
, &showlist
);
4062 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
4063 &may_insert_tracepoints_1
, _("\
4064 Set permission to insert tracepoints in the target."), _("\
4065 Show permission to insert tracepoints in the target."), _("\
4066 When this permission is on, GDB may insert tracepoints in the program.\n\
4067 Otherwise, any sort of insertion attempt will result in an error."),
4068 set_target_permissions
, NULL
,
4069 &setlist
, &showlist
);
4071 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
4072 &may_insert_fast_tracepoints_1
, _("\
4073 Set permission to insert fast tracepoints in the target."), _("\
4074 Show permission to insert fast tracepoints in the target."), _("\
4075 When this permission is on, GDB may insert fast tracepoints.\n\
4076 Otherwise, any sort of insertion attempt will result in an error."),
4077 set_target_permissions
, NULL
,
4078 &setlist
, &showlist
);
4080 add_setshow_boolean_cmd ("may-interrupt", class_support
,
4082 Set permission to interrupt or signal the target."), _("\
4083 Show permission to interrupt or signal the target."), _("\
4084 When this permission is on, GDB may interrupt/stop the target's execution.\n\
4085 Otherwise, any attempt to interrupt or stop will be ignored."),
4086 set_target_permissions
, NULL
,
4087 &setlist
, &showlist
);
4089 add_com ("flash-erase", no_class
, flash_erase_command
,
4090 _("Erase all flash memory regions."));
4092 add_setshow_boolean_cmd ("auto-connect-native-target", class_support
,
4093 &auto_connect_native_target
, _("\
4094 Set whether GDB may automatically connect to the native target."), _("\
4095 Show whether GDB may automatically connect to the native target."), _("\
4096 When on, and GDB is not connected to a target yet, GDB\n\
4097 attempts \"run\" and other commands with the native target."),
4098 NULL
, show_auto_connect_native_target
,
4099 &setlist
, &showlist
);