/* Select target systems and architectures at runtime for GDB.
- Copyright (C) 1990-2016 Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 Free Software Foundation, Inc.
Contributed by Cygnus Support.
static void target_command (char *, int);
-static struct target_ops *find_default_run_target (char *);
+static struct target_ops *find_default_run_target (const char *);
static struct gdbarch *default_thread_architecture (struct target_ops *ops,
ptid_t ptid);
static char *dummy_make_corefile_notes (struct target_ops *self,
bfd *ignore1, int *ignore2);
-static char *default_pid_to_str (struct target_ops *ops, ptid_t ptid);
+static const char *default_pid_to_str (struct target_ops *ops, ptid_t ptid);
static enum exec_direction_kind default_execution_direction
(struct target_ops *self);
/* See target.h. */
void
-add_deprecated_target_alias (struct target_ops *t, char *alias)
+add_deprecated_target_alias (struct target_ops *t, const char *alias)
{
struct cmd_list_element *c;
char *alt;
return minus_one_ptid;
}
-char *
+const char *
target_pid_to_str (ptid_t ptid)
{
return (*current_target.to_pid_to_str) (¤t_target, ptid);
clear_inline_frame_state (ptid);
}
+/* If true, target_commit_resume is a nop. */
+static int defer_target_commit_resume;
+
+/* See target.h. */
+
+void
+target_commit_resume (void)
+{
+ struct target_ops *t;
+
+ if (defer_target_commit_resume)
+ return;
+
+ current_target.to_commit_resume (¤t_target);
+}
+
+/* See target.h. */
+
+struct cleanup *
+make_cleanup_defer_target_commit_resume (void)
+{
+ struct cleanup *old_chain;
+
+ old_chain = make_cleanup_restore_integer (&defer_target_commit_resume);
+ defer_target_commit_resume = 1;
+ return old_chain;
+}
+
void
target_pass_signals (int numsigs, unsigned char *pass_signals)
{
}
void
-target_mourn_inferior (void)
+target_mourn_inferior (ptid_t ptid)
{
+ gdb_assert (ptid_equal (ptid, inferior_ptid));
current_target.to_mourn_inferior (¤t_target);
/* We no longer need to keep handles on any of the object files.
called for errors); else, return NULL on error. */
static struct target_ops *
-find_default_run_target (char *do_mesg)
+find_default_run_target (const char *do_mesg)
{
struct target_ops *runable = NULL;
return 0;
}
+/* See target/target.h. */
+
+int
+target_supports_multi_process (void)
+{
+ return (*current_target.to_supports_multi_process) (¤t_target);
+}
+
char *
target_get_osdata (const char *type)
{
target_announce_detach (int from_tty)
{
pid_t pid;
- char *exec_file;
+ const char *exec_file;
if (!from_tty)
return;
/* Convert a normal process ID to a string. Returns the string in a
static buffer. */
-char *
+const char *
normal_pid_to_str (ptid_t ptid)
{
static char buf[32];
return buf;
}
-static char *
+static const char *
default_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
return normal_pid_to_str (ptid);
static char *
do_option (int *target_options, char *ret,
- int opt, char *opt_str)
+ int opt, const char *opt_str)
{
if ((*target_options & opt) != 0)
{
return ret;
}
-static void
-debug_print_register (const char * func,
- struct regcache *regcache, int regno)
-{
- struct gdbarch *gdbarch = get_regcache_arch (regcache);
-
- fprintf_unfiltered (gdb_stdlog, "%s ", func);
- if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
- && gdbarch_register_name (gdbarch, regno) != NULL
- && gdbarch_register_name (gdbarch, regno)[0] != '\0')
- fprintf_unfiltered (gdb_stdlog, "(%s)",
- gdbarch_register_name (gdbarch, regno));
- else
- fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
- if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
- {
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- int i, size = register_size (gdbarch, regno);
- gdb_byte buf[MAX_REGISTER_SIZE];
-
- regcache_raw_collect (regcache, regno, buf);
- fprintf_unfiltered (gdb_stdlog, " = ");
- for (i = 0; i < size; i++)
- {
- fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
- }
- if (size <= sizeof (LONGEST))
- {
- ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
-
- fprintf_unfiltered (gdb_stdlog, " %s %s",
- core_addr_to_string_nz (val), plongest (val));
- }
- }
- fprintf_unfiltered (gdb_stdlog, "\n");
-}
-
void
target_fetch_registers (struct regcache *regcache, int regno)
{
current_target.to_fetch_registers (¤t_target, regcache, regno);
if (targetdebug)
- debug_print_register ("target_fetch_registers", regcache, regno);
+ regcache_debug_print_register ("target_fetch_registers", regcache, regno);
}
void
current_target.to_store_registers (¤t_target, regcache, regno);
if (targetdebug)
{
- debug_print_register ("target_store_registers", regcache, regno);
+ regcache_debug_print_register ("target_store_registers", regcache,
+ regno);
}
}
ULONGEST xfered_len;
enum target_xfer_status status;
gdb_byte buf[1024];
- ULONGEST howmuch = std::min (sizeof (buf), size - total_xfered);
+ ULONGEST howmuch = std::min<ULONGEST> (sizeof (buf), size - total_xfered);
status = target_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
buf, NULL, lma + total_xfered, howmuch,
/* See target.h. */
+enum record_method
+target_record_method (ptid_t ptid)
+{
+ return current_target.to_record_method (¤t_target, ptid);
+}
+
+/* See target.h. */
+
int
target_record_is_replaying (ptid_t ptid)
{
target_rcmd (cmd, gdb_stdtarg);
}
+/* Erases all the memory regions marked as flash. CMD and FROM_TTY are
+ ignored. */
+
+void
+flash_erase_command (char *cmd, int from_tty)
+{
+ /* Used to communicate termination of flash operations to the target. */
+ bool found_flash_region = false;
+ struct mem_region *m;
+ struct gdbarch *gdbarch = target_gdbarch ();
+
+ VEC(mem_region_s) *mem_regions = target_memory_map ();
+
+ /* Iterate over all memory regions. */
+ for (int i = 0; VEC_iterate (mem_region_s, mem_regions, i, m); i++)
+ {
+ /* Fetch the memory attribute. */
+ struct mem_attrib *attrib = &m->attrib;
+
+ /* Is this a flash memory region? */
+ if (attrib->mode == MEM_FLASH)
+ {
+ found_flash_region = true;
+ target_flash_erase (m->lo, m->hi - m->lo);
+
+ struct cleanup *cleanup_tuple
+ = make_cleanup_ui_out_tuple_begin_end (current_uiout,
+ "erased-regions");
+
+ current_uiout->message (_("Erasing flash memory region at address "));
+ current_uiout->field_fmt ("address", "%s", paddress (gdbarch,
+ m->lo));
+ current_uiout->message (", size = ");
+ current_uiout->field_fmt ("size", "%s", hex_string (m->hi - m->lo));
+ current_uiout->message ("\n");
+ do_cleanups (cleanup_tuple);
+ }
+ }
+
+ /* Did we do any flash operations? If so, we need to finalize them. */
+ if (found_flash_region)
+ target_flash_done ();
+ else
+ current_uiout->message (_("No flash memory regions found.\n"));
+}
+
/* Print the name of each layers of our target stack. */
static void
set_target_permissions, NULL,
&setlist, &showlist);
+ add_com ("flash-erase", no_class, flash_erase_command,
+ _("Erase all flash memory regions."));
+
add_setshow_boolean_cmd ("auto-connect-native-target", class_support,
&auto_connect_native_target, _("\
Set whether GDB may automatically connect to the native target."), _("\