#include "common/scoped_restore.h"
#include "environ.h"
#include "common/byte-vector.h"
+#include <unordered_map>
+
+/* The remote target. */
+
+static const char remote_doc[] = N_("\
+Use a remote computer via a serial line, using a gdb-specific protocol.\n\
+Specify the serial device it is connected to\n\
+(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
+
+static const target_info remote_target_info = {
+ "remote",
+ N_("Remote serial target in gdb-specific protocol"),
+ remote_doc
+};
+
+class remote_target : public target_ops
+{
+public:
+ remote_target ()
+ {
+ to_stratum = process_stratum;
+ }
+
+ const target_info &info () const override
+ { return remote_target_info; }
+
+ thread_control_capabilities get_thread_control_capabilities () override
+ { return tc_schedlock; }
+
+ /* Open a remote connection. */
+ static void open (const char *, int);
+
+ void close () override;
+
+ void detach (inferior *, int) override;
+ void disconnect (const char *, int) override;
+
+ void commit_resume () override;
+ void resume (ptid_t, int, enum gdb_signal) override;
+ ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
+
+ void fetch_registers (struct regcache *, int) override;
+ void store_registers (struct regcache *, int) override;
+ void prepare_to_store (struct regcache *) override;
+
+ void files_info () override;
+
+ int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override;
+
+ int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
+ enum remove_bp_reason) override;
+
+
+ bool stopped_by_sw_breakpoint () override;
+ bool supports_stopped_by_sw_breakpoint () override;
+
+ bool stopped_by_hw_breakpoint () override;
+
+ bool supports_stopped_by_hw_breakpoint () override;
+
+ bool stopped_by_watchpoint () override;
+
+ bool stopped_data_address (CORE_ADDR *) override;
+
+ bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
+
+ int can_use_hw_breakpoint (enum bptype, int, int) override;
+
+ int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
+
+ int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
+
+ int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
+
+ int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
+ struct expression *) override;
+
+ int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
+ struct expression *) override;
+
+ void kill () override;
+
+ void load (const char *, int) override;
+
+ void mourn_inferior () override;
+
+ void pass_signals (int, unsigned char *) override;
+
+ int set_syscall_catchpoint (int, bool, int,
+ gdb::array_view<const int>) override;
+
+ void program_signals (int, unsigned char *) override;
+
+ bool thread_alive (ptid_t ptid) override;
+
+ const char *thread_name (struct thread_info *) override;
+
+ void update_thread_list () override;
+
+ const char *pid_to_str (ptid_t) override;
+
+ const char *extra_thread_info (struct thread_info *) override;
+
+ ptid_t get_ada_task_ptid (long lwp, long thread) override;
+
+ thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle,
+ int handle_len,
+ inferior *inf) override;
+
+ void stop (ptid_t) override;
+
+ void interrupt () override;
+
+ void pass_ctrlc () override;
+
+ enum target_xfer_status xfer_partial (enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len) override;
+
+ ULONGEST get_memory_xfer_limit () override;
+
+ void rcmd (const char *command, struct ui_file *output) override;
+
+ char *pid_to_exec_file (int pid) override;
+
+ void log_command (const char *cmd) override
+ {
+ serial_log_command (this, cmd);
+ }
+
+ CORE_ADDR get_thread_local_address (ptid_t ptid,
+ CORE_ADDR load_module_addr,
+ CORE_ADDR offset) override;
+
+ bool has_all_memory () override { return default_child_has_all_memory (); }
+ bool has_memory () override { return default_child_has_memory (); }
+ bool has_stack () override { return default_child_has_stack (); }
+ bool has_registers () override { return default_child_has_registers (); }
+ bool has_execution (ptid_t ptid) override { return default_child_has_execution (ptid); }
+
+ bool can_execute_reverse () override;
+
+ std::vector<mem_region> memory_map () override;
+
+ void flash_erase (ULONGEST address, LONGEST length) override;
+
+ void flash_done () override;
+
+ const struct target_desc *read_description () override;
+
+ int search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
+ const gdb_byte *pattern, ULONGEST pattern_len,
+ CORE_ADDR *found_addrp) override;
+
+ bool can_async_p () override;
+
+ bool is_async_p () override;
+
+ void async (int) override;
+
+ void thread_events (int) override;
+
+ int can_do_single_step () override;
+
+ void terminal_inferior () override;
+
+ void terminal_ours () override;
+
+ bool supports_non_stop () override;
+
+ bool supports_multi_process () override;
+
+ bool supports_disable_randomization () override;
+
+ bool filesystem_is_local () override;
+
+
+ int fileio_open (struct inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
+ int *target_errno) override;
+
+ int fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
+ ULONGEST offset, int *target_errno) override;
+
+ int fileio_pread (int fd, gdb_byte *read_buf, int len,
+ ULONGEST offset, int *target_errno) override;
+
+ int fileio_fstat (int fd, struct stat *sb, int *target_errno) override;
+
+ int fileio_close (int fd, int *target_errno) override;
+
+ int fileio_unlink (struct inferior *inf,
+ const char *filename,
+ int *target_errno) override;
+
+ gdb::optional<std::string>
+ fileio_readlink (struct inferior *inf,
+ const char *filename,
+ int *target_errno) override;
+
+ bool supports_enable_disable_tracepoint () override;
+
+ bool supports_string_tracing () override;
+
+ bool supports_evaluation_of_breakpoint_conditions () override;
+
+ bool can_run_breakpoint_commands () override;
+
+ void trace_init () override;
+
+ void download_tracepoint (struct bp_location *location) override;
+
+ bool can_download_tracepoint () override;
+
+ void download_trace_state_variable (const trace_state_variable &tsv) override;
+
+ void enable_tracepoint (struct bp_location *location) override;
+
+ void disable_tracepoint (struct bp_location *location) override;
+
+ void trace_set_readonly_regions () override;
+
+ void trace_start () override;
+
+ int get_trace_status (struct trace_status *ts) override;
+
+ void get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
+ override;
+
+ void trace_stop () override;
+
+ int trace_find (enum trace_find_type type, int num,
+ CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override;
+
+ bool get_trace_state_variable_value (int tsv, LONGEST *val) override;
+
+ int save_trace_data (const char *filename) override;
+
+ int upload_tracepoints (struct uploaded_tp **utpp) override;
+
+ int upload_trace_state_variables (struct uploaded_tsv **utsvp) override;
+
+ LONGEST get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) override;
+
+ int get_min_fast_tracepoint_insn_len () override;
+
+ void set_disconnected_tracing (int val) override;
+
+ void set_circular_trace_buffer (int val) override;
+
+ void set_trace_buffer_size (LONGEST val) override;
+
+ bool set_trace_notes (const char *user, const char *notes,
+ const char *stopnotes) override;
+
+ int core_of_thread (ptid_t ptid) override;
+
+ int verify_memory (const gdb_byte *data,
+ CORE_ADDR memaddr, ULONGEST size) override;
+
+
+ bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override;
+
+ void set_permissions () override;
+
+ bool static_tracepoint_marker_at (CORE_ADDR,
+ struct static_tracepoint_marker *marker)
+ override;
+
+ std::vector<static_tracepoint_marker>
+ static_tracepoint_markers_by_strid (const char *id) override;
+
+ traceframe_info_up traceframe_info () override;
+
+ bool use_agent (bool use) override;
+ bool can_use_agent () override;
+
+ struct btrace_target_info *enable_btrace (ptid_t ptid,
+ const struct btrace_config *conf) override;
+
+ void disable_btrace (struct btrace_target_info *tinfo) override;
+
+ void teardown_btrace (struct btrace_target_info *tinfo) override;
+
+ enum btrace_error read_btrace (struct btrace_data *data,
+ struct btrace_target_info *btinfo,
+ enum btrace_read_type type) override;
+
+ const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
+ bool augmented_libraries_svr4_read () override;
+ int follow_fork (int, int) override;
+ void follow_exec (struct inferior *, char *) override;
+ int insert_fork_catchpoint (int) override;
+ int remove_fork_catchpoint (int) override;
+ int insert_vfork_catchpoint (int) override;
+ int remove_vfork_catchpoint (int) override;
+ int insert_exec_catchpoint (int) override;
+ int remove_exec_catchpoint (int) override;
+ enum exec_direction_kind execution_direction () override;
+
+protected:
+ static void open_1 (const char *name, int from_tty, int extended_p);
+ void start_remote (int from_tty, int extended_p);
+};
+
+static const target_info extended_remote_target_info = {
+ "extended-remote",
+ N_("Extended remote serial target in gdb-specific protocol"),
+ remote_doc
+};
+
+/* Set up the extended remote target by extending the standard remote
+ target and adding to it. */
+
+class extended_remote_target final : public remote_target
+{
+public:
+ const target_info &info () const override
+ { return extended_remote_target_info; }
+
+ /* Open an extended-remote connection. */
+ static void open (const char *, int);
+
+ bool can_create_inferior () override { return true; }
+ void create_inferior (const char *, const std::string &,
+ char **, int) override;
+
+ void detach (inferior *, int) override;
+
+ bool can_attach () override { return true; }
+ void attach (const char *, int) override;
+
+ void post_attach (int) override;
+ bool supports_disable_randomization () override;
+};
/* Per-program-space data key. */
static const struct program_space_data *remote_pspace_data;
static int getpkt_or_notif_sane (char **buf, long *sizeof_buf,
int forever, int *is_notif);
-static void remote_files_info (struct target_ops *ignore);
-
-static void remote_prepare_to_store (struct target_ops *self,
- struct regcache *regcache);
-
-static void remote_open_1 (const char *, int, struct target_ops *,
- int extended_p);
-
-static void remote_close (struct target_ops *self);
-
struct remote_state;
static int remote_vkill (int pid, struct remote_state *rs);
static void remote_kill_k (void);
-static void remote_mourn (struct target_ops *ops);
-
-static void extended_remote_restart (void);
-
-static void remote_send (char **buf, long *sizeof_buf_p);
-
static int readchar (int timeout);
static void remote_serial_write (const char *str, int len);
-static void remote_kill (struct target_ops *ops);
-
-static int remote_can_async_p (struct target_ops *);
-
-static int remote_is_async_p (struct target_ops *);
-
-static void remote_async (struct target_ops *ops, int enable);
-
-static void remote_thread_events (struct target_ops *ops, int enable);
-
static void interrupt_query (void);
static void set_general_thread (ptid_t ptid);
static int hexnumlen (ULONGEST num);
-static void init_remote_ops (void);
-
-static void init_extended_remote_ops (void);
-
-static void remote_stop (struct target_ops *self, ptid_t);
-
static int stubhex (int ch);
static int hexnumstr (char *, ULONGEST);
static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
static ptid_t read_ptid (const char *buf, const char **obuf);
-static void remote_set_permissions (struct target_ops *self);
-
-static int remote_get_trace_status (struct target_ops *self,
- struct trace_status *ts);
-
-static int remote_upload_tracepoints (struct target_ops *self,
- struct uploaded_tp **utpp);
-
-static int remote_upload_trace_state_variables (struct target_ops *self,
- struct uploaded_tsv **utsvp);
-
static void remote_query_supported (void);
static void remote_check_symbols (void);
static void remote_async_inferior_event_handler (gdb_client_data);
-static void remote_terminal_ours (struct target_ops *self);
-
static int remote_read_description_p (struct target_ops *target);
static void remote_console_output (char *msg);
-static int remote_supports_cond_breakpoints (struct target_ops *self);
-
-static int remote_can_run_breakpoint_commands (struct target_ops *self);
-
static void remote_btrace_reset (void);
static void remote_btrace_maybe_reopen (void);
static int stop_reply_queue_length (void);
-static void readahead_cache_invalidate (void);
-
static void remote_unpush_and_throw (void);
static struct remote_state *get_remote_state (void);
struct vCont_action_support
{
/* vCont;t */
- int t;
+ bool t = false;
/* vCont;r */
- int r;
+ bool r = false;
/* vCont;s */
- int s;
+ bool s = false;
/* vCont;S */
- int S;
+ bool S = false;
};
/* Controls whether GDB is willing to use range stepping. */
struct readahead_cache
{
+ /* Invalidate the readahead cache. */
+ void invalidate ();
+
+ /* Invalidate the readahead cache if it is holding data for FD. */
+ void invalidate_fd (int fd);
+
+ /* Serve pread from the readahead cache. Returns number of bytes
+ read, or 0 if the request can't be served from the cache. */
+ int pread (int fd, gdb_byte *read_buf, size_t len, ULONGEST offset);
+
/* The file descriptor for the file that is being cached. -1 if the
cache is invalid. */
- int fd;
+ int fd = -1;
/* The offset into the file that the cache buffer corresponds
to. */
- ULONGEST offset;
+ ULONGEST offset = 0;
/* The buffer holding the cache contents. */
- gdb_byte *buf;
+ gdb_byte *buf = nullptr;
/* The buffer's size. We try to read as much as fits into a packet
at a time. */
- size_t bufsize;
+ size_t bufsize = 0;
/* Cache hit and miss counters. */
- ULONGEST hit_count;
- ULONGEST miss_count;
+ ULONGEST hit_count = 0;
+ ULONGEST miss_count = 0;
+};
+
+/* Description of the remote protocol for a given architecture. */
+
+struct packet_reg
+{
+ long offset; /* Offset into G packet. */
+ long regnum; /* GDB's internal register number. */
+ LONGEST pnum; /* Remote protocol register number. */
+ int in_g_packet; /* Always part of G packet. */
+ /* long size in bytes; == register_size (target_gdbarch (), regnum);
+ at present. */
+ /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
+ at present. */
+};
+
+struct remote_arch_state
+{
+ explicit remote_arch_state (struct gdbarch *gdbarch);
+
+ /* Description of the remote protocol registers. */
+ long sizeof_g_packet;
+
+ /* Description of the remote protocol registers indexed by REGNUM
+ (making an array gdbarch_num_regs in size). */
+ std::unique_ptr<packet_reg[]> regs;
+
+ /* This is the size (in chars) of the first response to the ``g''
+ packet. It is used as a heuristic when determining the maximum
+ size of memory-read and memory-write packets. A target will
+ typically only reserve a buffer large enough to hold the ``g''
+ packet. The size does not include packet overhead (headers and
+ trailers). */
+ long actual_register_packet_size;
+
+ /* This is the maximum size (in chars) of a non read/write packet.
+ It is also used as a cap on the size of read/write packets. */
+ long remote_packet_size;
};
/* Description of the remote protocol state for the currently
connected target. This is per-target state, and independent of the
selected architecture. */
-struct remote_state
+class remote_state
{
+public:
+
+ remote_state ();
+ ~remote_state ();
+
+ /* Get the remote arch state for GDBARCH. */
+ struct remote_arch_state *get_remote_arch_state (struct gdbarch *gdbarch);
+
+public: /* data */
+
/* A buffer to use for incoming packets, and its current size. The
buffer is grown dynamically for larger incoming packets.
Outgoing packets may also be constructed in this buffer.
/* True if we're going through initial connection setup (finding out
about the remote side's threads, relocating symbols, etc.). */
- int starting_up;
+ bool starting_up = false;
/* If we negotiated packet size explicitly (and thus can bypass
heuristics for the largest packet size that will not overflow
a buffer in the stub), this will be set to that packet size.
Otherwise zero, meaning to use the guessed size. */
- long explicit_packet_size;
+ long explicit_packet_size = 0;
/* remote_wait is normally called when the target is running and
waits for a stop reply packet. But sometimes we need to call it
the response, we can stash it in BUF and tell remote_wait to
skip calling getpkt. This flag is set when BUF contains a
stop reply packet and the target is not waiting. */
- int cached_wait_status;
+ int cached_wait_status = 0;
/* True, if in no ack mode. That is, neither GDB nor the stub will
expect acks from each other. The connection is assumed to be
reliable. */
- int noack_mode;
+ bool noack_mode = false;
/* True if we're connected in extended remote mode. */
- int extended;
+ bool extended = false;
/* True if we resumed the target and we're waiting for the target to
stop. In the mean time, we can't start another command/query.
timeout waiting for a reply that would never come and eventually
we'd close the connection. This can happen in asynchronous mode
because we allow GDB commands while the target is running. */
- int waiting_for_stop_reply;
+ bool waiting_for_stop_reply = false;
/* The status of the stub support for the various vCont actions. */
- struct vCont_action_support supports_vCont;
+ vCont_action_support supports_vCont;
- /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
+ /* True if the user has pressed Ctrl-C, but the target hasn't
responded to that. */
- int ctrlc_pending_p;
+ bool ctrlc_pending_p = false;
/* True if we saw a Ctrl-C while reading or writing from/to the
remote descriptor. At that point it is not safe to send a remote
process it once we're done with sending/receiving the current
packet, which should be shortly. If however that takes too long,
and the user presses Ctrl-C again, we offer to disconnect. */
- int got_ctrlc_during_io;
+ bool got_ctrlc_during_io = false;
/* Descriptor for I/O to remote machine. Initialize it to NULL so that
remote_open knows that we don't have a file open when the program
starts. */
- struct serial *remote_desc;
+ struct serial *remote_desc = nullptr;
/* These are the threads which we last sent to the remote system. The
TID member will be -1 for all or -2 for not sent yet. */
- ptid_t general_thread;
- ptid_t continue_thread;
+ ptid_t general_thread = null_ptid;
+ ptid_t continue_thread = null_ptid;
/* This is the traceframe which we last selected on the remote system.
It will be -1 if no traceframe is selected. */
- int remote_traceframe_number;
+ int remote_traceframe_number = -1;
- char *last_pass_packet;
+ char *last_pass_packet = nullptr;
/* The last QProgramSignals packet sent to the target. We bypass
sending a new program signals list down to the target if the new
packet is exactly the same as the last we sent. IOW, we only let
the target know about program signals list changes. */
- char *last_program_signals_packet;
+ char *last_program_signals_packet = nullptr;
- enum gdb_signal last_sent_signal;
+ gdb_signal last_sent_signal = GDB_SIGNAL_0;
- int last_sent_step;
+ bool last_sent_step = false;
/* The execution direction of the last resume we got. */
- enum exec_direction_kind last_resume_exec_dir;
+ exec_direction_kind last_resume_exec_dir = EXEC_FORWARD;
- char *finished_object;
- char *finished_annex;
- ULONGEST finished_offset;
+ char *finished_object = nullptr;
+ char *finished_annex = nullptr;
+ ULONGEST finished_offset = 0;
/* Should we try the 'ThreadInfo' query packet?
query or the older, more complex syntax for thread queries.
This is an auto-detect variable (set to true at each connect,
and set to false when the target fails to recognize it). */
- int use_threadinfo_query;
- int use_threadextra_query;
+ bool use_threadinfo_query = false;
+ bool use_threadextra_query = false;
- threadref echo_nextthread;
- threadref nextthread;
- threadref resultthreadlist[MAXTHREADLISTRESULTS];
+ threadref echo_nextthread {};
+ threadref nextthread {};
+ threadref resultthreadlist[MAXTHREADLISTRESULTS] {};
/* The state of remote notification. */
- struct remote_notif_state *notif_state;
+ struct remote_notif_state *notif_state = nullptr;
/* The branch trace configuration. */
- struct btrace_config btrace_config;
+ struct btrace_config btrace_config {};
/* The argument to the last "vFile:setfs:" packet we sent, used
to avoid sending repeated unnecessary "vFile:setfs:" packets.
Initialized to -1 to indicate that no "vFile:setfs:" packet
has yet been sent. */
- int fs_pid;
+ int fs_pid = -1;
/* A readahead cache for vFile:pread. Often, reading a binary
involves a sequence of small reads. E.g., when parsing an ELF
request/reply nature of the RSP. We only cache data for a single
file descriptor at a time. */
struct readahead_cache readahead_cache;
+
+private:
+ /* Mapping of remote protocol data for each gdbarch. Usually there
+ is only one entry here, though we may see more with stubs that
+ support multi-process. */
+ std::unordered_map<struct gdbarch *, remote_arch_state>
+ m_arch_states;
};
/* Private data that we'll store in (struct thread_info)->priv. */
int vcont_resumed = 0;
};
+remote_state::remote_state ()
+{
+ /* The default buffer size is unimportant; it will be expanded
+ whenever a larger buffer is needed. */
+ this->buf_size = 400;
+ this->buf = (char *) xmalloc (this->buf_size);
+}
+
+remote_state::~remote_state ()
+{
+ xfree (this->last_pass_packet);
+ xfree (this->last_program_signals_packet);
+ xfree (this->buf);
+ xfree (this->finished_object);
+ xfree (this->finished_annex);
+}
+
/* This data could be associated with a target, but we do not always
have access to the current target when we need it, so for now it is
static. This will be fine for as long as only one target is in use
return remote_state;
}
-/* Allocate a new struct remote_state with xmalloc, initialize it, and
- return it. */
-
-static struct remote_state *
-new_remote_state (void)
-{
- struct remote_state *result = XCNEW (struct remote_state);
-
- /* The default buffer size is unimportant; it will be expanded
- whenever a larger buffer is needed. */
- result->buf_size = 400;
- result->buf = (char *) xmalloc (result->buf_size);
- result->remote_traceframe_number = -1;
- result->last_sent_signal = GDB_SIGNAL_0;
- result->last_resume_exec_dir = EXEC_FORWARD;
- result->fs_pid = -1;
-
- return result;
-}
-
-/* Description of the remote protocol for a given architecture. */
-
-struct packet_reg
-{
- long offset; /* Offset into G packet. */
- long regnum; /* GDB's internal register number. */
- LONGEST pnum; /* Remote protocol register number. */
- int in_g_packet; /* Always part of G packet. */
- /* long size in bytes; == register_size (target_gdbarch (), regnum);
- at present. */
- /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
- at present. */
-};
-
-struct remote_arch_state
-{
- /* Description of the remote protocol registers. */
- long sizeof_g_packet;
-
- /* Description of the remote protocol registers indexed by REGNUM
- (making an array gdbarch_num_regs in size). */
- struct packet_reg *regs;
-
- /* This is the size (in chars) of the first response to the ``g''
- packet. It is used as a heuristic when determining the maximum
- size of memory-read and memory-write packets. A target will
- typically only reserve a buffer large enough to hold the ``g''
- packet. The size does not include packet overhead (headers and
- trailers). */
- long actual_register_packet_size;
-
- /* This is the maximum size (in chars) of a non read/write packet.
- It is also used as a cap on the size of read/write packets. */
- long remote_packet_size;
-};
-
/* Utility: generate error from an incoming stub packet. */
static void
trace_error (char *buf)
while (1);
}
-/* Handle for retreving the remote protocol data from gdbarch. */
-static struct gdbarch_data *remote_gdbarch_data_handle;
-
-static struct remote_arch_state *
-get_remote_arch_state (struct gdbarch *gdbarch)
+struct remote_arch_state *
+remote_state::get_remote_arch_state (struct gdbarch *gdbarch)
{
- gdb_assert (gdbarch != NULL);
- return ((struct remote_arch_state *)
- gdbarch_data (gdbarch, remote_gdbarch_data_handle));
+ remote_arch_state *rsa;
+
+ auto it = this->m_arch_states.find (gdbarch);
+ if (it == this->m_arch_states.end ())
+ {
+ auto p = this->m_arch_states.emplace (std::piecewise_construct,
+ std::forward_as_tuple (gdbarch),
+ std::forward_as_tuple (gdbarch));
+ rsa = &p.first->second;
+
+ /* Make sure that the packet buffer is plenty big enough for
+ this architecture. */
+ if (this->buf_size < rsa->remote_packet_size)
+ {
+ this->buf_size = 2 * rsa->remote_packet_size;
+ this->buf = (char *) xrealloc (this->buf, this->buf_size);
+ }
+ }
+ else
+ rsa = &it->second;
+
+ return rsa;
}
/* Fetch the global remote target state. */
static struct remote_state *
get_remote_state (void)
{
+ struct remote_state *rs = get_remote_state_raw ();
+
/* Make sure that the remote architecture state has been
initialized, because doing so might reallocate rs->buf. Any
function which calls getpkt also needs to be mindful of changes
to rs->buf, but this call limits the number of places which run
into trouble. */
- get_remote_arch_state (target_gdbarch ());
+ rs->get_remote_arch_state (target_gdbarch ());
- return get_remote_state_raw ();
+ return rs;
}
/* Cleanup routine for the remote module's pspace data. */
return *pnum != -1;
}
-static void *
-init_remote_state (struct gdbarch *gdbarch)
+remote_arch_state::remote_arch_state (struct gdbarch *gdbarch)
{
- struct remote_state *rs = get_remote_state_raw ();
- struct remote_arch_state *rsa;
-
- rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
-
/* Use the architecture to build a regnum<->pnum table, which will be
1:1 unless a feature set specifies otherwise. */
- rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
- gdbarch_num_regs (gdbarch),
- struct packet_reg);
+ this->regs.reset (new packet_reg [gdbarch_num_regs (gdbarch)] ());
/* Record the maximum possible size of the g packet - it may turn out
to be smaller. */
- rsa->sizeof_g_packet = map_regcache_remote_table (gdbarch, rsa->regs);
+ this->sizeof_g_packet
+ = map_regcache_remote_table (gdbarch, this->regs.get ());
/* Default maximum number of characters in a packet body. Many
remote stubs have a hardwired buffer size of 400 bytes
NUL character can always fit in the buffer. This stops GDB
trashing stubs that try to squeeze an extra NUL into what is
already a full buffer (As of 1999-12-04 that was most stubs). */
- rsa->remote_packet_size = 400 - 1;
+ this->remote_packet_size = 400 - 1;
/* This one is filled in when a ``g'' packet is received. */
- rsa->actual_register_packet_size = 0;
+ this->actual_register_packet_size = 0;
/* Should rsa->sizeof_g_packet needs more space than the
default, adjust the size accordingly. Remember that each byte is
header / footer. NOTE: cagney/1999-10-26: I suspect that 8
(``$NN:G...#NN'') is a better guess, the below has been padded a
little. */
- if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
- rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
-
- /* Make sure that the packet buffer is plenty big enough for
- this architecture. */
- if (rs->buf_size < rsa->remote_packet_size)
- {
- rs->buf_size = 2 * rsa->remote_packet_size;
- rs->buf = (char *) xrealloc (rs->buf, rs->buf_size);
- }
-
- return rsa;
+ if (this->sizeof_g_packet > ((this->remote_packet_size - 32) / 2))
+ this->remote_packet_size = (this->sizeof_g_packet * 2 + 32);
}
/* Return the current allowed size of a remote packet. This is
get_remote_packet_size (void)
{
struct remote_state *rs = get_remote_state ();
- remote_arch_state *rsa = get_remote_arch_state (target_gdbarch ());
+ remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
if (rs->explicit_packet_size)
return rs->explicit_packet_size;
return NULL;
}
-static struct target_ops remote_ops;
+static remote_target remote_ops;
-static struct target_ops extended_remote_ops;
+static extended_remote_target extended_remote_ops;
/* FIXME: cagney/1999-09-23: Even though getpkt was called with
``forever'' still use the normal timeout mechanism. This is
get_memory_packet_size (struct memory_packet_config *config)
{
struct remote_state *rs = get_remote_state ();
- remote_arch_state *rsa = get_remote_arch_state (target_gdbarch ());
+ remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
long what_they_get;
if (config->fixed_p)
/* Insert fork catchpoint target routine. If fork events are enabled
then return success, nothing more to do. */
-static int
-remote_insert_fork_catchpoint (struct target_ops *ops, int pid)
+int
+remote_target::insert_fork_catchpoint (int pid)
{
struct remote_state *rs = get_remote_state ();
/* Remove fork catchpoint target routine. Nothing to do, just
return success. */
-static int
-remote_remove_fork_catchpoint (struct target_ops *ops, int pid)
+int
+remote_target::remove_fork_catchpoint (int pid)
{
return 0;
}
/* Insert vfork catchpoint target routine. If vfork events are enabled
then return success, nothing more to do. */
-static int
-remote_insert_vfork_catchpoint (struct target_ops *ops, int pid)
+int
+remote_target::insert_vfork_catchpoint (int pid)
{
struct remote_state *rs = get_remote_state ();
/* Remove vfork catchpoint target routine. Nothing to do, just
return success. */
-static int
-remote_remove_vfork_catchpoint (struct target_ops *ops, int pid)
+int
+remote_target::remove_vfork_catchpoint (int pid)
{
return 0;
}
/* Insert exec catchpoint target routine. If exec events are
enabled, just return success. */
-static int
-remote_insert_exec_catchpoint (struct target_ops *ops, int pid)
+int
+remote_target::insert_exec_catchpoint (int pid)
{
struct remote_state *rs = get_remote_state ();
/* Remove exec catchpoint target routine. Nothing to do, just
return success. */
-static int
-remote_remove_exec_catchpoint (struct target_ops *ops, int pid)
+int
+remote_target::remove_exec_catchpoint (int pid)
{
return 0;
}
/* If 'QPassSignals' is supported, tell the remote stub what signals
it can simply pass through to the inferior without reporting. */
-static void
-remote_pass_signals (struct target_ops *self,
- int numsigs, unsigned char *pass_signals)
+void
+remote_target::pass_signals (int numsigs, unsigned char *pass_signals)
{
if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
{
/* If 'QCatchSyscalls' is supported, tell the remote stub
to report syscalls to GDB. */
-static int
-remote_set_syscall_catchpoint (struct target_ops *self,
- int pid, bool needed, int any_count,
- gdb::array_view<const int> syscall_counts)
+int
+remote_target::set_syscall_catchpoint (int pid, bool needed, int any_count,
+ gdb::array_view<const int> syscall_counts)
{
const char *catch_packet;
enum packet_result result;
/* If 'QProgramSignals' is supported, tell the remote stub what
signals it should pass through to the inferior when detaching. */
-static void
-remote_program_signals (struct target_ops *self,
- int numsigs, unsigned char *signals)
+void
+remote_target::program_signals (int numsigs, unsigned char *signals)
{
if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
{
to model non-threaded targets as single-threaded. */
static int
-remote_thread_always_alive (struct target_ops *ops, ptid_t ptid)
+remote_thread_always_alive (ptid_t ptid)
{
if (ptid_equal (ptid, magic_null_ptid))
/* The main thread is always alive. */
/* Return nonzero if the thread PTID is still alive on the remote
system. */
-static int
-remote_thread_alive (struct target_ops *ops, ptid_t ptid)
+bool
+remote_target::thread_alive (ptid_t ptid)
{
struct remote_state *rs = get_remote_state ();
char *p, *endp;
/* Check if this is a thread that we made up ourselves to model
non-threaded targets as single-threaded. */
- if (remote_thread_always_alive (ops, ptid))
+ if (remote_thread_always_alive (ptid))
return 1;
p = rs->buf;
/* Return a pointer to a thread name if we know it and NULL otherwise.
The thread_info object owns the memory for the name. */
-static const char *
-remote_thread_name (struct target_ops *ops, struct thread_info *info)
+const char *
+remote_target::thread_name (struct thread_info *info)
{
if (info->priv != NULL)
{
/* Implement the to_update_thread_list function for the remote
targets. */
-static void
-remote_update_thread_list (struct target_ops *ops)
+void
+remote_target::update_thread_list ()
{
struct threads_listing_context context;
int got_list = 0;
/* We have a few different mechanisms to fetch the thread list. Try
them all, starting with the most preferred one first, falling
back to older methods. */
- if (remote_get_threads_with_qxfer (ops, &context)
- || remote_get_threads_with_qthreadinfo (ops, &context)
- || remote_get_threads_with_ql (ops, &context))
+ if (remote_get_threads_with_qxfer (this, &context)
+ || remote_get_threads_with_qthreadinfo (this, &context)
+ || remote_get_threads_with_ql (this, &context))
{
struct thread_info *tp, *tmp;
got_list = 1;
if (context.items.empty ()
- && remote_thread_always_alive (ops, inferior_ptid))
+ && remote_thread_always_alive (inferior_ptid))
{
/* Some targets don't really support threads, but still
reply an (empty) thread list in response to the thread
* Optional: targets are not required to implement this function.
*/
-static const char *
-remote_threads_extra_info (struct target_ops *self, struct thread_info *tp)
+const char *
+remote_target::extra_thread_info (thread_info *tp)
{
struct remote_state *rs = get_remote_state ();
int result;
}
\f
-static bool
-remote_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR addr,
- struct static_tracepoint_marker *marker)
+bool
+remote_target::static_tracepoint_marker_at (CORE_ADDR addr,
+ struct static_tracepoint_marker *marker)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
return false;
}
-static std::vector<static_tracepoint_marker>
-remote_static_tracepoint_markers_by_strid (struct target_ops *self,
- const char *strid)
+std::vector<static_tracepoint_marker>
+remote_target::static_tracepoint_markers_by_strid (const char *strid)
{
struct remote_state *rs = get_remote_state ();
std::vector<static_tracepoint_marker> markers;
\f
/* Implement the to_get_ada_task_ptid function for the remote targets. */
-static ptid_t
-remote_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
+ptid_t
+remote_target::get_ada_task_ptid (long lwp, long thread)
{
return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
}
\f
/* Clean up connection to a remote debugger. */
-static void
-remote_close (struct target_ops *self)
+void
+remote_target::close ()
{
struct remote_state *rs = get_remote_state ();
return; /* already closed */
/* Make sure we leave stdin registered in the event loop. */
- remote_terminal_ours (self);
+ terminal_ours ();
serial_close (rs->remote_desc);
rs->remote_desc = NULL;
/* Start the remote connection and sync state. */
-static void
-remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
+void
+remote_target::start_remote (int from_tty, int extended_p)
{
struct remote_state *rs = get_remote_state ();
struct packet_config *noack_config;
/* If the stub wants to get a QAllow, compose one and send it. */
if (packet_support (PACKET_QAllow) != PACKET_DISABLE)
- remote_set_permissions (target);
+ set_permissions ();
/* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
controlling. We default to adding them in the running state.
The '?' query below will then tell us about which threads are
stopped. */
- remote_update_thread_list (target);
+ this->update_thread_list ();
}
else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE)
{
/* Upload TSVs regardless of whether the target is running or not. The
remote stub, such as GDBserver, may have some predefined or builtin
TSVs, even if the target is not running. */
- if (remote_get_trace_status (target, current_trace_status ()) != -1)
+ if (get_trace_status (current_trace_status ()) != -1)
{
struct uploaded_tsv *uploaded_tsvs = NULL;
- remote_upload_trace_state_variables (target, &uploaded_tsvs);
+ upload_trace_state_variables (&uploaded_tsvs);
merge_uploaded_trace_state_variables (&uploaded_tsvs);
}
how to do it some other way, try again. This is not
supported for non-stop; it could be, but it is tricky if
there are no stopped threads when we connect. */
- if (remote_read_description_p (target)
+ if (remote_read_description_p (this)
&& gdbarch_target_desc (target_gdbarch ()) == NULL)
{
target_clear_description ();
strcpy (rs->buf, wait_status);
rs->cached_wait_status = 1;
- start_remote (from_tty); /* Initialize gdb process mechanisms. */
+ ::start_remote (from_tty); /* Initialize gdb process mechanisms. */
}
else
{
gdb_assert (wait_status == NULL);
/* Report all signals during attach/startup. */
- remote_pass_signals (target, 0, NULL);
+ pass_signals (0, NULL);
/* If there are already stopped threads, mark them stopped and
report their stops before giving the prompt to the user. */
/* Possibly the target has been engaged in a trace run started
previously; find out where things are at. */
- if (remote_get_trace_status (target, current_trace_status ()) != -1)
+ if (get_trace_status (current_trace_status ()) != -1)
{
struct uploaded_tp *uploaded_tps = NULL;
if (current_trace_status ()->running)
printf_filtered (_("Trace is already running on the target.\n"));
- remote_upload_tracepoints (target, &uploaded_tps);
+ upload_tracepoints (&uploaded_tps);
merge_uploaded_tracepoints (&uploaded_tps);
}
/* Open a connection to a remote debugger.
NAME is the filename used for communication. */
-static void
-remote_open (const char *name, int from_tty)
+void
+remote_target::open (const char *name, int from_tty)
{
- remote_open_1 (name, from_tty, &remote_ops, 0);
+ open_1 (name, from_tty, 0);
}
/* Open a connection to a remote debugger using the extended
remote gdb protocol. NAME is the filename used for communication. */
-static void
-extended_remote_open (const char *name, int from_tty)
+void
+extended_remote_target::open (const char *name, int from_tty)
{
- remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */);
+ open_1 (name, from_tty, 1 /*extended_p */);
}
/* Reset all packets back to "unknown support". Called when opening a
instead of any data function descriptor. */
sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
sym_addr,
- ¤t_target);
+ target_stack);
xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
phex_nz (sym_addr, addr_size), &reply[8]);
permissions. */
void
-remote_set_permissions (struct target_ops *self)
+remote_target::set_permissions ()
{
struct remote_state *rs = get_remote_state ();
#endif
}
-static char *
-remote_query_supported_append (char *msg, const char *append)
+static void
+remote_query_supported_append (std::string *msg, const char *append)
{
- if (msg)
- return reconcat (msg, msg, ";", append, (char *) NULL);
- else
- return xstrdup (append);
+ if (!msg->empty ())
+ msg->append (";");
+ msg->append (append);
}
static void
rs->buf[0] = 0;
if (packet_support (PACKET_qSupported) != PACKET_DISABLE)
{
- char *q = NULL;
- struct cleanup *old_chain = make_cleanup (free_current_contents, &q);
+ std::string q;
if (packet_set_cmd_state (PACKET_multiprocess_feature) != AUTO_BOOLEAN_FALSE)
- q = remote_query_supported_append (q, "multiprocess+");
+ remote_query_supported_append (&q, "multiprocess+");
if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE)
- q = remote_query_supported_append (q, "swbreak+");
+ remote_query_supported_append (&q, "swbreak+");
if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE)
- q = remote_query_supported_append (q, "hwbreak+");
+ remote_query_supported_append (&q, "hwbreak+");
- q = remote_query_supported_append (q, "qRelocInsn+");
+ remote_query_supported_append (&q, "qRelocInsn+");
if (packet_set_cmd_state (PACKET_fork_event_feature)
!= AUTO_BOOLEAN_FALSE)
- q = remote_query_supported_append (q, "fork-events+");
+ remote_query_supported_append (&q, "fork-events+");
if (packet_set_cmd_state (PACKET_vfork_event_feature)
!= AUTO_BOOLEAN_FALSE)
- q = remote_query_supported_append (q, "vfork-events+");
+ remote_query_supported_append (&q, "vfork-events+");
if (packet_set_cmd_state (PACKET_exec_event_feature)
!= AUTO_BOOLEAN_FALSE)
- q = remote_query_supported_append (q, "exec-events+");
+ remote_query_supported_append (&q, "exec-events+");
if (packet_set_cmd_state (PACKET_vContSupported) != AUTO_BOOLEAN_FALSE)
- q = remote_query_supported_append (q, "vContSupported+");
+ remote_query_supported_append (&q, "vContSupported+");
if (packet_set_cmd_state (PACKET_QThreadEvents) != AUTO_BOOLEAN_FALSE)
- q = remote_query_supported_append (q, "QThreadEvents+");
+ remote_query_supported_append (&q, "QThreadEvents+");
if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE)
- q = remote_query_supported_append (q, "no-resumed+");
+ remote_query_supported_append (&q, "no-resumed+");
/* Keep this one last to work around a gdbserver <= 7.10 bug in
the qSupported:xmlRegisters=i386 handling. */
if (remote_support_xml != NULL
&& packet_support (PACKET_qXfer_features) != PACKET_DISABLE)
- q = remote_query_supported_append (q, remote_support_xml);
+ remote_query_supported_append (&q, remote_support_xml);
- q = reconcat (q, "qSupported:", q, (char *) NULL);
- putpkt (q);
-
- do_cleanups (old_chain);
+ q = "qSupported:" + q;
+ putpkt (q.c_str ());
getpkt (&rs->buf, &rs->buf_size, 0);
throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
}
-static void
-remote_open_1 (const char *name, int from_tty,
- struct target_ops *target, int extended_p)
+void
+remote_target::open_1 (const char *name, int from_tty, int extended_p)
{
struct remote_state *rs = get_remote_state ();
puts_filtered (name);
puts_filtered ("\n");
}
+
+ remote_target *target
+ = extended_p ? &extended_remote_ops : &remote_ops;
push_target (target); /* Switch to using remote target now. */
/* Register extra event sources in the event loop. */
rs->use_threadinfo_query = 1;
rs->use_threadextra_query = 1;
- readahead_cache_invalidate ();
+ rs->readahead_cache.invalidate ();
if (target_async_permitted)
{
TRY
{
- remote_start_remote (from_tty, target, extended_p);
+ target->start_remote (from_tty, extended_p);
}
CATCH (ex, RETURN_MASK_ALL)
{
}
}
-static void
-remote_detach (struct target_ops *ops, inferior *inf, int from_tty)
+void
+remote_target::detach (inferior *inf, int from_tty)
{
remote_detach_1 (from_tty, inf);
}
-static void
-extended_remote_detach (struct target_ops *ops, inferior *inf, int from_tty)
+void
+extended_remote_target::detach (inferior *inf, int from_tty)
{
remote_detach_1 (from_tty, inf);
}
it is named remote_follow_fork in anticipation of using it for the
remote target as well. */
-static int
-remote_follow_fork (struct target_ops *ops, int follow_child,
- int detach_fork)
+int
+remote_target::follow_fork (int follow_child, int detach_fork)
{
struct remote_state *rs = get_remote_state ();
enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
inferior, which may be the same as the exec'ing inferior unless
follow-exec-mode is "new". */
-static void
-remote_follow_exec (struct target_ops *ops,
- struct inferior *inf, char *execd_pathname)
+void
+remote_target::follow_exec (struct inferior *inf, char *execd_pathname)
{
/* We know that this is a target file name, so if it has the "target:"
prefix we strip it off before saving it in the program space. */
/* Same as remote_detach, but don't send the "D" packet; just disconnect. */
-static void
-remote_disconnect (struct target_ops *target, const char *args, int from_tty)
+void
+remote_target::disconnect (const char *args, int from_tty)
{
if (args)
error (_("Argument given to \"disconnect\" when remotely debugging."));
/* Make sure we unpush even the extended remote targets. Calling
target_mourn_inferior won't unpush, and remote_mourn won't
unpush if there is more than one inferior left. */
- unpush_target (target);
+ unpush_target (this);
generic_mourn_inferior ();
if (from_tty)
/* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
be chatty about it. */
-static void
-extended_remote_attach (struct target_ops *target, const char *args,
- int from_tty)
+void
+extended_remote_target::attach (const char *args, int from_tty)
{
struct remote_state *rs = get_remote_state ();
int pid;
struct thread_info *thread;
/* Get list of threads. */
- remote_update_thread_list (target);
+ update_thread_list ();
thread = first_thread_of_process (pid);
if (thread)
/* Implementation of the to_post_attach method. */
-static void
-extended_remote_post_attach (struct target_ops *ops, int pid)
+void
+extended_remote_target::post_attach (int pid)
{
/* Get text, data & bss offsets. */
get_offsets ();
/* Tell the remote machine to resume. */
-static void
-remote_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum gdb_signal siggnal)
+void
+remote_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
request; the actual remote resumption will be done in
target_commit_resume / remote_commit_resume, where we'll be able
to do vCont action coalescing. */
- if (target_is_non_stop_p () && execution_direction != EXEC_REVERSE)
+ if (target_is_non_stop_p () && ::execution_direction != EXEC_REVERSE)
{
remote_thread_info *remote_thr;
if (!target_is_non_stop_p ())
remote_notif_process (rs->notif_state, ¬if_client_stop);
- rs->last_resume_exec_dir = execution_direction;
+ rs->last_resume_exec_dir = ::execution_direction;
/* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
if (!remote_resume_with_vcont (ptid, step, siggnal))
- remote_resume_with_hc (ops, ptid, step, siggnal);
+ remote_resume_with_hc (this, ptid, step, siggnal);
/* We are about to start executing the inferior, let's register it
with the event loop. NOTE: this is the one place where all the
/* to_commit_resume implementation. */
-static void
-remote_commit_resume (struct target_ops *ops)
+void
+remote_target::commit_resume ()
{
struct inferior *inf;
struct thread_info *tp;
request directly from remote_resume. Likewise if
reverse-debugging, as there are no defined vCont actions for
reverse execution. */
- if (!target_is_non_stop_p () || execution_direction == EXEC_REVERSE)
+ if (!target_is_non_stop_p () || ::execution_direction == EXEC_REVERSE)
return;
/* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
/* Implement the to_stop function for the remote targets. */
-static void
-remote_stop (struct target_ops *self, ptid_t ptid)
+void
+remote_target::stop (ptid_t ptid)
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
/* Implement the to_interrupt function for the remote targets. */
-static void
-remote_interrupt (struct target_ops *self)
+void
+remote_target::interrupt ()
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
/* Implement the to_pass_ctrlc function for the remote targets. */
-static void
-remote_pass_ctrlc (struct target_ops *self)
+void
+remote_target::pass_ctrlc ()
{
struct remote_state *rs = get_remote_state ();
different in that explicit transfer of ownership to/from GDB/target
is required. */
-static void
-remote_terminal_inferior (struct target_ops *self)
+void
+remote_target::terminal_inferior ()
{
/* NOTE: At this point we could also register our selves as the
recipient of all input. Any characters typed could then be
passed on down to the target. */
}
-static void
-remote_terminal_ours (struct target_ops *self)
+void
+remote_target::terminal_ours ()
{
}
}
event->arch = inf->gdbarch;
- rsa = get_remote_arch_state (event->arch);
+ rsa = event->rs->get_remote_arch_state (event->arch);
}
packet_reg *reg
putpkt (buf);
break;
}
- /* else fallthrough */
+ /* fallthrough */
default:
warning (_("Invalid remote reply: %s"), buf);
break;
/* Wait until the remote machine stops, then return, storing status in
STATUS just as `wait' would. */
-static ptid_t
-remote_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *status, int options)
+ptid_t
+remote_target::wait (ptid_t ptid, struct target_waitstatus *status, int options)
{
ptid_t event_ptid;
int buf_len;
xsnprintf (rs->buf, get_remote_packet_size (), "g");
- remote_send (&rs->buf, &rs->buf_size);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ if (packet_check_result (rs->buf) == PACKET_ERROR)
+ error (_("Could not read registers; remote failure reply '%s'"),
+ rs->buf);
/* We can get out of synch in various cases. If the first character
in the buffer is not a hex character, assume that has happened
{
struct gdbarch *gdbarch = regcache->arch ();
struct remote_state *rs = get_remote_state ();
- remote_arch_state *rsa = get_remote_arch_state (gdbarch);
+ remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
int i, buf_len;
char *p;
char *regs;
warning (_("could not set remote traceframe"));
}
-static void
-remote_fetch_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+void
+remote_target::fetch_registers (struct regcache *regcache, int regnum)
{
struct gdbarch *gdbarch = regcache->arch ();
- remote_arch_state *rsa = get_remote_arch_state (gdbarch);
+ struct remote_state *rs = get_remote_state ();
+ remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
int i;
set_remote_traceframe ();
'G' request), we have to read out the ones we don't want to change
first. */
-static void
-remote_prepare_to_store (struct target_ops *self, struct regcache *regcache)
+void
+remote_target::prepare_to_store (struct regcache *regcache)
{
- remote_arch_state *rsa = get_remote_arch_state (regcache->arch ());
+ struct remote_state *rs = get_remote_state ();
+ remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ());
int i;
/* Make sure the entire registers array is valid. */
store_registers_using_G (const struct regcache *regcache)
{
struct remote_state *rs = get_remote_state ();
- remote_arch_state *rsa = get_remote_arch_state (regcache->arch ());
+ remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ());
gdb_byte *regs;
char *p;
/* Store register REGNUM, or all registers if REGNUM == -1, from the contents
of the register cache buffer. FIXME: ignores errors. */
-static void
-remote_store_registers (struct target_ops *ops,
- struct regcache *regcache, int regnum)
+void
+remote_target::store_registers (struct regcache *regcache, int regnum)
{
struct gdbarch *gdbarch = regcache->arch ();
- remote_arch_state *rsa = get_remote_arch_state (gdbarch);
+ struct remote_state *rs = get_remote_state ();
+ remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
int i;
set_remote_traceframe ();
In future, we'll need to decide on a better approach. */
static const int remote_flash_timeout = 1000;
-static void
-remote_flash_erase (struct target_ops *ops,
- ULONGEST address, LONGEST length)
+void
+remote_target::flash_erase (ULONGEST address, LONGEST length)
{
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
enum packet_result ret;
xfered_len,'X', 0);
}
-static void
-remote_flash_done (struct target_ops *ops)
+void
+remote_target::flash_done ()
{
int ret;
}
}
-static void
-remote_files_info (struct target_ops *ignore)
+void
+remote_target::files_info ()
{
puts_filtered ("Debugging a target over a serial line.\n");
}
set_quit_flag ();
}
-/* Send the command in *BUF to the remote machine, and read the reply
- into *BUF. Report an error if we get an error reply. Resize
- *BUF using xrealloc if necessary to hold the result, and update
- *SIZEOF_BUF. */
-
-static void
-remote_send (char **buf,
- long *sizeof_buf)
-{
- putpkt (*buf);
- getpkt (buf, sizeof_buf, 0);
-
- if ((*buf)[0] == 'E')
- error (_("Remote failure reply: %s"), *buf);
-}
-
/* Return a string representing an escaped version of BUF, of len N.
E.g. \n is converted to \\n, \t to \\t, etc. */
\f
/* Target hook to kill the current inferior. */
-static void
-remote_kill (struct target_ops *ops)
+void
+remote_target::kill ()
{
int res = -1;
int pid = ptid_get_pid (inferior_ptid);
END_CATCH
}
-static void
-remote_mourn (struct target_ops *target)
+void
+remote_target::mourn_inferior ()
{
struct remote_state *rs = get_remote_state ();
+ /* We're no longer interested in notification events of an inferior
+ that exited or was killed/detached. */
+ discard_pending_stop_replies (current_inferior ());
+
/* In 'target remote' mode with one inferior, we close the connection. */
if (!rs->extended && number_of_live_inferiors () <= 1)
{
- unpush_target (target);
+ unpush_target (this);
/* remote_close takes care of doing most of the clean up. */
generic_mourn_inferior ();
}
}
-static int
-extended_remote_supports_disable_randomization (struct target_ops *self)
+bool
+extended_remote_target::supports_disable_randomization ()
{
return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
}
executable file and the command line arguments, but not the
environment. */
-static void
-extended_remote_create_inferior (struct target_ops *ops,
- const char *exec_file,
- const std::string &args,
- char **env, int from_tty)
+void
+extended_remote_target::create_inferior (const char *exec_file,
+ const std::string &args,
+ char **env, int from_tty)
{
int run_worked;
char *stop_reply;
target_async (1);
/* Disable address space randomization if requested (and supported). */
- if (extended_remote_supports_disable_randomization (ops))
+ if (supports_disable_randomization ())
extended_remote_disable_randomization (disable_randomization);
/* If startup-with-shell is on, we inform gdbserver to start the
support, we ask the remote target to do the work; on targets
which don't, we insert a traditional memory breakpoint. */
-static int
-remote_insert_breakpoint (struct target_ops *ops,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
+int
+remote_target::insert_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
/* Try the "Z" s/w breakpoint packet if it is not already disabled.
If it succeeds, then set the support to PACKET_ENABLE. If it
p += hexnumstr (p, addr);
xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
- if (remote_supports_cond_breakpoints (ops))
+ if (supports_evaluation_of_breakpoint_conditions ())
remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
- if (remote_can_run_breakpoint_commands (ops))
+ if (can_run_breakpoint_commands ())
remote_add_target_side_commands (gdbarch, bp_tgt, p);
putpkt (rs->buf);
throw_error (NOT_SUPPORTED_ERROR, _("\
Target doesn't support breakpoints that have target side commands."));
- return memory_insert_breakpoint (ops, gdbarch, bp_tgt);
+ return memory_insert_breakpoint (this, gdbarch, bp_tgt);
}
-static int
-remote_remove_breakpoint (struct target_ops *ops,
- struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt,
- enum remove_bp_reason reason)
+int
+remote_target::remove_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt,
+ enum remove_bp_reason reason)
{
CORE_ADDR addr = bp_tgt->placed_address;
struct remote_state *rs = get_remote_state ();
return (rs->buf[0] == 'E');
}
- return memory_remove_breakpoint (ops, gdbarch, bp_tgt, reason);
+ return memory_remove_breakpoint (this, gdbarch, bp_tgt, reason);
}
static enum Z_packet_type
}
}
-static int
-remote_insert_watchpoint (struct target_ops *self, CORE_ADDR addr, int len,
- enum target_hw_bp_type type, struct expression *cond)
+int
+remote_target::insert_watchpoint (CORE_ADDR addr, int len,
+ enum target_hw_bp_type type, struct expression *cond)
{
struct remote_state *rs = get_remote_state ();
char *endbuf = rs->buf + get_remote_packet_size ();
_("remote_insert_watchpoint: reached end of function"));
}
-static int
-remote_watchpoint_addr_within_range (struct target_ops *target, CORE_ADDR addr,
- CORE_ADDR start, int length)
+bool
+remote_target::watchpoint_addr_within_range (CORE_ADDR addr,
+ CORE_ADDR start, int length)
{
CORE_ADDR diff = remote_address_masked (addr - start);
}
-static int
-remote_remove_watchpoint (struct target_ops *self, CORE_ADDR addr, int len,
- enum target_hw_bp_type type, struct expression *cond)
+int
+remote_target::remove_watchpoint (CORE_ADDR addr, int len,
+ enum target_hw_bp_type type, struct expression *cond)
{
struct remote_state *rs = get_remote_state ();
char *endbuf = rs->buf + get_remote_packet_size ();
int remote_hw_watchpoint_length_limit = -1;
int remote_hw_breakpoint_limit = -1;
-static int
-remote_region_ok_for_hw_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len)
+int
+remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
{
if (remote_hw_watchpoint_length_limit == 0)
return 0;
return 0;
}
-static int
-remote_check_watch_resources (struct target_ops *self,
- enum bptype type, int cnt, int ot)
+int
+remote_target::can_use_hw_breakpoint (enum bptype type, int cnt, int ot)
{
if (type == bp_hardware_breakpoint)
{
/* The to_stopped_by_sw_breakpoint method of target remote. */
-static int
-remote_stopped_by_sw_breakpoint (struct target_ops *ops)
+bool
+remote_target::stopped_by_sw_breakpoint ()
{
struct thread_info *thread = inferior_thread ();
/* The to_supports_stopped_by_sw_breakpoint method of target
remote. */
-static int
-remote_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
+bool
+remote_target::supports_stopped_by_sw_breakpoint ()
{
return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE);
}
/* The to_stopped_by_hw_breakpoint method of target remote. */
-static int
-remote_stopped_by_hw_breakpoint (struct target_ops *ops)
+bool
+remote_target::stopped_by_hw_breakpoint ()
{
struct thread_info *thread = inferior_thread ();
/* The to_supports_stopped_by_hw_breakpoint method of target
remote. */
-static int
-remote_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
+bool
+remote_target::supports_stopped_by_hw_breakpoint ()
{
return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE);
}
-static int
-remote_stopped_by_watchpoint (struct target_ops *ops)
+bool
+remote_target::stopped_by_watchpoint ()
{
struct thread_info *thread = inferior_thread ();
== TARGET_STOPPED_BY_WATCHPOINT));
}
-static int
-remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
+bool
+remote_target::stopped_data_address (CORE_ADDR *addr_p)
{
struct thread_info *thread = inferior_thread ();
== TARGET_STOPPED_BY_WATCHPOINT))
{
*addr_p = get_remote_thread_info (thread)->watch_data_address;
- return 1;
+ return true;
}
- return 0;
+ return false;
}
-static int
-remote_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
+int
+remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
CORE_ADDR addr = bp_tgt->reqstd_address;
struct remote_state *rs;
p += hexnumstr (p, (ULONGEST) addr);
xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind);
- if (remote_supports_cond_breakpoints (self))
+ if (supports_evaluation_of_breakpoint_conditions ())
remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
- if (remote_can_run_breakpoint_commands (self))
+ if (can_run_breakpoint_commands ())
remote_add_target_side_commands (gdbarch, bp_tgt, p);
putpkt (rs->buf);
}
-static int
-remote_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
+int
+remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
CORE_ADDR addr;
struct remote_state *rs = get_remote_state ();
/* Verify memory using the "qCRC:" request. */
-static int
-remote_verify_memory (struct target_ops *ops,
- const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
+int
+remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
{
struct remote_state *rs = get_remote_state ();
unsigned long host_crc, target_crc;
}
}
- return simple_verify_memory (ops, data, lma, size);
+ return simple_verify_memory (this, data, lma, size);
}
/* compare-sections command
if (!exec_bfd)
error (_("command cannot be used without an exec file"));
- /* Make sure the remote is pointing at the right process. */
- set_general_process ();
-
if (args != NULL && strcmp (args, "-r") == 0)
{
read_only = 1;
target is returned, or -1 for error. */
static enum target_xfer_status
-remote_write_qxfer (struct target_ops *ops, const char *object_name,
+remote_write_qxfer (const char *object_name,
const char *annex, const gdb_byte *writebuf,
ULONGEST offset, LONGEST len, ULONGEST *xfered_len,
struct packet_config *packet)
target supports this object. */
static enum target_xfer_status
-remote_read_qxfer (struct target_ops *ops, const char *object_name,
+remote_read_qxfer (const char *object_name,
const char *annex,
gdb_byte *readbuf, ULONGEST offset, LONGEST len,
ULONGEST *xfered_len,
}
}
-static enum target_xfer_status
-remote_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
- ULONGEST *xfered_len)
+enum target_xfer_status
+remote_target::xfer_partial (enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len)
{
struct remote_state *rs;
int i;
return remote_write_bytes (offset, writebuf, len, unit_size,
xfered_len);
else
- return remote_read_bytes (ops, offset, readbuf, len, unit_size,
+ return remote_read_bytes (this, offset, readbuf, len, unit_size,
xfered_len);
}
if (object == TARGET_OBJECT_SPU)
{
if (readbuf)
- return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,
+ return remote_read_qxfer ("spu", annex, readbuf, offset, len,
xfered_len, &remote_protocol_packets
[PACKET_qXfer_spu_read]);
else
- return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,
+ return remote_write_qxfer ("spu", annex, writebuf, offset, len,
xfered_len, &remote_protocol_packets
[PACKET_qXfer_spu_write]);
}
if (object == TARGET_OBJECT_SIGNAL_INFO)
{
if (readbuf)
- return remote_read_qxfer (ops, "siginfo", annex, readbuf, offset, len,
+ return remote_read_qxfer ("siginfo", annex, readbuf, offset, len,
xfered_len, &remote_protocol_packets
[PACKET_qXfer_siginfo_read]);
else
- return remote_write_qxfer (ops, "siginfo", annex,
+ return remote_write_qxfer ("siginfo", annex,
writebuf, offset, len, xfered_len,
&remote_protocol_packets
[PACKET_qXfer_siginfo_write]);
if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
{
if (readbuf)
- return remote_read_qxfer (ops, "statictrace", annex,
+ return remote_read_qxfer ("statictrace", annex,
readbuf, offset, len, xfered_len,
&remote_protocol_packets
[PACKET_qXfer_statictrace_read]);
switch (object)
{
case TARGET_OBJECT_FLASH:
- return remote_flash_write (ops, offset, len, xfered_len,
+ return remote_flash_write (this, offset, len, xfered_len,
writebuf);
default:
case TARGET_OBJECT_AUXV:
gdb_assert (annex == NULL);
- return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
+ return remote_read_qxfer ("auxv", annex, readbuf, offset, len,
xfered_len,
&remote_protocol_packets[PACKET_qXfer_auxv]);
case TARGET_OBJECT_AVAILABLE_FEATURES:
return remote_read_qxfer
- (ops, "features", annex, readbuf, offset, len, xfered_len,
+ ("features", annex, readbuf, offset, len, xfered_len,
&remote_protocol_packets[PACKET_qXfer_features]);
case TARGET_OBJECT_LIBRARIES:
return remote_read_qxfer
- (ops, "libraries", annex, readbuf, offset, len, xfered_len,
+ ("libraries", annex, readbuf, offset, len, xfered_len,
&remote_protocol_packets[PACKET_qXfer_libraries]);
case TARGET_OBJECT_LIBRARIES_SVR4:
return remote_read_qxfer
- (ops, "libraries-svr4", annex, readbuf, offset, len, xfered_len,
+ ("libraries-svr4", annex, readbuf, offset, len, xfered_len,
&remote_protocol_packets[PACKET_qXfer_libraries_svr4]);
case TARGET_OBJECT_MEMORY_MAP:
gdb_assert (annex == NULL);
- return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
+ return remote_read_qxfer ("memory-map", annex, readbuf, offset, len,
xfered_len,
&remote_protocol_packets[PACKET_qXfer_memory_map]);
/* Should only get here if we're connected. */
gdb_assert (rs->remote_desc);
return remote_read_qxfer
- (ops, "osdata", annex, readbuf, offset, len, xfered_len,
+ ("osdata", annex, readbuf, offset, len, xfered_len,
&remote_protocol_packets[PACKET_qXfer_osdata]);
case TARGET_OBJECT_THREADS:
gdb_assert (annex == NULL);
- return remote_read_qxfer (ops, "threads", annex, readbuf, offset, len,
+ return remote_read_qxfer ("threads", annex, readbuf, offset, len,
xfered_len,
&remote_protocol_packets[PACKET_qXfer_threads]);
case TARGET_OBJECT_TRACEFRAME_INFO:
gdb_assert (annex == NULL);
return remote_read_qxfer
- (ops, "traceframe-info", annex, readbuf, offset, len, xfered_len,
+ ("traceframe-info", annex, readbuf, offset, len, xfered_len,
&remote_protocol_packets[PACKET_qXfer_traceframe_info]);
case TARGET_OBJECT_FDPIC:
- return remote_read_qxfer (ops, "fdpic", annex, readbuf, offset, len,
+ return remote_read_qxfer ("fdpic", annex, readbuf, offset, len,
xfered_len,
&remote_protocol_packets[PACKET_qXfer_fdpic]);
case TARGET_OBJECT_OPENVMS_UIB:
- return remote_read_qxfer (ops, "uib", annex, readbuf, offset, len,
+ return remote_read_qxfer ("uib", annex, readbuf, offset, len,
xfered_len,
&remote_protocol_packets[PACKET_qXfer_uib]);
case TARGET_OBJECT_BTRACE:
- return remote_read_qxfer (ops, "btrace", annex, readbuf, offset, len,
+ return remote_read_qxfer ("btrace", annex, readbuf, offset, len,
xfered_len,
&remote_protocol_packets[PACKET_qXfer_btrace]);
case TARGET_OBJECT_BTRACE_CONF:
- return remote_read_qxfer (ops, "btrace-conf", annex, readbuf, offset,
+ return remote_read_qxfer ("btrace-conf", annex, readbuf, offset,
len, xfered_len,
&remote_protocol_packets[PACKET_qXfer_btrace_conf]);
case TARGET_OBJECT_EXEC_FILE:
- return remote_read_qxfer (ops, "exec-file", annex, readbuf, offset,
+ return remote_read_qxfer ("exec-file", annex, readbuf, offset,
len, xfered_len,
&remote_protocol_packets[PACKET_qXfer_exec_file]);
/* Implementation of to_get_memory_xfer_limit. */
-static ULONGEST
-remote_get_memory_xfer_limit (struct target_ops *ops)
+ULONGEST
+remote_target::get_memory_xfer_limit ()
{
return get_memory_write_packet_size ();
}
-static int
-remote_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)
+int
+remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
+ const gdb_byte *pattern, ULONGEST pattern_len,
+ CORE_ADDR *found_addrp)
{
int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
struct remote_state *rs = get_remote_state ();
{
/* Target doesn't provided special support, fall back and use the
standard support (copy memory and do the search here). */
- return simple_search_memory (ops, start_addr, search_space_len,
+ return simple_search_memory (this, start_addr, search_space_len,
pattern, pattern_len, found_addrp);
}
supported. If so, fall back to the simple way. */
if (packet_config_support (packet) == PACKET_DISABLE)
{
- return simple_search_memory (ops, start_addr, search_space_len,
+ return simple_search_memory (this, start_addr, search_space_len,
pattern, pattern_len, found_addrp);
}
return -1;
return found;
}
-static void
-remote_rcmd (struct target_ops *self, const char *command,
- struct ui_file *outbuf)
+void
+remote_target::rcmd (const char *command, struct ui_file *outbuf)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
}
}
-static std::vector<mem_region>
-remote_memory_map (struct target_ops *ops)
+std::vector<mem_region>
+remote_target::memory_map ()
{
std::vector<mem_region> result;
gdb::optional<gdb::char_vector> text
- = target_read_stralloc (¤t_target, TARGET_OBJECT_MEMORY_MAP, NULL);
+ = target_read_stralloc (target_stack, TARGET_OBJECT_MEMORY_MAP, NULL);
if (text)
result = parse_memory_map (text->data ());
/* Convert a thread ID to a string. Returns the string in a static
buffer. */
-static const char *
-remote_pid_to_str (struct target_ops *ops, ptid_t ptid)
+const char *
+remote_target::pid_to_str (ptid_t ptid)
{
static char buf[64];
struct remote_state *rs = get_remote_state ();
/* Get the address of the thread local variable in OBJFILE which is
stored at OFFSET within the thread local storage for thread PTID. */
-static CORE_ADDR
-remote_get_thread_local_address (struct target_ops *ops,
- ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
+CORE_ADDR
+remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm,
+ CORE_ADDR offset)
{
if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
{
/* Provide thread local base, i.e. Thread Information Block address.
Returns 1 if ptid is found and thread_local_base is non zero. */
-static int
-remote_get_tib_address (struct target_ops *self, ptid_t ptid, CORE_ADDR *addr)
+bool
+remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
{
if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
{
unpack_varlen_hex (rs->buf, &result);
if (addr)
*addr = (CORE_ADDR) result;
- return 1;
+ return true;
}
else if (result == PACKET_UNKNOWN)
error (_("Remote target doesn't support qGetTIBAddr packet"));
else
error (_("qGetTIBAddr not supported or disabled on this target"));
/* Not reached. */
- return 0;
+ return false;
}
/* Support for inferring a target description based on the current
return 0;
}
-static const struct target_desc *
-remote_read_description (struct target_ops *target)
+const struct target_desc *
+remote_target::read_description ()
{
struct remote_g_packet_data *data
= ((struct remote_g_packet_data *)
/* Do not try this during initial connection, when we do not know
whether there is a running but stopped thread. */
if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid))
- return target->beneath->to_read_description (target->beneath);
+ return beneath->read_description ();
if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
{
an architecture, but it's too tricky to do safely. */
}
- return target->beneath->to_read_description (target->beneath);
+ return beneath->read_description ();
}
/* Remote file transfer support. This is host-initiated I/O, not
return ret;
}
-/* Invalidate the readahead cache. */
+/* See declaration.h. */
-static void
-readahead_cache_invalidate (void)
+void
+readahead_cache::invalidate ()
{
- struct remote_state *rs = get_remote_state ();
-
- rs->readahead_cache.fd = -1;
+ this->fd = -1;
}
-/* Invalidate the readahead cache if it is holding data for FD. */
+/* See declaration.h. */
-static void
-readahead_cache_invalidate_fd (int fd)
+void
+readahead_cache::invalidate_fd (int fd)
{
- struct remote_state *rs = get_remote_state ();
-
- if (rs->readahead_cache.fd == fd)
- rs->readahead_cache.fd = -1;
+ if (this->fd == fd)
+ this->fd = -1;
}
/* Set the filesystem remote_hostio functions that take FILENAME
remote_errno, NULL, NULL);
}
+int
+remote_target::fileio_open (struct inferior *inf, const char *filename,
+ int flags, int mode, int warn_if_slow,
+ int *remote_errno)
+{
+ return remote_hostio_open (this, inf, filename, flags, mode, warn_if_slow,
+ remote_errno);
+}
+
/* Implementation of to_fileio_pwrite. */
static int
int left = get_remote_packet_size ();
int out_len;
- readahead_cache_invalidate_fd (fd);
+ rs->readahead_cache.invalidate_fd (fd);
remote_buffer_add_string (&p, &left, "vFile:pwrite:");
remote_errno, NULL, NULL);
}
+int
+remote_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
+ ULONGEST offset, int *remote_errno)
+{
+ return remote_hostio_pwrite (this, fd, write_buf, len, offset, remote_errno);
+}
+
/* Helper for the implementation of to_fileio_pread. Read the file
from the remote side with vFile:pread. */
return ret;
}
-/* Serve pread from the readahead cache. Returns number of bytes
- read, or 0 if the request can't be served from the cache. */
+/* See declaration.h. */
-static int
-remote_hostio_pread_from_cache (struct remote_state *rs,
- int fd, gdb_byte *read_buf, size_t len,
- ULONGEST offset)
+int
+readahead_cache::pread (int fd, gdb_byte *read_buf, size_t len,
+ ULONGEST offset)
{
- struct readahead_cache *cache = &rs->readahead_cache;
-
- if (cache->fd == fd
- && cache->offset <= offset
- && offset < cache->offset + cache->bufsize)
+ if (this->fd == fd
+ && this->offset <= offset
+ && offset < this->offset + this->bufsize)
{
- ULONGEST max = cache->offset + cache->bufsize;
+ ULONGEST max = this->offset + this->bufsize;
if (offset + len > max)
len = max - offset;
- memcpy (read_buf, cache->buf + offset - cache->offset, len);
+ memcpy (read_buf, this->buf + offset - this->offset, len);
return len;
}
{
int ret;
struct remote_state *rs = get_remote_state ();
- struct readahead_cache *cache = &rs->readahead_cache;
+ readahead_cache *cache = &rs->readahead_cache;
- ret = remote_hostio_pread_from_cache (rs, fd, read_buf, len, offset);
+ ret = cache->pread (fd, read_buf, len, offset);
if (ret > 0)
{
cache->hit_count++;
cache->offset, remote_errno);
if (ret <= 0)
{
- readahead_cache_invalidate_fd (fd);
+ cache->invalidate_fd (fd);
return ret;
}
cache->bufsize = ret;
- return remote_hostio_pread_from_cache (rs, fd, read_buf, len, offset);
+ return cache->pread (fd, read_buf, len, offset);
+}
+
+int
+remote_target::fileio_pread (int fd, gdb_byte *read_buf, int len,
+ ULONGEST offset, int *remote_errno)
+{
+ return remote_hostio_pread (this, fd, read_buf, len, offset, remote_errno);
}
/* Implementation of to_fileio_close. */
char *p = rs->buf;
int left = get_remote_packet_size () - 1;
- readahead_cache_invalidate_fd (fd);
+ rs->readahead_cache.invalidate_fd (fd);
remote_buffer_add_string (&p, &left, "vFile:close:");
remote_errno, NULL, NULL);
}
+int
+remote_target::fileio_close (int fd, int *remote_errno)
+{
+ return remote_hostio_close (this, fd, remote_errno);
+}
+
/* Implementation of to_fileio_unlink. */
static int
remote_errno, NULL, NULL);
}
+int
+remote_target::fileio_unlink (struct inferior *inf, const char *filename,
+ int *remote_errno)
+{
+ return remote_hostio_unlink (this, inf, filename, remote_errno);
+}
+
/* Implementation of to_fileio_readlink. */
-static gdb::optional<std::string>
-remote_hostio_readlink (struct target_ops *self,
- struct inferior *inf, const char *filename,
- int *remote_errno)
+gdb::optional<std::string>
+remote_target::fileio_readlink (struct inferior *inf, const char *filename,
+ int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
/* Implementation of to_fileio_fstat. */
-static int
-remote_hostio_fstat (struct target_ops *self,
- int fd, struct stat *st,
- int *remote_errno)
+int
+remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno)
{
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
/* Implementation of to_filesystem_is_local. */
-static int
-remote_filesystem_is_local (struct target_ops *self)
+bool
+remote_target::filesystem_is_local ()
{
/* Valgrind GDB presents itself as a remote target but works
on the local filesystem: it does not implement remote get
/* Try opening a file to probe support. The supplied
filename is irrelevant, we only care about whether
the stub recognizes the packet or not. */
- fd = remote_hostio_open (self, NULL, "just probing",
+ fd = remote_hostio_open (this, NULL, "just probing",
FILEIO_O_RDONLY, 0700, 0,
&remote_errno);
if (fd >= 0)
- remote_hostio_close (self, fd, &remote_errno);
+ remote_hostio_close (this, fd, &remote_errno);
ps = packet_support (PACKET_vFile_open);
}
warning_issued = 1;
}
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
static int
error (_("Remote I/O error: %s"), safe_strerror (host_error));
}
-static void
-remote_hostio_close_cleanup (void *opaque)
+/* A RAII wrapper around a remote file descriptor. */
+
+class scoped_remote_fd
{
- int fd = *(int *) opaque;
- int remote_errno;
+public:
+ explicit scoped_remote_fd (int fd)
+ : m_fd (fd)
+ {
+ }
- remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno);
-}
+ ~scoped_remote_fd ()
+ {
+ if (m_fd != -1)
+ {
+ try
+ {
+ int remote_errno;
+ remote_hostio_close (find_target_at (process_stratum),
+ m_fd, &remote_errno);
+ }
+ catch (...)
+ {
+ /* Swallow exception before it escapes the dtor. If
+ something goes wrong, likely the connection is gone,
+ and there's nothing else that can be done. */
+ }
+ }
+ }
+
+ DISABLE_COPY_AND_ASSIGN (scoped_remote_fd);
+
+ /* Release ownership of the file descriptor, and return it. */
+ int release () noexcept
+ {
+ int fd = m_fd;
+ m_fd = -1;
+ return fd;
+ }
+
+ /* Return the owned file descriptor. */
+ int get () const noexcept
+ {
+ return m_fd;
+ }
+
+private:
+ /* The owned remote I/O file descriptor. */
+ int m_fd;
+};
void
remote_file_put (const char *local_file, const char *remote_file, int from_tty)
{
- struct cleanup *back_to, *close_cleanup;
- int retcode, fd, remote_errno, bytes, io_size;
+ struct cleanup *back_to;
+ int retcode, remote_errno, bytes, io_size;
gdb_byte *buffer;
int bytes_in_buffer;
int saw_eof;
if (file == NULL)
perror_with_name (local_file);
- fd = remote_hostio_open (find_target_at (process_stratum), NULL,
- remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
- | FILEIO_O_TRUNC),
- 0700, 0, &remote_errno);
- if (fd == -1)
+ scoped_remote_fd fd
+ (remote_hostio_open (find_target_at (process_stratum), NULL,
+ remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
+ | FILEIO_O_TRUNC),
+ 0700, 0, &remote_errno));
+ if (fd.get () == -1)
remote_hostio_error (remote_errno);
/* Send up to this many bytes at once. They won't all fit in the
buffer = (gdb_byte *) xmalloc (io_size);
back_to = make_cleanup (xfree, buffer);
- close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
-
bytes_in_buffer = 0;
saw_eof = 0;
offset = 0;
bytes_in_buffer = 0;
retcode = remote_hostio_pwrite (find_target_at (process_stratum),
- fd, buffer, bytes,
+ fd.get (), buffer, bytes,
offset, &remote_errno);
if (retcode < 0)
offset += retcode;
}
- discard_cleanups (close_cleanup);
- if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))
+ if (remote_hostio_close (find_target_at (process_stratum),
+ fd.release (), &remote_errno))
remote_hostio_error (remote_errno);
if (from_tty)
void
remote_file_get (const char *remote_file, const char *local_file, int from_tty)
{
- struct cleanup *back_to, *close_cleanup;
- int fd, remote_errno, bytes, io_size;
+ struct cleanup *back_to;
+ int remote_errno, bytes, io_size;
gdb_byte *buffer;
ULONGEST offset;
struct remote_state *rs = get_remote_state ();
if (!rs->remote_desc)
error (_("command can only be used with remote target"));
- fd = remote_hostio_open (find_target_at (process_stratum), NULL,
- remote_file, FILEIO_O_RDONLY, 0, 0,
- &remote_errno);
- if (fd == -1)
+ scoped_remote_fd fd
+ (remote_hostio_open (find_target_at (process_stratum), NULL,
+ remote_file, FILEIO_O_RDONLY, 0, 0,
+ &remote_errno));
+ if (fd.get () == -1)
remote_hostio_error (remote_errno);
gdb_file_up file = gdb_fopen_cloexec (local_file, "wb");
buffer = (gdb_byte *) xmalloc (io_size);
back_to = make_cleanup (xfree, buffer);
- close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
-
offset = 0;
while (1)
{
bytes = remote_hostio_pread (find_target_at (process_stratum),
- fd, buffer, io_size, offset, &remote_errno);
+ fd.get (), buffer, io_size, offset,
+ &remote_errno);
if (bytes == 0)
/* Success, but no bytes, means end-of-file. */
break;
perror_with_name (local_file);
}
- discard_cleanups (close_cleanup);
- if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))
+ if (remote_hostio_close (find_target_at (process_stratum),
+ fd.release (), &remote_errno))
remote_hostio_error (remote_errno);
if (from_tty)
help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout);
}
-static int
-remote_can_execute_reverse (struct target_ops *self)
+bool
+remote_target::can_execute_reverse ()
{
if (packet_support (PACKET_bs) == PACKET_ENABLE
|| packet_support (PACKET_bc) == PACKET_ENABLE)
- return 1;
+ return true;
else
- return 0;
+ return false;
}
-static int
-remote_supports_non_stop (struct target_ops *self)
+bool
+remote_target::supports_non_stop ()
{
- return 1;
+ return true;
}
-static int
-remote_supports_disable_randomization (struct target_ops *self)
+bool
+remote_target::supports_disable_randomization ()
{
/* Only supported in extended mode. */
- return 0;
+ return false;
}
-static int
-remote_supports_multi_process (struct target_ops *self)
+bool
+remote_target::supports_multi_process ()
{
struct remote_state *rs = get_remote_state ();
}
static int
-remote_supports_cond_tracepoints (void)
+remote_supports_cond_tracepoints ()
{
return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE;
}
-static int
-remote_supports_cond_breakpoints (struct target_ops *self)
+bool
+remote_target::supports_evaluation_of_breakpoint_conditions ()
{
return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE;
}
static int
-remote_supports_fast_tracepoints (void)
+remote_supports_fast_tracepoints ()
{
return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE;
}
static int
-remote_supports_static_tracepoints (void)
+remote_supports_static_tracepoints ()
{
return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE;
}
static int
-remote_supports_install_in_trace (void)
+remote_supports_install_in_trace ()
{
return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
}
-static int
-remote_supports_enable_disable_tracepoint (struct target_ops *self)
+bool
+remote_target::supports_enable_disable_tracepoint ()
{
return (packet_support (PACKET_EnableDisableTracepoints_feature)
== PACKET_ENABLE);
}
-static int
-remote_supports_string_tracing (struct target_ops *self)
+bool
+remote_target::supports_string_tracing ()
{
return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
}
-static int
-remote_can_run_breakpoint_commands (struct target_ops *self)
+bool
+remote_target::can_run_breakpoint_commands ()
{
return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
}
-static void
-remote_trace_init (struct target_ops *self)
+void
+remote_target::trace_init ()
{
struct remote_state *rs = get_remote_state ();
if (cmd->control_type == while_control
|| cmd->control_type == while_stepping_control)
{
- remote_download_command_source (num, addr, *cmd->body_list);
+ remote_download_command_source (num, addr, cmd->body_list_0.get ());
QUIT; /* Allow user to bail out with ^C. */
strcpy (rs->buf, "QTDPsrc:");
}
}
-static void
-remote_download_tracepoint (struct target_ops *self, struct bp_location *loc)
+void
+remote_target::download_tracepoint (struct bp_location *loc)
{
#define BUF_SIZE 2048
}
}
-static int
-remote_can_download_tracepoint (struct target_ops *self)
+bool
+remote_target::can_download_tracepoint ()
{
struct remote_state *rs = get_remote_state ();
struct trace_status *ts;
symbols, and fetched and merged the target's tracepoint list with
ours. */
if (rs->starting_up)
- return 0;
+ return false;
ts = current_trace_status ();
- status = remote_get_trace_status (self, ts);
+ status = get_trace_status (ts);
if (status == -1 || !ts->running_known || !ts->running)
- return 0;
+ return false;
/* If we are in a tracing experiment, but remote stub doesn't support
installing tracepoint in trace, we have to return. */
if (!remote_supports_install_in_trace ())
- return 0;
+ return false;
- return 1;
+ return true;
}
-static void
-remote_download_trace_state_variable (struct target_ops *self,
- const trace_state_variable &tsv)
+void
+remote_target::download_trace_state_variable (const trace_state_variable &tsv)
{
struct remote_state *rs = get_remote_state ();
char *p;
error (_("Error on target while downloading trace state variable."));
}
-static void
-remote_enable_tracepoint (struct target_ops *self,
- struct bp_location *location)
+void
+remote_target::enable_tracepoint (struct bp_location *location)
{
struct remote_state *rs = get_remote_state ();
char addr_buf[40];
error (_("Error on target while enabling tracepoint."));
}
-static void
-remote_disable_tracepoint (struct target_ops *self,
- struct bp_location *location)
+void
+remote_target::disable_tracepoint (struct bp_location *location)
{
struct remote_state *rs = get_remote_state ();
char addr_buf[40];
error (_("Error on target while disabling tracepoint."));
}
-static void
-remote_trace_set_readonly_regions (struct target_ops *self)
+void
+remote_target::trace_set_readonly_regions ()
{
asection *s;
bfd *abfd = NULL;
}
}
-static void
-remote_trace_start (struct target_ops *self)
+void
+remote_target::trace_start ()
{
struct remote_state *rs = get_remote_state ();
error (_("Bogus reply from target: %s"), rs->buf);
}
-static int
-remote_get_trace_status (struct target_ops *self, struct trace_status *ts)
+int
+remote_target::get_trace_status (struct trace_status *ts)
{
/* Initialize it just to avoid a GCC false warning. */
char *p = NULL;
return -1;
trace_regblock_size
- = get_remote_arch_state (target_gdbarch ())->sizeof_g_packet;
+ = rs->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet;
putpkt ("qTStatus");
return ts->running;
}
-static void
-remote_get_tracepoint_status (struct target_ops *self, struct breakpoint *bp,
- struct uploaded_tp *utp)
+void
+remote_target::get_tracepoint_status (struct breakpoint *bp,
+ struct uploaded_tp *utp)
{
struct remote_state *rs = get_remote_state ();
char *reply;
}
}
-static void
-remote_trace_stop (struct target_ops *self)
+void
+remote_target::trace_stop ()
{
struct remote_state *rs = get_remote_state ();
error (_("Bogus reply from target: %s"), rs->buf);
}
-static int
-remote_trace_find (struct target_ops *self,
- enum trace_find_type type, int num,
- CORE_ADDR addr1, CORE_ADDR addr2,
- int *tpp)
+int
+remote_target::trace_find (enum trace_find_type type, int num,
+ CORE_ADDR addr1, CORE_ADDR addr2,
+ int *tpp)
{
struct remote_state *rs = get_remote_state ();
char *endbuf = rs->buf + get_remote_packet_size ();
return target_frameno;
}
-static int
-remote_get_trace_state_variable_value (struct target_ops *self,
- int tsvnum, LONGEST *val)
+bool
+remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val)
{
struct remote_state *rs = get_remote_state ();
char *reply;
{
unpack_varlen_hex (reply + 1, &uval);
*val = (LONGEST) uval;
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
-static int
-remote_save_trace_data (struct target_ops *self, const char *filename)
+int
+remote_target::save_trace_data (const char *filename)
{
struct remote_state *rs = get_remote_state ();
char *p, *reply;
memory, plus we want to be able to ask for as much as possible, but
not be unhappy if we don't get as much as we ask for. */
-static LONGEST
-remote_get_raw_trace_data (struct target_ops *self,
- gdb_byte *buf, ULONGEST offset, LONGEST len)
+LONGEST
+remote_target::get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
{
struct remote_state *rs = get_remote_state ();
char *reply;
return -1;
}
-static void
-remote_set_disconnected_tracing (struct target_ops *self, int val)
+void
+remote_target::set_disconnected_tracing (int val)
{
struct remote_state *rs = get_remote_state ();
warning (_("Target does not support disconnected tracing."));
}
-static int
-remote_core_of_thread (struct target_ops *ops, ptid_t ptid)
+int
+remote_target::core_of_thread (ptid_t ptid)
{
struct thread_info *info = find_thread_ptid (ptid);
return -1;
}
-static void
-remote_set_circular_trace_buffer (struct target_ops *self, int val)
+void
+remote_target::set_circular_trace_buffer (int val)
{
struct remote_state *rs = get_remote_state ();
char *reply;
error (_("Bogus reply from target: %s"), reply);
}
-static traceframe_info_up
-remote_traceframe_info (struct target_ops *self)
+traceframe_info_up
+remote_target::traceframe_info ()
{
gdb::optional<gdb::char_vector> text
- = target_read_stralloc (¤t_target, TARGET_OBJECT_TRACEFRAME_INFO,
+ = target_read_stralloc (target_stack, TARGET_OBJECT_TRACEFRAME_INFO,
NULL);
if (text)
return parse_traceframe_info (text->data ());
if the packet is not supported, and 0 if the minimum instruction
length is unknown. */
-static int
-remote_get_min_fast_tracepoint_insn_len (struct target_ops *self)
+int
+remote_target::get_min_fast_tracepoint_insn_len ()
{
struct remote_state *rs = get_remote_state ();
char *reply;
}
}
-static void
-remote_set_trace_buffer_size (struct target_ops *self, LONGEST val)
+void
+remote_target::set_trace_buffer_size (LONGEST val)
{
if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
{
}
}
-static int
-remote_set_trace_notes (struct target_ops *self,
- const char *user, const char *notes,
- const char *stop_notes)
+bool
+remote_target::set_trace_notes (const char *user, const char *notes,
+ const char *stop_notes)
{
struct remote_state *rs = get_remote_state ();
char *reply;
putpkt (rs->buf);
reply = remote_get_noisy_reply ();
if (*reply == '\0')
- return 0;
+ return false;
if (strcmp (reply, "OK") != 0)
error (_("Bogus reply from target: %s"), reply);
- return 1;
+ return true;
}
-static int
-remote_use_agent (struct target_ops *self, int use)
+bool
+remote_target::use_agent (bool use)
{
if (packet_support (PACKET_QAgent) != PACKET_DISABLE)
{
if (strcmp (rs->buf, "OK") == 0)
{
- use_agent = use;
- return 1;
+ ::use_agent = use;
+ return true;
}
}
- return 0;
+ return false;
}
-static int
-remote_can_use_agent (struct target_ops *self)
+bool
+remote_target::can_use_agent ()
{
return (packet_support (PACKET_QAgent) != PACKET_DISABLE);
}
btrace_read_config (struct btrace_config *conf)
{
gdb::optional<gdb::char_vector> xml
- = target_read_stralloc (¤t_target, TARGET_OBJECT_BTRACE_CONF, "");
+ = target_read_stralloc (target_stack, TARGET_OBJECT_BTRACE_CONF, "");
if (xml)
parse_xml_btrace_conf (conf, xml->data ());
}
/* Enable branch tracing. */
-static struct btrace_target_info *
-remote_enable_btrace (struct target_ops *self, ptid_t ptid,
- const struct btrace_config *conf)
+struct btrace_target_info *
+remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf)
{
struct btrace_target_info *tinfo = NULL;
struct packet_config *packet = NULL;
/* Disable branch tracing. */
-static void
-remote_disable_btrace (struct target_ops *self,
- struct btrace_target_info *tinfo)
+void
+remote_target::disable_btrace (struct btrace_target_info *tinfo)
{
struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off];
struct remote_state *rs = get_remote_state ();
/* Teardown branch tracing. */
-static void
-remote_teardown_btrace (struct target_ops *self,
- struct btrace_target_info *tinfo)
+void
+remote_target::teardown_btrace (struct btrace_target_info *tinfo)
{
/* We must not talk to the target during teardown. */
xfree (tinfo);
/* Read the branch trace. */
-static enum btrace_error
-remote_read_btrace (struct target_ops *self,
- struct btrace_data *btrace,
- struct btrace_target_info *tinfo,
- enum btrace_read_type type)
+enum btrace_error
+remote_target::read_btrace (struct btrace_data *btrace,
+ struct btrace_target_info *tinfo,
+ enum btrace_read_type type)
{
struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace];
const char *annex;
}
gdb::optional<gdb::char_vector> xml
- = target_read_stralloc (¤t_target, TARGET_OBJECT_BTRACE, annex);
+ = target_read_stralloc (target_stack, TARGET_OBJECT_BTRACE, annex);
if (!xml)
return BTRACE_ERR_UNKNOWN;
return BTRACE_ERR_NONE;
}
-static const struct btrace_config *
-remote_btrace_conf (struct target_ops *self,
- const struct btrace_target_info *tinfo)
+const struct btrace_config *
+remote_target::btrace_conf (const struct btrace_target_info *tinfo)
{
return &tinfo->conf;
}
-static int
-remote_augmented_libraries_svr4_read (struct target_ops *self)
+bool
+remote_target::augmented_libraries_svr4_read ()
{
return (packet_support (PACKET_augmented_libraries_svr4_read_feature)
== PACKET_ENABLE);
/* Implementation of to_load. */
-static void
-remote_load (struct target_ops *self, const char *name, int from_tty)
+void
+remote_target::load (const char *name, int from_tty)
{
generic_load (name, from_tty);
}
can be opened on the remote side to get the symbols for the child
process. Returns NULL if the operation is not supported. */
-static char *
-remote_pid_to_exec_file (struct target_ops *self, int pid)
+char *
+remote_target::pid_to_exec_file (int pid)
{
static gdb::optional<gdb::char_vector> filename;
struct inferior *inf;
xsnprintf (annex, annex_size, "%x", pid);
}
- filename = target_read_stralloc (¤t_target,
+ filename = target_read_stralloc (target_stack,
TARGET_OBJECT_EXEC_FILE, annex);
return filename ? filename->data () : nullptr;
/* Implement the to_can_do_single_step target_ops method. */
-static int
-remote_can_do_single_step (struct target_ops *ops)
+int
+remote_target::can_do_single_step ()
{
/* We can only tell whether target supports single step or not by
supported s and S vCont actions if the stub supports vContSupported
/* Implementation of the to_execution_direction method for the remote
target. */
-static enum exec_direction_kind
-remote_execution_direction (struct target_ops *self)
+enum exec_direction_kind
+remote_target::execution_direction ()
{
struct remote_state *rs = get_remote_state ();
/* Return pointer to the thread_info struct which corresponds to
THREAD_HANDLE (having length HANDLE_LEN). */
-static struct thread_info *
-remote_thread_handle_to_thread_info (struct target_ops *ops,
- const gdb_byte *thread_handle,
- int handle_len,
- struct inferior *inf)
+thread_info *
+remote_target::thread_handle_to_thread_info (const gdb_byte *thread_handle,
+ int handle_len,
+ inferior *inf)
{
struct thread_info *tp;
return NULL;
}
-static void
-init_remote_ops (void)
-{
- remote_ops.to_shortname = "remote";
- remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
- remote_ops.to_doc =
- "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
-Specify the serial device it is connected to\n\
-(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
- remote_ops.to_open = remote_open;
- remote_ops.to_close = remote_close;
- remote_ops.to_detach = remote_detach;
- remote_ops.to_disconnect = remote_disconnect;
- remote_ops.to_resume = remote_resume;
- remote_ops.to_commit_resume = remote_commit_resume;
- remote_ops.to_wait = remote_wait;
- remote_ops.to_fetch_registers = remote_fetch_registers;
- remote_ops.to_store_registers = remote_store_registers;
- remote_ops.to_prepare_to_store = remote_prepare_to_store;
- remote_ops.to_files_info = remote_files_info;
- remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
- remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
- remote_ops.to_stopped_by_sw_breakpoint = remote_stopped_by_sw_breakpoint;
- remote_ops.to_supports_stopped_by_sw_breakpoint = remote_supports_stopped_by_sw_breakpoint;
- remote_ops.to_stopped_by_hw_breakpoint = remote_stopped_by_hw_breakpoint;
- remote_ops.to_supports_stopped_by_hw_breakpoint = remote_supports_stopped_by_hw_breakpoint;
- remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
- remote_ops.to_stopped_data_address = remote_stopped_data_address;
- remote_ops.to_watchpoint_addr_within_range =
- remote_watchpoint_addr_within_range;
- remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
- remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
- remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
- remote_ops.to_region_ok_for_hw_watchpoint
- = remote_region_ok_for_hw_watchpoint;
- remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
- remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
- remote_ops.to_kill = remote_kill;
- remote_ops.to_load = remote_load;
- remote_ops.to_mourn_inferior = remote_mourn;
- remote_ops.to_pass_signals = remote_pass_signals;
- remote_ops.to_set_syscall_catchpoint = remote_set_syscall_catchpoint;
- remote_ops.to_program_signals = remote_program_signals;
- remote_ops.to_thread_alive = remote_thread_alive;
- remote_ops.to_thread_name = remote_thread_name;
- remote_ops.to_update_thread_list = remote_update_thread_list;
- remote_ops.to_pid_to_str = remote_pid_to_str;
- remote_ops.to_extra_thread_info = remote_threads_extra_info;
- remote_ops.to_get_ada_task_ptid = remote_get_ada_task_ptid;
- remote_ops.to_stop = remote_stop;
- remote_ops.to_interrupt = remote_interrupt;
- remote_ops.to_pass_ctrlc = remote_pass_ctrlc;
- remote_ops.to_xfer_partial = remote_xfer_partial;
- remote_ops.to_get_memory_xfer_limit = remote_get_memory_xfer_limit;
- remote_ops.to_rcmd = remote_rcmd;
- remote_ops.to_pid_to_exec_file = remote_pid_to_exec_file;
- remote_ops.to_log_command = serial_log_command;
- remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
- remote_ops.to_stratum = process_stratum;
- remote_ops.to_has_all_memory = default_child_has_all_memory;
- remote_ops.to_has_memory = default_child_has_memory;
- remote_ops.to_has_stack = default_child_has_stack;
- remote_ops.to_has_registers = default_child_has_registers;
- remote_ops.to_has_execution = default_child_has_execution;
- remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
- remote_ops.to_can_execute_reverse = remote_can_execute_reverse;
- remote_ops.to_magic = OPS_MAGIC;
- remote_ops.to_memory_map = remote_memory_map;
- remote_ops.to_flash_erase = remote_flash_erase;
- remote_ops.to_flash_done = remote_flash_done;
- remote_ops.to_read_description = remote_read_description;
- remote_ops.to_search_memory = remote_search_memory;
- remote_ops.to_can_async_p = remote_can_async_p;
- remote_ops.to_is_async_p = remote_is_async_p;
- remote_ops.to_async = remote_async;
- remote_ops.to_thread_events = remote_thread_events;
- remote_ops.to_can_do_single_step = remote_can_do_single_step;
- remote_ops.to_terminal_inferior = remote_terminal_inferior;
- remote_ops.to_terminal_ours = remote_terminal_ours;
- remote_ops.to_supports_non_stop = remote_supports_non_stop;
- remote_ops.to_supports_multi_process = remote_supports_multi_process;
- remote_ops.to_supports_disable_randomization
- = remote_supports_disable_randomization;
- remote_ops.to_filesystem_is_local = remote_filesystem_is_local;
- remote_ops.to_fileio_open = remote_hostio_open;
- remote_ops.to_fileio_pwrite = remote_hostio_pwrite;
- remote_ops.to_fileio_pread = remote_hostio_pread;
- remote_ops.to_fileio_fstat = remote_hostio_fstat;
- remote_ops.to_fileio_close = remote_hostio_close;
- remote_ops.to_fileio_unlink = remote_hostio_unlink;
- remote_ops.to_fileio_readlink = remote_hostio_readlink;
- remote_ops.to_supports_enable_disable_tracepoint = remote_supports_enable_disable_tracepoint;
- remote_ops.to_supports_string_tracing = remote_supports_string_tracing;
- remote_ops.to_supports_evaluation_of_breakpoint_conditions = remote_supports_cond_breakpoints;
- remote_ops.to_can_run_breakpoint_commands = remote_can_run_breakpoint_commands;
- remote_ops.to_trace_init = remote_trace_init;
- remote_ops.to_download_tracepoint = remote_download_tracepoint;
- remote_ops.to_can_download_tracepoint = remote_can_download_tracepoint;
- remote_ops.to_download_trace_state_variable
- = remote_download_trace_state_variable;
- remote_ops.to_enable_tracepoint = remote_enable_tracepoint;
- remote_ops.to_disable_tracepoint = remote_disable_tracepoint;
- remote_ops.to_trace_set_readonly_regions = remote_trace_set_readonly_regions;
- remote_ops.to_trace_start = remote_trace_start;
- remote_ops.to_get_trace_status = remote_get_trace_status;
- remote_ops.to_get_tracepoint_status = remote_get_tracepoint_status;
- remote_ops.to_trace_stop = remote_trace_stop;
- remote_ops.to_trace_find = remote_trace_find;
- remote_ops.to_get_trace_state_variable_value
- = remote_get_trace_state_variable_value;
- remote_ops.to_save_trace_data = remote_save_trace_data;
- remote_ops.to_upload_tracepoints = remote_upload_tracepoints;
- remote_ops.to_upload_trace_state_variables
- = remote_upload_trace_state_variables;
- remote_ops.to_get_raw_trace_data = remote_get_raw_trace_data;
- remote_ops.to_get_min_fast_tracepoint_insn_len = remote_get_min_fast_tracepoint_insn_len;
- remote_ops.to_set_disconnected_tracing = remote_set_disconnected_tracing;
- remote_ops.to_set_circular_trace_buffer = remote_set_circular_trace_buffer;
- remote_ops.to_set_trace_buffer_size = remote_set_trace_buffer_size;
- remote_ops.to_set_trace_notes = remote_set_trace_notes;
- remote_ops.to_core_of_thread = remote_core_of_thread;
- remote_ops.to_verify_memory = remote_verify_memory;
- remote_ops.to_get_tib_address = remote_get_tib_address;
- remote_ops.to_set_permissions = remote_set_permissions;
- remote_ops.to_static_tracepoint_marker_at
- = remote_static_tracepoint_marker_at;
- remote_ops.to_static_tracepoint_markers_by_strid
- = remote_static_tracepoint_markers_by_strid;
- remote_ops.to_traceframe_info = remote_traceframe_info;
- remote_ops.to_use_agent = remote_use_agent;
- remote_ops.to_can_use_agent = remote_can_use_agent;
- remote_ops.to_enable_btrace = remote_enable_btrace;
- remote_ops.to_disable_btrace = remote_disable_btrace;
- remote_ops.to_teardown_btrace = remote_teardown_btrace;
- remote_ops.to_read_btrace = remote_read_btrace;
- remote_ops.to_btrace_conf = remote_btrace_conf;
- remote_ops.to_augmented_libraries_svr4_read =
- remote_augmented_libraries_svr4_read;
- remote_ops.to_follow_fork = remote_follow_fork;
- remote_ops.to_follow_exec = remote_follow_exec;
- remote_ops.to_insert_fork_catchpoint = remote_insert_fork_catchpoint;
- remote_ops.to_remove_fork_catchpoint = remote_remove_fork_catchpoint;
- remote_ops.to_insert_vfork_catchpoint = remote_insert_vfork_catchpoint;
- remote_ops.to_remove_vfork_catchpoint = remote_remove_vfork_catchpoint;
- remote_ops.to_insert_exec_catchpoint = remote_insert_exec_catchpoint;
- remote_ops.to_remove_exec_catchpoint = remote_remove_exec_catchpoint;
- remote_ops.to_execution_direction = remote_execution_direction;
- remote_ops.to_thread_handle_to_thread_info =
- remote_thread_handle_to_thread_info;
-}
-
-/* Set up the extended remote vector by making a copy of the standard
- remote vector and adding to it. */
-
-static void
-init_extended_remote_ops (void)
-{
- extended_remote_ops = remote_ops;
-
- extended_remote_ops.to_shortname = "extended-remote";
- extended_remote_ops.to_longname =
- "Extended remote serial target in gdb-specific protocol";
- extended_remote_ops.to_doc =
- "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
- extended_remote_ops.to_open = extended_remote_open;
- extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
- extended_remote_ops.to_detach = extended_remote_detach;
- extended_remote_ops.to_attach = extended_remote_attach;
- extended_remote_ops.to_post_attach = extended_remote_post_attach;
- extended_remote_ops.to_supports_disable_randomization
- = extended_remote_supports_disable_randomization;
-}
-
-static int
-remote_can_async_p (struct target_ops *ops)
+bool
+remote_target::can_async_p ()
{
struct remote_state *rs = get_remote_state ();
/* We don't go async if the user has explicitly prevented it with the
"maint set target-async" command. */
if (!target_async_permitted)
- return 0;
+ return false;
/* We're async whenever the serial device is. */
return serial_can_async_p (rs->remote_desc);
}
-static int
-remote_is_async_p (struct target_ops *ops)
+bool
+remote_target::is_async_p ()
{
struct remote_state *rs = get_remote_state ();
if (!target_async_permitted)
/* We only enable async when the user specifically asks for it. */
- return 0;
+ return false;
/* We're async whenever the serial device is. */
return serial_is_async_p (rs->remote_desc);
inferior_event_handler (INF_REG_EVENT, NULL);
}
-static void
-remote_async (struct target_ops *ops, int enable)
+void
+remote_target::async (int enable)
{
struct remote_state *rs = get_remote_state ();
/* Implementation of the to_thread_events method. */
-static void
-remote_thread_events (struct target_ops *ops, int enable)
+void
+remote_target::thread_events (int enable)
{
struct remote_state *rs = get_remote_state ();
size_t size = get_remote_packet_size ();
tracepoints yet, we don't want to mess up the user's existing
collection. */
-static int
-remote_upload_tracepoints (struct target_ops *self, struct uploaded_tp **utpp)
+int
+remote_target::upload_tracepoints (struct uploaded_tp **utpp)
{
struct remote_state *rs = get_remote_state ();
char *p;
return 0;
}
-static int
-remote_upload_trace_state_variables (struct target_ops *self,
- struct uploaded_tsv **utsvp)
+int
+remote_target::upload_trace_state_variables (struct uploaded_tsv **utsvp)
{
struct remote_state *rs = get_remote_state ();
char *p;
const char *cmd_name;
/* architecture specific data */
- remote_gdbarch_data_handle =
- gdbarch_data_register_post_init (init_remote_state);
remote_g_packet_data_handle =
gdbarch_data_register_pre_init (remote_g_packet_data_init);
/* Initialize the per-target state. At the moment there is only one
of these, not one per target. Only one target is active at a
time. */
- remote_state = new_remote_state ();
+ remote_state = new struct remote_state ();
- init_remote_ops ();
- add_target (&remote_ops);
-
- init_extended_remote_ops ();
- add_target (&extended_remote_ops);
+ add_target (remote_target_info, remote_target::open);
+ add_target (extended_remote_target_info, extended_remote_target::open);
/* Hook into new objfile notification. */
gdb::observers::new_objfile.attach (remote_new_objfile);
- /* We're no longer interested in notification events of an inferior
- when it exits. */
- gdb::observers::inferior_exit.attach (discard_pending_stop_replies);
#if 0
init_remote_threadtests ();
projects / deliverable / binutils-gdb.git / blobdiff