/* Select target systems and architectures at runtime for GDB.
- Copyright (C) 1990-2017 Free Software Foundation, Inc.
+ Copyright (C) 1990-2018 Free Software Foundation, Inc.
Contributed by Cygnus Support.
#include "event-top.h"
#include <algorithm>
#include "byte-vector.h"
-
-static void info_target_command (char *, int);
+#include "terminal.h"
static void generic_tls_error (void) ATTRIBUTE_NORETURN;
static int return_zero_has_execution (struct target_ops *, ptid_t);
-static void target_command (char *, int);
-
static struct target_ops *find_default_run_target (const char *);
static struct gdbarch *default_thread_architecture (struct target_ops *ops,
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 ();
}
/* The user just typed 'target' without the name of a target. */
static void
-target_command (char *arg, int from_tty)
+target_command (const char *arg, int from_tty)
{
fputs_filtered ("Argument required (target name). Try `help target'\n",
gdb_stdout);
/* 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);
information on the arguments for a particular protocol, type\n\
`help target ' followed by the protocol name."),
&targetlist, "target ", 0, &cmdlist);
- c = add_cmd (t->to_shortname, no_class, NULL, t->to_doc, &targetlist);
+ c = add_cmd (t->to_shortname, no_class, t->to_doc, &targetlist);
set_cmd_sfunc (c, open_target);
set_cmd_context (c, t);
if (completer != NULL)
/* If we use add_alias_cmd, here, we do not get the deprecated warning,
see PR cli/15104. */
- c = add_cmd (alias, no_class, NULL, t->to_doc, &targetlist);
+ c = add_cmd (alias, no_class, t->to_doc, &targetlist);
set_cmd_sfunc (c, open_target);
set_cmd_context (c, t);
alt = xstrprintf ("target %s", t->to_shortname);
/* Define it. */
-enum target_terminal::terminal_state target_terminal::terminal_state
- = target_terminal::terminal_is_ours;
+target_terminal_state target_terminal::m_terminal_state
+ = target_terminal_state::is_ours;
/* See target/target.h. */
{
(*current_target.to_terminal_init) (¤t_target);
- terminal_state = terminal_is_ours;
+ m_terminal_state = target_terminal_state::is_ours;
}
/* See target/target.h. */
if (ui != main_ui)
return;
- if (terminal_state == terminal_is_inferior)
- return;
-
/* If GDB is resuming the inferior in the foreground, install
inferior's terminal modes. */
- (*current_target.to_terminal_inferior) (¤t_target);
- terminal_state = terminal_is_inferior;
+
+ struct inferior *inf = current_inferior ();
+
+ if (inf->terminal_state != target_terminal_state::is_inferior)
+ {
+ (*current_target.to_terminal_inferior) (¤t_target);
+ inf->terminal_state = target_terminal_state::is_inferior;
+ }
+
+ m_terminal_state = target_terminal_state::is_inferior;
+
+ /* If the user hit C-c before, pretend that it was hit right
+ here. */
+ if (check_quit_flag ())
+ target_pass_ctrlc ();
+}
+
+/* See target/target.h. */
+
+void
+target_terminal::restore_inferior (void)
+{
+ struct ui *ui = current_ui;
+
+ /* See target_terminal::inferior(). */
+ if (ui->prompt_state != PROMPT_BLOCKED || ui != main_ui)
+ return;
+
+ /* Restore the terminal settings of inferiors that were in the
+ foreground but are now ours_for_output due to a temporary
+ target_target::ours_for_output() call. */
+
+ {
+ scoped_restore_current_inferior restore_inferior;
+ struct inferior *inf;
+
+ ALL_INFERIORS (inf)
+ {
+ if (inf->terminal_state == target_terminal_state::is_ours_for_output)
+ {
+ set_current_inferior (inf);
+ (*current_target.to_terminal_inferior) (¤t_target);
+ inf->terminal_state = target_terminal_state::is_inferior;
+ }
+ }
+ }
+
+ m_terminal_state = target_terminal_state::is_inferior;
/* If the user hit C-c before, pretend that it was hit right
here. */
target_pass_ctrlc ();
}
+/* Switch terminal state to DESIRED_STATE, either is_ours, or
+ is_ours_for_output. */
+
+static void
+target_terminal_is_ours_kind (target_terminal_state desired_state)
+{
+ scoped_restore_current_inferior restore_inferior;
+ struct inferior *inf;
+
+ /* Must do this in two passes. First, have all inferiors save the
+ current terminal settings. Then, after all inferiors have add a
+ chance to safely save the terminal settings, restore GDB's
+ terminal settings. */
+
+ ALL_INFERIORS (inf)
+ {
+ if (inf->terminal_state == target_terminal_state::is_inferior)
+ {
+ set_current_inferior (inf);
+ (*current_target.to_terminal_save_inferior) (¤t_target);
+ }
+ }
+
+ ALL_INFERIORS (inf)
+ {
+ /* Note we don't check is_inferior here like above because we
+ need to handle 'is_ours_for_output -> is_ours' too. Careful
+ to never transition from 'is_ours' to 'is_ours_for_output',
+ though. */
+ if (inf->terminal_state != target_terminal_state::is_ours
+ && inf->terminal_state != desired_state)
+ {
+ set_current_inferior (inf);
+ if (desired_state == target_terminal_state::is_ours)
+ (*current_target.to_terminal_ours) (¤t_target);
+ else if (desired_state == target_terminal_state::is_ours_for_output)
+ (*current_target.to_terminal_ours_for_output) (¤t_target);
+ else
+ gdb_assert_not_reached ("unhandled desired state");
+ inf->terminal_state = desired_state;
+ }
+ }
+}
+
/* See target/target.h. */
void
if (ui != main_ui)
return;
- if (terminal_state == terminal_is_ours)
+ if (m_terminal_state == target_terminal_state::is_ours)
return;
- (*current_target.to_terminal_ours) (¤t_target);
- terminal_state = terminal_is_ours;
+ target_terminal_is_ours_kind (target_terminal_state::is_ours);
+ m_terminal_state = target_terminal_state::is_ours;
}
/* See target/target.h. */
if (ui != main_ui)
return;
- if (terminal_state != terminal_is_inferior)
+ if (!target_terminal::is_inferior ())
return;
- (*current_target.to_terminal_ours_for_output) (¤t_target);
- terminal_state = terminal_is_ours_for_output;
+
+ target_terminal_is_ours_kind (target_terminal_state::is_ours_for_output);
+ target_terminal::m_terminal_state = target_terminal_state::is_ours_for_output;
}
/* See target/target.h. */
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;
}
read_whatever_is_readable (struct target_ops *ops,
const ULONGEST begin, const ULONGEST end,
int unit_size,
- VEC(memory_read_result_s) **result)
+ std::vector<memory_read_result> *result)
{
- gdb_byte *buf = (gdb_byte *) xmalloc (end - begin);
ULONGEST current_begin = begin;
ULONGEST current_end = end;
int forward;
- memory_read_result_s r;
ULONGEST xfered_len;
/* If we previously failed to read 1 byte, nothing can be done here. */
if (end - begin <= 1)
- {
- xfree (buf);
- return;
- }
+ return;
+
+ gdb::unique_xmalloc_ptr<gdb_byte> buf ((gdb_byte *) xmalloc (end - begin));
/* Check that either first or the last byte is readable, and give up
if not. This heuristic is meant to permit reading accessible memory
at the boundary of accessible region. */
if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
- buf, begin, 1, &xfered_len) == TARGET_XFER_OK)
+ buf.get (), begin, 1, &xfered_len) == TARGET_XFER_OK)
{
forward = 1;
++current_begin;
}
else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
- buf + (end - begin) - 1, end - 1, 1,
+ buf.get () + (end - begin) - 1, end - 1, 1,
&xfered_len) == TARGET_XFER_OK)
{
forward = 0;
--current_end;
}
else
- {
- xfree (buf);
- return;
- }
+ return;
/* Loop invariant is that the [current_begin, current_end) was previously
found to be not readable as a whole.
}
xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
- buf + (first_half_begin - begin) * unit_size,
+ buf.get () + (first_half_begin - begin) * unit_size,
first_half_begin,
first_half_end - first_half_begin);
if (forward)
{
/* The [begin, current_begin) range has been read. */
- r.begin = begin;
- r.end = current_begin;
- r.data = buf;
+ result->emplace_back (begin, current_end, std::move (buf));
}
else
{
/* The [current_end, end) range has been read. */
LONGEST region_len = end - current_end;
- r.data = (gdb_byte *) xmalloc (region_len * unit_size);
- memcpy (r.data, buf + (current_end - begin) * unit_size,
+ gdb::unique_xmalloc_ptr<gdb_byte> data
+ ((gdb_byte *) xmalloc (region_len * unit_size));
+ memcpy (data.get (), buf.get () + (current_end - begin) * unit_size,
region_len * unit_size);
- r.begin = current_end;
- r.end = end;
- xfree (buf);
+ result->emplace_back (current_end, end, std::move (data));
}
- VEC_safe_push(memory_read_result_s, (*result), &r);
}
-void
-free_memory_read_result_vector (void *x)
-{
- VEC(memory_read_result_s) **v = (VEC(memory_read_result_s) **) x;
- memory_read_result_s *current;
- int ix;
-
- for (ix = 0; VEC_iterate (memory_read_result_s, *v, ix, current); ++ix)
- {
- xfree (current->data);
- }
- VEC_free (memory_read_result_s, *v);
-}
-
-VEC(memory_read_result_s) *
+std::vector<memory_read_result>
read_memory_robust (struct target_ops *ops,
const ULONGEST offset, const LONGEST len)
{
- VEC(memory_read_result_s) *result = 0;
+ std::vector<memory_read_result> result;
int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
- struct cleanup *cleanup = make_cleanup (free_memory_read_result_vector,
- &result);
LONGEST xfered_total = 0;
while (xfered_total < len)
else
{
LONGEST to_read = std::min (len - xfered_total, region_len);
- gdb_byte *buffer = (gdb_byte *) xmalloc (to_read * unit_size);
- struct cleanup *inner_cleanup = make_cleanup (xfree, buffer);
+ gdb::unique_xmalloc_ptr<gdb_byte> buffer
+ ((gdb_byte *) xmalloc (to_read * unit_size));
LONGEST xfered_partial =
- target_read (ops, TARGET_OBJECT_MEMORY, NULL,
- (gdb_byte *) buffer,
+ target_read (ops, TARGET_OBJECT_MEMORY, NULL, buffer.get (),
offset + xfered_total, to_read);
/* Call an observer, notifying them of the xfer progress? */
if (xfered_partial <= 0)
{
/* Got an error reading full chunk. See if maybe we can read
some subrange. */
- do_cleanups (inner_cleanup);
read_whatever_is_readable (ops, offset + xfered_total,
offset + xfered_total + to_read,
unit_size, &result);
}
else
{
- struct memory_read_result r;
-
- discard_cleanups (inner_cleanup);
- r.data = buffer;
- r.begin = offset + xfered_total;
- r.end = r.begin + xfered_partial;
- VEC_safe_push (memory_read_result_s, result, &r);
+ result.emplace_back (offset + xfered_total,
+ offset + xfered_total + xfered_partial,
+ std::move (buffer));
xfered_total += xfered_partial;
}
QUIT;
}
}
- discard_cleanups (cleanup);
return result;
}
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;
if (target_has_execution)
target_kill ();
else
- target_detach (NULL, 0);
+ target_detach (inf, 0);
}
return 0;
target_pre_inferior (from_tty);
}
-/* Detach a target after doing deferred register stores. */
+/* See target.h. */
void
-target_detach (const char *args, int from_tty)
+target_detach (inferior *inf, int from_tty)
{
+ /* As long as some to_detach implementations rely on the current_inferior
+ (either directly, or indirectly, like through target_gdbarch or by
+ reading memory), INF needs to be the current inferior. When that
+ requirement will become no longer true, then we can remove this
+ assertion. */
+ gdb_assert (inf == current_inferior ());
+
if (gdbarch_has_global_breakpoints (target_gdbarch ()))
/* Don't remove global breakpoints here. They're removed on
disconnection from the target. */
prepare_for_detach ();
- current_target.to_detach (¤t_target, args, from_tty);
+ current_target.to_detach (¤t_target, inf, from_tty);
}
void
return current_target.to_thread_name (¤t_target, info);
}
+struct thread_info *
+target_thread_handle_to_thread_info (const gdb_byte *thread_handle,
+ int handle_len,
+ struct inferior *inf)
+{
+ return current_target.to_thread_handle_to_thread_info
+ (¤t_target, thread_handle, handle_len, inf);
+}
+
void
target_resume (ptid_t ptid, int step, enum gdb_signal signal)
{
void
target_commit_resume (void)
{
- struct target_ops *t;
-
if (defer_target_commit_resume)
return;
/* See target.h. */
-struct cleanup *
-make_cleanup_defer_target_commit_resume (void)
+scoped_restore_tmpl<int>
+make_scoped_defer_target_commit_resume ()
{
- struct cleanup *old_chain;
-
- old_chain = make_cleanup_restore_integer (&defer_target_commit_resume);
- defer_target_commit_resume = 1;
- return old_chain;
+ return make_scoped_restore (&defer_target_commit_resume, 1);
}
void
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 struct gdbarch *
default_thread_architecture (struct target_ops *ops, ptid_t ptid)
{
- return target_gdbarch ();
+ inferior *inf = find_inferior_ptid (ptid);
+ gdb_assert (inf != NULL);
+ return inf->gdbarch;
}
static int
}
void
-target_interrupt (ptid_t ptid)
+target_interrupt ()
{
if (!may_stop)
{
return;
}
- (*current_target.to_interrupt) (¤t_target, ptid);
+ (*current_target.to_interrupt) (¤t_target);
}
/* See target.h. */
void
default_target_pass_ctrlc (struct target_ops *ops)
{
- target_interrupt (inferior_ptid);
+ target_interrupt ();
}
/* See target/target.h. */
/* See target.h. */
-int
-target_supports_btrace (enum btrace_format format)
-{
- return current_target.to_supports_btrace (¤t_target, format);
-}
-
-/* See target.h. */
-
struct btrace_target_info *
target_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
{
}
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");
}
}
/* Print the name of each layers of our target stack. */
static void
-maintenance_print_target_stack (char *cmd, int from_tty)
+maintenance_print_target_stack (const char *cmd, int from_tty)
{
struct target_ops *t;
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)
projects / deliverable / binutils-gdb.git / blobdiff