/* 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:
to_stratum = process_stratum;
}
- const char *shortname () override
- { return "remote"; }
-
- const char *longname () override
- { return _("Remote serial target in gdb-specific protocol"); }
-
- const char *doc () override
- {
- return _("\
-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.).");
- }
+ const target_info &info () const override
+ { return remote_target_info; }
thread_control_capabilities get_thread_control_capabilities () override
{ return tc_schedlock; }
- void open (const char *, int) override;
+ /* Open a remote connection. */
+ static void open (const char *, int);
+
void close () override;
void detach (inferior *, int) override;
enum remove_bp_reason) override;
- int stopped_by_sw_breakpoint () override;
- int supports_stopped_by_sw_breakpoint () override;
+ bool stopped_by_sw_breakpoint () override;
+ bool supports_stopped_by_sw_breakpoint () override;
- int stopped_by_hw_breakpoint () override;
+ bool stopped_by_hw_breakpoint () override;
- int supports_stopped_by_hw_breakpoint () override;
+ bool supports_stopped_by_hw_breakpoint () override;
- int stopped_by_watchpoint () override;
+ bool stopped_by_watchpoint () override;
- int stopped_data_address (CORE_ADDR *) override;
+ bool stopped_data_address (CORE_ADDR *) override;
- int watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
+ bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
int can_use_hw_breakpoint (enum bptype, int, int) override;
void program_signals (int, unsigned char *) override;
- int thread_alive (ptid_t ptid) override;
+ bool thread_alive (ptid_t ptid) override;
const char *thread_name (struct thread_info *) override;
CORE_ADDR load_module_addr,
CORE_ADDR offset) override;
- int has_all_memory () override { return default_child_has_all_memory (); }
- int has_memory () override { return default_child_has_memory (); }
- int has_stack () override { return default_child_has_stack (); }
- int has_registers () override { return default_child_has_registers (); }
- int has_execution (ptid_t ptid) override { return default_child_has_execution (ptid); }
+ 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); }
- int can_execute_reverse () override;
+ bool can_execute_reverse () override;
std::vector<mem_region> memory_map () override;
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp) override;
- int can_async_p () override;
+ bool can_async_p () override;
- int is_async_p () override;
+ bool is_async_p () override;
void async (int) override;
void terminal_ours () override;
- int supports_non_stop () override;
+ bool supports_non_stop () override;
- int supports_multi_process () override;
+ bool supports_multi_process () override;
- int supports_disable_randomization () override;
+ bool supports_disable_randomization () override;
- int filesystem_is_local () override;
+ bool filesystem_is_local () override;
int fileio_open (struct inferior *inf, const char *filename,
const char *filename,
int *target_errno) override;
- int supports_enable_disable_tracepoint () override;
+ bool supports_enable_disable_tracepoint () override;
- int supports_string_tracing () override;
+ bool supports_string_tracing () override;
- int supports_evaluation_of_breakpoint_conditions () override;
+ bool supports_evaluation_of_breakpoint_conditions () override;
- int can_run_breakpoint_commands () override;
+ bool can_run_breakpoint_commands () override;
void trace_init () override;
void download_tracepoint (struct bp_location *location) override;
- int can_download_tracepoint () override;
+ bool can_download_tracepoint () override;
void download_trace_state_variable (const trace_state_variable &tsv) override;
int trace_find (enum trace_find_type type, int num,
CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override;
- int get_trace_state_variable_value (int tsv, LONGEST *val) override;
+ bool get_trace_state_variable_value (int tsv, LONGEST *val) override;
int save_trace_data (const char *filename) override;
void set_trace_buffer_size (LONGEST val) override;
- int set_trace_notes (const char *user, const char *notes,
- const char *stopnotes) override;
+ bool set_trace_notes (const char *user, const char *notes,
+ const char *stopnotes) override;
int core_of_thread (ptid_t ptid) override;
CORE_ADDR memaddr, ULONGEST size) override;
- int get_tib_address (ptid_t ptid, CORE_ADDR *addr) override;
+ bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override;
void set_permissions () override;
traceframe_info_up traceframe_info () override;
- int use_agent (int use) override;
- int can_use_agent () 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;
enum btrace_read_type type) override;
const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
- int augmented_libraries_svr4_read () 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;
enum exec_direction_kind execution_direction () override;
protected:
- void open_1 (const char *name, int from_tty, int extended_p);
+ 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 char *shortname () override
- { return "extended-remote"; }
+ const target_info &info () const override
+ { return extended_remote_target_info; }
- const char *longname () override
- { return _("Extended remote serial target in gdb-specific protocol"); }
-
- void open (const char *, int) override;
+ /* 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 &,
void attach (const char *, int) override;
void post_attach (int) override;
- int supports_disable_randomization () override;
+ bool supports_disable_randomization () override;
};
/* Per-program-space data key. */
/* Return nonzero if the thread PTID is still alive on the remote
system. */
-int
+bool
remote_target::thread_alive (ptid_t ptid)
{
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);
-
- q = reconcat (q, "qSupported:", q, (char *) NULL);
- putpkt (q);
+ remote_query_supported_append (&q, remote_support_xml);
- do_cleanups (old_chain);
+ q = "qSupported:" + q;
+ putpkt (q.c_str ());
getpkt (&rs->buf, &rs->buf_size, 0);
puts_filtered (name);
puts_filtered ("\n");
}
- push_target (this); /* Switch to using remote target now. */
+
+ 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. */
remote_async_inferior_event_token
TRY
{
- start_remote (from_tty, extended_p);
+ target->start_remote (from_tty, extended_p);
}
CATCH (ex, RETURN_MASK_ALL)
{
putpkt (buf);
break;
}
- /* else fallthrough */
+ /* fallthrough */
default:
warning (_("Invalid remote reply: %s"), buf);
break;
}
}
-int
+bool
extended_remote_target::supports_disable_randomization ()
{
return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
_("remote_insert_watchpoint: reached end of function"));
}
-int
+bool
remote_target::watchpoint_addr_within_range (CORE_ADDR addr,
CORE_ADDR start, int length)
{
/* The to_stopped_by_sw_breakpoint method of target remote. */
-int
+bool
remote_target::stopped_by_sw_breakpoint ()
{
struct thread_info *thread = inferior_thread ();
/* The to_supports_stopped_by_sw_breakpoint method of target
remote. */
-int
+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. */
-int
+bool
remote_target::stopped_by_hw_breakpoint ()
{
struct thread_info *thread = inferior_thread ();
/* The to_supports_stopped_by_hw_breakpoint method of target
remote. */
-int
+bool
remote_target::supports_stopped_by_hw_breakpoint ()
{
return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE);
}
-int
+bool
remote_target::stopped_by_watchpoint ()
{
struct thread_info *thread = inferior_thread ();
== TARGET_STOPPED_BY_WATCHPOINT));
}
-int
+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;
}
/* Provide thread local base, i.e. Thread Information Block address.
Returns 1 if ptid is found and thread_local_base is non zero. */
-int
+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
/* Implementation of to_filesystem_is_local. */
-int
+bool
remote_target::filesystem_is_local ()
{
/* Valgrind GDB presents itself as a remote target but works
warning_issued = 1;
}
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
static int
help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout);
}
-int
+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;
}
-int
+bool
remote_target::supports_non_stop ()
{
- return 1;
+ return true;
}
-int
+bool
remote_target::supports_disable_randomization ()
{
/* Only supported in extended mode. */
- return 0;
+ return false;
}
-int
+bool
remote_target::supports_multi_process ()
{
struct remote_state *rs = get_remote_state ();
return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE;
}
-int
+bool
remote_target::supports_evaluation_of_breakpoint_conditions ()
{
return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE;
return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
}
-int
+bool
remote_target::supports_enable_disable_tracepoint ()
{
return (packet_support (PACKET_EnableDisableTracepoints_feature)
== PACKET_ENABLE);
}
-int
+bool
remote_target::supports_string_tracing ()
{
return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
}
-int
+bool
remote_target::can_run_breakpoint_commands ()
{
return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
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:");
}
}
-int
+bool
remote_target::can_download_tracepoint ()
{
struct remote_state *rs = get_remote_state ();
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 = 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;
}
return target_frameno;
}
-int
+bool
remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val)
{
struct remote_state *rs = get_remote_state ();
{
unpack_varlen_hex (reply + 1, &uval);
*val = (LONGEST) uval;
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
int
}
}
-int
+bool
remote_target::set_trace_notes (const char *user, const char *notes,
const char *stop_notes)
{
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;
}
-int
-remote_target::use_agent (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;
+ return true;
}
}
- return 0;
+ return false;
}
-int
+bool
remote_target::can_use_agent ()
{
return (packet_support (PACKET_QAgent) != PACKET_DISABLE);
return &tinfo->conf;
}
-int
+bool
remote_target::augmented_libraries_svr4_read ()
{
return (packet_support (PACKET_augmented_libraries_svr4_read_feature)
return NULL;
}
-int
+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);
}
-int
+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);
time. */
remote_state = new_remote_state ();
- add_target (&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);