/* 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 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);
/* 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. */
/* 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. */
+ if (check_quit_flag ())
+ 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
target_terminal::ours ()
{
struct ui *ui = current_ui;
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;
}
}
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
void
target_commit_resume (void)
{
- struct target_ops *t;
-
if (defer_target_commit_resume)
return;
}
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. */
}
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)