FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* (struct remote_state): New type, only containing

Browse source 
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.
This commit is contained in:
Daniel Jacobowitz 2006-06-08 18:32:12 +00:00
parent a4d8b6901f
commit ea9c271d4e
2 changed files with 155 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
gdb/ChangeLog
View file

@ -1,6 +1,24 @@
2006-06-08 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.
2006-06-06 Nathan Sidwell <nathan@codesourcery.com>
* gdb/remote.c (remote_insert_watchpoint): Return -1, rather than
* remote.c (remote_insert_watchpoint): Return -1, rather than
fatal error if packet is disabled.
(remote_remove_watchpoint, remote_insert_hw_breakpoint,
remote_remove_hw_breakpoint): Likewise.

229
gdb/remote.c
View file

@ -188,12 +188,35 @@ static void update_packet_config (struct packet_config *config);
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 *gdbarch)
/* 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 *gdbarch)
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;
/* Should rs->sizeof_g_packet needs more space than the
/* This one is filled in when a ``g'' packet is received. */
rsa->actual_register_packet_size = 0;
/* Should rsa->sizeof_g_packet needs more space than the
default, adjust the size accordingly. Remember that each byte is
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 rs;
/* 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 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_packet_config *config)
}
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, int from_tty)
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, threadref *nextthread, int result_limit,
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_info *tp)
{
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 *objfile)
/* 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 *objfile)
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 step, enum target_signal siggnal)
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);
@ -4753,7 +4786,7 @@ compare_sections_command (char *args, int from_tty)
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);
@ -4849,8 +4882,8 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
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));
@ -4885,12 +4918,12 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
/* 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)
@ -4909,7 +4942,7 @@ remote_xfer_partial (struct target_ops *ops, enum target_object object,
(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] != '#');
@ -4948,7 +4981,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. */
@ -5466,6 +5499,8 @@ remote_new_objfile (struct objfile *objfile)
void
_initialize_remote (void)
{
struct remote_state *rs;
/* architecture specific data */
remote_gdbarch_data_handle =
gdbarch_data_register_post_init (init_remote_state);
@ -5475,6 +5510,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);