#include <algorithm>
#include "byte-vector.h"
-static void info_target_command (char *, int);
-
static void generic_tls_error (void) ATTRIBUTE_NORETURN;
static void default_terminal_info (struct target_ops *, const char *, int);
static unsigned int targetdebug = 0;
static void
-set_targetdebug (char *args, int from_tty, struct cmd_list_element *c)
+set_targetdebug (const char *args, int from_tty, struct cmd_list_element *c)
{
update_current_target ();
}
/* This is used to implement the various target commands. */
static void
-open_target (char *args, int from_tty, struct cmd_list_element *command)
+open_target (const char *args, int from_tty, struct cmd_list_element *command)
{
struct target_ops *ops = (struct target_ops *) get_cmd_context (command);
if (len == 0)
return TARGET_XFER_EOF;
+ memaddr = address_significant (target_gdbarch (), memaddr);
+
/* Fill in READBUF with breakpoint shadows, or WRITEBUF with
breakpoint insns, thus hiding out from higher layers whether
there are software breakpoints inserted in the code stream. */
/* Fetch the target's memory map. */
-VEC(mem_region_s) *
+std::vector<mem_region>
target_memory_map (void)
{
- VEC(mem_region_s) *result;
- struct mem_region *last_one, *this_one;
- int ix;
- result = current_target.to_memory_map (¤t_target);
- if (result == NULL)
- return NULL;
+ std::vector<mem_region> result
+ = current_target.to_memory_map (¤t_target);
+ if (result.empty ())
+ return result;
- qsort (VEC_address (mem_region_s, result),
- VEC_length (mem_region_s, result),
- sizeof (struct mem_region), mem_region_cmp);
+ std::sort (result.begin (), result.end ());
/* Check that regions do not overlap. Simultaneously assign
a numbering for the "mem" commands to use to refer to
each region. */
- last_one = NULL;
- for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
+ mem_region *last_one = NULL;
+ for (size_t ix = 0; ix < result.size (); ix++)
{
+ mem_region *this_one = &result[ix];
this_one->number = ix;
- if (last_one && last_one->hi > this_one->lo)
+ if (last_one != NULL && last_one->hi > this_one->lo)
{
warning (_("Overlapping regions in memory map: ignoring"));
- VEC_free (mem_region_s, result);
- return NULL;
+ return std::vector<mem_region> ();
}
+
last_one = this_one;
}
return target_read_alloc_1 (ops, object, annex, buf_p, 0);
}
-/* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
- returned as a string, allocated using xmalloc. If an error occurs
- or the transfer is unsupported, NULL is returned. Empty objects
- are returned as allocated but empty strings. A warning is issued
- if the result contains any embedded NUL bytes. */
+/* See target.h. */
-char *
+gdb::unique_xmalloc_ptr<char>
target_read_stralloc (struct target_ops *ops, enum target_object object,
const char *annex)
{
return NULL;
if (transferred == 0)
- return xstrdup ("");
+ return gdb::unique_xmalloc_ptr<char> (xstrdup (""));
bufstr[transferred] = 0;
break;
}
- return bufstr;
+ return gdb::unique_xmalloc_ptr<char> (bufstr);
}
/* Memory transfer methods. */
}
static void
-info_target_command (char *args, int from_tty)
+info_target_command (const char *args, int from_tty)
{
struct target_ops *t;
int has_all_mem = 0;
void
target_commit_resume (void)
{
- struct target_ops *t;
-
if (defer_target_commit_resume)
return;
return (*current_target.to_supports_multi_process) (¤t_target);
}
-char *
+/* See target.h. */
+
+gdb::unique_xmalloc_ptr<char>
target_get_osdata (const char *type)
{
struct target_ops *t;
/* See target.h. */
-char *
+gdb::unique_xmalloc_ptr<char>
target_fileio_read_stralloc (struct inferior *inf, const char *filename)
{
gdb_byte *buffer;
bufstr = (char *) buffer;
if (transferred < 0)
- return NULL;
+ return gdb::unique_xmalloc_ptr<char> (nullptr);
if (transferred == 0)
- return xstrdup ("");
+ return gdb::unique_xmalloc_ptr<char> (xstrdup (""));
bufstr[transferred] = 0;
break;
}
- return bufstr;
+ return gdb::unique_xmalloc_ptr<char> (bufstr);
}
}
static void
-do_monitor_command (char *cmd,
- int from_tty)
+do_monitor_command (const char *cmd, int from_tty)
{
target_rcmd (cmd, gdb_stdtarg);
}
ignored. */
void
-flash_erase_command (char *cmd, int from_tty)
+flash_erase_command (const 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 ();
+ std::vector<mem_region> mem_regions = target_memory_map ();
/* Iterate over all memory regions. */
- for (int i = 0; VEC_iterate (mem_region_s, mem_regions, i, m); i++)
+ for (const mem_region &m : mem_regions)
{
- /* Fetch the memory attribute. */
- struct mem_attrib *attrib = &m->attrib;
-
/* Is this a flash memory region? */
- if (attrib->mode == MEM_FLASH)
+ if (m.attrib.mode == MEM_FLASH)
{
found_flash_region = true;
- target_flash_erase (m->lo, m->hi - m->lo);
+ target_flash_erase (m.lo, m.hi - m.lo);
ui_out_emit_tuple tuple_emitter (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->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->field_fmt ("size", "%s", hex_string (m.hi - m.lo));
current_uiout->message ("\n");
}
}
static int target_async_permitted_1 = 1;
static void
-maint_set_target_async_command (char *args, int from_tty,
+maint_set_target_async_command (const char *args, int from_tty,
struct cmd_list_element *c)
{
if (have_live_inferiors ())
/* Implementation of "maint set target-non-stop". */
static void
-maint_set_target_non_stop_command (char *args, int from_tty,
+maint_set_target_non_stop_command (const char *args, int from_tty,
struct cmd_list_element *c)
{
if (have_live_inferiors ())
way. */
static void
-set_target_permissions (char *args, int from_tty,
+set_target_permissions (const char *args, int from_tty,
struct cmd_list_element *c)
{
if (target_has_execution)
/* Set memory write permission independently of observer mode. */
static void
-set_write_memory_permission (char *args, int from_tty,
+set_write_memory_permission (const char *args, int from_tty,
struct cmd_list_element *c)
{
/* Make the real values match the user-changed values. */
update_observer_mode ();
}
+#if GDB_SELF_TEST
+namespace selftests {
+
+static int
+test_target_has_registers (target_ops *self)
+{
+ return 1;
+}
+
+static int
+test_target_has_stack (target_ops *self)
+{
+ return 1;
+}
+
+static int
+test_target_has_memory (target_ops *self)
+{
+ return 1;
+}
+
+static void
+test_target_prepare_to_store (target_ops *self, regcache *regs)
+{
+}
+
+static void
+test_target_store_registers (target_ops *self, regcache *regs, int regno)
+{
+}
+
+test_target_ops::test_target_ops ()
+ : target_ops {}
+{
+ to_magic = OPS_MAGIC;
+ to_stratum = process_stratum;
+ to_has_memory = test_target_has_memory;
+ to_has_stack = test_target_has_stack;
+ to_has_registers = test_target_has_registers;
+ to_prepare_to_store = test_target_prepare_to_store;
+ to_store_registers = test_target_store_registers;
+
+ complete_target_initialization (this);
+}
+
+} // namespace selftests
+#endif /* GDB_SELF_TEST */
void
initialize_targets (void)