This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Separate remote.c per-target state from per-architecture state
- From: Daniel Jacobowitz <drow at false dot org>
- To: gdb-patches at sourceware dot org
- Date: Thu, 1 Jun 2006 23:32:59 -0400
- Subject: Separate remote.c per-target state from per-architecture state
There's a single "struct remote_state" in remote.c, with an instance per
gdbarch, and comments saying that it ought to be per-target. But in fact
this isn't right, because it contains the description of the target's
register layout, which depends on the selected architecture.
I recently added a static packet buffer to this, along with that buffer's
size. This is different from the other members: it does not need to be per
architecture, in fact it's completely independent of the architecture. The
buffer (buf_size) needs to be at least as large as the currently selected
architecture's remote_packet_size, which can be accomplished by keeping a
single buffer larger than any created gdbarch's packet size.
On its own separating the per-architecture and per-target data only
accomplishes a little; it saves 0.5K or so per gdbarch created.
The qSupported packet proposal adds another benefit. Even if the
architecture changes after we've connected to the target, we should remember
if it supplied an explicit packet size. Other similar things in remote.c
use file static variables; this is a small step towards keeping the
per-target state associated with the target.
And this patch also centralizes the "how big should a remote packet be"
check into a new function, get_remote_packet_size. This is also a cleanup
on the one hand and preparation for qSupported on the other; later we will
need to check both the target state (did the target say how big?) and the
architecture (if it didn't use a guess based on the architecture, i.e.
current behavior).
This is pretty obvious, and I've had it in my tree for a few weeks.
I'll commit it in a few days unless someone sees a problem with it.
--
Daniel Jacobowitz
CodeSourcery
2006-06-01 Daniel Jacobowitz <dan@codesourcery.com>
* (struct remote_state): New type, only containing
buf and buf_size.
(remote_state): New variable.
(get_remote_state): New function.
(struct remote_arch_state): Renamed from struct remote_state.
Removed buf and buf_size.
(get_remote_arch_state): Renamed from get_remote_state. All
necessary callers updated to call this function.
(init_remote_state): Initialize the architecture-specific state.
Update the target-specific state if necessary.
(get_remote_packet_size): New function. All previous references
changed to use this accessor function.
(packet_reg_from_regnum, packet_reg_from_pnum): Take a
remote_arch_state instead of a remote_state. All callers changed.
(_initialize_remote): Initialize the packet buffer here.
Index: src/gdb/remote.c
===================================================================
--- src.orig/gdb/remote.c 2006-06-01 23:16:29.000000000 -0400
+++ src/gdb/remote.c 2006-06-01 23:25:27.000000000 -0400
@@ -188,12 +188,35 @@ static void update_packet_config (struct
void _initialize_remote (void);
-/* Description of the remote protocol. Strictly speaking, when the
- target is open()ed, remote.c should create a per-target description
- of the remote protocol using that target's architecture.
- Unfortunately, the target stack doesn't include local state. For
- the moment keep the information in the target's architecture
- object. Sigh.. */
+/* Description of the remote protocol state for the currently
+ connected target. This is per-target state, and independent of the
+ selected architecture. */
+
+struct remote_state
+{
+ /* A buffer to use for incoming packets, and its current size. The
+ buffer is grown dynamically for larger incoming packets.
+ Outgoing packets may also be constructed in this buffer.
+ BUF_SIZE is always at least REMOTE_PACKET_SIZE;
+ REMOTE_PACKET_SIZE should be used to limit the length of outgoing
+ packets. */
+ char *buf;
+ long buf_size;
+};
+
+/* This data could be associated with a target, but we do not always
+ have access to the current target when we need it, so for now it is
+ static. This will be fine for as long as only one target is in use
+ at a time. */
+static struct remote_state remote_state;
+
+static struct remote_state *
+get_remote_state (void)
+{
+ return &remote_state;
+}
+
+/* Description of the remote protocol for a given architecture. */
struct packet_reg
{
@@ -206,7 +229,7 @@ struct packet_reg
/* char *name; == REGISTER_NAME (regnum); at present. */
};
-struct remote_state
+struct remote_arch_state
{
/* Description of the remote protocol registers. */
long sizeof_g_packet;
@@ -226,23 +249,14 @@ struct remote_state
/* This is the maximum size (in chars) of a non read/write packet.
It is also used as a cap on the size of read/write packets. */
long remote_packet_size;
-
- /* A buffer to use for incoming packets, and its current size. The
- buffer is grown dynamically for larger incoming packets.
- Outgoing packets may also be constructed in this buffer.
- BUF_SIZE is always at least REMOTE_PACKET_SIZE;
- REMOTE_PACKET_SIZE should be used to limit the length of outgoing
- packets. */
- char *buf;
- long buf_size;
};
/* Handle for retreving the remote protocol data from gdbarch. */
static struct gdbarch_data *remote_gdbarch_data_handle;
-static struct remote_state *
-get_remote_state (void)
+static struct remote_arch_state *
+get_remote_arch_state (void)
{
return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
}
@@ -251,16 +265,19 @@ static void *
init_remote_state (struct gdbarch *gdbarch)
{
int regnum;
- struct remote_state *rs = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_state);
+ struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa;
- rs->sizeof_g_packet = 0;
+ rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
+
+ rsa->sizeof_g_packet = 0;
/* Assume a 1:1 regnum<->pnum table. */
- rs->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
- struct packet_reg);
+ rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch, NUM_REGS + NUM_PSEUDO_REGS,
+ struct packet_reg);
for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
{
- struct packet_reg *r = &rs->regs[regnum];
+ struct packet_reg *r = &rsa->regs[regnum];
r->pnum = regnum;
r->regnum = regnum;
r->offset = DEPRECATED_REGISTER_BYTE (regnum);
@@ -269,7 +286,7 @@ init_remote_state (struct gdbarch *gdbar
/* Compute packet size by accumulating the size of all registers. */
if (regnum < NUM_REGS)
- rs->sizeof_g_packet += register_size (current_gdbarch, regnum);
+ rsa->sizeof_g_packet += register_size (current_gdbarch, regnum);
}
/* Default maximum number of characters in a packet body. Many
@@ -278,52 +295,63 @@ init_remote_state (struct gdbarch *gdbar
as the maximum packet-size to ensure that the packet and an extra
NUL character can always fit in the buffer. This stops GDB
trashing stubs that try to squeeze an extra NUL into what is
- already a full buffer (As of 1999-12-04 that was most stubs. */
- rs->remote_packet_size = 400 - 1;
+ already a full buffer (As of 1999-12-04 that was most stubs). */
+ rsa->remote_packet_size = 400 - 1;
+
+ /* This one is filled in when a ``g'' packet is received. */
+ rsa->actual_register_packet_size = 0;
- /* Should rs->sizeof_g_packet needs more space than the
+ /* Should rsa->sizeof_g_packet needs more space than the
default, adjust the size accordingly. Remember that each byte is
encoded as two characters. 32 is the overhead for the packet
header / footer. NOTE: cagney/1999-10-26: I suspect that 8
(``$NN:G...#NN'') is a better guess, the below has been padded a
little. */
- if (rs->sizeof_g_packet > ((rs->remote_packet_size - 32) / 2))
- rs->remote_packet_size = (rs->sizeof_g_packet * 2 + 32);
+ if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
+ rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
- /* This one is filled in when a ``g'' packet is received. */
- rs->actual_register_packet_size = 0;
+ /* Make sure that the packet buffer is plenty big enough for
+ this architecture. */
+ if (rs->buf_size < rsa->remote_packet_size)
+ {
+ rs->buf_size = 2 * rsa->remote_packet_size;
+ rs->buf = xmalloc (rs->buf_size);
+ }
- /* Create the buffer at a default size. Note that this would
- leak memory if the gdbarch were ever destroyed; there's no
- way to register a destructor for it, and we can't realloc
- using the gdbarch obstack. But gdbarches are never
- destroyed. */
- rs->buf_size = rs->remote_packet_size;
- rs->buf = xmalloc (rs->buf_size);
+ return rsa;
+}
+
+/* Return the current allowed size of a remote packet. This is
+ inferred from the current architecture, and should be used to
+ limit the length of outgoing packets. */
+static long
+get_remote_packet_size (void)
+{
+ struct remote_arch_state *rsa = get_remote_arch_state ();
- return rs;
+ return rsa->remote_packet_size;
}
static struct packet_reg *
-packet_reg_from_regnum (struct remote_state *rs, long regnum)
+packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
{
if (regnum < 0 && regnum >= NUM_REGS + NUM_PSEUDO_REGS)
return NULL;
else
{
- struct packet_reg *r = &rs->regs[regnum];
+ struct packet_reg *r = &rsa->regs[regnum];
gdb_assert (r->regnum == regnum);
return r;
}
}
static struct packet_reg *
-packet_reg_from_pnum (struct remote_state *rs, LONGEST pnum)
+packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
{
int i;
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
{
- struct packet_reg *r = &rs->regs[i];
+ struct packet_reg *r = &rsa->regs[i];
if (r->pnum == pnum)
return r;
}
@@ -393,8 +421,8 @@ static int remote_async_terminal_ours_p;
/* User configurable variables for the number of characters in a
- memory read/write packet. MIN (rs->remote_packet_size,
- rs->sizeof_g_packet) is the default. Some targets need smaller
+ memory read/write packet. MIN (rsa->remote_packet_size,
+ rsa->sizeof_g_packet) is the default. Some targets need smaller
values (fifo overruns, et.al.) and some users need larger values
(speed up transfers). The variables ``preferred_*'' (the user
request), ``current_*'' (what was actually set) and ``forced_*''
@@ -414,6 +442,8 @@ static long
get_memory_packet_size (struct memory_packet_config *config)
{
struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+
/* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
law?) that some hosts don't cope very well with large alloca()
calls. Eventually the alloca() code will be replaced by calls to
@@ -436,15 +466,15 @@ get_memory_packet_size (struct memory_pa
}
else
{
- what_they_get = rs->remote_packet_size;
+ what_they_get = get_remote_packet_size ();
/* Limit the packet to the size specified by the user. */
if (config->size > 0
&& what_they_get > config->size)
what_they_get = config->size;
/* Limit it to the size of the targets ``g'' response. */
- if ((rs->actual_register_packet_size) > 0
- && what_they_get > (rs->actual_register_packet_size))
- what_they_get = (rs->actual_register_packet_size);
+ if ((rsa->actual_register_packet_size) > 0
+ && what_they_get > (rsa->actual_register_packet_size))
+ what_they_get = (rsa->actual_register_packet_size);
}
if (what_they_get > MAX_REMOTE_PACKET_SIZE)
what_they_get = MAX_REMOTE_PACKET_SIZE;
@@ -561,13 +591,12 @@ show_memory_read_packet_size (char *args
static long
get_memory_read_packet_size (void)
{
- struct remote_state *rs = get_remote_state ();
long size = get_memory_packet_size (&memory_read_packet_config);
/* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
extra buffer size argument before the memory read size can be
- increased beyond RS->remote_packet_size. */
- if (size > rs->remote_packet_size)
- size = rs->remote_packet_size;
+ increased beyond this. */
+ if (size > get_remote_packet_size ())
+ size = get_remote_packet_size ();
return size;
}
@@ -922,9 +951,9 @@ set_thread (int th, int gen)
buf[3] = '\0';
}
else if (th < 0)
- xsnprintf (&buf[2], rs->remote_packet_size - 2, "-%x", -th);
+ xsnprintf (&buf[2], get_remote_packet_size () - 2, "-%x", -th);
else
- xsnprintf (&buf[2], rs->remote_packet_size - 2, "%x", th);
+ xsnprintf (&buf[2], get_remote_packet_size () - 2, "%x", th);
putpkt (buf);
getpkt (&rs->buf, &rs->buf_size, 0);
if (gen)
@@ -943,9 +972,9 @@ remote_thread_alive (ptid_t ptid)
char *buf = rs->buf;
if (tid < 0)
- xsnprintf (buf, rs->remote_packet_size, "T-%08x", -tid);
+ xsnprintf (buf, get_remote_packet_size (), "T-%08x", -tid);
else
- xsnprintf (buf, rs->remote_packet_size, "T%08x", tid);
+ xsnprintf (buf, get_remote_packet_size (), "T%08x", tid);
putpkt (buf);
getpkt (&rs->buf, &rs->buf_size, 0);
return (buf[0] == 'O' && buf[1] == 'K');
@@ -1512,8 +1541,8 @@ remote_get_threadlist (int startflag, th
int result = 1;
/* Trancate result limit to be smaller than the packet size. */
- if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= rs->remote_packet_size)
- result_limit = (rs->remote_packet_size / BUF_THREAD_ID_SIZE) - 2;
+ if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= get_remote_packet_size ())
+ result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
putpkt (rs->buf);
@@ -1734,7 +1763,7 @@ remote_threads_extra_info (struct thread
{
char *bufp = rs->buf;
- xsnprintf (bufp, rs->remote_packet_size, "qThreadExtraInfo,%x",
+ xsnprintf (bufp, get_remote_packet_size (), "qThreadExtraInfo,%x",
PIDGET (tp->ptid));
putpkt (bufp);
getpkt (&rs->buf, &rs->buf_size, 0);
@@ -1786,7 +1815,7 @@ extended_remote_restart (void)
/* Send the restart command; for reasons I don't understand the
remote side really expects a number after the "R". */
- xsnprintf (rs->buf, rs->remote_packet_size, "R%x", 0);
+ xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
putpkt (rs->buf);
/* Now query for status so this looks just like we restarted
@@ -1979,7 +2008,7 @@ remote_check_symbols (struct objfile *ob
/* Allocate a message buffer. We can't reuse the input buffer in RS,
because we need both at the same time. */
- msg = alloca (rs->remote_packet_size);
+ msg = alloca (get_remote_packet_size ());
reply = rs->buf;
@@ -1996,9 +2025,9 @@ remote_check_symbols (struct objfile *ob
msg[end] = '\0';
sym = lookup_minimal_symbol (msg, NULL, NULL);
if (sym == NULL)
- xsnprintf (msg, rs->remote_packet_size, "qSymbol::%s", &reply[8]);
+ xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
else
- xsnprintf (msg, rs->remote_packet_size, "qSymbol:%s:%s",
+ xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
paddr_nz (SYMBOL_VALUE_ADDRESS (sym)),
&reply[8]);
putpkt (msg);
@@ -2378,7 +2407,7 @@ remote_vcont_resume (ptid_t ptid, int st
outbuf = xstrprintf ("vCont;c:%x", pid);
}
- gdb_assert (outbuf && strlen (outbuf) < rs->remote_packet_size);
+ gdb_assert (outbuf && strlen (outbuf) < get_remote_packet_size ());
old_cleanup = make_cleanup (xfree, outbuf);
putpkt (outbuf);
@@ -2668,6 +2697,7 @@ static ptid_t
remote_wait (ptid_t ptid, struct target_waitstatus *status)
{
struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
char *buf = rs->buf;
ULONGEST thread_num = -1;
ULONGEST addr;
@@ -2764,7 +2794,7 @@ Packet: '%s'\n"),
}
else
{
- struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
+ struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
p = p1;
if (*p++ != ':')
@@ -2857,6 +2887,7 @@ static ptid_t
remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
{
struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
char *buf = rs->buf;
ULONGEST thread_num = -1;
ULONGEST addr;
@@ -2960,7 +2991,7 @@ Packet: '%s'\n"),
else
{
- struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
+ struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
p = p1;
if (*p++ != ':')
error (_("Malformed packet(b) (missing colon): %s\n\
@@ -3105,16 +3136,17 @@ static void
remote_fetch_registers (int regnum)
{
struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
char *buf = rs->buf;
int i;
char *p;
- char *regs = alloca (rs->sizeof_g_packet);
+ char *regs = alloca (rsa->sizeof_g_packet);
set_thread (PIDGET (inferior_ptid), 1);
if (regnum >= 0)
{
- struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
+ struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
gdb_assert (reg != NULL);
if (!reg->in_g_packet)
internal_error (__FILE__, __LINE__,
@@ -3153,11 +3185,11 @@ remote_fetch_registers (int regnum)
/* Save the size of the packet sent to us by the target. Its used
as a heuristic when determining the max size of packets that the
target can safely receive. */
- if ((rs->actual_register_packet_size) == 0)
- (rs->actual_register_packet_size) = strlen (buf);
+ if ((rsa->actual_register_packet_size) == 0)
+ (rsa->actual_register_packet_size) = strlen (buf);
/* Unimplemented registers read as all bits zero. */
- memset (regs, 0, rs->sizeof_g_packet);
+ memset (regs, 0, rsa->sizeof_g_packet);
/* We can get out of synch in various cases. If the first character
in the buffer is not a hex character, assume that has happened
@@ -3178,7 +3210,7 @@ remote_fetch_registers (int regnum)
register cacheing/storage mechanism. */
p = buf;
- for (i = 0; i < rs->sizeof_g_packet; i++)
+ for (i = 0; i < rsa->sizeof_g_packet; i++)
{
if (p[0] == 0)
break;
@@ -3209,7 +3241,7 @@ remote_fetch_registers (int regnum)
int i;
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
{
- struct packet_reg *r = &rs->regs[i];
+ struct packet_reg *r = &rsa->regs[i];
if (r->in_g_packet)
{
if (r->offset * 2 >= strlen (buf))
@@ -3241,7 +3273,7 @@ remote_fetch_registers (int regnum)
static void
remote_prepare_to_store (void)
{
- struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
int i;
gdb_byte buf[MAX_REGISTER_SIZE];
@@ -3252,8 +3284,8 @@ remote_prepare_to_store (void)
case PACKET_SUPPORT_UNKNOWN:
/* Make sure all the necessary registers are cached. */
for (i = 0; i < NUM_REGS; i++)
- if (rs->regs[i].in_g_packet)
- regcache_raw_read (current_regcache, rs->regs[i].regnum, buf);
+ if (rsa->regs[i].in_g_packet)
+ regcache_raw_read (current_regcache, rsa->regs[i].regnum, buf);
break;
case PACKET_ENABLE:
break;
@@ -3267,13 +3299,14 @@ static int
store_register_using_P (int regnum)
{
struct remote_state *rs = get_remote_state ();
- struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
+ struct remote_arch_state *rsa = get_remote_arch_state ();
+ struct packet_reg *reg = packet_reg_from_regnum (rsa, regnum);
/* Try storing a single register. */
char *buf = rs->buf;
gdb_byte regp[MAX_REGISTER_SIZE];
char *p;
- xsnprintf (buf, rs->remote_packet_size, "P%s=", phex_nz (reg->pnum, 0));
+ xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
p = buf + strlen (buf);
regcache_raw_collect (current_regcache, reg->regnum, regp);
bin2hex (regp, p, register_size (current_gdbarch, reg->regnum));
@@ -3290,6 +3323,7 @@ static void
remote_store_registers (int regnum)
{
struct remote_state *rs = get_remote_state ();
+ struct remote_arch_state *rsa = get_remote_arch_state ();
gdb_byte *regs;
char *p;
@@ -3328,11 +3362,11 @@ remote_store_registers (int regnum)
local buffer. */
{
int i;
- regs = alloca (rs->sizeof_g_packet);
- memset (regs, 0, rs->sizeof_g_packet);
+ regs = alloca (rsa->sizeof_g_packet);
+ memset (regs, 0, rsa->sizeof_g_packet);
for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
{
- struct packet_reg *r = &rs->regs[i];
+ struct packet_reg *r = &rsa->regs[i];
if (r->in_g_packet)
regcache_raw_collect (current_regcache, r->regnum, regs + r->offset);
}
@@ -3798,14 +3832,13 @@ putpkt (char *buf)
/* Send a packet to the remote machine, with error checking. The data
of the packet is in BUF. The string in BUF can be at most
- RS->remote_packet_size - 5 to account for the $, # and checksum,
+ get_remote_packet_size () - 5 to account for the $, # and checksum,
and for a possible /0 if we are debugging (remote_debug) and want
to print the sent packet as a string. */
static int
putpkt_binary (char *buf, int cnt)
{
- struct remote_state *rs = get_remote_state ();
int i;
unsigned char csum = 0;
char *buf2 = alloca (cnt + 6);
@@ -4761,7 +4794,7 @@ compare_sections_command (char *args, in
matched = 1; /* do this section */
lma = s->lma;
/* FIXME: assumes lma can fit into long. */
- xsnprintf (rs->buf, rs->remote_packet_size, "qCRC:%lx,%lx",
+ xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
(long) lma, (long) size);
putpkt (rs->buf);
@@ -4857,8 +4890,8 @@ remote_xfer_partial (struct target_ops *
unsigned int total = 0;
while (len > 0)
{
- LONGEST n = min ((rs->remote_packet_size - 2) / 2, len);
- snprintf (rs->buf, rs->remote_packet_size,
+ LONGEST n = min ((get_remote_packet_size () - 2) / 2, len);
+ snprintf (rs->buf, get_remote_packet_size (),
"qPart:auxv:read::%s,%s",
phex_nz (offset, sizeof offset),
phex_nz (n, sizeof n));
@@ -4893,12 +4926,12 @@ remote_xfer_partial (struct target_ops *
/* Note: a zero OFFSET and LEN can be used to query the minimum
buffer size. */
if (offset == 0 && len == 0)
- return (rs->remote_packet_size);
- /* Minimum outbuf size is RS->remote_packet_size. If LEN is not
+ return (get_remote_packet_size ());
+ /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
large enough let the caller deal with it. */
- if (len < rs->remote_packet_size)
+ if (len < get_remote_packet_size ())
return -1;
- len = rs->remote_packet_size;
+ len = get_remote_packet_size ();
/* Except for querying the minimum buffer size, target must be open. */
if (!remote_desc)
@@ -4917,7 +4950,7 @@ remote_xfer_partial (struct target_ops *
(remote_debug), we have PBUFZIZ - 7 left to pack the query
string. */
i = 0;
- while (annex[i] && (i < (rs->remote_packet_size - 8)))
+ while (annex[i] && (i < (get_remote_packet_size () - 8)))
{
/* Bad caller may have sent forbidden characters. */
gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
@@ -4956,7 +4989,7 @@ remote_rcmd (char *command,
strcpy (buf, "qRcmd,");
p = strchr (buf, '\0');
- if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > rs->remote_packet_size)
+ if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ())
error (_("\"monitor\" command ``%s'' is too long."), command);
/* Encode the actual command. */
@@ -5474,6 +5507,8 @@ remote_new_objfile (struct objfile *objf
void
_initialize_remote (void)
{
+ struct remote_state *rs;
+
/* architecture specific data */
remote_gdbarch_data_handle =
gdbarch_data_register_post_init (init_remote_state);
@@ -5483,6 +5518,14 @@ _initialize_remote (void)
DEPRECATED_REGISTER_GDBARCH_SWAP (remote_address_size);
deprecated_register_gdbarch_swap (NULL, 0, build_remote_gdbarch_data);
+ /* Initialize the per-target state. At the moment there is only one
+ of these, not one per target. Only one target is active at a
+ time. The default buffer size is unimportant; it will be expanded
+ whenever a larger buffer is needed. */
+ rs = get_remote_state ();
+ rs->buf_size = 400;
+ rs->buf = xmalloc (rs->buf_size);
+
init_remote_ops ();
add_target (&remote_ops);