/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
- 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1988-2012 Free Software Foundation, Inc.
This file is part of GDB.
#include "cli/cli-decode.h"
#include "cli/cli-setshow.h"
#include "target-descriptions.h"
+#include "gdb_bfd.h"
#include <ctype.h>
#include <sys/time.h>
#include "tracepoint.h"
#include "ax.h"
#include "ax-gdb.h"
+#include "agent.h"
/* Temp hacks for tracepoint encoding migration. */
static char *target_buf;
static long target_buf_size;
-/*static*/ void
-encode_actions (struct breakpoint *t, struct bp_location *tloc,
- char ***tdp_actions, char ***stepping_actions);
/* The size to align memory write packets, when practical. The protocol
does not guarantee any alignment, and gdb will generate short
static void remote_async (void (*callback) (enum inferior_event_type event_type,
void *context), void *context);
-static int remote_async_mask (int new_mask);
-
static void remote_detach (struct target_ops *ops, char *args, int from_tty);
static void remote_interrupt (int signo);
static void remote_console_output (char *msg);
+static int remote_supports_cond_breakpoints (void);
+
+static int remote_can_run_breakpoint_commands (void);
+
/* The non-stop remote protocol provisions for one pending stop reply.
This is where we keep it until it is acknowledged. */
char *buf;
long buf_size;
+ /* True if we're going through initial connection setup (finding out
+ about the remote side's threads, relocating symbols, etc.). */
+ int starting_up;
+
/* 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.
/* True if the stub reports support for conditional tracepoints. */
int cond_tracepoints;
+ /* True if the stub reports support for target-side breakpoint
+ conditions. */
+ int cond_breakpoints;
+
+ /* True if the stub reports support for target-side breakpoint
+ commands. */
+ int breakpoint_commands;
+
/* True if the stub reports support for fast tracepoints. */
int fast_tracepoints;
/* True if the stub reports support for static tracepoints. */
int static_tracepoints;
+ /* True if the stub reports support for installing tracepoint while
+ tracing. */
+ int install_in_trace;
+
/* True if the stub can continue running a trace while GDB is
disconnected. */
int disconnected_tracing;
+ /* True if the stub reports support for enabling and disabling
+ tracepoints while a trace experiment is running. */
+ int enable_disable_tracepoints;
+
+ /* True if the stub can collect strings using tracenz bytecode. */
+ int string_tracing;
+
/* Nonzero if the user has pressed Ctrl-C, but the target hasn't
responded to that. */
int ctrlc_pending_p;
static int
remote_multi_process_p (struct remote_state *rs)
{
- return rs->extended && rs->multi_process_aware;
+ return rs->multi_process_aware;
}
/* This data could be associated with a target, but we do not always
{
adjusted_size = to - org_to;
- sprintf (buf, "qRelocInsn:%x", adjusted_size);
+ xsnprintf (buf, *sizeof_buf, "qRelocInsn:%x", adjusted_size);
putpkt (buf);
}
else if (ex.reason < 0 && ex.error == MEMORY_ERROR)
return 1;
}
-static void *
-init_remote_state (struct gdbarch *gdbarch)
+static int
+map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
{
int regnum, num_remote_regs, offset;
- struct remote_state *rs = get_remote_state_raw ();
- struct remote_arch_state *rsa;
struct packet_reg **remote_regs;
- 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);
for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
{
- struct packet_reg *r = &rsa->regs[regnum];
+ struct packet_reg *r = ®s[regnum];
if (register_size (gdbarch, regnum) == 0)
/* Do not try to fetch zero-sized (placeholder) registers. */
number. */
remote_regs = alloca (gdbarch_num_regs (gdbarch)
- * sizeof (struct packet_reg *));
+ * sizeof (struct packet_reg *));
for (num_remote_regs = 0, regnum = 0;
regnum < gdbarch_num_regs (gdbarch);
regnum++)
- if (rsa->regs[regnum].pnum != -1)
- remote_regs[num_remote_regs++] = &rsa->regs[regnum];
+ if (regs[regnum].pnum != -1)
+ remote_regs[num_remote_regs++] = ®s[regnum];
qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
compare_pnums);
offset += register_size (gdbarch, remote_regs[regnum]->regnum);
}
+ return offset;
+}
+
+/* Given the architecture described by GDBARCH, return the remote
+ protocol register's number and the register's offset in the g/G
+ packets of GDB register REGNUM, in PNUM and POFFSET respectively.
+ If the target does not have a mapping for REGNUM, return false,
+ otherwise, return true. */
+
+int
+remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum,
+ int *pnum, int *poffset)
+{
+ int sizeof_g_packet;
+ struct packet_reg *regs;
+ struct cleanup *old_chain;
+
+ gdb_assert (regnum < gdbarch_num_regs (gdbarch));
+
+ regs = xcalloc (gdbarch_num_regs (gdbarch), sizeof (struct packet_reg));
+ old_chain = make_cleanup (xfree, regs);
+
+ sizeof_g_packet = map_regcache_remote_table (gdbarch, regs);
+
+ *pnum = regs[regnum].pnum;
+ *poffset = regs[regnum].offset;
+
+ do_cleanups (old_chain);
+
+ return *pnum != -1;
+}
+
+static void *
+init_remote_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);
+
/* Record the maximum possible size of the g packet - it may turn out
to be smaller. */
- rsa->sizeof_g_packet = offset;
+ rsa->sizeof_g_packet = map_regcache_remote_table (gdbarch, rsa->regs);
/* Default maximum number of characters in a packet body. Many
remote stubs have a hardwired buffer size of 400 bytes
static struct target_ops extended_remote_ops;
-static int remote_async_mask_value = 1;
-
/* FIXME: cagney/1999-09-23: Even though getpkt was called with
``forever'' still use the normal timeout mechanism. This is
currently used by the ASYNC code to guarentee that target reads
const char interrupt_sequence_control_c[] = "Ctrl-C";
const char interrupt_sequence_break[] = "BREAK";
const char interrupt_sequence_break_g[] = "BREAK-g";
-static const char *interrupt_sequence_modes[] =
+static const char *const interrupt_sequence_modes[] =
{
interrupt_sequence_control_c,
interrupt_sequence_break,
PACKET_vFile_pwrite,
PACKET_vFile_close,
PACKET_vFile_unlink,
+ PACKET_vFile_readlink,
PACKET_qXfer_auxv,
PACKET_qXfer_features,
PACKET_qXfer_libraries,
+ PACKET_qXfer_libraries_svr4,
PACKET_qXfer_memory_map,
PACKET_qXfer_spu_read,
PACKET_qXfer_spu_write,
PACKET_qXfer_threads,
PACKET_qXfer_statictrace_read,
PACKET_qXfer_traceframe_info,
+ PACKET_qXfer_uib,
PACKET_qGetTIBAddr,
PACKET_qGetTLSAddr,
PACKET_qSupported,
PACKET_QPassSignals,
+ PACKET_QProgramSignals,
PACKET_qSearch_memory,
PACKET_vAttach,
PACKET_vRun,
PACKET_qXfer_siginfo_write,
PACKET_qAttached,
PACKET_ConditionalTracepoints,
+ PACKET_ConditionalBreakpoints,
+ PACKET_BreakpointCommands,
PACKET_FastTracepoints,
PACKET_StaticTracepoints,
+ PACKET_InstallInTrace,
PACKET_bc,
PACKET_bs,
PACKET_TracepointSource,
PACKET_QAllow,
+ PACKET_qXfer_fdpic,
+ PACKET_QDisableRandomization,
+ PACKET_QAgent,
PACKET_MAX
};
static ptid_t general_thread;
static ptid_t continue_thread;
-/* This the traceframe which we last selected on the remote system.
+/* This is the traceframe which we last selected on the remote system.
It will be -1 if no traceframe is selected. */
static int remote_traceframe_number = -1;
remote_query_attached (int pid)
{
struct remote_state *rs = get_remote_state ();
+ size_t size = get_remote_packet_size ();
if (remote_protocol_packets[PACKET_qAttached].support == PACKET_DISABLE)
return 0;
if (remote_multi_process_p (rs))
- sprintf (rs->buf, "qAttached:%x", pid);
+ xsnprintf (rs->buf, size, "qAttached:%x", pid);
else
- sprintf (rs->buf, "qAttached");
+ xsnprintf (rs->buf, size, "qAttached");
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
return 0;
}
-/* Add PID to GDB's inferior table. Since we can be connected to a
- remote system before before knowing about any inferior, mark the
- target with execution when we find the first inferior. If ATTACHED
- is 1, then we had just attached to this inferior. If it is 0, then
- we just created this inferior. If it is -1, then try querying the
- remote stub to find out if it had attached to the inferior or
- not. */
+/* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
+ has been invented by GDB, instead of reported by the target. Since
+ we can be connected to a remote system before before knowing about
+ any inferior, mark the target with execution when we find the first
+ inferior. If ATTACHED is 1, then we had just attached to this
+ inferior. If it is 0, then we just created this inferior. If it
+ is -1, then try querying the remote stub to find out if it had
+ attached to the inferior or not. */
static struct inferior *
-remote_add_inferior (int pid, int attached)
+remote_add_inferior (int fake_pid_p, int pid, int attached)
{
struct inferior *inf;
}
inf->attach_flag = attached;
+ inf->fake_pid_p = fake_pid_p;
return inf;
}
may not know about it yet. Add it before adding its child
thread, so notifications are emitted in a sensible order. */
if (!in_inferior_list (ptid_get_pid (currthread)))
- inf = remote_add_inferior (ptid_get_pid (currthread), -1);
+ {
+ struct remote_state *rs = get_remote_state ();
+ int fake_pid_p = !remote_multi_process_p (rs);
+
+ inf = remote_add_inferior (fake_pid_p,
+ ptid_get_pid (currthread), -1);
+ }
/* This is really a new thread. Add it. */
remote_add_thread (currthread, running);
/* Return the private thread data, creating it if necessary. */
-struct private_thread_info *
+static struct private_thread_info *
demand_private_info (ptid_t ptid)
{
struct thread_info *info = find_thread_ptid (ptid);
it can simply pass through to the inferior without reporting. */
static void
-remote_pass_signals (void)
+remote_pass_signals (int numsigs, unsigned char *pass_signals)
{
if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
{
char *pass_packet, *p;
- int numsigs = (int) TARGET_SIGNAL_LAST;
int count = 0, i;
gdb_assert (numsigs < 256);
for (i = 0; i < numsigs; i++)
{
- if (signal_stop_state (i) == 0
- && signal_print_state (i) == 0
- && signal_pass_state (i) == 1)
+ if (pass_signals[i])
count++;
}
pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
p = pass_packet + strlen (pass_packet);
for (i = 0; i < numsigs; i++)
{
- if (signal_stop_state (i) == 0
- && signal_print_state (i) == 0
- && signal_pass_state (i) == 1)
+ if (pass_signals[i])
{
if (i >= 16)
*p++ = tohex (i >> 4);
}
}
+/* 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. */
+
+static char *last_program_signals_packet;
+
+/* If 'QProgramSignals' is supported, tell the remote stub what
+ signals it should pass through to the inferior when detaching. */
+
static void
-remote_notice_signals (ptid_t ptid)
+remote_program_signals (int numsigs, unsigned char *signals)
{
- /* Update the remote on signals to silently pass, if they've
- changed. */
- remote_pass_signals ();
+ if (remote_protocol_packets[PACKET_QProgramSignals].support != PACKET_DISABLE)
+ {
+ char *packet, *p;
+ int count = 0, i;
+
+ gdb_assert (numsigs < 256);
+ for (i = 0; i < numsigs; i++)
+ {
+ if (signals[i])
+ count++;
+ }
+ packet = xmalloc (count * 3 + strlen ("QProgramSignals:") + 1);
+ strcpy (packet, "QProgramSignals:");
+ p = packet + strlen (packet);
+ for (i = 0; i < numsigs; i++)
+ {
+ if (signal_pass_state (i))
+ {
+ if (i >= 16)
+ *p++ = tohex (i >> 4);
+ *p++ = tohex (i & 15);
+ if (count)
+ *p++ = ';';
+ else
+ break;
+ count--;
+ }
+ }
+ *p = 0;
+ if (!last_program_signals_packet
+ || strcmp (last_program_signals_packet, packet) != 0)
+ {
+ struct remote_state *rs = get_remote_state ();
+ char *buf = rs->buf;
+
+ putpkt (packet);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ packet_ok (buf, &remote_protocol_packets[PACKET_QProgramSignals]);
+ xfree (last_program_signals_packet);
+ last_program_signals_packet = packet;
+ }
+ else
+ xfree (packet);
+ }
}
/* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
struct remote_state *rs = get_remote_state ();
/* If the remote can't handle multiple processes, don't bother. */
- if (!remote_multi_process_p (rs))
+ if (!rs->extended || !remote_multi_process_p (rs))
return;
/* We only need to change the remote current thread if it's pointing
/* Multi-process ptid. */
pp = unpack_varlen_hex (p + 1, &pid);
if (*pp != '.')
- error (_("invalid remote ptid: %s\n"), p);
+ error (_("invalid remote ptid: %s"), p);
p = pp;
pp = unpack_varlen_hex (p + 1, &tid);
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
- sprintf (p, "qTSTMat:");
+ xsnprintf (p, get_remote_packet_size (), "qTSTMat:");
p += strlen (p);
p += hexnumstr (p, addr);
putpkt (rs->buf);
return 0;
}
-static void
-free_current_marker (void *arg)
-{
- struct static_tracepoint_marker **marker_p = arg;
-
- if (*marker_p != NULL)
- {
- release_static_tracepoint_marker (*marker_p);
- xfree (*marker_p);
- }
- else
- *marker_p = NULL;
-}
-
static VEC(static_tracepoint_marker_p) *
remote_static_tracepoint_markers_by_strid (const char *strid)
{
return 0;
}
-/* Stub for catch_exception. */
-
-struct start_remote_args
-{
- int from_tty;
-
- /* The current target. */
- struct target_ops *target;
-
- /* Non-zero if this is an extended-remote target. */
- int extended_p;
-};
-
/* Send interrupt_sequence to remote target. */
static void
-send_interrupt_sequence ()
+send_interrupt_sequence (void)
{
if (interrupt_sequence_mode == interrupt_sequence_control_c)
serial_write (remote_desc, "\x03", 1);
interrupt_sequence_mode);
}
+/* Query the remote target for which is the current thread/process,
+ add it to our tables, and update INFERIOR_PTID. The caller is
+ responsible for setting the state such that the remote end is ready
+ to return the current thread. */
+
+static void
+add_current_inferior_and_thread (void)
+{
+ struct remote_state *rs = get_remote_state ();
+ int fake_pid_p = 0;
+ ptid_t ptid;
+
+ inferior_ptid = null_ptid;
+
+ /* Now, if we have thread information, update inferior_ptid. */
+ ptid = remote_current_thread (inferior_ptid);
+ if (!ptid_equal (ptid, null_ptid))
+ {
+ if (!remote_multi_process_p (rs))
+ fake_pid_p = 1;
+
+ inferior_ptid = ptid;
+ }
+ else
+ {
+ /* Without this, some commands which require an active target
+ (such as kill) won't work. This variable serves (at least)
+ double duty as both the pid of the target process (if it has
+ such), and as a flag indicating that a target is active. */
+ inferior_ptid = magic_null_ptid;
+ fake_pid_p = 1;
+ }
+
+ remote_add_inferior (fake_pid_p, ptid_get_pid (inferior_ptid), -1);
+
+ /* Add the main thread. */
+ add_thread_silent (inferior_ptid);
+}
+
static void
-remote_start_remote (struct ui_out *uiout, void *opaque)
+remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
{
- struct start_remote_args *args = opaque;
struct remote_state *rs = get_remote_state ();
struct packet_config *noack_config;
char *wait_status = NULL;
immediate_quit++; /* Allow user to interrupt it. */
+ QUIT;
+
+ if (interrupt_on_connect)
+ send_interrupt_sequence ();
/* Ack any packet which the remote side has already sent. */
serial_write (remote_desc, "+", 1);
- if (interrupt_on_connect)
- send_interrupt_sequence ();
+ /* Signal other parts that we're going through the initial setup,
+ and so things may not be stable yet. */
+ rs->starting_up = 1;
/* The first packet we send to the target is the optional "supported
packets" request. If the target can answer this, it will tell us
rs->noack_mode = 1;
}
- if (args->extended_p)
+ if (extended_p)
{
/* Tell the remote that we are using the extended protocol. */
putpkt ("!");
getpkt (&rs->buf, &rs->buf_size, 0);
}
+ /* Let the target know which signals it is allowed to pass down to
+ the program. */
+ update_signals_program_target ();
+
/* Next, if the target can specify a description, read it. We do
this before anything involving memory or registers. */
target_find_description ();
/* On OSs where the list of libraries is global to all
processes, we fetch them early. */
if (gdbarch_has_global_solist (target_gdbarch))
- solib_add (NULL, args->from_tty, args->target, auto_solib_add);
+ solib_add (NULL, from_tty, target, auto_solib_add);
if (non_stop)
{
controlling. We default to adding them in the running state.
The '?' query below will then tell us about which threads are
stopped. */
- remote_threads_info (args->target);
+ remote_threads_info (target);
}
else if (rs->non_stop_aware)
{
if (!non_stop)
{
+ ptid_t ptid;
+ int fake_pid_p = 0;
+ struct inferior *inf;
+
if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
{
- if (!args->extended_p)
+ if (!extended_p)
error (_("The target is not running (try extended-remote?)"));
/* We're connected, but not running. Drop out before we
call start_remote. */
+ rs->starting_up = 0;
return;
}
else
/* Let the stub know that we want it to return the thread. */
set_continue_thread (minus_one_ptid);
- /* Without this, some commands which require an active target
- (such as kill) won't work. This variable serves (at least)
- double duty as both the pid of the target process (if it has
- such), and as a flag indicating that a target is active.
- These functions should be split out into seperate variables,
- especially since GDB will someday have a notion of debugging
- several processes. */
- inferior_ptid = magic_null_ptid;
-
- /* Now, if we have thread information, update inferior_ptid. */
- inferior_ptid = remote_current_thread (inferior_ptid);
-
- remote_add_inferior (ptid_get_pid (inferior_ptid), -1);
-
- /* Always add the main thread. */
- add_thread_silent (inferior_ptid);
+ add_current_inferior_and_thread ();
+
+ /* init_wait_for_inferior should be called before get_offsets in order
+ to manage `inserted' flag in bp loc in a correct state.
+ breakpoint_init_inferior, called from init_wait_for_inferior, set
+ `inserted' flag to 0, while before breakpoint_re_set, called from
+ start_remote, set `inserted' flag to 1. In the initialization of
+ inferior, breakpoint_init_inferior should be called first, and then
+ breakpoint_re_set can be called. If this order is broken, state of
+ `inserted' flag is wrong, and cause some problems on breakpoint
+ manipulation. */
+ init_wait_for_inferior ();
get_offsets (); /* Get text, data & bss offsets. */
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 (args->target)
+ if (remote_read_description_p (target)
&& gdbarch_target_desc (target_gdbarch) == NULL)
{
target_clear_description ();
rs->cached_wait_status = 1;
immediate_quit--;
- start_remote (args->from_tty); /* Initialize gdb process mechanisms. */
+ start_remote (from_tty); /* Initialize gdb process mechanisms. */
}
else
{
if (thread_count () == 0)
{
- if (!args->extended_p)
+ if (!extended_p)
error (_("The target is not running (try extended-remote?)"));
/* We're connected, but not running. Drop out before we
call start_remote. */
+ rs->starting_up = 0;
return;
}
the stop reply queue. */
gdb_assert (wait_status == NULL);
- /* Update the remote on signals to silently pass, or more
- importantly, which to not ignore, in case a previous session
- had set some different set of signals to be ignored. */
- remote_pass_signals ();
+ /* Report all signals during attach/startup. */
+ remote_pass_signals (0, NULL);
}
/* If we connected to a live target, do some additional setup. */
merge_uploaded_tracepoints (&uploaded_tps);
}
+ /* The thread and inferior lists are now synchronized with the
+ target, our symbols have been relocated, and we're merged the
+ target's tracepoints with ours. We're done with basic start
+ up. */
+ rs->starting_up = 0;
+
/* If breakpoints are global, insert them now. */
if (gdbarch_has_global_breakpoints (target_gdbarch)
&& breakpoints_always_inserted_mode ())
{
struct remote_state *rs = get_remote_state ();
- sprintf (rs->buf, "QAllow:"
- "WriteReg:%x;WriteMem:%x;"
- "InsertBreak:%x;InsertTrace:%x;"
- "InsertFastTrace:%x;Stop:%x",
- may_write_registers, may_write_memory,
- may_insert_breakpoints, may_insert_tracepoints,
- may_insert_fast_tracepoints, may_stop);
+ xsnprintf (rs->buf, get_remote_packet_size (), "QAllow:"
+ "WriteReg:%x;WriteMem:%x;"
+ "InsertBreak:%x;InsertTrace:%x;"
+ "InsertFastTrace:%x;Stop:%x",
+ may_write_registers, may_write_memory,
+ may_insert_breakpoints, may_insert_tracepoints,
+ may_insert_fast_tracepoints, may_stop);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
/* If the target didn't like the packet, warn the user. Do not try
to undo the user's settings, that would just be maddening. */
if (strcmp (rs->buf, "OK") != 0)
- warning ("Remote refused setting permissions with: %s", rs->buf);
+ warning (_("Remote refused setting permissions with: %s"), rs->buf);
}
/* This type describes each known response to the qSupported
rs->cond_tracepoints = (support == PACKET_ENABLE);
}
+static void
+remote_cond_breakpoint_feature (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *value)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ rs->cond_breakpoints = (support == PACKET_ENABLE);
+}
+
+static void
+remote_breakpoint_commands_feature (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *value)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ rs->breakpoint_commands = (support == PACKET_ENABLE);
+}
+
static void
remote_fast_tracepoint_feature (const struct protocol_feature *feature,
enum packet_support support,
rs->static_tracepoints = (support == PACKET_ENABLE);
}
+static void
+remote_install_in_trace_feature (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *value)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ rs->install_in_trace = (support == PACKET_ENABLE);
+}
+
static void
remote_disconnected_tracing_feature (const struct protocol_feature *feature,
enum packet_support support,
rs->disconnected_tracing = (support == PACKET_ENABLE);
}
+static void
+remote_enable_disable_tracepoint_feature (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *value)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ rs->enable_disable_tracepoints = (support == PACKET_ENABLE);
+}
+
+static void
+remote_string_tracing_feature (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *value)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ rs->string_tracing = (support == PACKET_ENABLE);
+}
+
static struct protocol_feature remote_protocol_features[] = {
{ "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
{ "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_features },
{ "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_libraries },
+ { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_libraries_svr4 },
{ "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_memory_map },
{ "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_traceframe_info },
{ "QPassSignals", PACKET_DISABLE, remote_supported_packet,
PACKET_QPassSignals },
+ { "QProgramSignals", PACKET_DISABLE, remote_supported_packet,
+ PACKET_QProgramSignals },
{ "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
PACKET_QStartNoAckMode },
{ "multiprocess", PACKET_DISABLE, remote_multi_process_feature, -1 },
PACKET_qXfer_siginfo_write },
{ "ConditionalTracepoints", PACKET_DISABLE, remote_cond_tracepoint_feature,
PACKET_ConditionalTracepoints },
+ { "ConditionalBreakpoints", PACKET_DISABLE, remote_cond_breakpoint_feature,
+ PACKET_ConditionalBreakpoints },
+ { "BreakpointCommands", PACKET_DISABLE, remote_breakpoint_commands_feature,
+ PACKET_BreakpointCommands },
{ "FastTracepoints", PACKET_DISABLE, remote_fast_tracepoint_feature,
PACKET_FastTracepoints },
{ "StaticTracepoints", PACKET_DISABLE, remote_static_tracepoint_feature,
PACKET_StaticTracepoints },
+ {"InstallInTrace", PACKET_DISABLE, remote_install_in_trace_feature,
+ PACKET_InstallInTrace},
{ "DisconnectedTracing", PACKET_DISABLE, remote_disconnected_tracing_feature,
-1 },
{ "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
PACKET_TracepointSource },
{ "QAllow", PACKET_DISABLE, remote_supported_packet,
PACKET_QAllow },
+ { "EnableDisableTracepoints", PACKET_DISABLE,
+ remote_enable_disable_tracepoint_feature, -1 },
+ { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_fdpic },
+ { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet,
+ PACKET_qXfer_uib },
+ { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet,
+ PACKET_QDisableRandomization },
+ { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
+ { "tracenz", PACKET_DISABLE,
+ remote_string_tracing_feature, -1 },
};
static char *remote_support_xml;
char *q = NULL;
struct cleanup *old_chain = make_cleanup (free_current_contents, &q);
- if (rs->extended)
- q = remote_query_supported_append (q, "multiprocess+");
+ q = remote_query_supported_append (q, "multiprocess+");
if (remote_support_xml)
q = remote_query_supported_append (q, remote_support_xml);
xfree (last_pass_packet);
last_pass_packet = NULL;
+ /* Make sure we send the program signals list the next time we
+ resume. */
+ xfree (last_program_signals_packet);
+ last_program_signals_packet = NULL;
+
remote_fileio_reset ();
reopen_exec_file ();
reread_symbols ();
all the ``target ....'' commands to share a common callback
function. See cli-dump.c. */
{
- struct gdb_exception ex;
- struct start_remote_args args;
-
- args.from_tty = from_tty;
- args.target = target;
- args.extended_p = extended_p;
+ volatile struct gdb_exception ex;
- ex = catch_exception (uiout, remote_start_remote, &args, RETURN_MASK_ALL);
+ TRY_CATCH (ex, RETURN_MASK_ALL)
+ {
+ remote_start_remote (from_tty, target, extended_p);
+ }
if (ex.reason < 0)
{
/* Pop the partially set up target - unless something else did
if (!target_has_execution)
error (_("No process to detach from."));
+ if (from_tty)
+ {
+ char *exec_file = get_exec_file (0);
+ if (exec_file == NULL)
+ exec_file = "";
+ printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
+ target_pid_to_str (pid_to_ptid (pid)));
+ gdb_flush (gdb_stdout);
+ }
+
/* Tell the remote target to detach. */
if (remote_multi_process_p (rs))
- sprintf (rs->buf, "D;%x", pid);
+ xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid);
else
strcpy (rs->buf, "D");
else
error (_("Can't detach process."));
- if (from_tty)
- {
- if (remote_multi_process_p (rs))
- printf_filtered (_("Detached from remote %s.\n"),
- target_pid_to_str (pid_to_ptid (pid)));
- else
- {
- if (extended)
- puts_filtered (_("Detached from remote process.\n"));
- else
- puts_filtered (_("Ending remote debugging.\n"));
- }
- }
+ if (from_tty && !extended)
+ puts_filtered (_("Ending remote debugging.\n"));
discard_pending_stop_replies (pid);
target_mourn_inferior ();
if (remote_protocol_packets[PACKET_vAttach].support == PACKET_DISABLE)
error (_("This target does not support attaching to a process"));
- sprintf (rs->buf, "vAttach;%x", pid);
+ if (from_tty)
+ {
+ char *exec_file = get_exec_file (0);
+
+ if (exec_file)
+ printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
+ target_pid_to_str (pid_to_ptid (pid)));
+ else
+ printf_unfiltered (_("Attaching to %s\n"),
+ target_pid_to_str (pid_to_ptid (pid)));
+
+ gdb_flush (gdb_stdout);
+ }
+
+ xsnprintf (rs->buf, get_remote_packet_size (), "vAttach;%x", pid);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
if (packet_ok (rs->buf,
&remote_protocol_packets[PACKET_vAttach]) == PACKET_OK)
{
- if (from_tty)
- printf_unfiltered (_("Attached to %s\n"),
- target_pid_to_str (pid_to_ptid (pid)));
-
if (!non_stop)
{
/* Save the reply for later. */
error (_("Attaching to %s failed"),
target_pid_to_str (pid_to_ptid (pid)));
- set_current_inferior (remote_add_inferior (pid, 1));
+ set_current_inferior (remote_add_inferior (0, pid, 1));
inferior_ptid = pid_to_ptid (pid);
static char *
append_resumption (char *p, char *endp,
- ptid_t ptid, int step, enum target_signal siggnal)
+ ptid_t ptid, int step, enum gdb_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
- if (step && siggnal != TARGET_SIGNAL_0)
+ if (step && siggnal != GDB_SIGNAL_0)
p += xsnprintf (p, endp - p, ";S%02x", siggnal);
else if (step)
p += xsnprintf (p, endp - p, ";s");
- else if (siggnal != TARGET_SIGNAL_0)
+ else if (siggnal != GDB_SIGNAL_0)
p += xsnprintf (p, endp - p, ";C%02x", siggnal);
else
p += xsnprintf (p, endp - p, ";c");
return p;
}
+/* Append a vCont continue-with-signal action for threads that have a
+ non-zero stop signal. */
+
+static char *
+append_pending_thread_resumptions (char *p, char *endp, ptid_t ptid)
+{
+ struct thread_info *thread;
+
+ ALL_THREADS (thread)
+ if (ptid_match (thread->ptid, ptid)
+ && !ptid_equal (inferior_ptid, thread->ptid)
+ && thread->suspend.stop_signal != GDB_SIGNAL_0
+ && signal_pass_state (thread->suspend.stop_signal))
+ {
+ p = append_resumption (p, endp, thread->ptid,
+ 0, thread->suspend.stop_signal);
+ thread->suspend.stop_signal = GDB_SIGNAL_0;
+ }
+
+ return p;
+}
+
/* Resume the remote inferior by using a "vCont" packet. The thread
to be resumed is PTID; STEP and SIGGNAL indicate whether the
resumed thread should be single-stepped and/or signalled. If PTID
moment. */
static int
-remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal)
+remote_vcont_resume (ptid_t ptid, int step, enum gdb_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
char *p;
process), with preference for INFERIOR_PTID. This assumes
inferior_ptid belongs to the set of all threads we are about
to resume. */
- if (step || siggnal != TARGET_SIGNAL_0)
+ if (step || siggnal != GDB_SIGNAL_0)
{
/* Step inferior_ptid, with or without signal. */
p = append_resumption (p, endp, inferior_ptid, step, siggnal);
}
+ /* Also pass down any pending signaled resumption for other
+ threads not the current. */
+ p = append_pending_thread_resumptions (p, endp, ptid);
+
/* And continue others without a signal. */
- append_resumption (p, endp, ptid, /*step=*/ 0, TARGET_SIGNAL_0);
+ append_resumption (p, endp, ptid, /*step=*/ 0, GDB_SIGNAL_0);
}
else
{
/* Tell the remote machine to resume. */
-static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
+static enum gdb_signal last_sent_signal = GDB_SIGNAL_0;
static int last_sent_step;
static void
remote_resume (struct target_ops *ops,
- ptid_t ptid, int step, enum target_signal siggnal)
+ ptid_t ptid, int step, enum gdb_signal siggnal)
{
struct remote_state *rs = get_remote_state ();
char *buf;
last_sent_signal = siggnal;
last_sent_step = step;
- /* Update the inferior on signals to silently pass, if they've changed. */
- remote_pass_signals ();
-
/* The vCont packet doesn't need to specify threads via Hc. */
/* No reverse support (yet) for vCont. */
if (execution_direction != EXEC_REVERSE)
if (execution_direction == EXEC_REVERSE)
{
/* We don't pass signals to the target in reverse exec mode. */
- if (info_verbose && siggnal != TARGET_SIGNAL_0)
- warning (" - Can't pass signal %d to target in reverse: ignored.\n",
+ if (info_verbose && siggnal != GDB_SIGNAL_0)
+ warning (_(" - Can't pass signal %d to target in reverse: ignored."),
siggnal);
if (step
strcpy (buf, step ? "bs" : "bc");
}
- else if (siggnal != TARGET_SIGNAL_0)
+ else if (siggnal != GDB_SIGNAL_0)
{
buf[0] = step ? 'S' : 'C';
buf[1] = tohex (((int) siggnal >> 4) & 0xf);
async_remote_interrupt (gdb_client_data arg)
{
if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
+ fprintf_unfiltered (gdb_stdlog, "async_remote_interrupt called\n");
target_stop (inferior_ptid);
}
async_remote_interrupt_twice (gdb_client_data arg)
{
if (remote_debug)
- fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
+ fprintf_unfiltered (gdb_stdlog, "async_remote_interrupt_twice called\n");
interrupt_query ();
}
tb[1] = 0;
fputs_unfiltered (tb, gdb_stdtarg);
}
- gdb_flush (gdb_stdtarg);
- }
+ gdb_flush (gdb_stdtarg);
+}
typedef struct cached_reg
{
struct target_waitstatus ws;
+ /* Expedited registers. This makes remote debugging a bit more
+ efficient for those targets that provide critical registers as
+ part of their normal status mechanism (as another roundtrip to
+ fetch them is avoided). */
VEC(cached_reg_t) *regcache;
int stopped_by_watchpoint_p;
else
{
event->ws.kind = TARGET_WAITKIND_STOPPED;
- event->ws.value.sig = (enum target_signal)
+ event->ws.value.sig = (enum gdb_signal)
(((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
}
break;
{
/* The remote process exited with a signal. */
event->ws.kind = TARGET_WAITKIND_SIGNALLED;
- event->ws.value.sig = (enum target_signal) value;
+ event->ws.value.sig = (enum gdb_signal) value;
}
/* If no process is specified, assume inferior_ptid. */
ofunc = signal (SIGINT, remote_interrupt);
/* If the user hit C-c before this packet, or between packets,
pretend that it was hit right here. */
- if (quit_flag)
+ if (check_quit_flag ())
{
- quit_flag = 0;
+ clear_quit_flag ();
remote_interrupt (SIGINT);
}
}
not? Not is more likely, so report a stop. */
warning (_("Remote failure reply: %s"), buf);
status->kind = TARGET_WAITKIND_STOPPED;
- status->value.sig = TARGET_SIGNAL_0;
+ status->value.sig = GDB_SIGNAL_0;
break;
case 'F': /* File-I/O request. */
remote_fileio_request (buf, rs->ctrlc_pending_p);
break;
case '\0':
- if (last_sent_signal != TARGET_SIGNAL_0)
+ if (last_sent_signal != GDB_SIGNAL_0)
{
/* Zero length reply means that we tried 'S' or 'C' and the
remote system doesn't support it. */
target_terminal_ours_for_output ();
printf_filtered
("Can't send signals to this remote system. %s not sent.\n",
- target_signal_to_name (last_sent_signal));
- last_sent_signal = TARGET_SIGNAL_0;
+ gdb_signal_to_name (last_sent_signal));
+ last_sent_signal = GDB_SIGNAL_0;
target_terminal_inferior ();
strcpy ((char *) buf, last_sent_step ? "s" : "c");
struct remote_state *rs = get_remote_state ();
int buf_len;
- sprintf (rs->buf, "g");
+ xsnprintf (rs->buf, get_remote_packet_size (), "g");
remote_send (&rs->buf, &rs->buf_size);
/* We can get out of synch in various cases. If the first character
{
if (remote_debug)
fprintf_unfiltered (gdb_stdlog,
- "binary downloading suppported by target\n");
+ "binary downloading supported by target\n");
remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
}
break;
static int
remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
- const gdb_byte *myaddr, int len,
+ const gdb_byte *myaddr, ssize_t len,
char packet_format, int use_length)
{
struct remote_state *rs = get_remote_state ();
if (todo <= 0)
internal_error (__FILE__, __LINE__,
- _("minumum packet size too small to write data"));
+ _("minimum packet size too small to write data"));
/* If we already need another packet, then try to align the end
of this packet to a useful boundary. */
error. Only transfer a single packet. */
static int
-remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
{
char *packet_format = 0;
/* Remote notification handler. */
static void
-handle_notification (char *buf, size_t length)
+handle_notification (char *buf)
{
if (strncmp (buf, "Stop:", 5) == 0)
{
str);
do_cleanups (old_chain);
}
- handle_notification (rs->buf, val);
+ handle_notification (rs->buf);
/* We're in sync now, rewait for the ack. */
tcount = 0;
}
do_cleanups (old_chain);
}
- handle_notification (*buf, val);
+ handle_notification (*buf);
/* Notifications require no acknowledgement. */
}
\f
+/* A helper function that just calls putpkt; for type correctness. */
+
+static int
+putpkt_for_catch_errors (void *arg)
+{
+ return putpkt (arg);
+}
+
static void
remote_kill (struct target_ops *ops)
{
/* Use catch_errors so the user can quit from gdb even when we
aren't on speaking terms with the remote system. */
- catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
+ catch_errors (putpkt_for_catch_errors, "k", "", RETURN_MASK_ERROR);
/* Don't wait for it to die. I'm not really sure it matters whether
we do or not. For the existing stubs, kill is a noop. */
return -1;
/* Tell the remote target to detach. */
- sprintf (rs->buf, "vKill;%x", pid);
+ xsnprintf (rs->buf, get_remote_packet_size (), "vKill;%x", pid);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
struct remote_state *rs = get_remote_state ();
res = remote_vkill (pid, rs);
- if (res == -1 && !remote_multi_process_p (rs))
+ if (res == -1 && !(rs->extended && remote_multi_process_p (rs)))
{
/* Don't try 'k' on a multi-process aware stub -- it has no way
to specify the pid. */
extended_remote_mourn_1 (ops);
}
+static int
+extended_remote_supports_disable_randomization (void)
+{
+ return (remote_protocol_packets[PACKET_QDisableRandomization].support
+ == PACKET_ENABLE);
+}
+
+static void
+extended_remote_disable_randomization (int val)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *reply;
+
+ xsnprintf (rs->buf, get_remote_packet_size (), "QDisableRandomization:%x",
+ val);
+ putpkt (rs->buf);
+ reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (*reply == '\0')
+ error (_("Target does not support QDisableRandomization."));
+ if (strcmp (reply, "OK") != 0)
+ error (_("Bogus QDisableRandomization reply from target: %s"), reply);
+}
+
static int
extended_remote_run (char *args)
{
if (target_can_async_p ())
target_async (inferior_event_handler, 0);
+ /* Disable address space randomization if requested (and supported). */
+ if (extended_remote_supports_disable_randomization ())
+ extended_remote_disable_randomization (disable_randomization);
+
/* Now restart the remote server. */
if (extended_remote_run (args) == -1)
{
init_wait_for_inferior ();
}
- /* Now mark the inferior as running before we do anything else. */
- inferior_ptid = magic_null_ptid;
-
- /* Now, if we have thread information, update inferior_ptid. */
- inferior_ptid = remote_current_thread (inferior_ptid);
-
- remote_add_inferior (ptid_get_pid (inferior_ptid), 0);
- add_thread_silent (inferior_ptid);
+ add_current_inferior_and_thread ();
/* Get updated offsets, if the stub uses qOffsets. */
get_offsets ();
}
\f
-/* Insert a breakpoint. On targets that have software breakpoint
- support, we ask the remote target to do the work; on targets
- which don't, we insert a traditional memory breakpoint. */
+/* Given a location's target info BP_TGT and the packet buffer BUF, output
+ the list of conditions (in agent expression bytecode format), if any, the
+ target needs to evaluate. The output is placed into the packet buffer
+ started from BUF and ended at BUF_END. */
static int
-remote_insert_breakpoint (struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
+remote_add_target_side_condition (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt, char *buf,
+ char *buf_end)
{
- /* 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
+ struct agent_expr *aexpr = NULL;
+ int i, ix;
+ char *pkt;
+ char *buf_start = buf;
+
+ if (VEC_empty (agent_expr_p, bp_tgt->conditions))
+ return 0;
+
+ buf += strlen (buf);
+ xsnprintf (buf, buf_end - buf, "%s", ";");
+ buf++;
+
+ /* Send conditions to the target and free the vector. */
+ for (ix = 0;
+ VEC_iterate (agent_expr_p, bp_tgt->conditions, ix, aexpr);
+ ix++)
+ {
+ xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len);
+ buf += strlen (buf);
+ for (i = 0; i < aexpr->len; ++i)
+ buf = pack_hex_byte (buf, aexpr->buf[i]);
+ *buf = '\0';
+ }
+
+ VEC_free (agent_expr_p, bp_tgt->conditions);
+ return 0;
+}
+
+static void
+remote_add_target_side_commands (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt, char *buf)
+{
+ struct agent_expr *aexpr = NULL;
+ int i, ix;
+
+ if (VEC_empty (agent_expr_p, bp_tgt->tcommands))
+ return;
+
+ buf += strlen (buf);
+
+ sprintf (buf, ";cmds:%x,", bp_tgt->persist);
+ buf += strlen (buf);
+
+ /* Concatenate all the agent expressions that are commands into the
+ cmds parameter. */
+ for (ix = 0;
+ VEC_iterate (agent_expr_p, bp_tgt->tcommands, ix, aexpr);
+ ix++)
+ {
+ sprintf (buf, "X%x,", aexpr->len);
+ buf += strlen (buf);
+ for (i = 0; i < aexpr->len; ++i)
+ buf = pack_hex_byte (buf, aexpr->buf[i]);
+ *buf = '\0';
+ }
+
+ VEC_free (agent_expr_p, bp_tgt->tcommands);
+}
+
+/* Insert a breakpoint. On targets that have software breakpoint
+ 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 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
fails, and the user has explicitly requested the Z support then
report an error, otherwise, mark it disabled and go on. */
{
CORE_ADDR addr = bp_tgt->placed_address;
struct remote_state *rs;
- char *p;
+ char *p, *endbuf;
int bpsize;
+ struct condition_list *cond = NULL;
gdbarch_remote_breakpoint_from_pc (gdbarch, &addr, &bpsize);
rs = get_remote_state ();
p = rs->buf;
+ endbuf = rs->buf + get_remote_packet_size ();
*(p++) = 'Z';
*(p++) = '0';
*(p++) = ',';
addr = (ULONGEST) remote_address_masked (addr);
p += hexnumstr (p, addr);
- sprintf (p, ",%d", bpsize);
+ xsnprintf (p, endbuf - p, ",%d", bpsize);
+
+ if (remote_supports_cond_breakpoints ())
+ remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
+
+ if (remote_can_run_breakpoint_commands ())
+ remote_add_target_side_commands (gdbarch, bp_tgt, p);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
{
char *p = rs->buf;
+ char *endbuf = rs->buf + get_remote_packet_size ();
*(p++) = 'z';
*(p++) = '0';
addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
p += hexnumstr (p, addr);
- sprintf (p, ",%d", bp_tgt->placed_size);
+ xsnprintf (p, endbuf - p, ",%d", bp_tgt->placed_size);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
struct expression *cond)
{
struct remote_state *rs = get_remote_state ();
+ char *endbuf = rs->buf + get_remote_packet_size ();
char *p;
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
return 1;
- sprintf (rs->buf, "Z%x,", packet);
+ xsnprintf (rs->buf, endbuf - rs->buf, "Z%x,", packet);
p = strchr (rs->buf, '\0');
addr = remote_address_masked (addr);
p += hexnumstr (p, (ULONGEST) addr);
- sprintf (p, ",%x", len);
+ xsnprintf (p, endbuf - p, ",%x", len);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
_("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)
+{
+ CORE_ADDR diff = remote_address_masked (addr - start);
+
+ return diff < length;
+}
+
static int
remote_remove_watchpoint (CORE_ADDR addr, int len, int type,
struct expression *cond)
{
struct remote_state *rs = get_remote_state ();
+ char *endbuf = rs->buf + get_remote_packet_size ();
char *p;
enum Z_packet_type packet = watchpoint_to_Z_packet (type);
if (remote_protocol_packets[PACKET_Z0 + packet].support == PACKET_DISABLE)
return -1;
- sprintf (rs->buf, "z%x,", packet);
+ xsnprintf (rs->buf, endbuf - rs->buf, "z%x,", packet);
p = strchr (rs->buf, '\0');
addr = remote_address_masked (addr);
p += hexnumstr (p, (ULONGEST) addr);
- sprintf (p, ",%x", len);
+ xsnprintf (p, endbuf - p, ",%x", len);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
int remote_hw_watchpoint_limit = -1;
+int remote_hw_watchpoint_length_limit = -1;
int remote_hw_breakpoint_limit = -1;
+static int
+remote_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
+{
+ if (remote_hw_watchpoint_length_limit == 0)
+ return 0;
+ else if (remote_hw_watchpoint_length_limit < 0)
+ return 1;
+ else if (len <= remote_hw_watchpoint_length_limit)
+ return 1;
+ else
+ return 0;
+}
+
static int
remote_check_watch_resources (int type, int cnt, int ot)
{
{
CORE_ADDR addr;
struct remote_state *rs;
- char *p;
+ char *p, *endbuf;
/* The length field should be set to the size of a breakpoint
instruction, even though we aren't inserting one ourselves. */
rs = get_remote_state ();
p = rs->buf;
+ endbuf = rs->buf + get_remote_packet_size ();
*(p++) = 'Z';
*(p++) = '1';
addr = remote_address_masked (bp_tgt->placed_address);
p += hexnumstr (p, (ULONGEST) addr);
- sprintf (p, ",%x", bp_tgt->placed_size);
+ xsnprintf (p, endbuf - p, ",%x", bp_tgt->placed_size);
+
+ if (remote_supports_cond_breakpoints ())
+ remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
+
+ if (remote_can_run_breakpoint_commands ())
+ remote_add_target_side_commands (gdbarch, bp_tgt, p);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
CORE_ADDR addr;
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
+ char *endbuf = rs->buf + get_remote_packet_size ();
if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
return -1;
addr = remote_address_masked (bp_tgt->placed_address);
p += hexnumstr (p, (ULONGEST) addr);
- sprintf (p, ",%x", bp_tgt->placed_size);
+ xsnprintf (p, endbuf - p, ",%x", bp_tgt->placed_size);
putpkt (rs->buf);
getpkt (&rs->buf, &rs->buf_size, 0);
(ops, "libraries", annex, readbuf, offset, len,
&remote_protocol_packets[PACKET_qXfer_libraries]);
+ case TARGET_OBJECT_LIBRARIES_SVR4:
+ return remote_read_qxfer
+ (ops, "libraries-svr4", annex, readbuf, offset, 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
(ops, "traceframe-info", annex, readbuf, offset, len,
&remote_protocol_packets[PACKET_qXfer_traceframe_info]);
+
+ case TARGET_OBJECT_FDPIC:
+ return remote_read_qxfer (ops, "fdpic", annex, readbuf, offset, len,
+ &remote_protocol_packets[PACKET_qXfer_fdpic]);
+
+ case TARGET_OBJECT_OPENVMS_UIB:
+ return remote_read_qxfer (ops, "uib", annex, readbuf, offset, len,
+ &remote_protocol_packets[PACKET_qXfer_uib]);
+
default:
return -1;
}
char *buf;
/* XXX - see also remote_get_noisy_reply(). */
+ QUIT; /* Allow user to bail out with ^C. */
rs->buf[0] = '\0';
- getpkt (&rs->buf, &rs->buf_size, 0);
+ if (getpkt_sane (&rs->buf, &rs->buf_size, 0) == -1)
+ {
+ /* Timeout. Continue to (try to) read responses.
+ This is better than stopping with an error, assuming the stub
+ is still executing the (long) monitor command.
+ If needed, the user can interrupt gdb using C-c, obtaining
+ an effect similar to stop on timeout. */
+ continue;
+ }
buf = rs->buf;
if (buf[0] == '\0')
error (_("Target does not support this command."));
static char buf[64];
struct remote_state *rs = get_remote_state ();
- if (ptid_is_pid (ptid))
+ if (ptid_equal (ptid, null_ptid))
+ return normal_pid_to_str (ptid);
+ else if (ptid_is_pid (ptid))
{
/* Printing an inferior target id. */
{
if (ptid_equal (magic_null_ptid, ptid))
xsnprintf (buf, sizeof buf, "Thread <main>");
- else if (remote_multi_process_p (rs))
+ else if (rs->extended && remote_multi_process_p (rs))
xsnprintf (buf, sizeof buf, "Thread %d.%ld",
ptid_get_pid (ptid), ptid_get_tid (ptid));
else
/* Provide thread local base, i.e. Thread Information Block address.
Returns 1 if ptid is found and thread_local_base is non zero. */
-int
+static int
remote_get_tib_address (ptid_t ptid, CORE_ADDR *addr)
{
if (remote_protocol_packets[PACKET_qGetTIBAddr].support != PACKET_DISABLE)
remote_errno, NULL, NULL);
}
+/* Read value of symbolic link FILENAME on the remote target. Return
+ a null-terminated string allocated via xmalloc, or NULL if an error
+ occurs (and set *REMOTE_ERRNO). */
+
+static char *
+remote_hostio_readlink (const char *filename, int *remote_errno)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *p = rs->buf;
+ char *attachment;
+ int left = get_remote_packet_size ();
+ int len, attachment_len;
+ int read_len;
+ char *ret;
+
+ remote_buffer_add_string (&p, &left, "vFile:readlink:");
+
+ remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
+ strlen (filename));
+
+ len = remote_hostio_send_command (p - rs->buf, PACKET_vFile_readlink,
+ remote_errno, &attachment,
+ &attachment_len);
+
+ if (len < 0)
+ return NULL;
+
+ ret = xmalloc (len + 1);
+
+ read_len = remote_unescape_input (attachment, attachment_len,
+ ret, len);
+ if (read_len != len)
+ error (_("Readlink returned %d, but %d bytes."), len, read_len);
+
+ ret[len] = '\0';
+ return ret;
+}
+
static int
remote_fileio_errno_to_host (int errnum)
{
bfd *
remote_bfd_open (const char *remote_file, const char *target)
{
- return bfd_openr_iovec (remote_file, target,
- remote_bfd_iovec_open, NULL,
- remote_bfd_iovec_pread,
- remote_bfd_iovec_close,
- remote_bfd_iovec_stat);
+ bfd *abfd = gdb_bfd_openr_iovec (remote_file, target,
+ remote_bfd_iovec_open, NULL,
+ remote_bfd_iovec_pread,
+ remote_bfd_iovec_close,
+ remote_bfd_iovec_stat);
+
+ return abfd;
}
void
return 1;
}
+static int
+remote_supports_disable_randomization (void)
+{
+ /* Only supported in extended mode. */
+ return 0;
+}
+
static int
remote_supports_multi_process (void)
{
struct remote_state *rs = get_remote_state ();
- return remote_multi_process_p (rs);
+ /* Only extended-remote handles being attached to multiple
+ processes, even though plain remote can use the multi-process
+ thread id extensions, so that GDB knows the target process's
+ PID. */
+ return rs->extended && remote_multi_process_p (rs);
}
-int
+static int
remote_supports_cond_tracepoints (void)
{
struct remote_state *rs = get_remote_state ();
return rs->cond_tracepoints;
}
-int
+static int
+remote_supports_cond_breakpoints (void)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return rs->cond_breakpoints;
+}
+
+static int
remote_supports_fast_tracepoints (void)
{
struct remote_state *rs = get_remote_state ();
return rs->static_tracepoints;
}
+static int
+remote_supports_install_in_trace (void)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return rs->install_in_trace;
+}
+
+static int
+remote_supports_enable_disable_tracepoint (void)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return rs->enable_disable_tracepoints;
+}
+
+static int
+remote_supports_string_tracing (void)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return rs->string_tracing;
+}
+
+static int
+remote_can_run_breakpoint_commands (void)
+{
+ struct remote_state *rs = get_remote_state ();
+
+ return rs->breakpoint_commands;
+}
+
static void
remote_trace_init (void)
{
}
static void
-remote_download_tracepoint (struct breakpoint *t)
+remote_download_tracepoint (struct bp_location *loc)
{
- struct bp_location *loc;
+#define BUF_SIZE 2048
+
CORE_ADDR tpaddr;
char addrbuf[40];
- char buf[2048];
+ char buf[BUF_SIZE];
char **tdp_actions;
char **stepping_actions;
int ndx;
struct agent_expr *aexpr;
struct cleanup *aexpr_chain = NULL;
char *pkt;
-
- /* Iterate over all the tracepoint locations. It's up to the target to
- notice multiple tracepoint packets with the same number but different
- addresses, and treat them as multiple locations. */
- for (loc = t->loc; loc; loc = loc->next)
- {
- encode_actions (t, loc, &tdp_actions, &stepping_actions);
- old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
- tdp_actions);
- (void) make_cleanup (free_actions_list_cleanup_wrapper,
- stepping_actions);
-
- tpaddr = loc->address;
- sprintf_vma (addrbuf, tpaddr);
- sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number,
- addrbuf, /* address */
- (t->enable_state == bp_enabled ? 'E' : 'D'),
- t->step_count, t->pass_count);
- /* Fast tracepoints are mostly handled by the target, but we can
- tell the target how big of an instruction block should be moved
- around. */
- if (t->type == bp_fast_tracepoint)
+ struct breakpoint *b = loc->owner;
+ struct tracepoint *t = (struct tracepoint *) b;
+
+ encode_actions (loc->owner, loc, &tdp_actions, &stepping_actions);
+ old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
+ tdp_actions);
+ (void) make_cleanup (free_actions_list_cleanup_wrapper,
+ stepping_actions);
+
+ tpaddr = loc->address;
+ sprintf_vma (addrbuf, tpaddr);
+ xsnprintf (buf, BUF_SIZE, "QTDP:%x:%s:%c:%lx:%x", b->number,
+ addrbuf, /* address */
+ (b->enable_state == bp_enabled ? 'E' : 'D'),
+ t->step_count, t->pass_count);
+ /* Fast tracepoints are mostly handled by the target, but we can
+ tell the target how big of an instruction block should be moved
+ around. */
+ if (b->type == bp_fast_tracepoint)
+ {
+ /* Only test for support at download time; we may not know
+ target capabilities at definition time. */
+ if (remote_supports_fast_tracepoints ())
{
- /* Only test for support at download time; we may not know
- target capabilities at definition time. */
- if (remote_supports_fast_tracepoints ())
- {
- int isize;
+ int isize;
- if (gdbarch_fast_tracepoint_valid_at (target_gdbarch,
- tpaddr, &isize, NULL))
- sprintf (buf + strlen (buf), ":F%x", isize);
- else
- /* If it passed validation at definition but fails now,
- something is very wrong. */
- internal_error (__FILE__, __LINE__,
- _("Fast tracepoint not "
- "valid during download"));
- }
+ if (gdbarch_fast_tracepoint_valid_at (target_gdbarch,
+ tpaddr, &isize, NULL))
+ xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":F%x",
+ isize);
else
- /* Fast tracepoints are functionally identical to regular
- tracepoints, so don't take lack of support as a reason to
- give up on the trace run. */
- warning (_("Target does not support fast tracepoints, "
- "downloading %d as regular tracepoint"), t->number);
+ /* If it passed validation at definition but fails now,
+ something is very wrong. */
+ internal_error (__FILE__, __LINE__,
+ _("Fast tracepoint not "
+ "valid during download"));
}
- else if (t->type == bp_static_tracepoint)
+ else
+ /* Fast tracepoints are functionally identical to regular
+ tracepoints, so don't take lack of support as a reason to
+ give up on the trace run. */
+ warning (_("Target does not support fast tracepoints, "
+ "downloading %d as regular tracepoint"), b->number);
+ }
+ else if (b->type == bp_static_tracepoint)
+ {
+ /* Only test for support at download time; we may not know
+ target capabilities at definition time. */
+ if (remote_supports_static_tracepoints ())
{
- /* Only test for support at download time; we may not know
- target capabilities at definition time. */
- if (remote_supports_static_tracepoints ())
- {
- struct static_tracepoint_marker marker;
+ struct static_tracepoint_marker marker;
- if (target_static_tracepoint_marker_at (tpaddr, &marker))
- strcat (buf, ":S");
- else
- error (_("Static tracepoint not valid during download"));
- }
+ if (target_static_tracepoint_marker_at (tpaddr, &marker))
+ strcat (buf, ":S");
else
- /* Fast tracepoints are functionally identical to regular
- tracepoints, so don't take lack of support as a reason
- to give up on the trace run. */
- error (_("Target does not support static tracepoints"));
+ error (_("Static tracepoint not valid during download"));
}
- /* If the tracepoint has a conditional, make it into an agent
- expression and append to the definition. */
- if (loc->cond)
+ else
+ /* Fast tracepoints are functionally identical to regular
+ tracepoints, so don't take lack of support as a reason
+ to give up on the trace run. */
+ error (_("Target does not support static tracepoints"));
+ }
+ /* If the tracepoint has a conditional, make it into an agent
+ expression and append to the definition. */
+ if (loc->cond)
+ {
+ /* Only test support at download time, we may not know target
+ capabilities at definition time. */
+ if (remote_supports_cond_tracepoints ())
{
- /* Only test support at download time, we may not know target
- capabilities at definition time. */
- if (remote_supports_cond_tracepoints ())
- {
- aexpr = gen_eval_for_expr (tpaddr, loc->cond);
- aexpr_chain = make_cleanup_free_agent_expr (aexpr);
- sprintf (buf + strlen (buf), ":X%x,", aexpr->len);
- pkt = buf + strlen (buf);
- for (ndx = 0; ndx < aexpr->len; ++ndx)
- pkt = pack_hex_byte (pkt, aexpr->buf[ndx]);
- *pkt = '\0';
- do_cleanups (aexpr_chain);
- }
- else
- warning (_("Target does not support conditional tracepoints, "
- "ignoring tp %d cond"), t->number);
+ aexpr = gen_eval_for_expr (tpaddr, loc->cond);
+ aexpr_chain = make_cleanup_free_agent_expr (aexpr);
+ xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":X%x,",
+ aexpr->len);
+ pkt = buf + strlen (buf);
+ for (ndx = 0; ndx < aexpr->len; ++ndx)
+ pkt = pack_hex_byte (pkt, aexpr->buf[ndx]);
+ *pkt = '\0';
+ do_cleanups (aexpr_chain);
}
+ else
+ warning (_("Target does not support conditional tracepoints, "
+ "ignoring tp %d cond"), b->number);
+ }
- if (t->commands || *default_collect)
- strcat (buf, "-");
- putpkt (buf);
- remote_get_noisy_reply (&target_buf, &target_buf_size);
- if (strcmp (target_buf, "OK"))
- error (_("Target does not support tracepoints."));
+ if (b->commands || *default_collect)
+ strcat (buf, "-");
+ putpkt (buf);
+ remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (strcmp (target_buf, "OK"))
+ error (_("Target does not support tracepoints."));
- /* do_single_steps (t); */
- if (tdp_actions)
+ /* do_single_steps (t); */
+ if (tdp_actions)
+ {
+ for (ndx = 0; tdp_actions[ndx]; ndx++)
{
- for (ndx = 0; tdp_actions[ndx]; ndx++)
- {
- QUIT; /* Allow user to bail out with ^C. */
- sprintf (buf, "QTDP:-%x:%s:%s%c",
- t->number, addrbuf, /* address */
- tdp_actions[ndx],
- ((tdp_actions[ndx + 1] || stepping_actions)
- ? '-' : 0));
- putpkt (buf);
- remote_get_noisy_reply (&target_buf,
- &target_buf_size);
- if (strcmp (target_buf, "OK"))
- error (_("Error on target while setting tracepoints."));
- }
+ QUIT; /* Allow user to bail out with ^C. */
+ xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%c",
+ b->number, addrbuf, /* address */
+ tdp_actions[ndx],
+ ((tdp_actions[ndx + 1] || stepping_actions)
+ ? '-' : 0));
+ putpkt (buf);
+ remote_get_noisy_reply (&target_buf,
+ &target_buf_size);
+ if (strcmp (target_buf, "OK"))
+ error (_("Error on target while setting tracepoints."));
}
- if (stepping_actions)
+ }
+ if (stepping_actions)
+ {
+ for (ndx = 0; stepping_actions[ndx]; ndx++)
{
- for (ndx = 0; stepping_actions[ndx]; ndx++)
- {
- QUIT; /* Allow user to bail out with ^C. */
- sprintf (buf, "QTDP:-%x:%s:%s%s%s",
- t->number, addrbuf, /* address */
- ((ndx == 0) ? "S" : ""),
- stepping_actions[ndx],
- (stepping_actions[ndx + 1] ? "-" : ""));
- putpkt (buf);
- remote_get_noisy_reply (&target_buf,
- &target_buf_size);
- if (strcmp (target_buf, "OK"))
- error (_("Error on target while setting tracepoints."));
- }
+ QUIT; /* Allow user to bail out with ^C. */
+ xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%s%s",
+ b->number, addrbuf, /* address */
+ ((ndx == 0) ? "S" : ""),
+ stepping_actions[ndx],
+ (stepping_actions[ndx + 1] ? "-" : ""));
+ putpkt (buf);
+ remote_get_noisy_reply (&target_buf,
+ &target_buf_size);
+ if (strcmp (target_buf, "OK"))
+ error (_("Error on target while setting tracepoints."));
}
+ }
- if (remote_protocol_packets[PACKET_TracepointSource].support
- == PACKET_ENABLE)
+ if (remote_protocol_packets[PACKET_TracepointSource].support
+ == PACKET_ENABLE)
+ {
+ if (b->addr_string)
{
- if (t->addr_string)
- {
- strcpy (buf, "QTDPsrc:");
- encode_source_string (t->number, loc->address,
- "at", t->addr_string, buf + strlen (buf),
- 2048 - strlen (buf));
+ strcpy (buf, "QTDPsrc:");
+ encode_source_string (b->number, loc->address,
+ "at", b->addr_string, buf + strlen (buf),
+ 2048 - strlen (buf));
- putpkt (buf);
- remote_get_noisy_reply (&target_buf, &target_buf_size);
- if (strcmp (target_buf, "OK"))
- warning (_("Target does not support source download."));
- }
- if (t->cond_string)
- {
- strcpy (buf, "QTDPsrc:");
- encode_source_string (t->number, loc->address,
- "cond", t->cond_string, buf + strlen (buf),
- 2048 - strlen (buf));
- putpkt (buf);
- remote_get_noisy_reply (&target_buf, &target_buf_size);
- if (strcmp (target_buf, "OK"))
- warning (_("Target does not support source download."));
- }
- remote_download_command_source (t->number, loc->address,
- breakpoint_commands (t));
+ putpkt (buf);
+ remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (strcmp (target_buf, "OK"))
+ warning (_("Target does not support source download."));
}
-
- do_cleanups (old_chain);
+ if (b->cond_string)
+ {
+ strcpy (buf, "QTDPsrc:");
+ encode_source_string (b->number, loc->address,
+ "cond", b->cond_string, buf + strlen (buf),
+ 2048 - strlen (buf));
+ putpkt (buf);
+ remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (strcmp (target_buf, "OK"))
+ warning (_("Target does not support source download."));
+ }
+ remote_download_command_source (b->number, loc->address,
+ breakpoint_commands (b));
}
+
+ do_cleanups (old_chain);
}
+static int
+remote_can_download_tracepoint (void)
+{
+ struct remote_state *rs = get_remote_state ();
+ struct trace_status *ts;
+ int status;
+
+ /* Don't try to install tracepoints until we've relocated our
+ symbols, and fetched and merged the target's tracepoint list with
+ ours. */
+ if (rs->starting_up)
+ return 0;
+
+ ts = current_trace_status ();
+ status = remote_get_trace_status (ts);
+
+ if (status == -1 || !ts->running_known || !ts->running)
+ return 0;
+
+ /* 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 1;
+}
+
+
static void
remote_download_trace_state_variable (struct trace_state_variable *tsv)
{
struct remote_state *rs = get_remote_state ();
char *p;
- sprintf (rs->buf, "QTDV:%x:%s:%x:",
- tsv->number, phex ((ULONGEST) tsv->initial_value, 8), tsv->builtin);
+ xsnprintf (rs->buf, get_remote_packet_size (), "QTDV:%x:%s:%x:",
+ tsv->number, phex ((ULONGEST) tsv->initial_value, 8),
+ tsv->builtin);
p = rs->buf + strlen (rs->buf);
if ((p - rs->buf) + strlen (tsv->name) * 2 >= get_remote_packet_size ())
error (_("Trace state variable name too long for tsv definition packet"));
error (_("Error on target while downloading trace state variable."));
}
+static void
+remote_enable_tracepoint (struct bp_location *location)
+{
+ struct remote_state *rs = get_remote_state ();
+ char addr_buf[40];
+
+ sprintf_vma (addr_buf, location->address);
+ xsnprintf (rs->buf, get_remote_packet_size (), "QTEnable:%x:%s",
+ location->owner->number, addr_buf);
+ putpkt (rs->buf);
+ remote_get_noisy_reply (&rs->buf, &rs->buf_size);
+ if (*rs->buf == '\0')
+ error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
+ if (strcmp (rs->buf, "OK") != 0)
+ error (_("Error on target while enabling tracepoint."));
+}
+
+static void
+remote_disable_tracepoint (struct bp_location *location)
+{
+ struct remote_state *rs = get_remote_state ();
+ char addr_buf[40];
+
+ sprintf_vma (addr_buf, location->address);
+ xsnprintf (rs->buf, get_remote_packet_size (), "QTDisable:%x:%s",
+ location->owner->number, addr_buf);
+ putpkt (rs->buf);
+ remote_get_noisy_reply (&rs->buf, &rs->buf_size);
+ if (*rs->buf == '\0')
+ error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
+ if (strcmp (rs->buf, "OK") != 0)
+ error (_("Error on target while disabling tracepoint."));
+}
+
static void
remote_trace_set_readonly_regions (void)
{
asection *s;
+ bfd *abfd = NULL;
bfd_size_type size;
bfd_vma vma;
int anysecs = 0;
+ int offset = 0;
if (!exec_bfd)
return; /* No information to give. */
for (s = exec_bfd->sections; s; s = s->next)
{
char tmp1[40], tmp2[40];
+ int sec_length;
if ((s->flags & SEC_LOAD) == 0 ||
/* (s->flags & SEC_CODE) == 0 || */
continue;
anysecs = 1;
- vma = bfd_get_section_vma (,s);
+ vma = bfd_get_section_vma (abfd, s);
size = bfd_get_section_size (s);
sprintf_vma (tmp1, vma);
sprintf_vma (tmp2, vma + size);
- sprintf (target_buf + strlen (target_buf),
- ":%s,%s", tmp1, tmp2);
+ sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
+ if (offset + sec_length + 1 > target_buf_size)
+ {
+ if (remote_protocol_packets[PACKET_qXfer_traceframe_info].support
+ != PACKET_ENABLE)
+ warning (_("\
+Too many sections for read-only sections definition packet."));
+ break;
+ }
+ xsnprintf (target_buf + offset, target_buf_size - offset, ":%s,%s",
+ tmp1, tmp2);
+ offset += sec_length;
}
if (anysecs)
{
static int
remote_get_trace_status (struct trace_status *ts)
{
- char *p;
+ /* Initialize it just to avoid a GCC false warning. */
+ char *p = NULL;
/* FIXME we need to get register block size some other way. */
extern int trace_regblock_size;
+ volatile struct gdb_exception ex;
trace_regblock_size = get_remote_arch_state ()->sizeof_g_packet;
putpkt ("qTStatus");
- p = remote_get_noisy_reply (&target_buf, &target_buf_size);
+
+ TRY_CATCH (ex, RETURN_MASK_ERROR)
+ {
+ p = remote_get_noisy_reply (&target_buf, &target_buf_size);
+ }
+ if (ex.reason < 0)
+ {
+ exception_fprintf (gdb_stderr, ex, "qTStatus: ");
+ return -1;
+ }
/* If the remote target doesn't do tracing, flag it. */
if (*p == '\0')
return ts->running;
}
+static void
+remote_get_tracepoint_status (struct breakpoint *bp,
+ struct uploaded_tp *utp)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *reply;
+ struct bp_location *loc;
+ struct tracepoint *tp = (struct tracepoint *) bp;
+ size_t size = get_remote_packet_size ();
+
+ if (tp)
+ {
+ tp->base.hit_count = 0;
+ tp->traceframe_usage = 0;
+ for (loc = tp->base.loc; loc; loc = loc->next)
+ {
+ /* If the tracepoint was never downloaded, don't go asking for
+ any status. */
+ if (tp->number_on_target == 0)
+ continue;
+ xsnprintf (rs->buf, size, "qTP:%x:%s", tp->number_on_target,
+ phex_nz (loc->address, 0));
+ putpkt (rs->buf);
+ reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (reply && *reply)
+ {
+ if (*reply == 'V')
+ parse_tracepoint_status (reply + 1, bp, utp);
+ }
+ }
+ }
+ else if (utp)
+ {
+ utp->hit_count = 0;
+ utp->traceframe_usage = 0;
+ xsnprintf (rs->buf, size, "qTP:%x:%s", utp->number,
+ phex_nz (utp->addr, 0));
+ putpkt (rs->buf);
+ reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (reply && *reply)
+ {
+ if (*reply == 'V')
+ parse_tracepoint_status (reply + 1, bp, utp);
+ }
+ }
+}
+
static void
remote_trace_stop (void)
{
int *tpp)
{
struct remote_state *rs = get_remote_state ();
+ char *endbuf = rs->buf + get_remote_packet_size ();
char *p, *reply;
int target_frameno = -1, target_tracept = -1;
switch (type)
{
case tfind_number:
- sprintf (p, "%x", num);
+ xsnprintf (p, endbuf - p, "%x", num);
break;
case tfind_pc:
- sprintf (p, "pc:%s", phex_nz (addr1, 0));
+ xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0));
break;
case tfind_tp:
- sprintf (p, "tdp:%x", num);
+ xsnprintf (p, endbuf - p, "tdp:%x", num);
break;
case tfind_range:
- sprintf (p, "range:%s:%s", phex_nz (addr1, 0), phex_nz (addr2, 0));
+ xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0),
+ phex_nz (addr2, 0));
break;
case tfind_outside:
- sprintf (p, "outside:%s:%s", phex_nz (addr1, 0), phex_nz (addr2, 0));
+ xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0),
+ phex_nz (addr2, 0));
break;
default:
error (_("Unknown trace find type %d"), type);
set_remote_traceframe ();
- sprintf (rs->buf, "qTV:%x", tsvnum);
+ xsnprintf (rs->buf, get_remote_packet_size (), "qTV:%x", tsvnum);
putpkt (rs->buf);
reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
if (reply && *reply)
*p++ = '\0';
putpkt (rs->buf);
reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
- if (*reply != '\0')
+ if (*reply == '\0')
error (_("Target does not support this command."));
if (strcmp (reply, "OK") != 0)
error (_("Bogus reply from target: %s"), reply);
{
char *reply;
- sprintf (rs->buf, "QTDisconnected:%x", val);
+ xsnprintf (rs->buf, get_remote_packet_size (), "QTDisconnected:%x", val);
putpkt (rs->buf);
reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
if (*reply == '\0')
struct remote_state *rs = get_remote_state ();
char *reply;
- sprintf (rs->buf, "QTBuffer:circular:%x", val);
+ xsnprintf (rs->buf, get_remote_packet_size (), "QTBuffer:circular:%x", val);
putpkt (rs->buf);
reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
if (*reply == '\0')
return NULL;
}
+/* Handle the qTMinFTPILen packet. Returns the minimum length of
+ instruction on which a fast tracepoint may be placed. Returns -1
+ if the packet is not supported, and 0 if the minimum instruction
+ length is unknown. */
+
+static int
+remote_get_min_fast_tracepoint_insn_len (void)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *reply;
+
+ /* If we're not debugging a process yet, the IPA can't be
+ loaded. */
+ if (!target_has_execution)
+ return 0;
+
+ /* Make sure the remote is pointing at the right process. */
+ set_general_process ();
+
+ xsnprintf (rs->buf, get_remote_packet_size (), "qTMinFTPILen");
+ putpkt (rs->buf);
+ reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (*reply == '\0')
+ return -1;
+ else
+ {
+ ULONGEST min_insn_len;
+
+ unpack_varlen_hex (reply, &min_insn_len);
+
+ return (int) min_insn_len;
+ }
+}
+
+static int
+remote_set_trace_notes (char *user, char *notes, char *stop_notes)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *reply;
+ char *buf = rs->buf;
+ char *endbuf = rs->buf + get_remote_packet_size ();
+ int nbytes;
+
+ buf += xsnprintf (buf, endbuf - buf, "QTNotes:");
+ if (user)
+ {
+ buf += xsnprintf (buf, endbuf - buf, "user:");
+ nbytes = bin2hex (user, buf, 0);
+ buf += 2 * nbytes;
+ *buf++ = ';';
+ }
+ if (notes)
+ {
+ buf += xsnprintf (buf, endbuf - buf, "notes:");
+ nbytes = bin2hex (notes, buf, 0);
+ buf += 2 * nbytes;
+ *buf++ = ';';
+ }
+ if (stop_notes)
+ {
+ buf += xsnprintf (buf, endbuf - buf, "tstop:");
+ nbytes = bin2hex (stop_notes, buf, 0);
+ buf += 2 * nbytes;
+ *buf++ = ';';
+ }
+ /* Ensure the buffer is terminated. */
+ *buf = '\0';
+
+ putpkt (rs->buf);
+ reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (*reply == '\0')
+ return 0;
+
+ if (strcmp (reply, "OK") != 0)
+ error (_("Bogus reply from target: %s"), reply);
+
+ return 1;
+}
+
+static int
+remote_use_agent (int use)
+{
+ if (remote_protocol_packets[PACKET_QAgent].support != PACKET_DISABLE)
+ {
+ struct remote_state *rs = get_remote_state ();
+
+ /* If the stub supports QAgent. */
+ xsnprintf (rs->buf, get_remote_packet_size (), "QAgent:%d", use);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+
+ if (strcmp (rs->buf, "OK") == 0)
+ {
+ use_agent = use;
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static int
+remote_can_use_agent (void)
+{
+ return (remote_protocol_packets[PACKET_QAgent].support != PACKET_DISABLE);
+}
+
static void
init_remote_ops (void)
{
remote_ops.to_remove_breakpoint = remote_remove_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 = generic_load;
remote_ops.to_mourn_inferior = remote_mourn;
- remote_ops.to_notice_signals = remote_notice_signals;
+ remote_ops.to_pass_signals = remote_pass_signals;
+ remote_ops.to_program_signals = remote_program_signals;
remote_ops.to_thread_alive = remote_thread_alive;
remote_ops.to_find_new_threads = remote_threads_info;
remote_ops.to_pid_to_str = remote_pid_to_str;
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_async_mask = remote_async_mask;
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_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_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_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_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_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;
}
/* Set up the extended remote vector by making a copy of the standard
extended_remote_ops.to_detach = extended_remote_detach;
extended_remote_ops.to_attach = extended_remote_attach;
extended_remote_ops.to_kill = extended_remote_kill;
+ extended_remote_ops.to_supports_disable_randomization
+ = extended_remote_supports_disable_randomization;
}
static int
return 0;
/* We're async whenever the serial device is. */
- return remote_async_mask_value && serial_can_async_p (remote_desc);
+ return serial_can_async_p (remote_desc);
}
static int
return 0;
/* We're async whenever the serial device is. */
- return remote_async_mask_value && serial_is_async_p (remote_desc);
+ return serial_is_async_p (remote_desc);
}
/* Pass the SERIAL event on and up to the client. One day this code
remote_async (void (*callback) (enum inferior_event_type event_type,
void *context), void *context)
{
- if (remote_async_mask_value == 0)
- internal_error (__FILE__, __LINE__,
- _("Calling remote_async when async is masked"));
-
if (callback != NULL)
{
serial_async (remote_desc, remote_async_serial_handler, NULL);
serial_async (remote_desc, NULL, NULL);
}
-static int
-remote_async_mask (int new_mask)
-{
- int curr_mask = remote_async_mask_value;
-
- remote_async_mask_value = new_mask;
- return curr_mask;
-}
-
static void
set_remote_cmd (char *args, int from_tty)
{
the redundant "show remote Z-packet" and the legacy aliases. */
struct cleanup *showlist_chain;
struct cmd_list_element *list = remote_show_cmdlist;
+ struct ui_out *uiout = current_uiout;
showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist");
for (; list != NULL; list = list->next)
ui_out_field_string (uiout, "name", list->name);
ui_out_text (uiout, ": ");
if (list->type == show_cmd)
- do_setshow_command ((char *) NULL, from_tty, list);
+ do_show_command ((char *) NULL, from_tty, list);
else
cmd_func (list, NULL, from_tty);
/* Close the tuple. */
sigint_remote_token =
create_async_signal_handler (async_remote_interrupt, NULL);
sigint_remote_twice_token =
- create_async_signal_handler (inferior_event_handler_wrapper, NULL);
+ create_async_signal_handler (async_remote_interrupt_twice, NULL);
#if 0
init_remote_threadtests ();
number of target hardware
watchpoints is %s. */
&remote_set_cmdlist, &remote_show_cmdlist);
+ add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class,
+ &remote_hw_watchpoint_length_limit, _("\
+Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
+Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
+Specify a negative limit for unlimited."),
+ NULL, NULL, /* FIXME: i18n: The maximum
+ length (in bytes) of a target
+ hardware watchpoint is %s. */
+ &remote_set_cmdlist, &remote_show_cmdlist);
add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
&remote_hw_breakpoint_limit, _("\
Set the maximum number of target hardware breakpoints."), _("\
add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
"QPassSignals", "pass-signals", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals],
+ "QProgramSignals", "program-signals", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
"qSymbol", "symbol-lookup", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
"qXfer:libraries:read", "library-info", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4],
+ "qXfer:libraries-svr4:read", "library-info-svr4", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
"qXfer:memory-map:read", "memory-map", 0);
(&remote_protocol_packets[PACKET_qXfer_traceframe_info],
"qXfer:trace-frame-info:read", "traceframe-info", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib],
+ "qXfer:uib:read", "unwind-info-block", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
"qGetTLSAddr", "get-thread-local-storage-address",
0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink],
"vFile:unlink", "hostio-unlink", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink],
+ "vFile:readlink", "hostio-readlink", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach],
"vAttach", "attach", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
"ConditionalTracepoints",
"conditional-tracepoints", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints],
+ "ConditionalBreakpoints",
+ "conditional-breakpoints", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands],
+ "BreakpointCommands",
+ "breakpoint-commands", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints],
"FastTracepoints", "fast-tracepoints", 0);
add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
"StaticTracepoints", "static-tracepoints", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace],
+ "InstallInTrace", "install-in-trace", 0);
+
add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
"qXfer:statictrace:read", "read-sdata-object", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic],
+ "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization],
+ "QDisableRandomization", "disable-randomization", 0);
+
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent],
+ "QAgent", "agent", 0);
+
/* Keep the old ``set remote Z-packet ...'' working. Each individual
Z sub-packet has its own set and show commands, but users may
have sets to this variable in their .gdbinit files (or in their
projects / deliverable / binutils-gdb.git / blobdiff