/* True if the stub reports support for vCont;t. */
int support_vCont_t;
+
+ /* True if the stub reports support for conditional tracepoints. */
+ int cond_tracepoints;
};
/* Returns true if the multi-process extensions are in effect. */
set_remote_protocol_packet_cmd,
show_remote_protocol_packet_cmd,
&remote_set_cmdlist, &remote_show_cmdlist);
+ /* The command code copies the documentation strings. */
+ xfree (set_doc);
+ xfree (show_doc);
/* set/show remote NAME-packet {auto,on,off} -- legacy. */
if (legacy)
{
PACKET_qXfer_siginfo_read,
PACKET_qXfer_siginfo_write,
PACKET_qAttached,
+ PACKET_ConditionalTracepoints,
PACKET_MAX
};
static struct inferior *
remote_add_inferior (int pid, int attached)
{
- struct remote_state *rs = get_remote_state ();
struct inferior *inf;
/* Check whether this process we're learning about is to be
inf->attach_flag = attached;
- /* This may be the first inferior we hear about. */
- if (!target_has_execution)
- {
- if (rs->extended)
- target_mark_running (&extended_remote_ops);
- else
- target_mark_running (&remote_ops);
- }
-
return inf;
}
static void
remote_notice_new_inferior (ptid_t currthread, int running)
{
- struct remote_state *rs = get_remote_state ();
-
/* If this is a new thread, add it to GDB's thread list.
If we leave it up to WFI to do this, bad things will happen. */
remote_thread_alive (struct target_ops *ops, ptid_t ptid)
{
struct remote_state *rs = get_remote_state ();
- int tid = ptid_get_tid (ptid);
char *p, *endp;
if (ptid_equal (ptid, magic_null_ptid))
char *p = buf;
char *pp;
ULONGEST pid = 0, tid = 0;
- ptid_t ptid;
if (*p == 'p')
{
remote_current_thread (ptid_t oldpid)
{
struct remote_state *rs = get_remote_state ();
- char *p = rs->buf;
- int tid;
- int pid;
putpkt ("qC");
getpkt (&rs->buf, &rs->buf_size, 0);
{
if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
{
- if (args->extended_p)
- {
- /* We're connected, but not running. Drop out before we
- call start_remote. */
- target_mark_exited (args->target);
- return;
- }
- else
+ if (!args->extended_p)
error (_("The target is not running (try extended-remote?)"));
+
+ /* We're connected, but not running. Drop out before we
+ call start_remote. */
+ return;
}
else
{
if (thread_count () == 0)
{
- if (args->extended_p)
- {
- /* We're connected, but not running. Drop out before we
- call start_remote. */
- target_mark_exited (args->target);
- return;
- }
- else
+ if (!args->extended_p)
error (_("The target is not running (try extended-remote?)"));
- }
- if (args->extended_p)
- target_mark_running (args->target);
+ /* We're connected, but not running. Drop out before we
+ call start_remote. */
+ return;
+ }
/* Let the stub know that we want it to return the thread. */
remote_check_symbols (symfile_objfile);
}
- /* If code is shared between processes, then breakpoints are global
- too; Insert them now. */
- if (gdbarch_has_global_solist (target_gdbarch)
+ /* If breakpoints are global, insert them now. */
+ if (gdbarch_has_global_breakpoints (target_gdbarch)
&& breakpoints_always_inserted_mode ())
insert_breakpoints ();
}
xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
else
{
+ int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
/* If this is a function address, return the start of code
¤t_target);
xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
- paddr_nz (sym_addr), &reply[8]);
+ phex_nz (sym_addr, addr_size), &reply[8]);
}
putpkt (msg);
rs->non_stop_aware = (support == PACKET_ENABLE);
}
+static void
+remote_cond_tracepoint_feature (const struct protocol_feature *feature,
+ enum packet_support support,
+ const char *value)
+{
+ struct remote_state *rs = get_remote_state ();
+ rs->cond_tracepoints = (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_siginfo_read },
{ "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet,
PACKET_qXfer_siginfo_write },
+ { "ConditionalTracepoints", PACKET_DISABLE, remote_cond_tracepoint_feature,
+ PACKET_ConditionalTracepoints },
};
static void
But if we're connected to a target system with no running process,
then we will still be connected when it returns. Ask this question
first, before target_preopen has a chance to kill anything. */
- if (remote_desc != NULL && !target_has_execution)
+ if (remote_desc != NULL && !have_inferiors ())
{
if (!from_tty
|| query (_("Already connected to a remote target. Disconnect? ")))
process, we may still be connected. If we are starting "target
remote" now, the extended-remote target will not have been
removed by unpush_target. */
- if (remote_desc != NULL && !target_has_execution)
+ if (remote_desc != NULL && !have_inferiors ())
pop_target ();
/* Make sure we send the passed signals list the next time we resume. */
}
push_target (target); /* Switch to using remote target now. */
- /* Assume that the target is not running, until we learn otherwise. */
- if (extended_p)
- target_mark_exited (target);
-
/* Register extra event sources in the event loop. */
remote_async_inferior_event_token
= create_async_event_handler (remote_async_inferior_event_handler,
struct remote_state *rs = get_remote_state ();
char *p = rs->buf;
char *endp = rs->buf + get_remote_packet_size ();
- struct stop_reply *reply, *next;
if (remote_protocol_packets[PACKET_vCont].support == PACKET_SUPPORT_UNKNOWN)
remote_vcont_probe (rs);
/* Nothing to do. */
return;
- /* FIXME: cagney/1999-09-27: Shouldn't need to test for
- sync_execution here. This function should only be called when
- GDB is resuming the inferior in the forground. A background
- resume (``run&'') should leave GDB in control of the terminal and
- consequently should not call this code. */
- if (!sync_execution)
- return;
- /* FIXME: cagney/1999-09-27: Closely related to the above. Make
- calls target_terminal_*() idenpotent. The event-loop GDB talking
- to an asynchronous target with a synchronous command calls this
- function from both event-top.c and infrun.c/infcmd.c. Once GDB
- stops trying to transfer the terminal to the target when it
- shouldn't this guard can go away. */
+ /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
+ idempotent. The event-loop GDB talking to an asynchronous target
+ with a synchronous command calls this function from both
+ event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
+ transfer the terminal to the target when it shouldn't this guard
+ can go away. */
if (!remote_async_terminal_ours_p)
return;
delete_file_handler (input_fd);
return;
/* See FIXME in remote_terminal_inferior. */
- if (!sync_execution)
- return;
- /* See FIXME in remote_terminal_inferior. */
if (remote_async_terminal_ours_p)
return;
cleanup_sigint_signal_handler (NULL);
switch (buf[0])
{
case 'T': /* Status with PC, SP, FP, ... */
- {
- gdb_byte regs[MAX_REGISTER_SIZE];
-
- /* Expedited reply, containing Signal, {regno, reg} repeat. */
- /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
- ss = signal number
- n... = register number
- r... = register contents
- */
-
- p = &buf[3]; /* after Txx */
- while (*p)
- {
- char *p1;
- char *p_temp;
- int fieldsize;
- LONGEST pnum = 0;
+ /* Expedited reply, containing Signal, {regno, reg} repeat. */
+ /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
+ ss = signal number
+ n... = register number
+ r... = register contents
+ */
+
+ p = &buf[3]; /* after Txx */
+ while (*p)
+ {
+ char *p1;
+ char *p_temp;
+ int fieldsize;
+ LONGEST pnum = 0;
- /* If the packet contains a register number, save it in
- pnum and set p1 to point to the character following it.
- Otherwise p1 points to p. */
+ /* If the packet contains a register number, save it in
+ pnum and set p1 to point to the character following it.
+ Otherwise p1 points to p. */
- /* If this packet is an awatch packet, don't parse the 'a'
- as a register number. */
+ /* If this packet is an awatch packet, don't parse the 'a'
+ as a register number. */
- if (strncmp (p, "awatch", strlen("awatch")) != 0)
- {
- /* Read the ``P'' register number. */
- pnum = strtol (p, &p_temp, 16);
- p1 = p_temp;
- }
- else
- p1 = p;
+ if (strncmp (p, "awatch", strlen("awatch")) != 0)
+ {
+ /* Read the ``P'' register number. */
+ pnum = strtol (p, &p_temp, 16);
+ p1 = p_temp;
+ }
+ else
+ p1 = p;
- if (p1 == p) /* No register number present here. */
- {
- p1 = strchr (p, ':');
- if (p1 == NULL)
- error (_("Malformed packet(a) (missing colon): %s\n\
+ if (p1 == p) /* No register number present here. */
+ {
+ p1 = strchr (p, ':');
+ if (p1 == NULL)
+ error (_("Malformed packet(a) (missing colon): %s\n\
Packet: '%s'\n"),
- p, buf);
- if (strncmp (p, "thread", p1 - p) == 0)
- event->ptid = read_ptid (++p1, &p);
- else if ((strncmp (p, "watch", p1 - p) == 0)
- || (strncmp (p, "rwatch", p1 - p) == 0)
- || (strncmp (p, "awatch", p1 - p) == 0))
- {
- event->stopped_by_watchpoint_p = 1;
- p = unpack_varlen_hex (++p1, &addr);
- event->watch_data_address = (CORE_ADDR) addr;
- }
- else if (strncmp (p, "library", p1 - p) == 0)
- {
- p1++;
- p_temp = p1;
- while (*p_temp && *p_temp != ';')
- p_temp++;
+ p, buf);
+ if (strncmp (p, "thread", p1 - p) == 0)
+ event->ptid = read_ptid (++p1, &p);
+ else if ((strncmp (p, "watch", p1 - p) == 0)
+ || (strncmp (p, "rwatch", p1 - p) == 0)
+ || (strncmp (p, "awatch", p1 - p) == 0))
+ {
+ event->stopped_by_watchpoint_p = 1;
+ p = unpack_varlen_hex (++p1, &addr);
+ event->watch_data_address = (CORE_ADDR) addr;
+ }
+ else if (strncmp (p, "library", p1 - p) == 0)
+ {
+ p1++;
+ p_temp = p1;
+ while (*p_temp && *p_temp != ';')
+ p_temp++;
- event->solibs_changed = 1;
+ event->solibs_changed = 1;
+ p = p_temp;
+ }
+ else if (strncmp (p, "replaylog", p1 - p) == 0)
+ {
+ /* NO_HISTORY event.
+ p1 will indicate "begin" or "end", but
+ it makes no difference for now, so ignore it. */
+ event->replay_event = 1;
+ p_temp = strchr (p1 + 1, ';');
+ if (p_temp)
p = p_temp;
- }
- else if (strncmp (p, "replaylog", p1 - p) == 0)
- {
- /* NO_HISTORY event.
- p1 will indicate "begin" or "end", but
- it makes no difference for now, so ignore it. */
- event->replay_event = 1;
- p_temp = strchr (p1 + 1, ';');
- if (p_temp)
- p = p_temp;
- }
- else
- {
- /* Silently skip unknown optional info. */
- p_temp = strchr (p1 + 1, ';');
- if (p_temp)
- p = p_temp;
- }
- }
- else
- {
- struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
- cached_reg_t cached_reg;
+ }
+ else
+ {
+ /* Silently skip unknown optional info. */
+ p_temp = strchr (p1 + 1, ';');
+ if (p_temp)
+ p = p_temp;
+ }
+ }
+ else
+ {
+ struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
+ cached_reg_t cached_reg;
- p = p1;
+ p = p1;
- if (*p != ':')
- error (_("Malformed packet(b) (missing colon): %s\n\
+ if (*p != ':')
+ error (_("Malformed packet(b) (missing colon): %s\n\
Packet: '%s'\n"),
- p, buf);
- ++p;
+ p, buf);
+ ++p;
- if (reg == NULL)
- error (_("Remote sent bad register number %s: %s\n\
+ if (reg == NULL)
+ error (_("Remote sent bad register number %s: %s\n\
Packet: '%s'\n"),
- phex_nz (pnum, 0), p, buf);
+ phex_nz (pnum, 0), p, buf);
- cached_reg.num = reg->regnum;
+ cached_reg.num = reg->regnum;
- fieldsize = hex2bin (p, cached_reg.data,
- register_size (target_gdbarch,
- reg->regnum));
- p += 2 * fieldsize;
- if (fieldsize < register_size (target_gdbarch,
- reg->regnum))
- warning (_("Remote reply is too short: %s"), buf);
+ fieldsize = hex2bin (p, cached_reg.data,
+ register_size (target_gdbarch,
+ reg->regnum));
+ p += 2 * fieldsize;
+ if (fieldsize < register_size (target_gdbarch,
+ reg->regnum))
+ warning (_("Remote reply is too short: %s"), buf);
- VEC_safe_push (cached_reg_t, event->regcache, &cached_reg);
- }
+ VEC_safe_push (cached_reg_t, event->regcache, &cached_reg);
+ }
- if (*p != ';')
- error (_("Remote register badly formatted: %s\nhere: %s"),
- buf, p);
- ++p;
- }
- }
+ if (*p != ';')
+ error (_("Remote register badly formatted: %s\nhere: %s"),
+ buf, p);
+ ++p;
+ }
/* fall through */
case 'S': /* Old style status, just signal only. */
if (event->solibs_changed)
remote_get_pending_stop_replies (void)
{
struct remote_state *rs = get_remote_state ();
- int ret;
if (pending_stop_reply)
{
/* Expedited registers. */
if (stop_reply->regcache)
{
+ struct regcache *regcache
+ = get_thread_arch_regcache (ptid, target_gdbarch);
cached_reg_t *reg;
int ix;
for (ix = 0;
VEC_iterate(cached_reg_t, stop_reply->regcache, ix, reg);
ix++)
- regcache_raw_supply (get_thread_regcache (ptid),
- reg->num, reg->data);
+ regcache_raw_supply (regcache, reg->num, reg->data);
VEC_free (cached_reg_t, stop_reply->regcache);
}
/* The non-stop mode version of target_wait. */
static ptid_t
-remote_wait_ns (ptid_t ptid, struct target_waitstatus *status)
+remote_wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
{
struct remote_state *rs = get_remote_state ();
- struct remote_arch_state *rsa = get_remote_arch_state ();
- ptid_t event_ptid = null_ptid;
struct stop_reply *stop_reply;
int ret;
if (stop_reply != NULL)
return process_stop_reply (stop_reply, status);
- /* Still no event. If we're in asynchronous mode, then just
+ /* Still no event. If we're just polling for an event, then
return to the event loop. */
- if (remote_is_async_p ())
+ if (options & TARGET_WNOHANG)
{
status->kind = TARGET_WAITKIND_IGNORE;
return minus_one_ptid;
}
- /* Otherwise, asynchronous mode is masked, so do a blocking
- wait. */
+ /* Otherwise do a blocking wait. */
ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
1 /* forever */);
}
STATUS just as `wait' would. */
static ptid_t
-remote_wait_as (ptid_t ptid, struct target_waitstatus *status)
+remote_wait_as (ptid_t ptid, struct target_waitstatus *status, int options)
{
struct remote_state *rs = get_remote_state ();
- struct remote_arch_state *rsa = get_remote_arch_state ();
ptid_t event_ptid = null_ptid;
- ULONGEST addr;
- int solibs_changed = 0;
- char *buf, *p;
+ char *buf;
struct stop_reply *stop_reply;
+ again:
+
status->kind = TARGET_WAITKIND_IGNORE;
status->value.integer = 0;
}
if (status->kind == TARGET_WAITKIND_IGNORE)
- /* Nothing interesting happened. */
- return minus_one_ptid;
+ {
+ /* Nothing interesting happened. If we're doing a non-blocking
+ poll, we're done. Otherwise, go back to waiting. */
+ if (options & TARGET_WNOHANG)
+ return minus_one_ptid;
+ else
+ goto again;
+ }
else if (status->kind != TARGET_WAITKIND_EXITED
&& status->kind != TARGET_WAITKIND_SIGNALLED)
{
static ptid_t
remote_wait (struct target_ops *ops,
- ptid_t ptid, struct target_waitstatus *status)
+ ptid_t ptid, struct target_waitstatus *status, int options)
{
ptid_t event_ptid;
if (non_stop)
- event_ptid = remote_wait_ns (ptid, status);
+ event_ptid = remote_wait_ns (ptid, status, options);
else
- {
- /* In synchronous mode, keep waiting until the target stops. In
- asynchronous mode, always return to the event loop. */
-
- do
- {
- event_ptid = remote_wait_as (ptid, status);
- }
- while (status->kind == TARGET_WAITKIND_IGNORE
- && !target_can_async_p ());
- }
+ event_ptid = remote_wait_as (ptid, status, options);
if (target_can_async_p ())
{
*p++ = 'p';
p += hexnumstr (p, reg->pnum);
*p++ = '\0';
- remote_send (&rs->buf, &rs->buf_size);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
buf = rs->buf;
case PACKET_UNKNOWN:
return 0;
case PACKET_ERROR:
- error (_("Could not fetch register \"%s\""),
- gdbarch_register_name (get_regcache_arch (regcache), reg->regnum));
+ error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
+ gdbarch_register_name (get_regcache_arch (regcache),
+ reg->regnum),
+ buf);
}
/* If this register is unfetchable, tell the regcache. */
send_g_packet (void)
{
struct remote_state *rs = get_remote_state ();
- int i, buf_len;
- char *p;
- char *regs;
+ int buf_len;
sprintf (rs->buf, "g");
remote_send (&rs->buf, &rs->buf_size);
remote_fetch_registers (struct target_ops *ops,
struct regcache *regcache, int regnum)
{
- struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
int i;
packet was not recognized. */
static int
-store_register_using_P (const struct regcache *regcache, struct packet_reg *reg)
+store_register_using_P (const struct regcache *regcache,
+ struct packet_reg *reg)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct remote_state *rs = get_remote_state ();
- struct remote_arch_state *rsa = get_remote_arch_state ();
/* Try storing a single register. */
char *buf = rs->buf;
gdb_byte regp[MAX_REGISTER_SIZE];
p = buf + strlen (buf);
regcache_raw_collect (regcache, reg->regnum, regp);
bin2hex (regp, p, register_size (gdbarch, reg->regnum));
- remote_send (&rs->buf, &rs->buf_size);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
{
case PACKET_OK:
return 1;
case PACKET_ERROR:
- error (_("Could not write register \"%s\""),
- gdbarch_register_name (gdbarch, reg->regnum));
+ error (_("Could not write register \"%s\"; remote failure reply '%s'"),
+ gdbarch_register_name (gdbarch, reg->regnum), rs->buf);
case PACKET_UNKNOWN:
return 0;
default:
/* remote_prepare_to_store insures that rsa->sizeof_g_packet gets
updated. */
bin2hex (regs, p, rsa->sizeof_g_packet);
- remote_send (&rs->buf, &rs->buf_size);
+ putpkt (rs->buf);
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ if (packet_check_result (rs->buf) == PACKET_ERROR)
+ error (_("Could not write registers; remote failure reply '%s'"),
+ rs->buf);
}
/* Store register REGNUM, or all registers if REGNUM == -1, from the contents
remote_store_registers (struct target_ops *ops,
struct regcache *regcache, int regnum)
{
- struct remote_state *rs = get_remote_state ();
struct remote_arch_state *rsa = get_remote_arch_state ();
int i;
remote_flash_erase (struct target_ops *ops,
ULONGEST address, LONGEST length)
{
+ int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
int saved_remote_timeout = remote_timeout;
enum packet_result ret;
remote_timeout = remote_flash_timeout;
ret = remote_send_printf ("vFlashErase:%s,%s",
- paddr (address),
+ phex (address, addr_size),
phex (length, 4));
switch (ret)
{
struct cleanup *old_chain;
struct ui_file *stb;
char *str;
- long length;
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
fputstrn_unfiltered (buf, n, 0, stb);
- str = ui_file_xstrdup (stb, &length);
+ str = ui_file_xstrdup (stb, NULL);
do_cleanups (old_chain);
return str;
}
int c;
int tries;
int timeout;
- int val;
+ int val = -1;
/* We're reading a new response. Make sure we don't look at a
previously cached response. */
so that the user can say "kill" again. */
inferior_ptid = magic_null_ptid;
}
- else
- {
- /* Mark this (still pushed) target as not executable until we
- restart it. */
- target_mark_exited (target);
- }
}
- else
- /* Always remove execution if this was the last process. */
- target_mark_exited (target);
}
}
extended_remote_run (char *args)
{
struct remote_state *rs = get_remote_state ();
- char *p;
int len;
/* If the user has disabled vRun support, or we have detected that
which don't, we insert a traditional memory breakpoint. */
static int
-remote_insert_breakpoint (struct bp_target_info *bp_tgt)
+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
char *p;
int bpsize;
- gdbarch_breakpoint_from_pc (target_gdbarch, &addr, &bpsize);
+ gdbarch_breakpoint_from_pc (gdbarch, &addr, &bpsize);
rs = get_remote_state ();
p = rs->buf;
}
}
- return memory_insert_breakpoint (bp_tgt);
+ return memory_insert_breakpoint (gdbarch, bp_tgt);
}
static int
-remote_remove_breakpoint (struct bp_target_info *bp_tgt)
+remote_remove_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
CORE_ADDR addr = bp_tgt->placed_address;
struct remote_state *rs = get_remote_state ();
- int bp_size;
if (remote_protocol_packets[PACKET_Z0].support != PACKET_DISABLE)
{
return (rs->buf[0] == 'E');
}
- return memory_remove_breakpoint (bp_tgt);
+ return memory_remove_breakpoint (gdbarch, bp_tgt);
}
static int
static int
-remote_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
+remote_insert_hw_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
CORE_ADDR addr;
struct remote_state *rs;
instruction, even though we aren't inserting one ourselves. */
gdbarch_breakpoint_from_pc
- (target_gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
+ (gdbarch, &bp_tgt->placed_address, &bp_tgt->placed_size);
if (remote_protocol_packets[PACKET_Z1].support == PACKET_DISABLE)
return -1;
static int
-remote_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
+remote_remove_hw_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
CORE_ADDR addr;
struct remote_state *rs = get_remote_state ();
struct remote_state *rs = get_remote_state ();
asection *s;
unsigned long host_crc, target_crc;
- extern bfd *exec_bfd;
struct cleanup *old_chain;
char *tmp;
char *sectdata;
getpkt (&rs->buf, &rs->buf_size, 0);
if (rs->buf[0] == 'E')
- error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
- sectname, paddr (lma), paddr (lma + size));
+ error (_("target memory fault, section %s, range %s -- %s"), sectname,
+ paddress (target_gdbarch, lma),
+ paddress (target_gdbarch, lma + size));
if (rs->buf[0] != 'C')
error (_("remote target does not support this operation"));
for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
target_crc = target_crc * 16 + fromhex (*tmp);
- printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
- sectname, paddr (lma), paddr (lma + size));
+ printf_filtered ("Section %s, range %s -- %s: ", sectname,
+ paddress (target_gdbarch, lma),
+ paddress (target_gdbarch, lma + size));
if (host_crc == target_crc)
printf_filtered ("matched.\n");
else
{
int i, buf_len;
ULONGEST n;
- gdb_byte *wbuf;
struct remote_state *rs = get_remote_state ();
int max_size = get_memory_write_packet_size ();
static ULONGEST finished_offset;
struct remote_state *rs = get_remote_state ();
- unsigned int total = 0;
LONGEST i, n, packet_len;
if (packet->support == PACKET_DISABLE)
const gdb_byte *pattern, ULONGEST pattern_len,
CORE_ADDR *found_addrp)
{
+ int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
struct remote_state *rs = get_remote_state ();
int max_size = get_memory_write_packet_size ();
struct packet_config *packet =
/* Insert header. */
i = snprintf (rs->buf, max_size,
"qSearch:memory:%s;%s;",
- paddr_nz (start_addr),
+ phex_nz (start_addr, addr_size),
phex_nz (search_space_len, sizeof (search_space_len)));
max_size -= (i + 1);
static char buf[64];
struct remote_state *rs = get_remote_state ();
- if (ptid_equal (magic_null_ptid, ptid))
- {
- xsnprintf (buf, sizeof buf, "Thread <main>");
- return buf;
- }
- else if (remote_multi_process_p (rs)
- && ptid_get_tid (ptid) != 0 && ptid_get_pid (ptid) != 0)
+ if (ptid_is_pid (ptid))
{
- xsnprintf (buf, sizeof buf, "Thread %d.%ld",
- ptid_get_pid (ptid), ptid_get_tid (ptid));
- return buf;
+ /* Printing an inferior target id. */
+
+ /* When multi-process extensions are off, there's no way in the
+ remote protocol to know the remote process id, if there's any
+ at all. There's one exception --- when we're connected with
+ target extended-remote, and we manually attached to a process
+ with "attach PID". We don't record anywhere a flag that
+ allows us to distinguish that case from the case of
+ connecting with extended-remote and the stub already being
+ attached to a process, and reporting yes to qAttached, hence
+ no smart special casing here. */
+ if (!remote_multi_process_p (rs))
+ {
+ xsnprintf (buf, sizeof buf, "Remote target");
+ return buf;
+ }
+
+ return normal_pid_to_str (ptid);
}
- else if (ptid_get_tid (ptid) != 0)
+ else
{
- xsnprintf (buf, sizeof buf, "Thread %ld",
- ptid_get_tid (ptid));
+ if (ptid_equal (magic_null_ptid, ptid))
+ xsnprintf (buf, sizeof buf, "Thread <main>");
+ else if (remote_multi_process_p (rs))
+ xsnprintf (buf, sizeof buf, "Thread %d.%ld",
+ ptid_get_pid (ptid), ptid_get_tid (ptid));
+ else
+ xsnprintf (buf, sizeof buf, "Thread %ld",
+ ptid_get_tid (ptid));
return buf;
}
-
- return normal_pid_to_str (ptid);
}
/* Get the address of the thread local variable in OBJFILE which is
remote_file_get (const char *remote_file, const char *local_file, int from_tty)
{
struct cleanup *back_to, *close_cleanup;
- int retcode, fd, remote_errno, bytes, io_size;
+ int fd, remote_errno, bytes, io_size;
FILE *file;
gdb_byte *buffer;
ULONGEST offset;
return remote_multi_process_p (rs);
}
+int
+remote_supports_cond_tracepoints (void)
+{
+ struct remote_state *rs = get_remote_state ();
+ return rs->cond_tracepoints;
+}
+
static void
init_remote_ops (void)
{
remote_ops.to_log_command = serial_log_command;
remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
remote_ops.to_stratum = process_stratum;
- remote_ops.to_has_all_memory = 1;
- remote_ops.to_has_memory = 1;
- remote_ops.to_has_stack = 1;
- remote_ops.to_has_registers = 1;
- remote_ops.to_has_execution = 1;
+ remote_ops.to_has_all_memory = default_child_has_all_memory;
+ remote_ops.to_has_memory = default_child_has_memory;
+ remote_ops.to_has_stack = default_child_has_stack;
+ remote_ops.to_has_registers = default_child_has_registers;
+ remote_ops.to_has_execution = default_child_has_execution;
remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
remote_ops.to_can_execute_reverse = remote_can_execute_reverse;
remote_ops.to_magic = OPS_MAGIC;
add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached],
"qAttached", "query-attached", 0);
+ add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
+ "ConditionalTracepoints", "conditional-tracepoints", 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