1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990-2020 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 "gdbsupport/agent.h"
45 #include "target-debug.h"
47 #include "event-top.h"
49 #include "gdbsupport/byte-vector.h"
51 #include <unordered_map>
52 #include "target-connection.h"
55 static void generic_tls_error (void) ATTRIBUTE_NORETURN
;
57 static void default_terminal_info (struct target_ops
*, const char *, int);
59 static int default_watchpoint_addr_within_range (struct target_ops
*,
60 CORE_ADDR
, CORE_ADDR
, int);
62 static int default_region_ok_for_hw_watchpoint (struct target_ops
*,
65 static void default_rcmd (struct target_ops
*, const char *, struct ui_file
*);
67 static ptid_t
default_get_ada_task_ptid (struct target_ops
*self
,
70 static void default_mourn_inferior (struct target_ops
*self
);
72 static int default_search_memory (struct target_ops
*ops
,
74 ULONGEST search_space_len
,
75 const gdb_byte
*pattern
,
77 CORE_ADDR
*found_addrp
);
79 static int default_verify_memory (struct target_ops
*self
,
81 CORE_ADDR memaddr
, ULONGEST size
);
83 static void tcomplain (void) ATTRIBUTE_NORETURN
;
85 static struct target_ops
*find_default_run_target (const char *);
87 static int dummy_find_memory_regions (struct target_ops
*self
,
88 find_memory_region_ftype ignore1
,
91 static char *dummy_make_corefile_notes (struct target_ops
*self
,
92 bfd
*ignore1
, int *ignore2
);
94 static std::string
default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
);
96 static enum exec_direction_kind default_execution_direction
97 (struct target_ops
*self
);
99 /* Mapping between target_info objects (which have address identity)
100 and corresponding open/factory function/callback. Each add_target
101 call adds one entry to this map, and registers a "target
102 TARGET_NAME" command that when invoked calls the factory registered
103 here. The target_info object is associated with the command via
104 the command's context. */
105 static std::unordered_map
<const target_info
*, target_open_ftype
*>
108 /* The singleton debug target. */
110 static struct target_ops
*the_debug_target
;
112 /* Top of target stack. */
113 /* The target structure we are currently using to talk to a process
114 or file or whatever "inferior" we have. */
117 current_top_target ()
119 return current_inferior ()->top_target ();
122 /* Command list for target. */
124 static struct cmd_list_element
*targetlist
= NULL
;
126 /* True if we should trust readonly sections from the
127 executable when reading memory. */
129 static bool trust_readonly
= false;
131 /* Nonzero if we should show true memory content including
132 memory breakpoint inserted by gdb. */
134 static int show_memory_breakpoints
= 0;
136 /* These globals control whether GDB attempts to perform these
137 operations; they are useful for targets that need to prevent
138 inadvertent disruption, such as in non-stop mode. */
140 bool may_write_registers
= true;
142 bool may_write_memory
= true;
144 bool may_insert_breakpoints
= true;
146 bool may_insert_tracepoints
= true;
148 bool may_insert_fast_tracepoints
= true;
150 bool may_stop
= true;
152 /* Non-zero if we want to see trace of target level stuff. */
154 static unsigned int targetdebug
= 0;
157 set_targetdebug (const char *args
, int from_tty
, struct cmd_list_element
*c
)
160 push_target (the_debug_target
);
162 unpush_target (the_debug_target
);
166 show_targetdebug (struct ui_file
*file
, int from_tty
,
167 struct cmd_list_element
*c
, const char *value
)
169 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
173 target_has_all_memory_1 (void)
175 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
176 if (t
->has_all_memory ())
183 target_has_memory_1 (void)
185 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
186 if (t
->has_memory ())
193 target_has_stack_1 (void)
195 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
203 target_has_registers_1 (void)
205 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
206 if (t
->has_registers ())
213 target_has_execution_1 (inferior
*inf
)
215 for (target_ops
*t
= inf
->top_target ();
217 t
= inf
->find_target_beneath (t
))
218 if (t
->has_execution (inf
))
225 target_has_execution_current (void)
227 return target_has_execution_1 (current_inferior ());
230 /* This is used to implement the various target commands. */
233 open_target (const char *args
, int from_tty
, struct cmd_list_element
*command
)
235 auto *ti
= static_cast<target_info
*> (get_cmd_context (command
));
236 target_open_ftype
*func
= target_factories
[ti
];
239 fprintf_unfiltered (gdb_stdlog
, "-> %s->open (...)\n",
242 func (args
, from_tty
);
245 fprintf_unfiltered (gdb_stdlog
, "<- %s->open (%s, %d)\n",
246 ti
->shortname
, args
, from_tty
);
252 add_target (const target_info
&t
, target_open_ftype
*func
,
253 completer_ftype
*completer
)
255 struct cmd_list_element
*c
;
257 auto &func_slot
= target_factories
[&t
];
258 if (func_slot
!= nullptr)
259 internal_error (__FILE__
, __LINE__
,
260 _("target already added (\"%s\")."), t
.shortname
);
263 if (targetlist
== NULL
)
264 add_basic_prefix_cmd ("target", class_run
, _("\
265 Connect to a target machine or process.\n\
266 The first argument is the type or protocol of the target machine.\n\
267 Remaining arguments are interpreted by the target protocol. For more\n\
268 information on the arguments for a particular protocol, type\n\
269 `help target ' followed by the protocol name."),
270 &targetlist
, "target ", 0, &cmdlist
);
271 c
= add_cmd (t
.shortname
, no_class
, t
.doc
, &targetlist
);
272 set_cmd_context (c
, (void *) &t
);
273 set_cmd_sfunc (c
, open_target
);
274 if (completer
!= NULL
)
275 set_cmd_completer (c
, completer
);
281 add_deprecated_target_alias (const target_info
&tinfo
, const char *alias
)
283 struct cmd_list_element
*c
;
286 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
288 c
= add_cmd (alias
, no_class
, tinfo
.doc
, &targetlist
);
289 set_cmd_sfunc (c
, open_target
);
290 set_cmd_context (c
, (void *) &tinfo
);
291 alt
= xstrprintf ("target %s", tinfo
.shortname
);
292 deprecate_cmd (c
, alt
);
300 current_top_target ()->kill ();
304 target_load (const char *arg
, int from_tty
)
306 target_dcache_invalidate ();
307 current_top_target ()->load (arg
, from_tty
);
312 target_terminal_state
target_terminal::m_terminal_state
313 = target_terminal_state::is_ours
;
315 /* See target/target.h. */
318 target_terminal::init (void)
320 current_top_target ()->terminal_init ();
322 m_terminal_state
= target_terminal_state::is_ours
;
325 /* See target/target.h. */
328 target_terminal::inferior (void)
330 struct ui
*ui
= current_ui
;
332 /* A background resume (``run&'') should leave GDB in control of the
334 if (ui
->prompt_state
!= PROMPT_BLOCKED
)
337 /* Since we always run the inferior in the main console (unless "set
338 inferior-tty" is in effect), when some UI other than the main one
339 calls target_terminal::inferior, then we leave the main UI's
340 terminal settings as is. */
344 /* If GDB is resuming the inferior in the foreground, install
345 inferior's terminal modes. */
347 struct inferior
*inf
= current_inferior ();
349 if (inf
->terminal_state
!= target_terminal_state::is_inferior
)
351 current_top_target ()->terminal_inferior ();
352 inf
->terminal_state
= target_terminal_state::is_inferior
;
355 m_terminal_state
= target_terminal_state::is_inferior
;
357 /* If the user hit C-c before, pretend that it was hit right
359 if (check_quit_flag ())
360 target_pass_ctrlc ();
363 /* See target/target.h. */
366 target_terminal::restore_inferior (void)
368 struct ui
*ui
= current_ui
;
370 /* See target_terminal::inferior(). */
371 if (ui
->prompt_state
!= PROMPT_BLOCKED
|| ui
!= main_ui
)
374 /* Restore the terminal settings of inferiors that were in the
375 foreground but are now ours_for_output due to a temporary
376 target_target::ours_for_output() call. */
379 scoped_restore_current_inferior restore_inferior
;
381 for (::inferior
*inf
: all_inferiors ())
383 if (inf
->terminal_state
== target_terminal_state::is_ours_for_output
)
385 set_current_inferior (inf
);
386 current_top_target ()->terminal_inferior ();
387 inf
->terminal_state
= target_terminal_state::is_inferior
;
392 m_terminal_state
= target_terminal_state::is_inferior
;
394 /* If the user hit C-c before, pretend that it was hit right
396 if (check_quit_flag ())
397 target_pass_ctrlc ();
400 /* Switch terminal state to DESIRED_STATE, either is_ours, or
401 is_ours_for_output. */
404 target_terminal_is_ours_kind (target_terminal_state desired_state
)
406 scoped_restore_current_inferior restore_inferior
;
408 /* Must do this in two passes. First, have all inferiors save the
409 current terminal settings. Then, after all inferiors have add a
410 chance to safely save the terminal settings, restore GDB's
411 terminal settings. */
413 for (inferior
*inf
: all_inferiors ())
415 if (inf
->terminal_state
== target_terminal_state::is_inferior
)
417 set_current_inferior (inf
);
418 current_top_target ()->terminal_save_inferior ();
422 for (inferior
*inf
: all_inferiors ())
424 /* Note we don't check is_inferior here like above because we
425 need to handle 'is_ours_for_output -> is_ours' too. Careful
426 to never transition from 'is_ours' to 'is_ours_for_output',
428 if (inf
->terminal_state
!= target_terminal_state::is_ours
429 && inf
->terminal_state
!= desired_state
)
431 set_current_inferior (inf
);
432 if (desired_state
== target_terminal_state::is_ours
)
433 current_top_target ()->terminal_ours ();
434 else if (desired_state
== target_terminal_state::is_ours_for_output
)
435 current_top_target ()->terminal_ours_for_output ();
437 gdb_assert_not_reached ("unhandled desired state");
438 inf
->terminal_state
= desired_state
;
443 /* See target/target.h. */
446 target_terminal::ours ()
448 struct ui
*ui
= current_ui
;
450 /* See target_terminal::inferior. */
454 if (m_terminal_state
== target_terminal_state::is_ours
)
457 target_terminal_is_ours_kind (target_terminal_state::is_ours
);
458 m_terminal_state
= target_terminal_state::is_ours
;
461 /* See target/target.h. */
464 target_terminal::ours_for_output ()
466 struct ui
*ui
= current_ui
;
468 /* See target_terminal::inferior. */
472 if (!target_terminal::is_inferior ())
475 target_terminal_is_ours_kind (target_terminal_state::is_ours_for_output
);
476 target_terminal::m_terminal_state
= target_terminal_state::is_ours_for_output
;
479 /* See target/target.h. */
482 target_terminal::info (const char *arg
, int from_tty
)
484 current_top_target ()->terminal_info (arg
, from_tty
);
490 target_supports_terminal_ours (void)
492 /* The current top target is the target at the top of the target
493 stack of the current inferior. While normally there's always an
494 inferior, we must check for nullptr here because we can get here
495 very early during startup, before the initial inferior is first
497 inferior
*inf
= current_inferior ();
501 return inf
->top_target ()->supports_terminal_ours ();
507 error (_("You can't do that when your target is `%s'"),
508 current_top_target ()->shortname ());
514 error (_("You can't do that without a process to debug."));
518 default_terminal_info (struct target_ops
*self
, const char *args
, int from_tty
)
520 printf_unfiltered (_("No saved terminal information.\n"));
523 /* A default implementation for the to_get_ada_task_ptid target method.
525 This function builds the PTID by using both LWP and TID as part of
526 the PTID lwp and tid elements. The pid used is the pid of the
530 default_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long tid
)
532 return ptid_t (inferior_ptid
.pid (), lwp
, tid
);
535 static enum exec_direction_kind
536 default_execution_direction (struct target_ops
*self
)
538 if (!target_can_execute_reverse
)
540 else if (!target_can_async_p ())
543 gdb_assert_not_reached ("\
544 to_execution_direction must be implemented for reverse async");
550 decref_target (target_ops
*t
)
553 if (t
->refcount () == 0)
555 if (t
->stratum () == process_stratum
)
556 connection_list_remove (as_process_stratum_target (t
));
564 target_stack::push (target_ops
*t
)
568 strata stratum
= t
->stratum ();
570 if (stratum
== process_stratum
)
571 connection_list_add (as_process_stratum_target (t
));
573 /* If there's already a target at this stratum, remove it. */
575 if (m_stack
[stratum
] != NULL
)
576 unpush (m_stack
[stratum
]);
578 /* Now add the new one. */
579 m_stack
[stratum
] = t
;
588 push_target (struct target_ops
*t
)
590 current_inferior ()->push_target (t
);
596 push_target (target_ops_up
&&t
)
598 current_inferior ()->push_target (t
.get ());
605 unpush_target (struct target_ops
*t
)
607 return current_inferior ()->unpush_target (t
);
613 target_stack::unpush (target_ops
*t
)
615 gdb_assert (t
!= NULL
);
617 strata stratum
= t
->stratum ();
619 if (stratum
== dummy_stratum
)
620 internal_error (__FILE__
, __LINE__
,
621 _("Attempt to unpush the dummy target"));
623 /* Look for the specified target. Note that a target can only occur
624 once in the target stack. */
626 if (m_stack
[stratum
] != t
)
628 /* If T wasn't pushed, quit. Only open targets should be
633 /* Unchain the target. */
634 m_stack
[stratum
] = NULL
;
636 if (m_top
== stratum
)
637 m_top
= t
->beneath ()->stratum ();
639 /* Finally close the target, if there are no inferiors
640 referencing this target still. Note we do this after unchaining,
641 so any target method calls from within the target_close
642 implementation don't end up in T anymore. Do leave the target
643 open if we have are other inferiors referencing this target
650 /* Unpush TARGET and assert that it worked. */
653 unpush_target_and_assert (struct target_ops
*target
)
655 if (!unpush_target (target
))
657 fprintf_unfiltered (gdb_stderr
,
658 "pop_all_targets couldn't find target %s\n",
659 target
->shortname ());
660 internal_error (__FILE__
, __LINE__
,
661 _("failed internal consistency check"));
666 pop_all_targets_above (enum strata above_stratum
)
668 while ((int) (current_top_target ()->stratum ()) > (int) above_stratum
)
669 unpush_target_and_assert (current_top_target ());
675 pop_all_targets_at_and_above (enum strata stratum
)
677 while ((int) (current_top_target ()->stratum ()) >= (int) stratum
)
678 unpush_target_and_assert (current_top_target ());
682 pop_all_targets (void)
684 pop_all_targets_above (dummy_stratum
);
687 /* Return true if T is now pushed in the current inferior's target
688 stack. Return false otherwise. */
691 target_is_pushed (target_ops
*t
)
693 return current_inferior ()->target_is_pushed (t
);
696 /* Default implementation of to_get_thread_local_address. */
699 generic_tls_error (void)
701 throw_error (TLS_GENERIC_ERROR
,
702 _("Cannot find thread-local variables on this target"));
705 /* Using the objfile specified in OBJFILE, find the address for the
706 current thread's thread-local storage with offset OFFSET. */
708 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
710 volatile CORE_ADDR addr
= 0;
711 struct target_ops
*target
= current_top_target ();
712 struct gdbarch
*gdbarch
= target_gdbarch ();
714 if (gdbarch_fetch_tls_load_module_address_p (gdbarch
))
716 ptid_t ptid
= inferior_ptid
;
722 /* Fetch the load module address for this objfile. */
723 lm_addr
= gdbarch_fetch_tls_load_module_address (gdbarch
,
726 if (gdbarch_get_thread_local_address_p (gdbarch
))
727 addr
= gdbarch_get_thread_local_address (gdbarch
, ptid
, lm_addr
,
730 addr
= target
->get_thread_local_address (ptid
, lm_addr
, offset
);
732 /* If an error occurred, print TLS related messages here. Otherwise,
733 throw the error to some higher catcher. */
734 catch (const gdb_exception
&ex
)
736 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
740 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
741 error (_("Cannot find thread-local variables "
742 "in this thread library."));
744 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
745 if (objfile_is_library
)
746 error (_("Cannot find shared library `%s' in dynamic"
747 " linker's load module list"), objfile_name (objfile
));
749 error (_("Cannot find executable file `%s' in dynamic"
750 " linker's load module list"), objfile_name (objfile
));
752 case TLS_NOT_ALLOCATED_YET_ERROR
:
753 if (objfile_is_library
)
754 error (_("The inferior has not yet allocated storage for"
755 " thread-local variables in\n"
756 "the shared library `%s'\n"
758 objfile_name (objfile
),
759 target_pid_to_str (ptid
).c_str ());
761 error (_("The inferior has not yet allocated storage for"
762 " thread-local variables in\n"
763 "the executable `%s'\n"
765 objfile_name (objfile
),
766 target_pid_to_str (ptid
).c_str ());
768 case TLS_GENERIC_ERROR
:
769 if (objfile_is_library
)
770 error (_("Cannot find thread-local storage for %s, "
771 "shared library %s:\n%s"),
772 target_pid_to_str (ptid
).c_str (),
773 objfile_name (objfile
), ex
.what ());
775 error (_("Cannot find thread-local storage for %s, "
776 "executable file %s:\n%s"),
777 target_pid_to_str (ptid
).c_str (),
778 objfile_name (objfile
), ex
.what ());
787 error (_("Cannot find thread-local variables on this target"));
793 target_xfer_status_to_string (enum target_xfer_status status
)
795 #define CASE(X) case X: return #X
798 CASE(TARGET_XFER_E_IO
);
799 CASE(TARGET_XFER_UNAVAILABLE
);
809 gdb::unique_xmalloc_ptr
<char>
810 target_read_string (CORE_ADDR memaddr
, int len
, int *bytes_read
)
812 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
;
815 if (bytes_read
== nullptr)
816 bytes_read
= &ignore
;
818 /* Note that the endian-ness does not matter here. */
819 int errcode
= read_string (memaddr
, -1, 1, len
, BFD_ENDIAN_LITTLE
,
820 &buffer
, bytes_read
);
824 return gdb::unique_xmalloc_ptr
<char> ((char *) buffer
.release ());
827 struct target_section_table
*
828 target_get_section_table (struct target_ops
*target
)
830 return target
->get_section_table ();
833 /* Find a section containing ADDR. */
835 struct target_section
*
836 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
838 struct target_section_table
*table
= target_get_section_table (target
);
839 struct target_section
*secp
;
844 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
846 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
853 /* Helper for the memory xfer routines. Checks the attributes of the
854 memory region of MEMADDR against the read or write being attempted.
855 If the access is permitted returns true, otherwise returns false.
856 REGION_P is an optional output parameter. If not-NULL, it is
857 filled with a pointer to the memory region of MEMADDR. REG_LEN
858 returns LEN trimmed to the end of the region. This is how much the
859 caller can continue requesting, if the access is permitted. A
860 single xfer request must not straddle memory region boundaries. */
863 memory_xfer_check_region (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
864 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*reg_len
,
865 struct mem_region
**region_p
)
867 struct mem_region
*region
;
869 region
= lookup_mem_region (memaddr
);
871 if (region_p
!= NULL
)
874 switch (region
->attrib
.mode
)
877 if (writebuf
!= NULL
)
887 /* We only support writing to flash during "load" for now. */
888 if (writebuf
!= NULL
)
889 error (_("Writing to flash memory forbidden in this context"));
896 /* region->hi == 0 means there's no upper bound. */
897 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
900 *reg_len
= region
->hi
- memaddr
;
905 /* Read memory from more than one valid target. A core file, for
906 instance, could have some of memory but delegate other bits to
907 the target below it. So, we must manually try all targets. */
909 enum target_xfer_status
910 raw_memory_xfer_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
911 const gdb_byte
*writebuf
, ULONGEST memaddr
, LONGEST len
,
912 ULONGEST
*xfered_len
)
914 enum target_xfer_status res
;
918 res
= ops
->xfer_partial (TARGET_OBJECT_MEMORY
, NULL
,
919 readbuf
, writebuf
, memaddr
, len
,
921 if (res
== TARGET_XFER_OK
)
924 /* Stop if the target reports that the memory is not available. */
925 if (res
== TARGET_XFER_UNAVAILABLE
)
928 /* We want to continue past core files to executables, but not
929 past a running target's memory. */
930 if (ops
->has_all_memory ())
933 ops
= ops
->beneath ();
937 /* The cache works at the raw memory level. Make sure the cache
938 gets updated with raw contents no matter what kind of memory
939 object was originally being written. Note we do write-through
940 first, so that if it fails, we don't write to the cache contents
941 that never made it to the target. */
943 && inferior_ptid
!= null_ptid
944 && target_dcache_init_p ()
945 && (stack_cache_enabled_p () || code_cache_enabled_p ()))
947 DCACHE
*dcache
= target_dcache_get ();
949 /* Note that writing to an area of memory which wasn't present
950 in the cache doesn't cause it to be loaded in. */
951 dcache_update (dcache
, res
, memaddr
, writebuf
, *xfered_len
);
957 /* Perform a partial memory transfer.
958 For docs see target.h, to_xfer_partial. */
960 static enum target_xfer_status
961 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
962 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
963 ULONGEST len
, ULONGEST
*xfered_len
)
965 enum target_xfer_status res
;
967 struct mem_region
*region
;
968 struct inferior
*inf
;
970 /* For accesses to unmapped overlay sections, read directly from
971 files. Must do this first, as MEMADDR may need adjustment. */
972 if (readbuf
!= NULL
&& overlay_debugging
)
974 struct obj_section
*section
= find_pc_overlay (memaddr
);
976 if (pc_in_unmapped_range (memaddr
, section
))
978 struct target_section_table
*table
979 = target_get_section_table (ops
);
980 const char *section_name
= section
->the_bfd_section
->name
;
982 memaddr
= overlay_mapped_address (memaddr
, section
);
983 return section_table_xfer_memory_partial (readbuf
, writebuf
,
984 memaddr
, len
, xfered_len
,
991 /* Try the executable files, if "trust-readonly-sections" is set. */
992 if (readbuf
!= NULL
&& trust_readonly
)
994 struct target_section
*secp
;
995 struct target_section_table
*table
;
997 secp
= target_section_by_addr (ops
, memaddr
);
999 && (bfd_section_flags (secp
->the_bfd_section
) & SEC_READONLY
))
1001 table
= target_get_section_table (ops
);
1002 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1003 memaddr
, len
, xfered_len
,
1005 table
->sections_end
,
1010 /* Try GDB's internal data cache. */
1012 if (!memory_xfer_check_region (readbuf
, writebuf
, memaddr
, len
, ®_len
,
1014 return TARGET_XFER_E_IO
;
1016 if (inferior_ptid
!= null_ptid
)
1017 inf
= current_inferior ();
1023 /* The dcache reads whole cache lines; that doesn't play well
1024 with reading from a trace buffer, because reading outside of
1025 the collected memory range fails. */
1026 && get_traceframe_number () == -1
1027 && (region
->attrib
.cache
1028 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1029 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1031 DCACHE
*dcache
= target_dcache_get_or_init ();
1033 return dcache_read_memory_partial (ops
, dcache
, memaddr
, readbuf
,
1034 reg_len
, xfered_len
);
1037 /* If none of those methods found the memory we wanted, fall back
1038 to a target partial transfer. Normally a single call to
1039 to_xfer_partial is enough; if it doesn't recognize an object
1040 it will call the to_xfer_partial of the next target down.
1041 But for memory this won't do. Memory is the only target
1042 object which can be read from more than one valid target.
1043 A core file, for instance, could have some of memory but
1044 delegate other bits to the target below it. So, we must
1045 manually try all targets. */
1047 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
,
1050 /* If we still haven't got anything, return the last error. We
1055 /* Perform a partial memory transfer. For docs see target.h,
1058 static enum target_xfer_status
1059 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1060 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1061 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1063 enum target_xfer_status res
;
1065 /* Zero length requests are ok and require no work. */
1067 return TARGET_XFER_EOF
;
1069 memaddr
= address_significant (target_gdbarch (), memaddr
);
1071 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1072 breakpoint insns, thus hiding out from higher layers whether
1073 there are software breakpoints inserted in the code stream. */
1074 if (readbuf
!= NULL
)
1076 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
,
1079 if (res
== TARGET_XFER_OK
&& !show_memory_breakpoints
)
1080 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, *xfered_len
);
1084 /* A large write request is likely to be partially satisfied
1085 by memory_xfer_partial_1. We will continually malloc
1086 and free a copy of the entire write request for breakpoint
1087 shadow handling even though we only end up writing a small
1088 subset of it. Cap writes to a limit specified by the target
1089 to mitigate this. */
1090 len
= std::min (ops
->get_memory_xfer_limit (), len
);
1092 gdb::byte_vector
buf (writebuf
, writebuf
+ len
);
1093 breakpoint_xfer_memory (NULL
, buf
.data (), writebuf
, memaddr
, len
);
1094 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
.data (), memaddr
, len
,
1101 scoped_restore_tmpl
<int>
1102 make_scoped_restore_show_memory_breakpoints (int show
)
1104 return make_scoped_restore (&show_memory_breakpoints
, show
);
1107 /* For docs see target.h, to_xfer_partial. */
1109 enum target_xfer_status
1110 target_xfer_partial (struct target_ops
*ops
,
1111 enum target_object object
, const char *annex
,
1112 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1113 ULONGEST offset
, ULONGEST len
,
1114 ULONGEST
*xfered_len
)
1116 enum target_xfer_status retval
;
1118 /* Transfer is done when LEN is zero. */
1120 return TARGET_XFER_EOF
;
1122 if (writebuf
&& !may_write_memory
)
1123 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1124 core_addr_to_string_nz (offset
), plongest (len
));
1128 /* If this is a memory transfer, let the memory-specific code
1129 have a look at it instead. Memory transfers are more
1131 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1132 || object
== TARGET_OBJECT_CODE_MEMORY
)
1133 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1134 writebuf
, offset
, len
, xfered_len
);
1135 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1137 /* Skip/avoid accessing the target if the memory region
1138 attributes block the access. Check this here instead of in
1139 raw_memory_xfer_partial as otherwise we'd end up checking
1140 this twice in the case of the memory_xfer_partial path is
1141 taken; once before checking the dcache, and another in the
1142 tail call to raw_memory_xfer_partial. */
1143 if (!memory_xfer_check_region (readbuf
, writebuf
, offset
, len
, &len
,
1145 return TARGET_XFER_E_IO
;
1147 /* Request the normal memory object from other layers. */
1148 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
,
1152 retval
= ops
->xfer_partial (object
, annex
, readbuf
,
1153 writebuf
, offset
, len
, xfered_len
);
1157 const unsigned char *myaddr
= NULL
;
1159 fprintf_unfiltered (gdb_stdlog
,
1160 "%s:target_xfer_partial "
1161 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1164 (annex
? annex
: "(null)"),
1165 host_address_to_string (readbuf
),
1166 host_address_to_string (writebuf
),
1167 core_addr_to_string_nz (offset
),
1168 pulongest (len
), retval
,
1169 pulongest (*xfered_len
));
1175 if (retval
== TARGET_XFER_OK
&& myaddr
!= NULL
)
1179 fputs_unfiltered (", bytes =", gdb_stdlog
);
1180 for (i
= 0; i
< *xfered_len
; i
++)
1182 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1184 if (targetdebug
< 2 && i
> 0)
1186 fprintf_unfiltered (gdb_stdlog
, " ...");
1189 fprintf_unfiltered (gdb_stdlog
, "\n");
1192 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1196 fputc_unfiltered ('\n', gdb_stdlog
);
1199 /* Check implementations of to_xfer_partial update *XFERED_LEN
1200 properly. Do assertion after printing debug messages, so that we
1201 can find more clues on assertion failure from debugging messages. */
1202 if (retval
== TARGET_XFER_OK
|| retval
== TARGET_XFER_UNAVAILABLE
)
1203 gdb_assert (*xfered_len
> 0);
1208 /* Read LEN bytes of target memory at address MEMADDR, placing the
1209 results in GDB's memory at MYADDR. Returns either 0 for success or
1210 -1 if any error occurs.
1212 If an error occurs, no guarantee is made about the contents of the data at
1213 MYADDR. In particular, the caller should not depend upon partial reads
1214 filling the buffer with good data. There is no way for the caller to know
1215 how much good data might have been transfered anyway. Callers that can
1216 deal with partial reads should call target_read (which will retry until
1217 it makes no progress, and then return how much was transferred). */
1220 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1222 if (target_read (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1223 myaddr
, memaddr
, len
) == len
)
1229 /* See target/target.h. */
1232 target_read_uint32 (CORE_ADDR memaddr
, uint32_t *result
)
1237 r
= target_read_memory (memaddr
, buf
, sizeof buf
);
1240 *result
= extract_unsigned_integer (buf
, sizeof buf
,
1241 gdbarch_byte_order (target_gdbarch ()));
1245 /* Like target_read_memory, but specify explicitly that this is a read
1246 from the target's raw memory. That is, this read bypasses the
1247 dcache, breakpoint shadowing, etc. */
1250 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1252 if (target_read (current_top_target (), TARGET_OBJECT_RAW_MEMORY
, NULL
,
1253 myaddr
, memaddr
, len
) == len
)
1259 /* Like target_read_memory, but specify explicitly that this is a read from
1260 the target's stack. This may trigger different cache behavior. */
1263 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1265 if (target_read (current_top_target (), TARGET_OBJECT_STACK_MEMORY
, NULL
,
1266 myaddr
, memaddr
, len
) == len
)
1272 /* Like target_read_memory, but specify explicitly that this is a read from
1273 the target's code. This may trigger different cache behavior. */
1276 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1278 if (target_read (current_top_target (), TARGET_OBJECT_CODE_MEMORY
, NULL
,
1279 myaddr
, memaddr
, len
) == len
)
1285 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1286 Returns either 0 for success or -1 if any error occurs. If an
1287 error occurs, no guarantee is made about how much data got written.
1288 Callers that can deal with partial writes should call
1292 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1294 if (target_write (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1295 myaddr
, memaddr
, len
) == len
)
1301 /* Write LEN bytes from MYADDR to target raw memory at address
1302 MEMADDR. Returns either 0 for success or -1 if any error occurs.
1303 If an error occurs, no guarantee is made about how much data got
1304 written. Callers that can deal with partial writes should call
1308 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1310 if (target_write (current_top_target (), TARGET_OBJECT_RAW_MEMORY
, NULL
,
1311 myaddr
, memaddr
, len
) == len
)
1317 /* Fetch the target's memory map. */
1319 std::vector
<mem_region
>
1320 target_memory_map (void)
1322 std::vector
<mem_region
> result
= current_top_target ()->memory_map ();
1323 if (result
.empty ())
1326 std::sort (result
.begin (), result
.end ());
1328 /* Check that regions do not overlap. Simultaneously assign
1329 a numbering for the "mem" commands to use to refer to
1331 mem_region
*last_one
= NULL
;
1332 for (size_t ix
= 0; ix
< result
.size (); ix
++)
1334 mem_region
*this_one
= &result
[ix
];
1335 this_one
->number
= ix
;
1337 if (last_one
!= NULL
&& last_one
->hi
> this_one
->lo
)
1339 warning (_("Overlapping regions in memory map: ignoring"));
1340 return std::vector
<mem_region
> ();
1343 last_one
= this_one
;
1350 target_flash_erase (ULONGEST address
, LONGEST length
)
1352 current_top_target ()->flash_erase (address
, length
);
1356 target_flash_done (void)
1358 current_top_target ()->flash_done ();
1362 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1363 struct cmd_list_element
*c
, const char *value
)
1365 fprintf_filtered (file
,
1366 _("Mode for reading from readonly sections is %s.\n"),
1370 /* Target vector read/write partial wrapper functions. */
1372 static enum target_xfer_status
1373 target_read_partial (struct target_ops
*ops
,
1374 enum target_object object
,
1375 const char *annex
, gdb_byte
*buf
,
1376 ULONGEST offset
, ULONGEST len
,
1377 ULONGEST
*xfered_len
)
1379 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
,
1383 static enum target_xfer_status
1384 target_write_partial (struct target_ops
*ops
,
1385 enum target_object object
,
1386 const char *annex
, const gdb_byte
*buf
,
1387 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
1389 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
,
1393 /* Wrappers to perform the full transfer. */
1395 /* For docs on target_read see target.h. */
1398 target_read (struct target_ops
*ops
,
1399 enum target_object object
,
1400 const char *annex
, gdb_byte
*buf
,
1401 ULONGEST offset
, LONGEST len
)
1403 LONGEST xfered_total
= 0;
1406 /* If we are reading from a memory object, find the length of an addressable
1407 unit for that architecture. */
1408 if (object
== TARGET_OBJECT_MEMORY
1409 || object
== TARGET_OBJECT_STACK_MEMORY
1410 || object
== TARGET_OBJECT_CODE_MEMORY
1411 || object
== TARGET_OBJECT_RAW_MEMORY
)
1412 unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
1414 while (xfered_total
< len
)
1416 ULONGEST xfered_partial
;
1417 enum target_xfer_status status
;
1419 status
= target_read_partial (ops
, object
, annex
,
1420 buf
+ xfered_total
* unit_size
,
1421 offset
+ xfered_total
, len
- xfered_total
,
1424 /* Call an observer, notifying them of the xfer progress? */
1425 if (status
== TARGET_XFER_EOF
)
1426 return xfered_total
;
1427 else if (status
== TARGET_XFER_OK
)
1429 xfered_total
+= xfered_partial
;
1433 return TARGET_XFER_E_IO
;
1439 /* Assuming that the entire [begin, end) range of memory cannot be
1440 read, try to read whatever subrange is possible to read.
1442 The function returns, in RESULT, either zero or one memory block.
1443 If there's a readable subrange at the beginning, it is completely
1444 read and returned. Any further readable subrange will not be read.
1445 Otherwise, if there's a readable subrange at the end, it will be
1446 completely read and returned. Any readable subranges before it
1447 (obviously, not starting at the beginning), will be ignored. In
1448 other cases -- either no readable subrange, or readable subrange(s)
1449 that is neither at the beginning, or end, nothing is returned.
1451 The purpose of this function is to handle a read across a boundary
1452 of accessible memory in a case when memory map is not available.
1453 The above restrictions are fine for this case, but will give
1454 incorrect results if the memory is 'patchy'. However, supporting
1455 'patchy' memory would require trying to read every single byte,
1456 and it seems unacceptable solution. Explicit memory map is
1457 recommended for this case -- and target_read_memory_robust will
1458 take care of reading multiple ranges then. */
1461 read_whatever_is_readable (struct target_ops
*ops
,
1462 const ULONGEST begin
, const ULONGEST end
,
1464 std::vector
<memory_read_result
> *result
)
1466 ULONGEST current_begin
= begin
;
1467 ULONGEST current_end
= end
;
1469 ULONGEST xfered_len
;
1471 /* If we previously failed to read 1 byte, nothing can be done here. */
1472 if (end
- begin
<= 1)
1475 gdb::unique_xmalloc_ptr
<gdb_byte
> buf ((gdb_byte
*) xmalloc (end
- begin
));
1477 /* Check that either first or the last byte is readable, and give up
1478 if not. This heuristic is meant to permit reading accessible memory
1479 at the boundary of accessible region. */
1480 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1481 buf
.get (), begin
, 1, &xfered_len
) == TARGET_XFER_OK
)
1486 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1487 buf
.get () + (end
- begin
) - 1, end
- 1, 1,
1488 &xfered_len
) == TARGET_XFER_OK
)
1496 /* Loop invariant is that the [current_begin, current_end) was previously
1497 found to be not readable as a whole.
1499 Note loop condition -- if the range has 1 byte, we can't divide the range
1500 so there's no point trying further. */
1501 while (current_end
- current_begin
> 1)
1503 ULONGEST first_half_begin
, first_half_end
;
1504 ULONGEST second_half_begin
, second_half_end
;
1506 ULONGEST middle
= current_begin
+ (current_end
- current_begin
) / 2;
1510 first_half_begin
= current_begin
;
1511 first_half_end
= middle
;
1512 second_half_begin
= middle
;
1513 second_half_end
= current_end
;
1517 first_half_begin
= middle
;
1518 first_half_end
= current_end
;
1519 second_half_begin
= current_begin
;
1520 second_half_end
= middle
;
1523 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1524 buf
.get () + (first_half_begin
- begin
) * unit_size
,
1526 first_half_end
- first_half_begin
);
1528 if (xfer
== first_half_end
- first_half_begin
)
1530 /* This half reads up fine. So, the error must be in the
1532 current_begin
= second_half_begin
;
1533 current_end
= second_half_end
;
1537 /* This half is not readable. Because we've tried one byte, we
1538 know some part of this half if actually readable. Go to the next
1539 iteration to divide again and try to read.
1541 We don't handle the other half, because this function only tries
1542 to read a single readable subrange. */
1543 current_begin
= first_half_begin
;
1544 current_end
= first_half_end
;
1550 /* The [begin, current_begin) range has been read. */
1551 result
->emplace_back (begin
, current_end
, std::move (buf
));
1555 /* The [current_end, end) range has been read. */
1556 LONGEST region_len
= end
- current_end
;
1558 gdb::unique_xmalloc_ptr
<gdb_byte
> data
1559 ((gdb_byte
*) xmalloc (region_len
* unit_size
));
1560 memcpy (data
.get (), buf
.get () + (current_end
- begin
) * unit_size
,
1561 region_len
* unit_size
);
1562 result
->emplace_back (current_end
, end
, std::move (data
));
1566 std::vector
<memory_read_result
>
1567 read_memory_robust (struct target_ops
*ops
,
1568 const ULONGEST offset
, const LONGEST len
)
1570 std::vector
<memory_read_result
> result
;
1571 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
1573 LONGEST xfered_total
= 0;
1574 while (xfered_total
< len
)
1576 struct mem_region
*region
= lookup_mem_region (offset
+ xfered_total
);
1579 /* If there is no explicit region, a fake one should be created. */
1580 gdb_assert (region
);
1582 if (region
->hi
== 0)
1583 region_len
= len
- xfered_total
;
1585 region_len
= region
->hi
- offset
;
1587 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
1589 /* Cannot read this region. Note that we can end up here only
1590 if the region is explicitly marked inaccessible, or
1591 'inaccessible-by-default' is in effect. */
1592 xfered_total
+= region_len
;
1596 LONGEST to_read
= std::min (len
- xfered_total
, region_len
);
1597 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
1598 ((gdb_byte
*) xmalloc (to_read
* unit_size
));
1600 LONGEST xfered_partial
=
1601 target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buffer
.get (),
1602 offset
+ xfered_total
, to_read
);
1603 /* Call an observer, notifying them of the xfer progress? */
1604 if (xfered_partial
<= 0)
1606 /* Got an error reading full chunk. See if maybe we can read
1608 read_whatever_is_readable (ops
, offset
+ xfered_total
,
1609 offset
+ xfered_total
+ to_read
,
1610 unit_size
, &result
);
1611 xfered_total
+= to_read
;
1615 result
.emplace_back (offset
+ xfered_total
,
1616 offset
+ xfered_total
+ xfered_partial
,
1617 std::move (buffer
));
1618 xfered_total
+= xfered_partial
;
1628 /* An alternative to target_write with progress callbacks. */
1631 target_write_with_progress (struct target_ops
*ops
,
1632 enum target_object object
,
1633 const char *annex
, const gdb_byte
*buf
,
1634 ULONGEST offset
, LONGEST len
,
1635 void (*progress
) (ULONGEST
, void *), void *baton
)
1637 LONGEST xfered_total
= 0;
1640 /* If we are writing to a memory object, find the length of an addressable
1641 unit for that architecture. */
1642 if (object
== TARGET_OBJECT_MEMORY
1643 || object
== TARGET_OBJECT_STACK_MEMORY
1644 || object
== TARGET_OBJECT_CODE_MEMORY
1645 || object
== TARGET_OBJECT_RAW_MEMORY
)
1646 unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
1648 /* Give the progress callback a chance to set up. */
1650 (*progress
) (0, baton
);
1652 while (xfered_total
< len
)
1654 ULONGEST xfered_partial
;
1655 enum target_xfer_status status
;
1657 status
= target_write_partial (ops
, object
, annex
,
1658 buf
+ xfered_total
* unit_size
,
1659 offset
+ xfered_total
, len
- xfered_total
,
1662 if (status
!= TARGET_XFER_OK
)
1663 return status
== TARGET_XFER_EOF
? xfered_total
: TARGET_XFER_E_IO
;
1666 (*progress
) (xfered_partial
, baton
);
1668 xfered_total
+= xfered_partial
;
1674 /* For docs on target_write see target.h. */
1677 target_write (struct target_ops
*ops
,
1678 enum target_object object
,
1679 const char *annex
, const gdb_byte
*buf
,
1680 ULONGEST offset
, LONGEST len
)
1682 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1686 /* Help for target_read_alloc and target_read_stralloc. See their comments
1689 template <typename T
>
1690 gdb::optional
<gdb::def_vector
<T
>>
1691 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1694 gdb::def_vector
<T
> buf
;
1696 const int chunk
= 4096;
1698 /* This function does not have a length parameter; it reads the
1699 entire OBJECT). Also, it doesn't support objects fetched partly
1700 from one target and partly from another (in a different stratum,
1701 e.g. a core file and an executable). Both reasons make it
1702 unsuitable for reading memory. */
1703 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1705 /* Start by reading up to 4K at a time. The target will throttle
1706 this number down if necessary. */
1709 ULONGEST xfered_len
;
1710 enum target_xfer_status status
;
1712 buf
.resize (buf_pos
+ chunk
);
1714 status
= target_read_partial (ops
, object
, annex
,
1715 (gdb_byte
*) &buf
[buf_pos
],
1719 if (status
== TARGET_XFER_EOF
)
1721 /* Read all there was. */
1722 buf
.resize (buf_pos
);
1725 else if (status
!= TARGET_XFER_OK
)
1727 /* An error occurred. */
1731 buf_pos
+= xfered_len
;
1739 gdb::optional
<gdb::byte_vector
>
1740 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1743 return target_read_alloc_1
<gdb_byte
> (ops
, object
, annex
);
1748 gdb::optional
<gdb::char_vector
>
1749 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1752 gdb::optional
<gdb::char_vector
> buf
1753 = target_read_alloc_1
<char> (ops
, object
, annex
);
1758 if (buf
->empty () || buf
->back () != '\0')
1759 buf
->push_back ('\0');
1761 /* Check for embedded NUL bytes; but allow trailing NULs. */
1762 for (auto it
= std::find (buf
->begin (), buf
->end (), '\0');
1763 it
!= buf
->end (); it
++)
1766 warning (_("target object %d, annex %s, "
1767 "contained unexpected null characters"),
1768 (int) object
, annex
? annex
: "(none)");
1775 /* Memory transfer methods. */
1778 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1781 /* This method is used to read from an alternate, non-current
1782 target. This read must bypass the overlay support (as symbols
1783 don't match this target), and GDB's internal cache (wrong cache
1784 for this target). */
1785 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
1787 memory_error (TARGET_XFER_E_IO
, addr
);
1791 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
1792 int len
, enum bfd_endian byte_order
)
1794 gdb_byte buf
[sizeof (ULONGEST
)];
1796 gdb_assert (len
<= sizeof (buf
));
1797 get_target_memory (ops
, addr
, buf
, len
);
1798 return extract_unsigned_integer (buf
, len
, byte_order
);
1804 target_insert_breakpoint (struct gdbarch
*gdbarch
,
1805 struct bp_target_info
*bp_tgt
)
1807 if (!may_insert_breakpoints
)
1809 warning (_("May not insert breakpoints"));
1813 return current_top_target ()->insert_breakpoint (gdbarch
, bp_tgt
);
1819 target_remove_breakpoint (struct gdbarch
*gdbarch
,
1820 struct bp_target_info
*bp_tgt
,
1821 enum remove_bp_reason reason
)
1823 /* This is kind of a weird case to handle, but the permission might
1824 have been changed after breakpoints were inserted - in which case
1825 we should just take the user literally and assume that any
1826 breakpoints should be left in place. */
1827 if (!may_insert_breakpoints
)
1829 warning (_("May not remove breakpoints"));
1833 return current_top_target ()->remove_breakpoint (gdbarch
, bp_tgt
, reason
);
1837 info_target_command (const char *args
, int from_tty
)
1839 int has_all_mem
= 0;
1841 if (symfile_objfile
!= NULL
)
1842 printf_unfiltered (_("Symbols from \"%s\".\n"),
1843 objfile_name (symfile_objfile
));
1845 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
1847 if (!t
->has_memory ())
1850 if ((int) (t
->stratum ()) <= (int) dummy_stratum
)
1853 printf_unfiltered (_("\tWhile running this, "
1854 "GDB does not access memory from...\n"));
1855 printf_unfiltered ("%s:\n", t
->longname ());
1857 has_all_mem
= t
->has_all_memory ();
1861 /* This function is called before any new inferior is created, e.g.
1862 by running a program, attaching, or connecting to a target.
1863 It cleans up any state from previous invocations which might
1864 change between runs. This is a subset of what target_preopen
1865 resets (things which might change between targets). */
1868 target_pre_inferior (int from_tty
)
1870 /* Clear out solib state. Otherwise the solib state of the previous
1871 inferior might have survived and is entirely wrong for the new
1872 target. This has been observed on GNU/Linux using glibc 2.3. How
1884 Cannot access memory at address 0xdeadbeef
1887 /* In some OSs, the shared library list is the same/global/shared
1888 across inferiors. If code is shared between processes, so are
1889 memory regions and features. */
1890 if (!gdbarch_has_global_solist (target_gdbarch ()))
1892 no_shared_libraries (NULL
, from_tty
);
1894 invalidate_target_mem_regions ();
1896 target_clear_description ();
1899 /* attach_flag may be set if the previous process associated with
1900 the inferior was attached to. */
1901 current_inferior ()->attach_flag
= 0;
1903 current_inferior ()->highest_thread_num
= 0;
1905 agent_capability_invalidate ();
1908 /* This is to be called by the open routine before it does
1912 target_preopen (int from_tty
)
1916 if (current_inferior ()->pid
!= 0)
1919 || !target_has_execution
1920 || query (_("A program is being debugged already. Kill it? ")))
1922 /* Core inferiors actually should be detached, not
1924 if (target_has_execution
)
1927 target_detach (current_inferior (), 0);
1930 error (_("Program not killed."));
1933 /* Calling target_kill may remove the target from the stack. But if
1934 it doesn't (which seems like a win for UDI), remove it now. */
1935 /* Leave the exec target, though. The user may be switching from a
1936 live process to a core of the same program. */
1937 pop_all_targets_above (file_stratum
);
1939 target_pre_inferior (from_tty
);
1945 target_detach (inferior
*inf
, int from_tty
)
1947 /* After we have detached, we will clear the register cache for this inferior
1948 by calling registers_changed_ptid. We must save the pid_ptid before
1949 detaching, as the target detach method will clear inf->pid. */
1950 ptid_t save_pid_ptid
= ptid_t (inf
->pid
);
1952 /* As long as some to_detach implementations rely on the current_inferior
1953 (either directly, or indirectly, like through target_gdbarch or by
1954 reading memory), INF needs to be the current inferior. When that
1955 requirement will become no longer true, then we can remove this
1957 gdb_assert (inf
== current_inferior ());
1959 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
1960 /* Don't remove global breakpoints here. They're removed on
1961 disconnection from the target. */
1964 /* If we're in breakpoints-always-inserted mode, have to remove
1965 breakpoints before detaching. */
1966 remove_breakpoints_inf (current_inferior ());
1968 prepare_for_detach ();
1970 /* Hold a strong reference because detaching may unpush the
1972 auto proc_target_ref
= target_ops_ref::new_reference (inf
->process_target ());
1974 current_top_target ()->detach (inf
, from_tty
);
1976 process_stratum_target
*proc_target
1977 = as_process_stratum_target (proc_target_ref
.get ());
1979 registers_changed_ptid (proc_target
, save_pid_ptid
);
1981 /* We have to ensure we have no frame cache left. Normally,
1982 registers_changed_ptid (save_pid_ptid) calls reinit_frame_cache when
1983 inferior_ptid matches save_pid_ptid, but in our case, it does not
1984 call it, as inferior_ptid has been reset. */
1985 reinit_frame_cache ();
1989 target_disconnect (const char *args
, int from_tty
)
1991 /* If we're in breakpoints-always-inserted mode or if breakpoints
1992 are global across processes, we have to remove them before
1994 remove_breakpoints ();
1996 current_top_target ()->disconnect (args
, from_tty
);
1999 /* See target/target.h. */
2002 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2004 return current_top_target ()->wait (ptid
, status
, options
);
2010 default_target_wait (struct target_ops
*ops
,
2011 ptid_t ptid
, struct target_waitstatus
*status
,
2014 status
->kind
= TARGET_WAITKIND_IGNORE
;
2015 return minus_one_ptid
;
2019 target_pid_to_str (ptid_t ptid
)
2021 return current_top_target ()->pid_to_str (ptid
);
2025 target_thread_name (struct thread_info
*info
)
2027 gdb_assert (info
->inf
== current_inferior ());
2029 return current_top_target ()->thread_name (info
);
2032 struct thread_info
*
2033 target_thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
2035 struct inferior
*inf
)
2037 return current_top_target ()->thread_handle_to_thread_info (thread_handle
,
2044 target_thread_info_to_thread_handle (struct thread_info
*tip
)
2046 return current_top_target ()->thread_info_to_thread_handle (tip
);
2050 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2052 process_stratum_target
*curr_target
= current_inferior ()->process_target ();
2054 target_dcache_invalidate ();
2056 current_top_target ()->resume (ptid
, step
, signal
);
2058 registers_changed_ptid (curr_target
, ptid
);
2059 /* We only set the internal executing state here. The user/frontend
2060 running state is set at a higher level. This also clears the
2061 thread's stop_pc as side effect. */
2062 set_executing (curr_target
, ptid
, true);
2063 clear_inline_frame_state (curr_target
, ptid
);
2066 /* If true, target_commit_resume is a nop. */
2067 static int defer_target_commit_resume
;
2072 target_commit_resume (void)
2074 if (defer_target_commit_resume
)
2077 current_top_target ()->commit_resume ();
2082 scoped_restore_tmpl
<int>
2083 make_scoped_defer_target_commit_resume ()
2085 return make_scoped_restore (&defer_target_commit_resume
, 1);
2089 target_pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2091 current_top_target ()->pass_signals (pass_signals
);
2095 target_program_signals (gdb::array_view
<const unsigned char> program_signals
)
2097 current_top_target ()->program_signals (program_signals
);
2101 default_follow_fork (struct target_ops
*self
, bool follow_child
,
2104 /* Some target returned a fork event, but did not know how to follow it. */
2105 internal_error (__FILE__
, __LINE__
,
2106 _("could not find a target to follow fork"));
2109 /* Look through the list of possible targets for a target that can
2113 target_follow_fork (bool follow_child
, bool detach_fork
)
2115 return current_top_target ()->follow_fork (follow_child
, detach_fork
);
2118 /* Target wrapper for follow exec hook. */
2121 target_follow_exec (struct inferior
*inf
, const char *execd_pathname
)
2123 current_top_target ()->follow_exec (inf
, execd_pathname
);
2127 default_mourn_inferior (struct target_ops
*self
)
2129 internal_error (__FILE__
, __LINE__
,
2130 _("could not find a target to follow mourn inferior"));
2134 target_mourn_inferior (ptid_t ptid
)
2136 gdb_assert (ptid
== inferior_ptid
);
2137 current_top_target ()->mourn_inferior ();
2139 /* We no longer need to keep handles on any of the object files.
2140 Make sure to release them to avoid unnecessarily locking any
2141 of them while we're not actually debugging. */
2142 bfd_cache_close_all ();
2145 /* Look for a target which can describe architectural features, starting
2146 from TARGET. If we find one, return its description. */
2148 const struct target_desc
*
2149 target_read_description (struct target_ops
*target
)
2151 return target
->read_description ();
2154 /* This implements a basic search of memory, reading target memory and
2155 performing the search here (as opposed to performing the search in on the
2156 target side with, for example, gdbserver). */
2159 simple_search_memory (struct target_ops
*ops
,
2160 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2161 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2162 CORE_ADDR
*found_addrp
)
2164 /* NOTE: also defined in find.c testcase. */
2165 #define SEARCH_CHUNK_SIZE 16000
2166 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2167 /* Buffer to hold memory contents for searching. */
2168 unsigned search_buf_size
;
2170 search_buf_size
= chunk_size
+ pattern_len
- 1;
2172 /* No point in trying to allocate a buffer larger than the search space. */
2173 if (search_space_len
< search_buf_size
)
2174 search_buf_size
= search_space_len
;
2176 gdb::byte_vector
search_buf (search_buf_size
);
2178 /* Prime the search buffer. */
2180 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2181 search_buf
.data (), start_addr
, search_buf_size
)
2184 warning (_("Unable to access %s bytes of target "
2185 "memory at %s, halting search."),
2186 pulongest (search_buf_size
), hex_string (start_addr
));
2190 /* Perform the search.
2192 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2193 When we've scanned N bytes we copy the trailing bytes to the start and
2194 read in another N bytes. */
2196 while (search_space_len
>= pattern_len
)
2198 gdb_byte
*found_ptr
;
2199 unsigned nr_search_bytes
2200 = std::min (search_space_len
, (ULONGEST
) search_buf_size
);
2202 found_ptr
= (gdb_byte
*) memmem (search_buf
.data (), nr_search_bytes
,
2203 pattern
, pattern_len
);
2205 if (found_ptr
!= NULL
)
2207 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
.data ());
2209 *found_addrp
= found_addr
;
2213 /* Not found in this chunk, skip to next chunk. */
2215 /* Don't let search_space_len wrap here, it's unsigned. */
2216 if (search_space_len
>= chunk_size
)
2217 search_space_len
-= chunk_size
;
2219 search_space_len
= 0;
2221 if (search_space_len
>= pattern_len
)
2223 unsigned keep_len
= search_buf_size
- chunk_size
;
2224 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2227 /* Copy the trailing part of the previous iteration to the front
2228 of the buffer for the next iteration. */
2229 gdb_assert (keep_len
== pattern_len
- 1);
2230 memcpy (&search_buf
[0], &search_buf
[chunk_size
], keep_len
);
2232 nr_to_read
= std::min (search_space_len
- keep_len
,
2233 (ULONGEST
) chunk_size
);
2235 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2236 &search_buf
[keep_len
], read_addr
,
2237 nr_to_read
) != nr_to_read
)
2239 warning (_("Unable to access %s bytes of target "
2240 "memory at %s, halting search."),
2241 plongest (nr_to_read
),
2242 hex_string (read_addr
));
2246 start_addr
+= chunk_size
;
2255 /* Default implementation of memory-searching. */
2258 default_search_memory (struct target_ops
*self
,
2259 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2260 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2261 CORE_ADDR
*found_addrp
)
2263 /* Start over from the top of the target stack. */
2264 return simple_search_memory (current_top_target (),
2265 start_addr
, search_space_len
,
2266 pattern
, pattern_len
, found_addrp
);
2269 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2270 sequence of bytes in PATTERN with length PATTERN_LEN.
2272 The result is 1 if found, 0 if not found, and -1 if there was an error
2273 requiring halting of the search (e.g. memory read error).
2274 If the pattern is found the address is recorded in FOUND_ADDRP. */
2277 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2278 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2279 CORE_ADDR
*found_addrp
)
2281 return current_top_target ()->search_memory (start_addr
, search_space_len
,
2282 pattern
, pattern_len
, found_addrp
);
2285 /* Look through the currently pushed targets. If none of them will
2286 be able to restart the currently running process, issue an error
2290 target_require_runnable (void)
2292 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
2294 /* If this target knows how to create a new program, then
2295 assume we will still be able to after killing the current
2296 one. Either killing and mourning will not pop T, or else
2297 find_default_run_target will find it again. */
2298 if (t
->can_create_inferior ())
2301 /* Do not worry about targets at certain strata that can not
2302 create inferiors. Assume they will be pushed again if
2303 necessary, and continue to the process_stratum. */
2304 if (t
->stratum () > process_stratum
)
2307 error (_("The \"%s\" target does not support \"run\". "
2308 "Try \"help target\" or \"continue\"."),
2312 /* This function is only called if the target is running. In that
2313 case there should have been a process_stratum target and it
2314 should either know how to create inferiors, or not... */
2315 internal_error (__FILE__
, __LINE__
, _("No targets found"));
2318 /* Whether GDB is allowed to fall back to the default run target for
2319 "run", "attach", etc. when no target is connected yet. */
2320 static bool auto_connect_native_target
= true;
2323 show_auto_connect_native_target (struct ui_file
*file
, int from_tty
,
2324 struct cmd_list_element
*c
, const char *value
)
2326 fprintf_filtered (file
,
2327 _("Whether GDB may automatically connect to the "
2328 "native target is %s.\n"),
2332 /* A pointer to the target that can respond to "run" or "attach".
2333 Native targets are always singletons and instantiated early at GDB
2335 static target_ops
*the_native_target
;
2340 set_native_target (target_ops
*target
)
2342 if (the_native_target
!= NULL
)
2343 internal_error (__FILE__
, __LINE__
,
2344 _("native target already set (\"%s\")."),
2345 the_native_target
->longname ());
2347 the_native_target
= target
;
2353 get_native_target ()
2355 return the_native_target
;
2358 /* Look through the list of possible targets for a target that can
2359 execute a run or attach command without any other data. This is
2360 used to locate the default process stratum.
2362 If DO_MESG is not NULL, the result is always valid (error() is
2363 called for errors); else, return NULL on error. */
2365 static struct target_ops
*
2366 find_default_run_target (const char *do_mesg
)
2368 if (auto_connect_native_target
&& the_native_target
!= NULL
)
2369 return the_native_target
;
2371 if (do_mesg
!= NULL
)
2372 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2379 find_attach_target (void)
2381 /* If a target on the current stack can attach, use it. */
2382 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
2384 if (t
->can_attach ())
2388 /* Otherwise, use the default run target for attaching. */
2389 return find_default_run_target ("attach");
2395 find_run_target (void)
2397 /* If a target on the current stack can run, use it. */
2398 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
2400 if (t
->can_create_inferior ())
2404 /* Otherwise, use the default run target. */
2405 return find_default_run_target ("run");
2409 target_ops::info_proc (const char *args
, enum info_proc_what what
)
2414 /* Implement the "info proc" command. */
2417 target_info_proc (const char *args
, enum info_proc_what what
)
2419 struct target_ops
*t
;
2421 /* If we're already connected to something that can get us OS
2422 related data, use it. Otherwise, try using the native
2424 t
= find_target_at (process_stratum
);
2426 t
= find_default_run_target (NULL
);
2428 for (; t
!= NULL
; t
= t
->beneath ())
2430 if (t
->info_proc (args
, what
))
2433 fprintf_unfiltered (gdb_stdlog
,
2434 "target_info_proc (\"%s\", %d)\n", args
, what
);
2444 find_default_supports_disable_randomization (struct target_ops
*self
)
2446 struct target_ops
*t
;
2448 t
= find_default_run_target (NULL
);
2450 return t
->supports_disable_randomization ();
2455 target_supports_disable_randomization (void)
2457 return current_top_target ()->supports_disable_randomization ();
2460 /* See target/target.h. */
2463 target_supports_multi_process (void)
2465 return current_top_target ()->supports_multi_process ();
2470 gdb::optional
<gdb::char_vector
>
2471 target_get_osdata (const char *type
)
2473 struct target_ops
*t
;
2475 /* If we're already connected to something that can get us OS
2476 related data, use it. Otherwise, try using the native
2478 t
= find_target_at (process_stratum
);
2480 t
= find_default_run_target ("get OS data");
2485 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
2488 /* Determine the current address space of thread PTID. */
2490 struct address_space
*
2491 target_thread_address_space (ptid_t ptid
)
2493 struct address_space
*aspace
;
2495 aspace
= current_top_target ()->thread_address_space (ptid
);
2496 gdb_assert (aspace
!= NULL
);
2504 target_ops::beneath () const
2506 return current_inferior ()->find_target_beneath (this);
2510 target_ops::close ()
2515 target_ops::can_attach ()
2521 target_ops::attach (const char *, int)
2523 gdb_assert_not_reached ("target_ops::attach called");
2527 target_ops::can_create_inferior ()
2533 target_ops::create_inferior (const char *, const std::string
&,
2536 gdb_assert_not_reached ("target_ops::create_inferior called");
2540 target_ops::can_run ()
2548 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
2557 /* Target file operations. */
2559 static struct target_ops
*
2560 default_fileio_target (void)
2562 struct target_ops
*t
;
2564 /* If we're already connected to something that can perform
2565 file I/O, use it. Otherwise, try using the native target. */
2566 t
= find_target_at (process_stratum
);
2569 return find_default_run_target ("file I/O");
2572 /* File handle for target file operations. */
2576 /* The target on which this file is open. NULL if the target is
2577 meanwhile closed while the handle is open. */
2580 /* The file descriptor on the target. */
2583 /* Check whether this fileio_fh_t represents a closed file. */
2586 return target_fd
< 0;
2590 /* Vector of currently open file handles. The value returned by
2591 target_fileio_open and passed as the FD argument to other
2592 target_fileio_* functions is an index into this vector. This
2593 vector's entries are never freed; instead, files are marked as
2594 closed, and the handle becomes available for reuse. */
2595 static std::vector
<fileio_fh_t
> fileio_fhandles
;
2597 /* Index into fileio_fhandles of the lowest handle that might be
2598 closed. This permits handle reuse without searching the whole
2599 list each time a new file is opened. */
2600 static int lowest_closed_fd
;
2602 /* Invalidate the target associated with open handles that were open
2603 on target TARG, since we're about to close (and maybe destroy) the
2604 target. The handles remain open from the client's perspective, but
2605 trying to do anything with them other than closing them will fail
2609 fileio_handles_invalidate_target (target_ops
*targ
)
2611 for (fileio_fh_t
&fh
: fileio_fhandles
)
2612 if (fh
.target
== targ
)
2616 /* Acquire a target fileio file descriptor. */
2619 acquire_fileio_fd (target_ops
*target
, int target_fd
)
2621 /* Search for closed handles to reuse. */
2622 for (; lowest_closed_fd
< fileio_fhandles
.size (); lowest_closed_fd
++)
2624 fileio_fh_t
&fh
= fileio_fhandles
[lowest_closed_fd
];
2626 if (fh
.is_closed ())
2630 /* Push a new handle if no closed handles were found. */
2631 if (lowest_closed_fd
== fileio_fhandles
.size ())
2632 fileio_fhandles
.push_back (fileio_fh_t
{target
, target_fd
});
2634 fileio_fhandles
[lowest_closed_fd
] = {target
, target_fd
};
2636 /* Should no longer be marked closed. */
2637 gdb_assert (!fileio_fhandles
[lowest_closed_fd
].is_closed ());
2639 /* Return its index, and start the next lookup at
2641 return lowest_closed_fd
++;
2644 /* Release a target fileio file descriptor. */
2647 release_fileio_fd (int fd
, fileio_fh_t
*fh
)
2650 lowest_closed_fd
= std::min (lowest_closed_fd
, fd
);
2653 /* Return a pointer to the fileio_fhandle_t corresponding to FD. */
2655 static fileio_fh_t
*
2656 fileio_fd_to_fh (int fd
)
2658 return &fileio_fhandles
[fd
];
2662 /* Default implementations of file i/o methods. We don't want these
2663 to delegate automatically, because we need to know which target
2664 supported the method, in order to call it directly from within
2665 pread/pwrite, etc. */
2668 target_ops::fileio_open (struct inferior
*inf
, const char *filename
,
2669 int flags
, int mode
, int warn_if_slow
,
2672 *target_errno
= FILEIO_ENOSYS
;
2677 target_ops::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
2678 ULONGEST offset
, int *target_errno
)
2680 *target_errno
= FILEIO_ENOSYS
;
2685 target_ops::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
2686 ULONGEST offset
, int *target_errno
)
2688 *target_errno
= FILEIO_ENOSYS
;
2693 target_ops::fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
)
2695 *target_errno
= FILEIO_ENOSYS
;
2700 target_ops::fileio_close (int fd
, int *target_errno
)
2702 *target_errno
= FILEIO_ENOSYS
;
2707 target_ops::fileio_unlink (struct inferior
*inf
, const char *filename
,
2710 *target_errno
= FILEIO_ENOSYS
;
2714 gdb::optional
<std::string
>
2715 target_ops::fileio_readlink (struct inferior
*inf
, const char *filename
,
2718 *target_errno
= FILEIO_ENOSYS
;
2725 target_fileio_open (struct inferior
*inf
, const char *filename
,
2726 int flags
, int mode
, bool warn_if_slow
, int *target_errno
)
2728 for (target_ops
*t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath ())
2730 int fd
= t
->fileio_open (inf
, filename
, flags
, mode
,
2731 warn_if_slow
, target_errno
);
2733 if (fd
== -1 && *target_errno
== FILEIO_ENOSYS
)
2739 fd
= acquire_fileio_fd (t
, fd
);
2742 fprintf_unfiltered (gdb_stdlog
,
2743 "target_fileio_open (%d,%s,0x%x,0%o,%d)"
2745 inf
== NULL
? 0 : inf
->num
,
2746 filename
, flags
, mode
,
2748 fd
!= -1 ? 0 : *target_errno
);
2752 *target_errno
= FILEIO_ENOSYS
;
2759 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
2760 ULONGEST offset
, int *target_errno
)
2762 fileio_fh_t
*fh
= fileio_fd_to_fh (fd
);
2765 if (fh
->is_closed ())
2766 *target_errno
= EBADF
;
2767 else if (fh
->target
== NULL
)
2768 *target_errno
= EIO
;
2770 ret
= fh
->target
->fileio_pwrite (fh
->target_fd
, write_buf
,
2771 len
, offset
, target_errno
);
2774 fprintf_unfiltered (gdb_stdlog
,
2775 "target_fileio_pwrite (%d,...,%d,%s) "
2777 fd
, len
, pulongest (offset
),
2778 ret
, ret
!= -1 ? 0 : *target_errno
);
2785 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
2786 ULONGEST offset
, int *target_errno
)
2788 fileio_fh_t
*fh
= fileio_fd_to_fh (fd
);
2791 if (fh
->is_closed ())
2792 *target_errno
= EBADF
;
2793 else if (fh
->target
== NULL
)
2794 *target_errno
= EIO
;
2796 ret
= fh
->target
->fileio_pread (fh
->target_fd
, read_buf
,
2797 len
, offset
, target_errno
);
2800 fprintf_unfiltered (gdb_stdlog
,
2801 "target_fileio_pread (%d,...,%d,%s) "
2803 fd
, len
, pulongest (offset
),
2804 ret
, ret
!= -1 ? 0 : *target_errno
);
2811 target_fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
)
2813 fileio_fh_t
*fh
= fileio_fd_to_fh (fd
);
2816 if (fh
->is_closed ())
2817 *target_errno
= EBADF
;
2818 else if (fh
->target
== NULL
)
2819 *target_errno
= EIO
;
2821 ret
= fh
->target
->fileio_fstat (fh
->target_fd
, sb
, target_errno
);
2824 fprintf_unfiltered (gdb_stdlog
,
2825 "target_fileio_fstat (%d) = %d (%d)\n",
2826 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
2833 target_fileio_close (int fd
, int *target_errno
)
2835 fileio_fh_t
*fh
= fileio_fd_to_fh (fd
);
2838 if (fh
->is_closed ())
2839 *target_errno
= EBADF
;
2842 if (fh
->target
!= NULL
)
2843 ret
= fh
->target
->fileio_close (fh
->target_fd
,
2847 release_fileio_fd (fd
, fh
);
2851 fprintf_unfiltered (gdb_stdlog
,
2852 "target_fileio_close (%d) = %d (%d)\n",
2853 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
2860 target_fileio_unlink (struct inferior
*inf
, const char *filename
,
2863 for (target_ops
*t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath ())
2865 int ret
= t
->fileio_unlink (inf
, filename
, target_errno
);
2867 if (ret
== -1 && *target_errno
== FILEIO_ENOSYS
)
2871 fprintf_unfiltered (gdb_stdlog
,
2872 "target_fileio_unlink (%d,%s)"
2874 inf
== NULL
? 0 : inf
->num
, filename
,
2875 ret
, ret
!= -1 ? 0 : *target_errno
);
2879 *target_errno
= FILEIO_ENOSYS
;
2885 gdb::optional
<std::string
>
2886 target_fileio_readlink (struct inferior
*inf
, const char *filename
,
2889 for (target_ops
*t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath ())
2891 gdb::optional
<std::string
> ret
2892 = t
->fileio_readlink (inf
, filename
, target_errno
);
2894 if (!ret
.has_value () && *target_errno
== FILEIO_ENOSYS
)
2898 fprintf_unfiltered (gdb_stdlog
,
2899 "target_fileio_readlink (%d,%s)"
2901 inf
== NULL
? 0 : inf
->num
,
2902 filename
, ret
? ret
->c_str () : "(nil)",
2903 ret
? 0 : *target_errno
);
2907 *target_errno
= FILEIO_ENOSYS
;
2911 /* Like scoped_fd, but specific to target fileio. */
2913 class scoped_target_fd
2916 explicit scoped_target_fd (int fd
) noexcept
2921 ~scoped_target_fd ()
2927 target_fileio_close (m_fd
, &target_errno
);
2931 DISABLE_COPY_AND_ASSIGN (scoped_target_fd
);
2933 int get () const noexcept
2942 /* Read target file FILENAME, in the filesystem as seen by INF. If
2943 INF is NULL, use the filesystem seen by the debugger (GDB or, for
2944 remote targets, the remote stub). Store the result in *BUF_P and
2945 return the size of the transferred data. PADDING additional bytes
2946 are available in *BUF_P. This is a helper function for
2947 target_fileio_read_alloc; see the declaration of that function for
2948 more information. */
2951 target_fileio_read_alloc_1 (struct inferior
*inf
, const char *filename
,
2952 gdb_byte
**buf_p
, int padding
)
2954 size_t buf_alloc
, buf_pos
;
2959 scoped_target_fd
fd (target_fileio_open (inf
, filename
, FILEIO_O_RDONLY
,
2960 0700, false, &target_errno
));
2961 if (fd
.get () == -1)
2964 /* Start by reading up to 4K at a time. The target will throttle
2965 this number down if necessary. */
2967 buf
= (gdb_byte
*) xmalloc (buf_alloc
);
2971 n
= target_fileio_pread (fd
.get (), &buf
[buf_pos
],
2972 buf_alloc
- buf_pos
- padding
, buf_pos
,
2976 /* An error occurred. */
2982 /* Read all there was. */
2992 /* If the buffer is filling up, expand it. */
2993 if (buf_alloc
< buf_pos
* 2)
2996 buf
= (gdb_byte
*) xrealloc (buf
, buf_alloc
);
3006 target_fileio_read_alloc (struct inferior
*inf
, const char *filename
,
3009 return target_fileio_read_alloc_1 (inf
, filename
, buf_p
, 0);
3014 gdb::unique_xmalloc_ptr
<char>
3015 target_fileio_read_stralloc (struct inferior
*inf
, const char *filename
)
3019 LONGEST i
, transferred
;
3021 transferred
= target_fileio_read_alloc_1 (inf
, filename
, &buffer
, 1);
3022 bufstr
= (char *) buffer
;
3024 if (transferred
< 0)
3025 return gdb::unique_xmalloc_ptr
<char> (nullptr);
3027 if (transferred
== 0)
3028 return make_unique_xstrdup ("");
3030 bufstr
[transferred
] = 0;
3032 /* Check for embedded NUL bytes; but allow trailing NULs. */
3033 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3036 warning (_("target file %s "
3037 "contained unexpected null characters"),
3042 return gdb::unique_xmalloc_ptr
<char> (bufstr
);
3047 default_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3048 CORE_ADDR addr
, int len
)
3050 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3054 default_watchpoint_addr_within_range (struct target_ops
*target
,
3056 CORE_ADDR start
, int length
)
3058 return addr
>= start
&& addr
< start
+ length
;
3064 target_stack::find_beneath (const target_ops
*t
) const
3066 /* Look for a non-empty slot at stratum levels beneath T's. */
3067 for (int stratum
= t
->stratum () - 1; stratum
>= 0; --stratum
)
3068 if (m_stack
[stratum
] != NULL
)
3069 return m_stack
[stratum
];
3077 find_target_at (enum strata stratum
)
3079 return current_inferior ()->target_at (stratum
);
3087 target_announce_detach (int from_tty
)
3090 const char *exec_file
;
3095 exec_file
= get_exec_file (0);
3096 if (exec_file
== NULL
)
3099 pid
= inferior_ptid
.pid ();
3100 printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file
,
3101 target_pid_to_str (ptid_t (pid
)).c_str ());
3104 /* The inferior process has died. Long live the inferior! */
3107 generic_mourn_inferior (void)
3109 inferior
*inf
= current_inferior ();
3111 switch_to_no_thread ();
3113 /* Mark breakpoints uninserted in case something tries to delete a
3114 breakpoint while we delete the inferior's threads (which would
3115 fail, since the inferior is long gone). */
3116 mark_breakpoints_out ();
3119 exit_inferior (inf
);
3121 /* Note this wipes step-resume breakpoints, so needs to be done
3122 after exit_inferior, which ends up referencing the step-resume
3123 breakpoints through clear_thread_inferior_resources. */
3124 breakpoint_init_inferior (inf_exited
);
3126 registers_changed ();
3128 reopen_exec_file ();
3129 reinit_frame_cache ();
3131 if (deprecated_detach_hook
)
3132 deprecated_detach_hook ();
3135 /* Convert a normal process ID to a string. Returns the string in a
3139 normal_pid_to_str (ptid_t ptid
)
3141 return string_printf ("process %d", ptid
.pid ());
3145 default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3147 return normal_pid_to_str (ptid
);
3150 /* Error-catcher for target_find_memory_regions. */
3152 dummy_find_memory_regions (struct target_ops
*self
,
3153 find_memory_region_ftype ignore1
, void *ignore2
)
3155 error (_("Command not implemented for this target."));
3159 /* Error-catcher for target_make_corefile_notes. */
3161 dummy_make_corefile_notes (struct target_ops
*self
,
3162 bfd
*ignore1
, int *ignore2
)
3164 error (_("Command not implemented for this target."));
3168 #include "target-delegates.c"
3170 /* The initial current target, so that there is always a semi-valid
3173 static dummy_target the_dummy_target
;
3180 return &the_dummy_target
;
3183 static const target_info dummy_target_info
= {
3190 dummy_target::stratum () const
3192 return dummy_stratum
;
3196 debug_target::stratum () const
3198 return debug_stratum
;
3202 dummy_target::info () const
3204 return dummy_target_info
;
3208 debug_target::info () const
3210 return beneath ()->info ();
3216 target_close (struct target_ops
*targ
)
3218 gdb_assert (!target_is_pushed (targ
));
3220 fileio_handles_invalidate_target (targ
);
3225 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3229 target_thread_alive (ptid_t ptid
)
3231 return current_top_target ()->thread_alive (ptid
);
3235 target_update_thread_list (void)
3237 current_top_target ()->update_thread_list ();
3241 target_stop (ptid_t ptid
)
3245 warning (_("May not interrupt or stop the target, ignoring attempt"));
3249 current_top_target ()->stop (ptid
);
3257 warning (_("May not interrupt or stop the target, ignoring attempt"));
3261 current_top_target ()->interrupt ();
3267 target_pass_ctrlc (void)
3269 /* Pass the Ctrl-C to the first target that has a thread
3271 for (inferior
*inf
: all_inferiors ())
3273 target_ops
*proc_target
= inf
->process_target ();
3274 if (proc_target
== NULL
)
3277 for (thread_info
*thr
: inf
->non_exited_threads ())
3279 /* A thread can be THREAD_STOPPED and executing, while
3280 running an infcall. */
3281 if (thr
->state
== THREAD_RUNNING
|| thr
->executing
)
3283 /* We can get here quite deep in target layers. Avoid
3284 switching thread context or anything that would
3285 communicate with the target (e.g., to fetch
3286 registers), or flushing e.g., the frame cache. We
3287 just switch inferior in order to be able to call
3288 through the target_stack. */
3289 scoped_restore_current_inferior restore_inferior
;
3290 set_current_inferior (inf
);
3291 current_top_target ()->pass_ctrlc ();
3301 default_target_pass_ctrlc (struct target_ops
*ops
)
3303 target_interrupt ();
3306 /* See target/target.h. */
3309 target_stop_and_wait (ptid_t ptid
)
3311 struct target_waitstatus status
;
3312 bool was_non_stop
= non_stop
;
3317 memset (&status
, 0, sizeof (status
));
3318 target_wait (ptid
, &status
, 0);
3320 non_stop
= was_non_stop
;
3323 /* See target/target.h. */
3326 target_continue_no_signal (ptid_t ptid
)
3328 target_resume (ptid
, 0, GDB_SIGNAL_0
);
3331 /* See target/target.h. */
3334 target_continue (ptid_t ptid
, enum gdb_signal signal
)
3336 target_resume (ptid
, 0, signal
);
3339 /* Concatenate ELEM to LIST, a comma-separated list. */
3342 str_comma_list_concat_elem (std::string
*list
, const char *elem
)
3344 if (!list
->empty ())
3345 list
->append (", ");
3347 list
->append (elem
);
3350 /* Helper for target_options_to_string. If OPT is present in
3351 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3352 OPT is removed from TARGET_OPTIONS. */
3355 do_option (int *target_options
, std::string
*ret
,
3356 int opt
, const char *opt_str
)
3358 if ((*target_options
& opt
) != 0)
3360 str_comma_list_concat_elem (ret
, opt_str
);
3361 *target_options
&= ~opt
;
3368 target_options_to_string (int target_options
)
3372 #define DO_TARG_OPTION(OPT) \
3373 do_option (&target_options, &ret, OPT, #OPT)
3375 DO_TARG_OPTION (TARGET_WNOHANG
);
3377 if (target_options
!= 0)
3378 str_comma_list_concat_elem (&ret
, "unknown???");
3384 target_fetch_registers (struct regcache
*regcache
, int regno
)
3386 current_top_target ()->fetch_registers (regcache
, regno
);
3388 regcache
->debug_print_register ("target_fetch_registers", regno
);
3392 target_store_registers (struct regcache
*regcache
, int regno
)
3394 if (!may_write_registers
)
3395 error (_("Writing to registers is not allowed (regno %d)"), regno
);
3397 current_top_target ()->store_registers (regcache
, regno
);
3400 regcache
->debug_print_register ("target_store_registers", regno
);
3405 target_core_of_thread (ptid_t ptid
)
3407 return current_top_target ()->core_of_thread (ptid
);
3411 simple_verify_memory (struct target_ops
*ops
,
3412 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
3414 LONGEST total_xfered
= 0;
3416 while (total_xfered
< size
)
3418 ULONGEST xfered_len
;
3419 enum target_xfer_status status
;
3421 ULONGEST howmuch
= std::min
<ULONGEST
> (sizeof (buf
), size
- total_xfered
);
3423 status
= target_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
3424 buf
, NULL
, lma
+ total_xfered
, howmuch
,
3426 if (status
== TARGET_XFER_OK
3427 && memcmp (data
+ total_xfered
, buf
, xfered_len
) == 0)
3429 total_xfered
+= xfered_len
;
3438 /* Default implementation of memory verification. */
3441 default_verify_memory (struct target_ops
*self
,
3442 const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3444 /* Start over from the top of the target stack. */
3445 return simple_verify_memory (current_top_target (),
3446 data
, memaddr
, size
);
3450 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3452 return current_top_target ()->verify_memory (data
, memaddr
, size
);
3455 /* The documentation for this function is in its prototype declaration in
3459 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
,
3460 enum target_hw_bp_type rw
)
3462 return current_top_target ()->insert_mask_watchpoint (addr
, mask
, rw
);
3465 /* The documentation for this function is in its prototype declaration in
3469 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
,
3470 enum target_hw_bp_type rw
)
3472 return current_top_target ()->remove_mask_watchpoint (addr
, mask
, rw
);
3475 /* The documentation for this function is in its prototype declaration
3479 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
3481 return current_top_target ()->masked_watch_num_registers (addr
, mask
);
3484 /* The documentation for this function is in its prototype declaration
3488 target_ranged_break_num_registers (void)
3490 return current_top_target ()->ranged_break_num_registers ();
3495 struct btrace_target_info
*
3496 target_enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
3498 return current_top_target ()->enable_btrace (ptid
, conf
);
3504 target_disable_btrace (struct btrace_target_info
*btinfo
)
3506 current_top_target ()->disable_btrace (btinfo
);
3512 target_teardown_btrace (struct btrace_target_info
*btinfo
)
3514 current_top_target ()->teardown_btrace (btinfo
);
3520 target_read_btrace (struct btrace_data
*btrace
,
3521 struct btrace_target_info
*btinfo
,
3522 enum btrace_read_type type
)
3524 return current_top_target ()->read_btrace (btrace
, btinfo
, type
);
3529 const struct btrace_config
*
3530 target_btrace_conf (const struct btrace_target_info
*btinfo
)
3532 return current_top_target ()->btrace_conf (btinfo
);
3538 target_stop_recording (void)
3540 current_top_target ()->stop_recording ();
3546 target_save_record (const char *filename
)
3548 current_top_target ()->save_record (filename
);
3554 target_supports_delete_record ()
3556 return current_top_target ()->supports_delete_record ();
3562 target_delete_record (void)
3564 current_top_target ()->delete_record ();
3570 target_record_method (ptid_t ptid
)
3572 return current_top_target ()->record_method (ptid
);
3578 target_record_is_replaying (ptid_t ptid
)
3580 return current_top_target ()->record_is_replaying (ptid
);
3586 target_record_will_replay (ptid_t ptid
, int dir
)
3588 return current_top_target ()->record_will_replay (ptid
, dir
);
3594 target_record_stop_replaying (void)
3596 current_top_target ()->record_stop_replaying ();
3602 target_goto_record_begin (void)
3604 current_top_target ()->goto_record_begin ();
3610 target_goto_record_end (void)
3612 current_top_target ()->goto_record_end ();
3618 target_goto_record (ULONGEST insn
)
3620 current_top_target ()->goto_record (insn
);
3626 target_insn_history (int size
, gdb_disassembly_flags flags
)
3628 current_top_target ()->insn_history (size
, flags
);
3634 target_insn_history_from (ULONGEST from
, int size
,
3635 gdb_disassembly_flags flags
)
3637 current_top_target ()->insn_history_from (from
, size
, flags
);
3643 target_insn_history_range (ULONGEST begin
, ULONGEST end
,
3644 gdb_disassembly_flags flags
)
3646 current_top_target ()->insn_history_range (begin
, end
, flags
);
3652 target_call_history (int size
, record_print_flags flags
)
3654 current_top_target ()->call_history (size
, flags
);
3660 target_call_history_from (ULONGEST begin
, int size
, record_print_flags flags
)
3662 current_top_target ()->call_history_from (begin
, size
, flags
);
3668 target_call_history_range (ULONGEST begin
, ULONGEST end
, record_print_flags flags
)
3670 current_top_target ()->call_history_range (begin
, end
, flags
);
3675 const struct frame_unwind
*
3676 target_get_unwinder (void)
3678 return current_top_target ()->get_unwinder ();
3683 const struct frame_unwind
*
3684 target_get_tailcall_unwinder (void)
3686 return current_top_target ()->get_tailcall_unwinder ();
3692 target_prepare_to_generate_core (void)
3694 current_top_target ()->prepare_to_generate_core ();
3700 target_done_generating_core (void)
3702 current_top_target ()->done_generating_core ();
3707 static char targ_desc
[] =
3708 "Names of targets and files being debugged.\nShows the entire \
3709 stack of targets currently in use (including the exec-file,\n\
3710 core-file, and process, if any), as well as the symbol file name.";
3713 default_rcmd (struct target_ops
*self
, const char *command
,
3714 struct ui_file
*output
)
3716 error (_("\"monitor\" command not supported by this target."));
3720 do_monitor_command (const char *cmd
, int from_tty
)
3722 target_rcmd (cmd
, gdb_stdtarg
);
3725 /* Erases all the memory regions marked as flash. CMD and FROM_TTY are
3729 flash_erase_command (const char *cmd
, int from_tty
)
3731 /* Used to communicate termination of flash operations to the target. */
3732 bool found_flash_region
= false;
3733 struct gdbarch
*gdbarch
= target_gdbarch ();
3735 std::vector
<mem_region
> mem_regions
= target_memory_map ();
3737 /* Iterate over all memory regions. */
3738 for (const mem_region
&m
: mem_regions
)
3740 /* Is this a flash memory region? */
3741 if (m
.attrib
.mode
== MEM_FLASH
)
3743 found_flash_region
= true;
3744 target_flash_erase (m
.lo
, m
.hi
- m
.lo
);
3746 ui_out_emit_tuple
tuple_emitter (current_uiout
, "erased-regions");
3748 current_uiout
->message (_("Erasing flash memory region at address "));
3749 current_uiout
->field_core_addr ("address", gdbarch
, m
.lo
);
3750 current_uiout
->message (", size = ");
3751 current_uiout
->field_string ("size", hex_string (m
.hi
- m
.lo
));
3752 current_uiout
->message ("\n");
3756 /* Did we do any flash operations? If so, we need to finalize them. */
3757 if (found_flash_region
)
3758 target_flash_done ();
3760 current_uiout
->message (_("No flash memory regions found.\n"));
3763 /* Print the name of each layers of our target stack. */
3766 maintenance_print_target_stack (const char *cmd
, int from_tty
)
3768 printf_filtered (_("The current target stack is:\n"));
3770 for (target_ops
*t
= current_top_target (); t
!= NULL
; t
= t
->beneath ())
3772 if (t
->stratum () == debug_stratum
)
3774 printf_filtered (" - %s (%s)\n", t
->shortname (), t
->longname ());
3781 target_async (int enable
)
3783 infrun_async (enable
);
3784 current_top_target ()->async (enable
);
3790 target_thread_events (int enable
)
3792 current_top_target ()->thread_events (enable
);
3795 /* Controls if targets can report that they can/are async. This is
3796 just for maintainers to use when debugging gdb. */
3797 bool target_async_permitted
= true;
3799 /* The set command writes to this variable. If the inferior is
3800 executing, target_async_permitted is *not* updated. */
3801 static bool target_async_permitted_1
= true;
3804 maint_set_target_async_command (const char *args
, int from_tty
,
3805 struct cmd_list_element
*c
)
3807 if (have_live_inferiors ())
3809 target_async_permitted_1
= target_async_permitted
;
3810 error (_("Cannot change this setting while the inferior is running."));
3813 target_async_permitted
= target_async_permitted_1
;
3817 maint_show_target_async_command (struct ui_file
*file
, int from_tty
,
3818 struct cmd_list_element
*c
,
3821 fprintf_filtered (file
,
3822 _("Controlling the inferior in "
3823 "asynchronous mode is %s.\n"), value
);
3826 /* Return true if the target operates in non-stop mode even with "set
3830 target_always_non_stop_p (void)
3832 return current_top_target ()->always_non_stop_p ();
3838 target_is_non_stop_p (void)
3841 || target_non_stop_enabled
== AUTO_BOOLEAN_TRUE
3842 || (target_non_stop_enabled
== AUTO_BOOLEAN_AUTO
3843 && target_always_non_stop_p ()));
3849 exists_non_stop_target ()
3851 if (target_is_non_stop_p ())
3854 scoped_restore_current_thread restore_thread
;
3856 for (inferior
*inf
: all_inferiors ())
3858 switch_to_inferior_no_thread (inf
);
3859 if (target_is_non_stop_p ())
3866 /* Controls if targets can report that they always run in non-stop
3867 mode. This is just for maintainers to use when debugging gdb. */
3868 enum auto_boolean target_non_stop_enabled
= AUTO_BOOLEAN_AUTO
;
3870 /* The set command writes to this variable. If the inferior is
3871 executing, target_non_stop_enabled is *not* updated. */
3872 static enum auto_boolean target_non_stop_enabled_1
= AUTO_BOOLEAN_AUTO
;
3874 /* Implementation of "maint set target-non-stop". */
3877 maint_set_target_non_stop_command (const char *args
, int from_tty
,
3878 struct cmd_list_element
*c
)
3880 if (have_live_inferiors ())
3882 target_non_stop_enabled_1
= target_non_stop_enabled
;
3883 error (_("Cannot change this setting while the inferior is running."));
3886 target_non_stop_enabled
= target_non_stop_enabled_1
;
3889 /* Implementation of "maint show target-non-stop". */
3892 maint_show_target_non_stop_command (struct ui_file
*file
, int from_tty
,
3893 struct cmd_list_element
*c
,
3896 if (target_non_stop_enabled
== AUTO_BOOLEAN_AUTO
)
3897 fprintf_filtered (file
,
3898 _("Whether the target is always in non-stop mode "
3899 "is %s (currently %s).\n"), value
,
3900 target_always_non_stop_p () ? "on" : "off");
3902 fprintf_filtered (file
,
3903 _("Whether the target is always in non-stop mode "
3904 "is %s.\n"), value
);
3907 /* Temporary copies of permission settings. */
3909 static bool may_write_registers_1
= true;
3910 static bool may_write_memory_1
= true;
3911 static bool may_insert_breakpoints_1
= true;
3912 static bool may_insert_tracepoints_1
= true;
3913 static bool may_insert_fast_tracepoints_1
= true;
3914 static bool may_stop_1
= true;
3916 /* Make the user-set values match the real values again. */
3919 update_target_permissions (void)
3921 may_write_registers_1
= may_write_registers
;
3922 may_write_memory_1
= may_write_memory
;
3923 may_insert_breakpoints_1
= may_insert_breakpoints
;
3924 may_insert_tracepoints_1
= may_insert_tracepoints
;
3925 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
3926 may_stop_1
= may_stop
;
3929 /* The one function handles (most of) the permission flags in the same
3933 set_target_permissions (const char *args
, int from_tty
,
3934 struct cmd_list_element
*c
)
3936 if (target_has_execution
)
3938 update_target_permissions ();
3939 error (_("Cannot change this setting while the inferior is running."));
3942 /* Make the real values match the user-changed values. */
3943 may_write_registers
= may_write_registers_1
;
3944 may_insert_breakpoints
= may_insert_breakpoints_1
;
3945 may_insert_tracepoints
= may_insert_tracepoints_1
;
3946 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
3947 may_stop
= may_stop_1
;
3948 update_observer_mode ();
3951 /* Set memory write permission independently of observer mode. */
3954 set_write_memory_permission (const char *args
, int from_tty
,
3955 struct cmd_list_element
*c
)
3957 /* Make the real values match the user-changed values. */
3958 may_write_memory
= may_write_memory_1
;
3959 update_observer_mode ();
3962 void _initialize_target ();
3965 _initialize_target ()
3967 the_debug_target
= new debug_target ();
3969 add_info ("target", info_target_command
, targ_desc
);
3970 add_info ("files", info_target_command
, targ_desc
);
3972 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3973 Set target debugging."), _("\
3974 Show target debugging."), _("\
3975 When non-zero, target debugging is enabled. Higher numbers are more\n\
3979 &setdebuglist
, &showdebuglist
);
3981 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3982 &trust_readonly
, _("\
3983 Set mode for reading from readonly sections."), _("\
3984 Show mode for reading from readonly sections."), _("\
3985 When this mode is on, memory reads from readonly sections (such as .text)\n\
3986 will be read from the object file instead of from the target. This will\n\
3987 result in significant performance improvement for remote targets."),
3989 show_trust_readonly
,
3990 &setlist
, &showlist
);
3992 add_com ("monitor", class_obscure
, do_monitor_command
,
3993 _("Send a command to the remote monitor (remote targets only)."));
3995 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3996 _("Print the name of each layer of the internal target stack."),
3997 &maintenanceprintlist
);
3999 add_setshow_boolean_cmd ("target-async", no_class
,
4000 &target_async_permitted_1
, _("\
4001 Set whether gdb controls the inferior in asynchronous mode."), _("\
4002 Show whether gdb controls the inferior in asynchronous mode."), _("\
4003 Tells gdb whether to control the inferior in asynchronous mode."),
4004 maint_set_target_async_command
,
4005 maint_show_target_async_command
,
4006 &maintenance_set_cmdlist
,
4007 &maintenance_show_cmdlist
);
4009 add_setshow_auto_boolean_cmd ("target-non-stop", no_class
,
4010 &target_non_stop_enabled_1
, _("\
4011 Set whether gdb always controls the inferior in non-stop mode."), _("\
4012 Show whether gdb always controls the inferior in non-stop mode."), _("\
4013 Tells gdb whether to control the inferior in non-stop mode."),
4014 maint_set_target_non_stop_command
,
4015 maint_show_target_non_stop_command
,
4016 &maintenance_set_cmdlist
,
4017 &maintenance_show_cmdlist
);
4019 add_setshow_boolean_cmd ("may-write-registers", class_support
,
4020 &may_write_registers_1
, _("\
4021 Set permission to write into registers."), _("\
4022 Show permission to write into registers."), _("\
4023 When this permission is on, GDB may write into the target's registers.\n\
4024 Otherwise, any sort of write attempt will result in an error."),
4025 set_target_permissions
, NULL
,
4026 &setlist
, &showlist
);
4028 add_setshow_boolean_cmd ("may-write-memory", class_support
,
4029 &may_write_memory_1
, _("\
4030 Set permission to write into target memory."), _("\
4031 Show permission to write into target memory."), _("\
4032 When this permission is on, GDB may write into the target's memory.\n\
4033 Otherwise, any sort of write attempt will result in an error."),
4034 set_write_memory_permission
, NULL
,
4035 &setlist
, &showlist
);
4037 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
4038 &may_insert_breakpoints_1
, _("\
4039 Set permission to insert breakpoints in the target."), _("\
4040 Show permission to insert breakpoints in the target."), _("\
4041 When this permission is on, GDB may insert breakpoints in the program.\n\
4042 Otherwise, any sort of insertion attempt will result in an error."),
4043 set_target_permissions
, NULL
,
4044 &setlist
, &showlist
);
4046 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
4047 &may_insert_tracepoints_1
, _("\
4048 Set permission to insert tracepoints in the target."), _("\
4049 Show permission to insert tracepoints in the target."), _("\
4050 When this permission is on, GDB may insert tracepoints in the program.\n\
4051 Otherwise, any sort of insertion attempt will result in an error."),
4052 set_target_permissions
, NULL
,
4053 &setlist
, &showlist
);
4055 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
4056 &may_insert_fast_tracepoints_1
, _("\
4057 Set permission to insert fast tracepoints in the target."), _("\
4058 Show permission to insert fast tracepoints in the target."), _("\
4059 When this permission is on, GDB may insert fast tracepoints.\n\
4060 Otherwise, any sort of insertion attempt will result in an error."),
4061 set_target_permissions
, NULL
,
4062 &setlist
, &showlist
);
4064 add_setshow_boolean_cmd ("may-interrupt", class_support
,
4066 Set permission to interrupt or signal the target."), _("\
4067 Show permission to interrupt or signal the target."), _("\
4068 When this permission is on, GDB may interrupt/stop the target's execution.\n\
4069 Otherwise, any attempt to interrupt or stop will be ignored."),
4070 set_target_permissions
, NULL
,
4071 &setlist
, &showlist
);
4073 add_com ("flash-erase", no_class
, flash_erase_command
,
4074 _("Erase all flash memory regions."));
4076 add_setshow_boolean_cmd ("auto-connect-native-target", class_support
,
4077 &auto_connect_native_target
, _("\
4078 Set whether GDB may automatically connect to the native target."), _("\
4079 Show whether GDB may automatically connect to the native target."), _("\
4080 When on, and GDB is not connected to a target yet, GDB\n\
4081 attempts \"run\" and other commands with the native target."),
4082 NULL
, show_auto_connect_native_target
,
4083 &setlist
, &showlist
);