/* Select target systems and architectures at runtime for GDB.
- Copyright (C) 1990-2020 Free Software Foundation, Inc.
+ Copyright (C) 1990-2021 Free Software Foundation, Inc.
Contributed by Cygnus Support.
#include "event-top.h"
#include <algorithm>
#include "gdbsupport/byte-vector.h"
+#include "gdbsupport/search.h"
#include "terminal.h"
#include <unordered_map>
#include "target-connection.h"
find_memory_region_ftype ignore1,
void *ignore2);
-static char *dummy_make_corefile_notes (struct target_ops *self,
- bfd *ignore1, int *ignore2);
+static gdb::unique_xmalloc_ptr<char> dummy_make_corefile_notes
+ (struct target_ops *self, bfd *ignore1, int *ignore2);
static std::string default_pid_to_str (struct target_ops *ops, ptid_t ptid);
static struct target_ops *the_debug_target;
-/* Top of target stack. */
-/* The target structure we are currently using to talk to a process
- or file or whatever "inferior" we have. */
+/* Command list for target. */
+
+static struct cmd_list_element *targetlist = NULL;
+
+/* True if we should trust readonly sections from the
+ executable when reading memory. */
+
+static bool trust_readonly = false;
+
+/* Nonzero if we should show true memory content including
+ memory breakpoint inserted by gdb. */
+
+static int show_memory_breakpoints = 0;
+
+/* These globals control whether GDB attempts to perform these
+ operations; they are useful for targets that need to prevent
+ inadvertent disruption, such as in non-stop mode. */
+
+bool may_write_registers = true;
+
+bool may_write_memory = true;
+
+bool may_insert_breakpoints = true;
+
+bool may_insert_tracepoints = true;
+
+bool may_insert_fast_tracepoints = true;
+
+bool may_stop = true;
+
+/* Non-zero if we want to see trace of target level stuff. */
+
+static unsigned int targetdebug = 0;
+
+static void
+set_targetdebug (const char *args, int from_tty, struct cmd_list_element *c)
+{
+ if (targetdebug)
+ current_inferior ()->push_target (the_debug_target);
+ else
+ current_inferior ()->unpush_target (the_debug_target);
+}
+
+static void
+show_targetdebug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Target debugging is %s.\n"), value);
+}
+
+int
+target_has_memory ()
+{
+ for (target_ops *t = current_inferior ()->top_target ();
+ t != NULL;
+ t = t->beneath ())
+ if (t->has_memory ())
+ return 1;
+
+ return 0;
+}
+
+int
+target_has_stack ()
+{
+ for (target_ops *t = current_inferior ()->top_target ();
+ t != NULL;
+ t = t->beneath ())
+ if (t->has_stack ())
+ return 1;
+
+ return 0;
+}
+
+int
+target_has_registers ()
+{
+ for (target_ops *t = current_inferior ()->top_target ();
+ t != NULL;
+ t = t->beneath ())
+ if (t->has_registers ())
+ return 1;
+
+ return 0;
+}
+
+bool
+target_has_execution (inferior *inf)
+{
+ if (inf == nullptr)
+ inf = current_inferior ();
+
+ for (target_ops *t = inf->top_target ();
+ t != nullptr;
+ t = inf->find_target_beneath (t))
+ if (t->has_execution (inf))
+ return true;
+
+ return false;
+}
+
+const char *
+target_shortname ()
+{
+ return current_inferior ()->top_target ()->shortname ();
+}
+
+/* See target.h. */
+
+bool
+target_attach_no_wait ()
+{
+ return current_inferior ()->top_target ()->attach_no_wait ();
+}
+
+/* See target.h. */
+
+void
+target_post_attach (int pid)
+{
+ return current_inferior ()->top_target ()->post_attach (pid);
+}
+
+/* See target.h. */
+
+void
+target_prepare_to_store (regcache *regcache)
+{
+ return current_inferior ()->top_target ()->prepare_to_store (regcache);
+}
+
+/* See target.h. */
+
+bool
+target_supports_enable_disable_tracepoint ()
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->supports_enable_disable_tracepoint ();
+}
+
+bool
+target_supports_string_tracing ()
+{
+ return current_inferior ()->top_target ()->supports_string_tracing ();
+}
+
+/* See target.h. */
+
+bool
+target_supports_evaluation_of_breakpoint_conditions ()
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->supports_evaluation_of_breakpoint_conditions ();
+}
+
+/* See target.h. */
+
+bool
+target_supports_dumpcore ()
+{
+ return current_inferior ()->top_target ()->supports_dumpcore ();
+}
+
+/* See target.h. */
+
+void
+target_dumpcore (const char *filename)
+{
+ return current_inferior ()->top_target ()->dumpcore (filename);
+}
+
+/* See target.h. */
+
+bool
+target_can_run_breakpoint_commands ()
+{
+ return current_inferior ()->top_target ()->can_run_breakpoint_commands ();
+}
+
+/* See target.h. */
+
+void
+target_files_info ()
+{
+ return current_inferior ()->top_target ()->files_info ();
+}
+
+/* See target.h. */
+
+void
+target_post_startup_inferior (ptid_t ptid)
+{
+ return current_inferior ()->top_target ()->post_startup_inferior (ptid);
+}
+
+/* See target.h. */
+
+int
+target_insert_fork_catchpoint (int pid)
+{
+ return current_inferior ()->top_target ()->insert_fork_catchpoint (pid);
+}
+
+/* See target.h. */
+
+int
+target_remove_fork_catchpoint (int pid)
+{
+ return current_inferior ()->top_target ()->remove_fork_catchpoint (pid);
+}
+
+/* See target.h. */
+
+int
+target_insert_vfork_catchpoint (int pid)
+{
+ return current_inferior ()->top_target ()->insert_vfork_catchpoint (pid);
+}
+
+/* See target.h. */
+
+int
+target_remove_vfork_catchpoint (int pid)
+{
+ return current_inferior ()->top_target ()->remove_vfork_catchpoint (pid);
+}
+
+/* See target.h. */
+
+int
+target_insert_exec_catchpoint (int pid)
+{
+ return current_inferior ()->top_target ()->insert_exec_catchpoint (pid);
+}
+
+/* See target.h. */
+
+int
+target_remove_exec_catchpoint (int pid)
+{
+ return current_inferior ()->top_target ()->remove_exec_catchpoint (pid);
+}
+
+/* See target.h. */
+
+int
+target_set_syscall_catchpoint (int pid, bool needed, int any_count,
+ gdb::array_view<const int> syscall_counts)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->set_syscall_catchpoint (pid, needed, any_count,
+ syscall_counts);
+}
+
+/* See target.h. */
+
+void
+target_rcmd (const char *command, struct ui_file *outbuf)
+{
+ return current_inferior ()->top_target ()->rcmd (command, outbuf);
+}
+
+/* See target.h. */
+
+bool
+target_can_lock_scheduler ()
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return (target->get_thread_control_capabilities ()& tc_schedlock) != 0;
+}
+
+/* See target.h. */
+
+bool
+target_can_async_p ()
+{
+ return current_inferior ()->top_target ()->can_async_p ();
+}
+
+/* See target.h. */
+
+bool
+target_is_async_p ()
+{
+ return current_inferior ()->top_target ()->is_async_p ();
+}
+
+exec_direction_kind
+target_execution_direction ()
+{
+ return current_inferior ()->top_target ()->execution_direction ();
+}
+
+/* See target.h. */
+
+const char *
+target_extra_thread_info (thread_info *tp)
+{
+ return current_inferior ()->top_target ()->extra_thread_info (tp);
+}
+
+/* See target.h. */
+
+char *
+target_pid_to_exec_file (int pid)
+{
+ return current_inferior ()->top_target ()->pid_to_exec_file (pid);
+}
+
+/* See target.h. */
+
+gdbarch *
+target_thread_architecture (ptid_t ptid)
+{
+ return current_inferior ()->top_target ()->thread_architecture (ptid);
+}
+
+/* See target.h. */
+
+int
+target_find_memory_regions (find_memory_region_ftype func, void *data)
+{
+ return current_inferior ()->top_target ()->find_memory_regions (func, data);
+}
+
+/* See target.h. */
+
+gdb::unique_xmalloc_ptr<char>
+target_make_corefile_notes (bfd *bfd, int *size_p)
+{
+ return current_inferior ()->top_target ()->make_corefile_notes (bfd, size_p);
+}
+
+gdb_byte *
+target_get_bookmark (const char *args, int from_tty)
+{
+ return current_inferior ()->top_target ()->get_bookmark (args, from_tty);
+}
+
+void
+target_goto_bookmark (const gdb_byte *arg, int from_tty)
+{
+ return current_inferior ()->top_target ()->goto_bookmark (arg, from_tty);
+}
+
+/* See target.h. */
+
+bool
+target_stopped_by_watchpoint ()
+{
+ return current_inferior ()->top_target ()->stopped_by_watchpoint ();
+}
+
+/* See target.h. */
+
+bool
+target_stopped_by_sw_breakpoint ()
+{
+ return current_inferior ()->top_target ()->stopped_by_sw_breakpoint ();
+}
+
+bool
+target_supports_stopped_by_sw_breakpoint ()
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->supports_stopped_by_sw_breakpoint ();
+}
+
+bool
+target_stopped_by_hw_breakpoint ()
+{
+ return current_inferior ()->top_target ()->stopped_by_hw_breakpoint ();
+}
+
+bool
+target_supports_stopped_by_hw_breakpoint ()
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->supports_stopped_by_hw_breakpoint ();
+}
+
+/* See target.h. */
+
+bool
+target_have_steppable_watchpoint ()
+{
+ return current_inferior ()->top_target ()->have_steppable_watchpoint ();
+}
+
+/* See target.h. */
+
+int
+target_can_use_hardware_watchpoint (bptype type, int cnt, int othertype)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->can_use_hw_breakpoint (type, cnt, othertype);
+}
+
+/* See target.h. */
+
+int
+target_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->region_ok_for_hw_watchpoint (addr, len);
+}
+
+
+int
+target_can_do_single_step ()
+{
+ return current_inferior ()->top_target ()->can_do_single_step ();
+}
+
+/* See target.h. */
+
+int
+target_insert_watchpoint (CORE_ADDR addr, int len, target_hw_bp_type type,
+ expression *cond)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->insert_watchpoint (addr, len, type, cond);
+}
+
+/* See target.h. */
+
+int
+target_remove_watchpoint (CORE_ADDR addr, int len, target_hw_bp_type type,
+ expression *cond)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->remove_watchpoint (addr, len, type, cond);
+}
+
+/* See target.h. */
+
+int
+target_insert_hw_breakpoint (gdbarch *gdbarch, bp_target_info *bp_tgt)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->insert_hw_breakpoint (gdbarch, bp_tgt);
+}
+
+/* See target.h. */
+
+int
+target_remove_hw_breakpoint (gdbarch *gdbarch, bp_target_info *bp_tgt)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->remove_hw_breakpoint (gdbarch, bp_tgt);
+}
+
+/* See target.h. */
+
+bool
+target_can_accel_watchpoint_condition (CORE_ADDR addr, int len, int type,
+ expression *cond)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->can_accel_watchpoint_condition (addr, len, type, cond);
+}
+
+/* See target.h. */
+
+bool
+target_can_execute_reverse ()
+{
+ return current_inferior ()->top_target ()->can_execute_reverse ();
+}
-target_ops *
-current_top_target ()
+ptid_t
+target_get_ada_task_ptid (long lwp, long tid)
{
- return current_inferior ()->top_target ();
+ return current_inferior ()->top_target ()->get_ada_task_ptid (lwp, tid);
}
-/* Command list for target. */
+bool
+target_filesystem_is_local ()
+{
+ return current_inferior ()->top_target ()->filesystem_is_local ();
+}
-static struct cmd_list_element *targetlist = NULL;
+void
+target_trace_init ()
+{
+ return current_inferior ()->top_target ()->trace_init ();
+}
-/* True if we should trust readonly sections from the
- executable when reading memory. */
+void
+target_download_tracepoint (bp_location *location)
+{
+ return current_inferior ()->top_target ()->download_tracepoint (location);
+}
-static bool trust_readonly = false;
+bool
+target_can_download_tracepoint ()
+{
+ return current_inferior ()->top_target ()->can_download_tracepoint ();
+}
-/* Nonzero if we should show true memory content including
- memory breakpoint inserted by gdb. */
+void
+target_download_trace_state_variable (const trace_state_variable &tsv)
+{
+ target_ops *target = current_inferior ()->top_target ();
-static int show_memory_breakpoints = 0;
+ return target->download_trace_state_variable (tsv);
+}
-/* These globals control whether GDB attempts to perform these
- operations; they are useful for targets that need to prevent
- inadvertent disruption, such as in non-stop mode. */
+void
+target_enable_tracepoint (bp_location *loc)
+{
+ return current_inferior ()->top_target ()->enable_tracepoint (loc);
+}
-bool may_write_registers = true;
+void
+target_disable_tracepoint (bp_location *loc)
+{
+ return current_inferior ()->top_target ()->disable_tracepoint (loc);
+}
-bool may_write_memory = true;
+void
+target_trace_start ()
+{
+ return current_inferior ()->top_target ()->trace_start ();
+}
-bool may_insert_breakpoints = true;
+void
+target_trace_set_readonly_regions ()
+{
+ return current_inferior ()->top_target ()->trace_set_readonly_regions ();
+}
-bool may_insert_tracepoints = true;
+int
+target_get_trace_status (trace_status *ts)
+{
+ return current_inferior ()->top_target ()->get_trace_status (ts);
+}
-bool may_insert_fast_tracepoints = true;
+void
+target_get_tracepoint_status (breakpoint *tp, uploaded_tp *utp)
+{
+ return current_inferior ()->top_target ()->get_tracepoint_status (tp, utp);
+}
-bool may_stop = true;
+void
+target_trace_stop ()
+{
+ return current_inferior ()->top_target ()->trace_stop ();
+}
-/* Non-zero if we want to see trace of target level stuff. */
+int
+target_trace_find (trace_find_type type, int num,
+ CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
+{
+ target_ops *target = current_inferior ()->top_target ();
-static unsigned int targetdebug = 0;
+ return target->trace_find (type, num, addr1, addr2, tpp);
+}
-static void
-set_targetdebug (const char *args, int from_tty, struct cmd_list_element *c)
+bool
+target_get_trace_state_variable_value (int tsv, LONGEST *val)
{
- if (targetdebug)
- push_target (the_debug_target);
- else
- unpush_target (the_debug_target);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->get_trace_state_variable_value (tsv, val);
}
-static void
-show_targetdebug (struct ui_file *file, int from_tty,
- struct cmd_list_element *c, const char *value)
+int
+target_save_trace_data (const char *filename)
{
- fprintf_filtered (file, _("Target debugging is %s.\n"), value);
+ return current_inferior ()->top_target ()->save_trace_data (filename);
}
int
-target_has_memory ()
+target_upload_tracepoints (uploaded_tp **utpp)
{
- for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
- if (t->has_memory ())
- return 1;
-
- return 0;
+ return current_inferior ()->top_target ()->upload_tracepoints (utpp);
}
int
-target_has_stack ()
+target_upload_trace_state_variables (uploaded_tsv **utsvp)
{
- for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
- if (t->has_stack ())
- return 1;
+ target_ops *target = current_inferior ()->top_target ();
- return 0;
+ return target->upload_trace_state_variables (utsvp);
+}
+
+LONGEST
+target_get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->get_raw_trace_data (buf, offset, len);
}
int
-target_has_registers ()
+target_get_min_fast_tracepoint_insn_len ()
{
- for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
- if (t->has_registers ())
- return 1;
+ target_ops *target = current_inferior ()->top_target ();
- return 0;
+ return target->get_min_fast_tracepoint_insn_len ();
+}
+
+void
+target_set_disconnected_tracing (int val)
+{
+ return current_inferior ()->top_target ()->set_disconnected_tracing (val);
+}
+
+void
+target_set_circular_trace_buffer (int val)
+{
+ return current_inferior ()->top_target ()->set_circular_trace_buffer (val);
+}
+
+void
+target_set_trace_buffer_size (LONGEST val)
+{
+ return current_inferior ()->top_target ()->set_trace_buffer_size (val);
}
bool
-target_has_execution_1 (inferior *inf)
+target_set_trace_notes (const char *user, const char *notes,
+ const char *stopnotes)
{
- for (target_ops *t = inf->top_target ();
- t != nullptr;
- t = inf->find_target_beneath (t))
- if (t->has_execution (inf))
- return true;
+ target_ops *target = current_inferior ()->top_target ();
- return false;
+ return target->set_trace_notes (user, notes, stopnotes);
}
-int
-target_has_execution_current (void)
+bool
+target_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
+{
+ return current_inferior ()->top_target ()->get_tib_address (ptid, addr);
+}
+
+void
+target_set_permissions ()
+{
+ return current_inferior ()->top_target ()->set_permissions ();
+}
+
+bool
+target_static_tracepoint_marker_at (CORE_ADDR addr,
+ static_tracepoint_marker *marker)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->static_tracepoint_marker_at (addr, marker);
+}
+
+std::vector<static_tracepoint_marker>
+target_static_tracepoint_markers_by_strid (const char *marker_id)
+{
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->static_tracepoint_markers_by_strid (marker_id);
+}
+
+traceframe_info_up
+target_traceframe_info ()
+{
+ return current_inferior ()->top_target ()->traceframe_info ();
+}
+
+bool
+target_use_agent (bool use)
+{
+ return current_inferior ()->top_target ()->use_agent (use);
+}
+
+bool
+target_can_use_agent ()
+{
+ return current_inferior ()->top_target ()->can_use_agent ();
+}
+
+bool
+target_augmented_libraries_svr4_read ()
+{
+ return current_inferior ()->top_target ()->augmented_libraries_svr4_read ();
+}
+
+bool
+target_supports_memory_tagging ()
+{
+ return current_inferior ()->top_target ()->supports_memory_tagging ();
+}
+
+bool
+target_fetch_memtags (CORE_ADDR address, size_t len, gdb::byte_vector &tags,
+ int type)
+{
+ return current_inferior ()->top_target ()->fetch_memtags (address, len, tags, type);
+}
+
+bool
+target_store_memtags (CORE_ADDR address, size_t len,
+ const gdb::byte_vector &tags, int type)
+{
+ return current_inferior ()->top_target ()->store_memtags (address, len, tags, type);
+}
+
+void
+target_log_command (const char *p)
{
- return target_has_execution_1 (current_inferior ());
+ return current_inferior ()->top_target ()->log_command (p);
}
/* This is used to implement the various target commands. */
void
target_kill (void)
{
- current_top_target ()->kill ();
+ current_inferior ()->top_target ()->kill ();
}
void
target_load (const char *arg, int from_tty)
{
target_dcache_invalidate ();
- current_top_target ()->load (arg, from_tty);
+ current_inferior ()->top_target ()->load (arg, from_tty);
}
/* Define it. */
void
target_terminal::init (void)
{
- current_top_target ()->terminal_init ();
+ current_inferior ()->top_target ()->terminal_init ();
m_terminal_state = target_terminal_state::is_ours;
}
if (inf->terminal_state != target_terminal_state::is_inferior)
{
- current_top_target ()->terminal_inferior ();
+ current_inferior ()->top_target ()->terminal_inferior ();
inf->terminal_state = target_terminal_state::is_inferior;
}
if (inf->terminal_state == target_terminal_state::is_ours_for_output)
{
set_current_inferior (inf);
- current_top_target ()->terminal_inferior ();
+ current_inferior ()->top_target ()->terminal_inferior ();
inf->terminal_state = target_terminal_state::is_inferior;
}
}
if (inf->terminal_state == target_terminal_state::is_inferior)
{
set_current_inferior (inf);
- current_top_target ()->terminal_save_inferior ();
+ current_inferior ()->top_target ()->terminal_save_inferior ();
}
}
{
set_current_inferior (inf);
if (desired_state == target_terminal_state::is_ours)
- current_top_target ()->terminal_ours ();
+ current_inferior ()->top_target ()->terminal_ours ();
else if (desired_state == target_terminal_state::is_ours_for_output)
- current_top_target ()->terminal_ours_for_output ();
+ current_inferior ()->top_target ()->terminal_ours_for_output ();
else
gdb_assert_not_reached ("unhandled desired state");
inf->terminal_state = desired_state;
void
target_terminal::info (const char *arg, int from_tty)
{
- current_top_target ()->terminal_info (arg, from_tty);
+ current_inferior ()->top_target ()->terminal_info (arg, from_tty);
}
/* See target.h. */
tcomplain (void)
{
error (_("You can't do that when your target is `%s'"),
- current_top_target ()->shortname ());
+ current_inferior ()->top_target ()->shortname ());
}
void
/* See target.h. */
-void
-push_target (struct target_ops *t)
-{
- current_inferior ()->push_target (t);
-}
-
-/* See target.h. */
-
-void
-push_target (target_ops_up &&t)
-{
- current_inferior ()->push_target (t.get ());
- t.release ();
-}
-
-/* See target.h. */
-
-int
-unpush_target (struct target_ops *t)
-{
- return current_inferior ()->unpush_target (t);
-}
-
-/* See target.h. */
-
bool
target_stack::unpush (target_ops *t)
{
static void
unpush_target_and_assert (struct target_ops *target)
{
- if (!unpush_target (target))
+ if (!current_inferior ()->unpush_target (target))
{
fprintf_unfiltered (gdb_stderr,
"pop_all_targets couldn't find target %s\n",
void
pop_all_targets_above (enum strata above_stratum)
{
- while ((int) (current_top_target ()->stratum ()) > (int) above_stratum)
- unpush_target_and_assert (current_top_target ());
+ while ((int) (current_inferior ()->top_target ()->stratum ())
+ > (int) above_stratum)
+ unpush_target_and_assert (current_inferior ()->top_target ());
}
/* See target.h. */
void
pop_all_targets_at_and_above (enum strata stratum)
{
- while ((int) (current_top_target ()->stratum ()) >= (int) stratum)
- unpush_target_and_assert (current_top_target ());
+ while ((int) (current_inferior ()->top_target ()->stratum ())
+ >= (int) stratum)
+ unpush_target_and_assert (current_inferior ()->top_target ());
}
void
pop_all_targets_above (dummy_stratum);
}
-/* Return true if T is now pushed in the current inferior's target
- stack. Return false otherwise. */
-
-bool
-target_is_pushed (target_ops *t)
+void
+target_unpusher::operator() (struct target_ops *ops) const
{
- return current_inferior ()->target_is_pushed (t);
+ current_inferior ()->unpush_target (ops);
}
/* Default implementation of to_get_thread_local_address. */
target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
{
volatile CORE_ADDR addr = 0;
- struct target_ops *target = current_top_target ();
+ struct target_ops *target = current_inferior ()->top_target ();
struct gdbarch *gdbarch = target_gdbarch ();
if (gdbarch_fetch_tls_load_module_address_p (gdbarch))
/* Fetch the load module address for this objfile. */
lm_addr = gdbarch_fetch_tls_load_module_address (gdbarch,
- objfile);
+ objfile);
if (gdbarch_get_thread_local_address_p (gdbarch))
addr = gdbarch_get_thread_local_address (gdbarch, ptid, lm_addr,
addr = target->get_thread_local_address (ptid, lm_addr, offset);
}
/* If an error occurred, print TLS related messages here. Otherwise,
- throw the error to some higher catcher. */
+ throw the error to some higher catcher. */
catch (const gdb_exception &ex)
{
int objfile_is_library = (objfile->flags & OBJF_SHARED);
case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
if (objfile_is_library)
error (_("Cannot find shared library `%s' in dynamic"
- " linker's load module list"), objfile_name (objfile));
+ " linker's load module list"), objfile_name (objfile));
else
error (_("Cannot find executable file `%s' in dynamic"
- " linker's load module list"), objfile_name (objfile));
+ " linker's load module list"), objfile_name (objfile));
break;
case TLS_NOT_ALLOCATED_YET_ERROR:
if (objfile_is_library)
error (_("The inferior has not yet allocated storage for"
- " thread-local variables in\n"
- "the shared library `%s'\n"
- "for %s"),
+ " thread-local variables in\n"
+ "the shared library `%s'\n"
+ "for %s"),
objfile_name (objfile),
target_pid_to_str (ptid).c_str ());
else
error (_("The inferior has not yet allocated storage for"
- " thread-local variables in\n"
- "the executable `%s'\n"
- "for %s"),
+ " thread-local variables in\n"
+ "the executable `%s'\n"
+ "for %s"),
objfile_name (objfile),
target_pid_to_str (ptid).c_str ());
break;
case TLS_GENERIC_ERROR:
if (objfile_is_library)
error (_("Cannot find thread-local storage for %s, "
- "shared library %s:\n%s"),
+ "shared library %s:\n%s"),
target_pid_to_str (ptid).c_str (),
objfile_name (objfile), ex.what ());
else
error (_("Cannot find thread-local storage for %s, "
- "executable file %s:\n%s"),
+ "executable file %s:\n%s"),
target_pid_to_str (ptid).c_str (),
objfile_name (objfile), ex.what ());
break;
return gdb::unique_xmalloc_ptr<char> ((char *) buffer.release ());
}
-struct target_section_table *
+const target_section_table *
target_get_section_table (struct target_ops *target)
{
return target->get_section_table ();
/* Find a section containing ADDR. */
-struct target_section *
+const struct target_section *
target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
{
- struct target_section_table *table = target_get_section_table (target);
- struct target_section *secp;
+ const target_section_table *table = target_get_section_table (target);
if (table == NULL)
return NULL;
- for (secp = table->sections; secp < table->sections_end; secp++)
+ for (const target_section &secp : *table)
{
- if (addr >= secp->addr && addr < secp->endaddr)
- return secp;
+ if (addr >= secp.addr && addr < secp.endaddr)
+ return &secp;
}
return NULL;
}
+/* See target.h. */
+
+const target_section_table *
+default_get_section_table ()
+{
+ return ¤t_program_space->target_sections ();
+}
/* Helper for the memory xfer routines. Checks the attributes of the
memory region of MEMADDR against the read or write being attempted.
break;
/* Don't continue past targets which have all the memory.
- At one time, this code was necessary to read data from
+ At one time, this code was necessary to read data from
executables / shared libraries when data for the requested
addresses weren't available in the core file. But now the
core target handles this case itself. */
if (pc_in_unmapped_range (memaddr, section))
{
- struct target_section_table *table
- = target_get_section_table (ops);
+ const target_section_table *table = target_get_section_table (ops);
const char *section_name = section->the_bfd_section->name;
memaddr = overlay_mapped_address (memaddr, section);
return section_table_xfer_memory_partial (readbuf, writebuf,
memaddr, len, xfered_len,
- table->sections,
- table->sections_end,
- match_cb);
+ *table, match_cb);
}
}
/* Try the executable files, if "trust-readonly-sections" is set. */
if (readbuf != NULL && trust_readonly)
{
- struct target_section *secp;
- struct target_section_table *table;
-
- secp = target_section_by_addr (ops, memaddr);
+ const struct target_section *secp
+ = target_section_by_addr (ops, memaddr);
if (secp != NULL
&& (bfd_section_flags (secp->the_bfd_section) & SEC_READONLY))
{
- table = target_get_section_table (ops);
+ const target_section_table *table = target_get_section_table (ops);
return section_table_xfer_memory_partial (readbuf, writebuf,
memaddr, len, xfered_len,
- table->sections,
- table->sections_end);
+ *table);
}
}
int
target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
{
- if (target_read (current_top_target (), TARGET_OBJECT_MEMORY, NULL,
+ if (target_read (current_inferior ()->top_target (),
+ TARGET_OBJECT_MEMORY, NULL,
myaddr, memaddr, len) == len)
return 0;
else
int
target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
{
- if (target_read (current_top_target (), TARGET_OBJECT_RAW_MEMORY, NULL,
+ if (target_read (current_inferior ()->top_target (),
+ TARGET_OBJECT_RAW_MEMORY, NULL,
myaddr, memaddr, len) == len)
return 0;
else
int
target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
{
- if (target_read (current_top_target (), TARGET_OBJECT_STACK_MEMORY, NULL,
+ if (target_read (current_inferior ()->top_target (),
+ TARGET_OBJECT_STACK_MEMORY, NULL,
myaddr, memaddr, len) == len)
return 0;
else
int
target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
{
- if (target_read (current_top_target (), TARGET_OBJECT_CODE_MEMORY, NULL,
+ if (target_read (current_inferior ()->top_target (),
+ TARGET_OBJECT_CODE_MEMORY, NULL,
myaddr, memaddr, len) == len)
return 0;
else
int
target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
{
- if (target_write (current_top_target (), TARGET_OBJECT_MEMORY, NULL,
+ if (target_write (current_inferior ()->top_target (),
+ TARGET_OBJECT_MEMORY, NULL,
myaddr, memaddr, len) == len)
return 0;
else
int
target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
{
- if (target_write (current_top_target (), TARGET_OBJECT_RAW_MEMORY, NULL,
+ if (target_write (current_inferior ()->top_target (),
+ TARGET_OBJECT_RAW_MEMORY, NULL,
myaddr, memaddr, len) == len)
return 0;
else
std::vector<mem_region>
target_memory_map (void)
{
- std::vector<mem_region> result = current_top_target ()->memory_map ();
+ target_ops *target = current_inferior ()->top_target ();
+ std::vector<mem_region> result = target->memory_map ();
if (result.empty ())
return result;
void
target_flash_erase (ULONGEST address, LONGEST length)
{
- current_top_target ()->flash_erase (address, length);
+ current_inferior ()->top_target ()->flash_erase (address, length);
}
void
target_flash_done (void)
{
- current_top_target ()->flash_done ();
+ current_inferior ()->top_target ()->flash_done ();
}
static void
return 1;
}
- return current_top_target ()->insert_breakpoint (gdbarch, bp_tgt);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->insert_breakpoint (gdbarch, bp_tgt);
}
/* See target.h. */
return 1;
}
- return current_top_target ()->remove_breakpoint (gdbarch, bp_tgt, reason);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->remove_breakpoint (gdbarch, bp_tgt, reason);
}
static void
{
int has_all_mem = 0;
- if (symfile_objfile != NULL)
- printf_unfiltered (_("Symbols from \"%s\".\n"),
- objfile_name (symfile_objfile));
+ if (current_program_space->symfile_object_file != NULL)
+ {
+ objfile *objf = current_program_space->symfile_object_file;
+ printf_unfiltered (_("Symbols from \"%s\".\n"),
+ objfile_name (objf));
+ }
- for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
+ for (target_ops *t = current_inferior ()->top_target ();
+ t != NULL;
+ t = t->beneath ())
{
if (!t->has_memory ())
continue;
if (current_inferior ()->pid != 0)
{
if (!from_tty
- || !target_has_execution
+ || !target_has_execution ()
|| query (_("A program is being debugged already. Kill it? ")))
{
/* Core inferiors actually should be detached, not
killed. */
- if (target_has_execution)
+ if (target_has_execution ())
target_kill ();
else
target_detach (current_inferior (), 0);
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. */
- ;
- else
- /* If we're in breakpoints-always-inserted mode, have to remove
- breakpoints before detaching. */
- remove_breakpoints_inf (current_inferior ());
-
prepare_for_detach ();
/* Hold a strong reference because detaching may unpush the
target. */
auto proc_target_ref = target_ops_ref::new_reference (inf->process_target ());
- current_top_target ()->detach (inf, from_tty);
+ current_inferior ()->top_target ()->detach (inf, from_tty);
process_stratum_target *proc_target
= as_process_stratum_target (proc_target_ref.get ());
disconnecting. */
remove_breakpoints ();
- current_top_target ()->disconnect (args, from_tty);
+ current_inferior ()->top_target ()->disconnect (args, from_tty);
}
/* See target/target.h. */
target_wait (ptid_t ptid, struct target_waitstatus *status,
target_wait_flags options)
{
- return current_top_target ()->wait (ptid, status, options);
+ target_ops *target = current_inferior ()->top_target ();
+ process_stratum_target *proc_target = current_inferior ()->process_target ();
+
+ gdb_assert (!proc_target->commit_resumed_state);
+
+ if (!target->can_async_p ())
+ gdb_assert ((options & TARGET_WNOHANG) == 0);
+
+ return target->wait (ptid, status, options);
}
/* See target.h. */
std::string
target_pid_to_str (ptid_t ptid)
{
- return current_top_target ()->pid_to_str (ptid);
+ return current_inferior ()->top_target ()->pid_to_str (ptid);
}
const char *
{
gdb_assert (info->inf == current_inferior ());
- return current_top_target ()->thread_name (info);
+ return current_inferior ()->top_target ()->thread_name (info);
}
struct thread_info *
int handle_len,
struct inferior *inf)
{
- return current_top_target ()->thread_handle_to_thread_info (thread_handle,
- handle_len, inf);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->thread_handle_to_thread_info (thread_handle, handle_len, inf);
}
/* See target.h. */
gdb::byte_vector
target_thread_info_to_thread_handle (struct thread_info *tip)
{
- return current_top_target ()->thread_info_to_thread_handle (tip);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->thread_info_to_thread_handle (tip);
}
void
target_resume (ptid_t ptid, int step, enum gdb_signal signal)
{
process_stratum_target *curr_target = current_inferior ()->process_target ();
+ gdb_assert (!curr_target->commit_resumed_state);
target_dcache_invalidate ();
- current_top_target ()->resume (ptid, step, signal);
+ current_inferior ()->top_target ()->resume (ptid, step, signal);
registers_changed_ptid (curr_target, ptid);
/* We only set the internal executing state here. The user/frontend
clear_inline_frame_state (curr_target, ptid);
}
-/* If true, target_commit_resume is a nop. */
-static int defer_target_commit_resume;
-
/* See target.h. */
void
-target_commit_resume (void)
+target_commit_resumed ()
{
- if (defer_target_commit_resume)
- return;
-
- current_top_target ()->commit_resume ();
+ gdb_assert (current_inferior ()->process_target ()->commit_resumed_state);
+ current_inferior ()->top_target ()->commit_resumed ();
}
/* See target.h. */
-scoped_restore_tmpl<int>
-make_scoped_defer_target_commit_resume ()
+bool
+target_has_pending_events ()
{
- return make_scoped_restore (&defer_target_commit_resume, 1);
+ return current_inferior ()->top_target ()->has_pending_events ();
}
void
target_pass_signals (gdb::array_view<const unsigned char> pass_signals)
{
- current_top_target ()->pass_signals (pass_signals);
+ current_inferior ()->top_target ()->pass_signals (pass_signals);
}
void
target_program_signals (gdb::array_view<const unsigned char> program_signals)
{
- current_top_target ()->program_signals (program_signals);
+ current_inferior ()->top_target ()->program_signals (program_signals);
}
-static bool
+static void
default_follow_fork (struct target_ops *self, bool follow_child,
bool detach_fork)
{
_("could not find a target to follow fork"));
}
-/* Look through the list of possible targets for a target that can
- follow forks. */
+/* See target.h. */
-bool
+void
target_follow_fork (bool follow_child, bool detach_fork)
{
- return current_top_target ()->follow_fork (follow_child, detach_fork);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->follow_fork (follow_child, detach_fork);
}
/* Target wrapper for follow exec hook. */
void
target_follow_exec (struct inferior *inf, const char *execd_pathname)
{
- current_top_target ()->follow_exec (inf, execd_pathname);
+ current_inferior ()->top_target ()->follow_exec (inf, execd_pathname);
}
static void
void
target_mourn_inferior (ptid_t ptid)
{
- gdb_assert (ptid == inferior_ptid);
- current_top_target ()->mourn_inferior ();
+ gdb_assert (ptid.pid () == inferior_ptid.pid ());
+ current_inferior ()->top_target ()->mourn_inferior ();
/* We no longer need to keep handles on any of the object files.
Make sure to release them to avoid unnecessarily locking any
return target->read_description ();
}
-/* This implements a basic search of memory, reading target memory and
- performing the search here (as opposed to performing the search in on the
- target side with, for example, gdbserver). */
-
-int
-simple_search_memory (struct target_ops *ops,
- CORE_ADDR start_addr, ULONGEST search_space_len,
- const gdb_byte *pattern, ULONGEST pattern_len,
- CORE_ADDR *found_addrp)
-{
- /* NOTE: also defined in find.c testcase. */
-#define SEARCH_CHUNK_SIZE 16000
- const unsigned chunk_size = SEARCH_CHUNK_SIZE;
- /* Buffer to hold memory contents for searching. */
- unsigned search_buf_size;
-
- search_buf_size = chunk_size + pattern_len - 1;
-
- /* No point in trying to allocate a buffer larger than the search space. */
- if (search_space_len < search_buf_size)
- search_buf_size = search_space_len;
-
- gdb::byte_vector search_buf (search_buf_size);
-
- /* Prime the search buffer. */
-
- if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
- search_buf.data (), start_addr, search_buf_size)
- != search_buf_size)
- {
- warning (_("Unable to access %s bytes of target "
- "memory at %s, halting search."),
- pulongest (search_buf_size), hex_string (start_addr));
- return -1;
- }
-
- /* Perform the search.
-
- The loop is kept simple by allocating [N + pattern-length - 1] bytes.
- When we've scanned N bytes we copy the trailing bytes to the start and
- read in another N bytes. */
-
- while (search_space_len >= pattern_len)
- {
- gdb_byte *found_ptr;
- unsigned nr_search_bytes
- = std::min (search_space_len, (ULONGEST) search_buf_size);
-
- found_ptr = (gdb_byte *) memmem (search_buf.data (), nr_search_bytes,
- pattern, pattern_len);
-
- if (found_ptr != NULL)
- {
- CORE_ADDR found_addr = start_addr + (found_ptr - search_buf.data ());
-
- *found_addrp = found_addr;
- return 1;
- }
-
- /* Not found in this chunk, skip to next chunk. */
-
- /* Don't let search_space_len wrap here, it's unsigned. */
- if (search_space_len >= chunk_size)
- search_space_len -= chunk_size;
- else
- search_space_len = 0;
-
- if (search_space_len >= pattern_len)
- {
- unsigned keep_len = search_buf_size - chunk_size;
- CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
- int nr_to_read;
-
- /* Copy the trailing part of the previous iteration to the front
- of the buffer for the next iteration. */
- gdb_assert (keep_len == pattern_len - 1);
- memcpy (&search_buf[0], &search_buf[chunk_size], keep_len);
-
- nr_to_read = std::min (search_space_len - keep_len,
- (ULONGEST) chunk_size);
-
- if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
- &search_buf[keep_len], read_addr,
- nr_to_read) != nr_to_read)
- {
- warning (_("Unable to access %s bytes of target "
- "memory at %s, halting search."),
- plongest (nr_to_read),
- hex_string (read_addr));
- return -1;
- }
-
- start_addr += chunk_size;
- }
- }
-
- /* Not found. */
-
- return 0;
-}
/* Default implementation of memory-searching. */
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp)
{
+ auto read_memory = [=] (CORE_ADDR addr, gdb_byte *result, size_t len)
+ {
+ return target_read (current_inferior ()->top_target (),
+ TARGET_OBJECT_MEMORY, NULL,
+ result, addr, len) == len;
+ };
+
/* Start over from the top of the target stack. */
- return simple_search_memory (current_top_target (),
- start_addr, search_space_len,
+ return simple_search_memory (read_memory, start_addr, search_space_len,
pattern, pattern_len, found_addrp);
}
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp)
{
- return current_top_target ()->search_memory (start_addr, search_space_len,
- pattern, pattern_len, found_addrp);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->search_memory (start_addr, search_space_len, pattern,
+ pattern_len, found_addrp);
}
/* Look through the currently pushed targets. If none of them will
void
target_require_runnable (void)
{
- for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
+ for (target_ops *t = current_inferior ()->top_target ();
+ t != NULL;
+ t = t->beneath ())
{
/* If this target knows how to create a new program, then
assume we will still be able to after killing the current
find_attach_target (void)
{
/* If a target on the current stack can attach, use it. */
- for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
+ for (target_ops *t = current_inferior ()->top_target ();
+ t != NULL;
+ t = t->beneath ())
{
if (t->can_attach ())
return t;
find_run_target (void)
{
/* If a target on the current stack can run, use it. */
- for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
+ for (target_ops *t = current_inferior ()->top_target ();
+ t != NULL;
+ t = t->beneath ())
{
if (t->can_create_inferior ())
return t;
int
target_supports_disable_randomization (void)
{
- return current_top_target ()->supports_disable_randomization ();
+ return current_inferior ()->top_target ()->supports_disable_randomization ();
}
/* See target/target.h. */
int
target_supports_multi_process (void)
{
- return current_top_target ()->supports_multi_process ();
+ return current_inferior ()->top_target ()->supports_multi_process ();
}
/* See target.h. */
{
struct address_space *aspace;
- aspace = current_top_target ()->thread_address_space (ptid);
+ aspace = current_inferior ()->top_target ()->thread_address_space (ptid);
gdb_assert (aspace != NULL);
return aspace;
int
target_can_run ()
{
- for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
+ for (target_ops *t = current_inferior ()->top_target ();
+ t != NULL;
+ t = t->beneath ())
{
if (t->can_run ())
return 1;
}
/* Error-catcher for target_make_corefile_notes. */
-static char *
+static gdb::unique_xmalloc_ptr<char>
dummy_make_corefile_notes (struct target_ops *self,
bfd *ignore1, int *ignore2)
{
void
target_close (struct target_ops *targ)
{
- gdb_assert (!target_is_pushed (targ));
+ gdb_assert (!current_inferior ()->target_is_pushed (targ));
fileio_handles_invalidate_target (targ);
int
target_thread_alive (ptid_t ptid)
{
- return current_top_target ()->thread_alive (ptid);
+ return current_inferior ()->top_target ()->thread_alive (ptid);
}
void
target_update_thread_list (void)
{
- current_top_target ()->update_thread_list ();
+ current_inferior ()->top_target ()->update_thread_list ();
}
void
target_stop (ptid_t ptid)
{
+ process_stratum_target *proc_target = current_inferior ()->process_target ();
+
+ gdb_assert (!proc_target->commit_resumed_state);
+
if (!may_stop)
{
warning (_("May not interrupt or stop the target, ignoring attempt"));
return;
}
- current_top_target ()->stop (ptid);
+ current_inferior ()->top_target ()->stop (ptid);
}
void
return;
}
- current_top_target ()->interrupt ();
+ current_inferior ()->top_target ()->interrupt ();
}
/* See target.h. */
through the target_stack. */
scoped_restore_current_inferior restore_inferior;
set_current_inferior (inf);
- current_top_target ()->pass_ctrlc ();
+ current_inferior ()->top_target ()->pass_ctrlc ();
return;
}
}
void
target_fetch_registers (struct regcache *regcache, int regno)
{
- current_top_target ()->fetch_registers (regcache, regno);
+ current_inferior ()->top_target ()->fetch_registers (regcache, regno);
if (targetdebug)
regcache->debug_print_register ("target_fetch_registers", regno);
}
if (!may_write_registers)
error (_("Writing to registers is not allowed (regno %d)"), regno);
- current_top_target ()->store_registers (regcache, regno);
+ current_inferior ()->top_target ()->store_registers (regcache, regno);
if (targetdebug)
{
regcache->debug_print_register ("target_store_registers", regno);
int
target_core_of_thread (ptid_t ptid)
{
- return current_top_target ()->core_of_thread (ptid);
+ return current_inferior ()->top_target ()->core_of_thread (ptid);
}
int
const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
{
/* Start over from the top of the target stack. */
- return simple_verify_memory (current_top_target (),
+ return simple_verify_memory (current_inferior ()->top_target (),
data, memaddr, size);
}
int
target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
{
- return current_top_target ()->verify_memory (data, memaddr, size);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->verify_memory (data, memaddr, size);
}
/* The documentation for this function is in its prototype declaration in
target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask,
enum target_hw_bp_type rw)
{
- return current_top_target ()->insert_mask_watchpoint (addr, mask, rw);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->insert_mask_watchpoint (addr, mask, rw);
}
/* The documentation for this function is in its prototype declaration in
target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask,
enum target_hw_bp_type rw)
{
- return current_top_target ()->remove_mask_watchpoint (addr, mask, rw);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->remove_mask_watchpoint (addr, mask, rw);
}
/* The documentation for this function is in its prototype declaration
int
target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask)
{
- return current_top_target ()->masked_watch_num_registers (addr, mask);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->masked_watch_num_registers (addr, mask);
}
/* The documentation for this function is in its prototype declaration
int
target_ranged_break_num_registers (void)
{
- return current_top_target ()->ranged_break_num_registers ();
+ return current_inferior ()->top_target ()->ranged_break_num_registers ();
}
/* See target.h. */
struct btrace_target_info *
target_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
{
- return current_top_target ()->enable_btrace (ptid, conf);
+ return current_inferior ()->top_target ()->enable_btrace (ptid, conf);
}
/* See target.h. */
void
target_disable_btrace (struct btrace_target_info *btinfo)
{
- current_top_target ()->disable_btrace (btinfo);
+ current_inferior ()->top_target ()->disable_btrace (btinfo);
}
/* See target.h. */
void
target_teardown_btrace (struct btrace_target_info *btinfo)
{
- current_top_target ()->teardown_btrace (btinfo);
+ current_inferior ()->top_target ()->teardown_btrace (btinfo);
}
/* See target.h. */
struct btrace_target_info *btinfo,
enum btrace_read_type type)
{
- return current_top_target ()->read_btrace (btrace, btinfo, type);
+ target_ops *target = current_inferior ()->top_target ();
+
+ return target->read_btrace (btrace, btinfo, type);
}
/* See target.h. */
const struct btrace_config *
target_btrace_conf (const struct btrace_target_info *btinfo)
{
- return current_top_target ()->btrace_conf (btinfo);
+ return current_inferior ()->top_target ()->btrace_conf (btinfo);
}
/* See target.h. */
void
target_stop_recording (void)
{
- current_top_target ()->stop_recording ();
+ current_inferior ()->top_target ()->stop_recording ();
}
/* See target.h. */
void
target_save_record (const char *filename)
{
- current_top_target ()->save_record (filename);
+ current_inferior ()->top_target ()->save_record (filename);
}
/* See target.h. */
int
target_supports_delete_record ()
{
- return current_top_target ()->supports_delete_record ();
+ return current_inferior ()->top_target ()->supports_delete_record ();
}
/* See target.h. */
void
target_delete_record (void)
{
- current_top_target ()->delete_record ();
+ current_inferior ()->top_target ()->delete_record ();
}
/* See target.h. */
enum record_method
target_record_method (ptid_t ptid)
{
- return current_top_target ()->record_method (ptid);
+ return current_inferior ()->top_target ()->record_method (ptid);
}
/* See target.h. */
int
target_record_is_replaying (ptid_t ptid)
{
- return current_top_target ()->record_is_replaying (ptid);
+ return current_inferior ()->top_target ()->record_is_replaying (ptid);
}
/* See target.h. */
int
target_record_will_replay (ptid_t ptid, int dir)
{
- return current_top_target ()->record_will_replay (ptid, dir);
+ return current_inferior ()->top_target ()->record_will_replay (ptid, dir);
}
/* See target.h. */
void
target_record_stop_replaying (void)
{
- current_top_target ()->record_stop_replaying ();
+ current_inferior ()->top_target ()->record_stop_replaying ();
}
/* See target.h. */
void
target_goto_record_begin (void)
{
- current_top_target ()->goto_record_begin ();
+ current_inferior ()->top_target ()->goto_record_begin ();
}
/* See target.h. */
void
target_goto_record_end (void)
{
- current_top_target ()->goto_record_end ();
+ current_inferior ()->top_target ()->goto_record_end ();
}
/* See target.h. */
void
target_goto_record (ULONGEST insn)
{
- current_top_target ()->goto_record (insn);
+ current_inferior ()->top_target ()->goto_record (insn);
}
/* See target.h. */
void
target_insn_history (int size, gdb_disassembly_flags flags)
{
- current_top_target ()->insn_history (size, flags);
+ current_inferior ()->top_target ()->insn_history (size, flags);
}
/* See target.h. */
target_insn_history_from (ULONGEST from, int size,
gdb_disassembly_flags flags)
{
- current_top_target ()->insn_history_from (from, size, flags);
+ current_inferior ()->top_target ()->insn_history_from (from, size, flags);
}
/* See target.h. */
target_insn_history_range (ULONGEST begin, ULONGEST end,
gdb_disassembly_flags flags)
{
- current_top_target ()->insn_history_range (begin, end, flags);
+ current_inferior ()->top_target ()->insn_history_range (begin, end, flags);
}
/* See target.h. */
void
target_call_history (int size, record_print_flags flags)
{
- current_top_target ()->call_history (size, flags);
+ current_inferior ()->top_target ()->call_history (size, flags);
}
/* See target.h. */
void
target_call_history_from (ULONGEST begin, int size, record_print_flags flags)
{
- current_top_target ()->call_history_from (begin, size, flags);
+ current_inferior ()->top_target ()->call_history_from (begin, size, flags);
}
/* See target.h. */
void
target_call_history_range (ULONGEST begin, ULONGEST end, record_print_flags flags)
{
- current_top_target ()->call_history_range (begin, end, flags);
+ current_inferior ()->top_target ()->call_history_range (begin, end, flags);
}
/* See target.h. */
const struct frame_unwind *
target_get_unwinder (void)
{
- return current_top_target ()->get_unwinder ();
+ return current_inferior ()->top_target ()->get_unwinder ();
}
/* See target.h. */
const struct frame_unwind *
target_get_tailcall_unwinder (void)
{
- return current_top_target ()->get_tailcall_unwinder ();
+ return current_inferior ()->top_target ()->get_tailcall_unwinder ();
}
/* See target.h. */
void
target_prepare_to_generate_core (void)
{
- current_top_target ()->prepare_to_generate_core ();
+ current_inferior ()->top_target ()->prepare_to_generate_core ();
}
/* See target.h. */
void
target_done_generating_core (void)
{
- current_top_target ()->done_generating_core ();
+ current_inferior ()->top_target ()->done_generating_core ();
}
\f
{
/* Is this a flash memory region? */
if (m.attrib.mode == MEM_FLASH)
- {
- found_flash_region = true;
- target_flash_erase (m.lo, m.hi - m.lo);
+ {
+ found_flash_region = true;
+ 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_core_addr ("address", gdbarch, m.lo);
- current_uiout->message (", size = ");
- current_uiout->field_string ("size", hex_string (m.hi - m.lo));
- current_uiout->message ("\n");
- }
+ current_uiout->message (_("Erasing flash memory region at address "));
+ current_uiout->field_core_addr ("address", gdbarch, m.lo);
+ current_uiout->message (", size = ");
+ current_uiout->field_string ("size", hex_string (m.hi - m.lo));
+ current_uiout->message ("\n");
+ }
}
/* Did we do any flash operations? If so, we need to finalize them. */
{
printf_filtered (_("The current target stack is:\n"));
- for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
+ for (target_ops *t = current_inferior ()->top_target ();
+ t != NULL;
+ t = t->beneath ())
{
if (t->stratum () == debug_stratum)
continue;
target_async (int enable)
{
infrun_async (enable);
- current_top_target ()->async (enable);
+ current_inferior ()->top_target ()->async (enable);
}
/* See target.h. */
void
target_thread_events (int enable)
{
- current_top_target ()->thread_events (enable);
+ current_inferior ()->top_target ()->thread_events (enable);
}
/* Controls if targets can report that they can/are async. This is
static int
target_always_non_stop_p (void)
{
- return current_top_target ()->always_non_stop_p ();
+ return current_inferior ()->top_target ()->always_non_stop_p ();
}
/* See target.h. */
-int
-target_is_non_stop_p (void)
+bool
+target_is_non_stop_p ()
{
- return (non_stop
- || target_non_stop_enabled == AUTO_BOOLEAN_TRUE
- || (target_non_stop_enabled == AUTO_BOOLEAN_AUTO
- && target_always_non_stop_p ()));
+ return ((non_stop
+ || target_non_stop_enabled == AUTO_BOOLEAN_TRUE
+ || (target_non_stop_enabled == AUTO_BOOLEAN_AUTO
+ && target_always_non_stop_p ()))
+ && target_can_async_p ());
}
/* See target.h. */
set_target_permissions (const char *args, int from_tty,
struct cmd_list_element *c)
{
- if (target_has_execution)
+ if (target_has_execution ())
{
update_target_permissions ();
error (_("Cannot change this setting while the inferior is running."));
_("Send a command to the remote monitor (remote targets only)."));
add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
- _("Print the name of each layer of the internal target stack."),
- &maintenanceprintlist);
+ _("Print the name of each layer of the internal target stack."),
+ &maintenanceprintlist);
add_setshow_boolean_cmd ("target-async", no_class,
&target_async_permitted_1, _("\
&setlist, &showlist);
add_com ("flash-erase", no_class, flash_erase_command,
- _("Erase all flash memory regions."));
+ _("Erase all flash memory regions."));
add_setshow_boolean_cmd ("auto-connect-native-target", class_support,
&auto_connect_native_target, _("\
projects / deliverable / binutils-gdb.git / blobdiff