diff options
| author | Tom Tromey <tom@tromey.com> | 2019-01-06 11:15:05 -0700 |
|---|---|---|
| committer | Tom Tromey <tom@tromey.com> | 2019-01-15 15:35:56 -0700 |
| commit | 8d64371b6b710831ddfd6a8636097396040476ee (patch) | |
| tree | 9490af708be90394f58de0bef90d1cb9732b9098 /gdb | |
| parent | bb27775165d9b992120371383012404e213b1981 (diff) | |
| download | fsf-binutils-gdb-8d64371b6b710831ddfd6a8636097396040476ee.zip fsf-binutils-gdb-8d64371b6b710831ddfd6a8636097396040476ee.tar.gz fsf-binutils-gdb-8d64371b6b710831ddfd6a8636097396040476ee.tar.bz2 | |
Remove cleanup from remote.c
This removes the remaining cleanup from remote.c, by changing
remote_state::buf to be a gdb::char_vector, and then fixing up all the
fallout. The resulting patch is somewhat ugly, but on the other hand,
it eliminates some possibilities for mistakes.
Regression tested using the
Fedora-x86_64-native-extended-gdbserver-m64 builder on the buildbot.
gdb/ChangeLog
2019-01-15 Tom Tromey <tom@tromey.com>
* remote.c (class remote_state) <buf>: Now a char_vector.
<buf_size>: Remove.
(remote_target::getpkt): Change type of buf. Remove sizeof_buf
parameter.
(remote_target::getpkt_or_notif_sane_1)
(remote_target::getpkt_sane)
(remote_target::getpkt_or_notif_sane): Likewise.
(class remote_target) <putpkt>: New overload.
(remote_target::read_frame): Change type of "buf_p". Remove
sizeof_p parameter.
(packet_ok): New overload.
(packet_check_result): New overload.
Update all uses.
Diffstat (limited to 'gdb')
| -rw-r--r-- | gdb/ChangeLog | 16 | ||||
| -rw-r--r-- | gdb/remote.c | 842 |
2 files changed, 440 insertions, 418 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 6ceb3f7..6b51d44 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,19 @@ +2019-01-15 Tom Tromey <tom@tromey.com> + + * remote.c (class remote_state) <buf>: Now a char_vector. + <buf_size>: Remove. + (remote_target::getpkt): Change type of buf. Remove sizeof_buf + parameter. + (remote_target::getpkt_or_notif_sane_1) + (remote_target::getpkt_sane) + (remote_target::getpkt_or_notif_sane): Likewise. + (class remote_target) <putpkt>: New overload. + (remote_target::read_frame): Change type of "buf_p". Remove + sizeof_p parameter. + (packet_ok): New overload. + (packet_check_result): New overload. + Update all uses. + 2019-01-14 Tom Tromey <tom@tromey.com> * remote-notif.c (handle_notification, remote_notif_ack) diff --git a/gdb/remote.c b/gdb/remote.c index 949c69c..4e2c85a 100644 --- a/gdb/remote.c +++ b/gdb/remote.c @@ -246,11 +246,10 @@ public: /* data */ /* 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; + The size of the buffer 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; + gdb::char_vector buf; /* True if we're going through initial connection setup (finding out about the remote side's threads, relocating symbols, etc.). */ @@ -893,13 +892,18 @@ public: /* Remote specific methods. */ int putpkt (const char *buf); int putpkt_binary (const char *buf, int cnt); + int putpkt (const gdb::char_vector &buf) + { + return putpkt (buf.data ()); + } + void skip_frame (); - long read_frame (char **buf_p, long *sizeof_buf); - void getpkt (char **buf, long *sizeof_buf, int forever); - int getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever, + long read_frame (gdb::char_vector *buf_p); + void getpkt (gdb::char_vector *buf, int forever); + int getpkt_or_notif_sane_1 (gdb::char_vector *buf, int forever, int expecting_notif, int *is_notif); - int getpkt_sane (char **buf, long *sizeof_buf, int forever); - int getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever, + int getpkt_sane (gdb::char_vector *buf, int forever); + int getpkt_or_notif_sane (gdb::char_vector *buf, int forever, int *is_notif); int remote_vkill (int pid); void remote_kill_k (); @@ -1086,18 +1090,14 @@ struct remote_thread_info : public private_thread_info }; remote_state::remote_state () + : buf (400) { - /* The default buffer size is unimportant; it will be expanded - whenever a larger buffer is needed. */ - this->buf_size = 400; - this->buf = (char *) xmalloc (this->buf_size); } remote_state::~remote_state () { xfree (this->last_pass_packet); xfree (this->last_program_signals_packet); - xfree (this->buf); xfree (this->finished_object); xfree (this->finished_annex); } @@ -1133,8 +1133,8 @@ remote_target::remote_get_noisy_reply () char *buf; QUIT; /* Allow user to bail out with ^C. */ - getpkt (&rs->buf, &rs->buf_size, 0); - buf = rs->buf; + getpkt (&rs->buf, 0); + buf = rs->buf.data (); if (buf[0] == 'E') trace_error (buf); else if (startswith (buf, "qRelocInsn:")) @@ -1187,7 +1187,7 @@ remote_target::remote_get_noisy_reply () { adjusted_size = to - org_to; - xsnprintf (buf, rs->buf_size, "qRelocInsn:%x", adjusted_size); + xsnprintf (buf, rs->buf.size (), "qRelocInsn:%x", adjusted_size); putpkt (buf); } } @@ -1214,11 +1214,8 @@ remote_state::get_remote_arch_state (struct gdbarch *gdbarch) /* Make sure that the packet buffer is plenty big enough for this architecture. */ - if (this->buf_size < rsa->remote_packet_size) - { - this->buf_size = 2 * rsa->remote_packet_size; - this->buf = (char *) xrealloc (this->buf, this->buf_size); - } + if (this->buf.size () < rsa->remote_packet_size) + this->buf.resize (2 * rsa->remote_packet_size); } else rsa = &it->second; @@ -1623,11 +1620,8 @@ remote_target::get_memory_packet_size (struct memory_packet_config *config) /* Make sure there is room in the global buffer for this packet (including its trailing NUL byte). */ - if (rs->buf_size < what_they_get + 1) - { - rs->buf_size = 2 * what_they_get; - rs->buf = (char *) xrealloc (rs->buf, 2 * what_they_get); - } + if (rs->buf.size () < what_they_get + 1) + rs->buf.resize (2 * what_they_get); return what_they_get; } @@ -1908,6 +1902,12 @@ packet_check_result (const char *buf) } static enum packet_result +packet_check_result (const gdb::char_vector &buf) +{ + return packet_check_result (buf.data ()); +} + +static enum packet_result packet_ok (const char *buf, struct packet_config *config) { enum packet_result result; @@ -1960,6 +1960,12 @@ packet_ok (const char *buf, struct packet_config *config) return result; } +static enum packet_result +packet_ok (const gdb::char_vector &buf, struct packet_config *config) +{ + return packet_ok (buf.data (), config); +} + enum { PACKET_vCont = 0, PACKET_X, @@ -2319,22 +2325,22 @@ remote_target::remote_query_attached (int pid) return 0; if (remote_multi_process_p (rs)) - xsnprintf (rs->buf, size, "qAttached:%x", pid); + xsnprintf (rs->buf.data (), size, "qAttached:%x", pid); else - xsnprintf (rs->buf, size, "qAttached"); + xsnprintf (rs->buf.data (), size, "qAttached"); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qAttached])) { case PACKET_OK: - if (strcmp (rs->buf, "1") == 0) + if (strcmp (rs->buf.data (), "1") == 0) return 1; break; case PACKET_ERROR: - warning (_("Remote failure reply: %s"), rs->buf); + warning (_("Remote failure reply: %s"), rs->buf.data ()); break; case PACKET_UNKNOWN: break; @@ -2590,7 +2596,7 @@ remote_target::pass_signals (int numsigs, const unsigned char *pass_signals) if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet)) { putpkt (pass_packet); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]); if (rs->last_pass_packet) xfree (rs->last_pass_packet); @@ -2669,7 +2675,7 @@ remote_target::set_syscall_catchpoint (int pid, bool needed, int any_count, struct remote_state *rs = get_remote_state (); putpkt (catch_packet); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]); if (result == PACKET_OK) return 0; @@ -2717,7 +2723,7 @@ remote_target::program_signals (int numsigs, const unsigned char *signals) || strcmp (rs->last_program_signals_packet, packet) != 0) { putpkt (packet); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]); xfree (rs->last_program_signals_packet); rs->last_program_signals_packet = packet; @@ -2736,8 +2742,8 @@ remote_target::set_thread (ptid_t ptid, int gen) { struct remote_state *rs = get_remote_state (); ptid_t state = gen ? rs->general_thread : rs->continue_thread; - char *buf = rs->buf; - char *endbuf = rs->buf + get_remote_packet_size (); + char *buf = rs->buf.data (); + char *endbuf = buf + get_remote_packet_size (); if (state == ptid) return; @@ -2753,7 +2759,7 @@ remote_target::set_thread (ptid_t ptid, int gen) else write_ptid (buf, endbuf, ptid); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (gen) rs->general_thread = ptid; else @@ -2830,14 +2836,14 @@ remote_target::thread_alive (ptid_t ptid) if (remote_thread_always_alive (ptid)) return 1; - p = rs->buf; - endp = rs->buf + get_remote_packet_size (); + p = rs->buf.data (); + endp = p + get_remote_packet_size (); *p++ = 'T'; write_ptid (p, endp, ptid); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); return (rs->buf[0] == 'O' && rs->buf[1] == 'K'); } @@ -3242,7 +3248,7 @@ remote_target::remote_unpack_thread_info_response (char *pkt, int mask, length; int tag; threadref ref; - char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */ + char *limit = pkt + rs->buf.size (); /* Plausible parsing limit. */ int retval = 1; /* info->threadid = 0; FIXME: implement zero_threadref. */ @@ -3335,14 +3341,14 @@ remote_target::remote_get_threadinfo (threadref *threadid, struct remote_state *rs = get_remote_state (); int result; - pack_threadinfo_request (rs->buf, fieldset, threadid); + pack_threadinfo_request (rs->buf.data (), fieldset, threadid); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (rs->buf[0] == '\0') return 0; - result = remote_unpack_thread_info_response (rs->buf + 2, + result = remote_unpack_thread_info_response (&rs->buf[2], threadid, info); return result; } @@ -3376,7 +3382,7 @@ remote_target::parse_threadlist_response (char *pkt, int result_limit, resultcount = 0; /* Assume the 'q' and 'M chars have been stripped. */ - limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE); + limit = pkt + (rs->buf.size () - BUF_THREAD_ID_SIZE); /* done parse past here */ pkt = unpack_byte (pkt, &count); /* count field */ pkt = unpack_nibble (pkt, &done); @@ -3409,17 +3415,18 @@ remote_target::remote_get_threadlist (int startflag, threadref *nextthread, >= get_remote_packet_size ()) result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2; - pack_threadlist_request (rs->buf, startflag, result_limit, nextthread); + pack_threadlist_request (rs->buf.data (), startflag, result_limit, + nextthread); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); - if (*rs->buf == '\0') + getpkt (&rs->buf, 0); + if (rs->buf[0] == '\0') { /* Packet not supported. */ return -1; } *result_count = - parse_threadlist_response (rs->buf + 2, result_limit, + parse_threadlist_response (&rs->buf[2], result_limit, &rs->echo_nextthread, threadlist, done); if (!threadmatch (&rs->echo_nextthread, nextthread)) @@ -3598,7 +3605,7 @@ remote_target::remote_current_thread (ptid_t oldpid) struct remote_state *rs = get_remote_state (); putpkt ("qC"); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (rs->buf[0] == 'Q' && rs->buf[1] == 'C') { const char *obuf; @@ -3733,8 +3740,8 @@ remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *con const char *bufp; putpkt ("qfThreadInfo"); - getpkt (&rs->buf, &rs->buf_size, 0); - bufp = rs->buf; + getpkt (&rs->buf, 0); + bufp = rs->buf.data (); if (bufp[0] != '\0') /* q packet recognized */ { while (*bufp++ == 'm') /* reply contains one or more TID */ @@ -3746,8 +3753,8 @@ remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *con } while (*bufp++ == ','); /* comma-separated list */ putpkt ("qsThreadInfo"); - getpkt (&rs->buf, &rs->buf_size, 0); - bufp = rs->buf; + getpkt (&rs->buf, 0); + bufp = rs->buf.data (); } return 1; } @@ -3883,19 +3890,19 @@ remote_target::extra_thread_info (thread_info *tp) if (rs->use_threadextra_query) { - char *b = rs->buf; - char *endb = rs->buf + get_remote_packet_size (); + char *b = rs->buf.data (); + char *endb = b + get_remote_packet_size (); xsnprintf (b, endb - b, "qThreadExtraInfo,"); b += strlen (b); write_ptid (b, endb, tp->ptid); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (rs->buf[0] != 0) { - extra.resize (strlen (rs->buf) / 2); - hex2bin (rs->buf, (gdb_byte *) &extra[0], extra.size ()); + extra.resize (strlen (rs->buf.data ()) / 2); + hex2bin (rs->buf.data (), (gdb_byte *) &extra[0], extra.size ()); return extra.c_str (); } } @@ -3933,14 +3940,14 @@ remote_target::static_tracepoint_marker_at (CORE_ADDR addr, struct static_tracepoint_marker *marker) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; + char *p = rs->buf.data (); xsnprintf (p, get_remote_packet_size (), "qTSTMat:"); p += strlen (p); p += hexnumstr (p, addr); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); - p = rs->buf; + getpkt (&rs->buf, 0); + p = rs->buf.data (); if (*p == 'E') error (_("Remote failure reply: %s"), p); @@ -3965,8 +3972,8 @@ remote_target::static_tracepoint_markers_by_strid (const char *strid) /* Ask for a first packet of static tracepoint marker definition. */ putpkt ("qTfSTM"); - getpkt (&rs->buf, &rs->buf_size, 0); - p = rs->buf; + getpkt (&rs->buf, 0); + p = rs->buf.data (); if (*p == 'E') error (_("Remote failure reply: %s"), p); @@ -3982,8 +3989,8 @@ remote_target::static_tracepoint_markers_by_strid (const char *strid) while (*p++ == ','); /* comma-separated list */ /* Ask for another packet of static tracepoint definition. */ putpkt ("qTsSTM"); - getpkt (&rs->buf, &rs->buf_size, 0); - p = rs->buf; + getpkt (&rs->buf, 0); + p = rs->buf.data (); } return markers; @@ -4008,7 +4015,7 @@ remote_target::extended_remote_restart () /* Send the restart command; for reasons I don't understand the remote side really expects a number after the "R". */ - xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0); + xsnprintf (rs->buf.data (), get_remote_packet_size (), "R%x", 0); putpkt (rs->buf); remote_fileio_reset (); @@ -4072,8 +4079,8 @@ remote_target::get_offsets () return; putpkt ("qOffsets"); - getpkt (&rs->buf, &rs->buf_size, 0); - buf = rs->buf; + getpkt (&rs->buf, 0); + buf = rs->buf.data (); if (buf[0] == '\000') return; /* Return silently. Stub doesn't support @@ -4563,12 +4570,12 @@ remote_target::start_remote (int from_tty, int extended_p) const char v_mustreplyempty[] = "vMustReplyEmpty"; putpkt (v_mustreplyempty); - getpkt (&rs->buf, &rs->buf_size, 0); - if (strcmp (rs->buf, "OK") == 0) + getpkt (&rs->buf, 0); + if (strcmp (rs->buf.data (), "OK") == 0) remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE; - else if (strcmp (rs->buf, "") != 0) + else if (strcmp (rs->buf.data (), "") != 0) error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty, - rs->buf); + rs->buf.data ()); } /* Next, we possibly activate noack mode. @@ -4588,7 +4595,7 @@ remote_target::start_remote (int from_tty, int extended_p) if (packet_config_support (noack_config) != PACKET_DISABLE) { putpkt ("QStartNoAckMode"); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (packet_ok (rs->buf, noack_config) == PACKET_OK) rs->noack_mode = 1; } @@ -4597,7 +4604,7 @@ remote_target::start_remote (int from_tty, int extended_p) { /* Tell the remote that we are using the extended protocol. */ putpkt ("!"); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); } /* Let the target know which signals it is allowed to pass down to @@ -4624,10 +4631,11 @@ remote_target::start_remote (int from_tty, int extended_p) "does not support non-stop")); putpkt ("QNonStop:1"); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); - if (strcmp (rs->buf, "OK") != 0) - error (_("Remote refused setting non-stop mode with: %s"), rs->buf); + if (strcmp (rs->buf.data (), "OK") != 0) + error (_("Remote refused setting non-stop mode with: %s"), + rs->buf.data ()); /* Find about threads and processes the stub is already controlling. We default to adding them in the running state. @@ -4640,10 +4648,11 @@ remote_target::start_remote (int from_tty, int extended_p) /* Don't assume that the stub can operate in all-stop mode. Request it explicitly. */ putpkt ("QNonStop:0"); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); - if (strcmp (rs->buf, "OK") != 0) - error (_("Remote refused setting all-stop mode with: %s"), rs->buf); + if (strcmp (rs->buf.data (), "OK") != 0) + error (_("Remote refused setting all-stop mode with: %s"), + rs->buf.data ()); } /* Upload TSVs regardless of whether the target is running or not. The @@ -4659,7 +4668,7 @@ remote_target::start_remote (int from_tty, int extended_p) /* Check whether the target is running now. */ putpkt ("?"); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (!target_is_non_stop_p ()) { @@ -4676,8 +4685,8 @@ remote_target::start_remote (int from_tty, int extended_p) else { /* Save the reply for later. */ - wait_status = (char *) alloca (strlen (rs->buf) + 1); - strcpy (wait_status, rs->buf); + wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1); + strcpy (wait_status, rs->buf.data ()); } /* Fetch thread list. */ @@ -4742,7 +4751,7 @@ remote_target::start_remote (int from_tty, int extended_p) /* Use the previously fetched status. */ gdb_assert (wait_status != NULL); - strcpy (rs->buf, wait_status); + strcpy (rs->buf.data (), wait_status); rs->cached_wait_status = 1; ::start_remote (from_tty); /* Initialize gdb process mechanisms. */ @@ -4761,14 +4770,14 @@ remote_target::start_remote (int from_tty, int extended_p) reply. In the latter case, there may be more than one thread stopped --- we pull them all out using the vStopped mechanism. */ - if (strcmp (rs->buf, "OK") != 0) + if (strcmp (rs->buf.data (), "OK") != 0) { struct notif_client *notif = ¬if_client_stop; /* remote_notif_get_pending_replies acks this one, and gets the rest out. */ rs->notif_state->pending_event[notif_client_stop.id] - = remote_notif_parse (this, notif, rs->buf); + = remote_notif_parse (this, notif, rs->buf.data ()); remote_notif_get_pending_events (notif); } @@ -4883,10 +4892,8 @@ init_all_packet_configs (void) void remote_target::remote_check_symbols () { - char *reply, *tmp; + char *tmp; int end; - long reply_size; - struct cleanup *old_chain; /* The remote side has no concept of inferiors that aren't running yet, it only knows about running processes. If we're connected @@ -4906,17 +4913,15 @@ remote_target::remote_check_symbols () /* Allocate a message buffer. We can't reuse the input buffer in RS, because we need both at the same time. */ gdb::char_vector msg (get_remote_packet_size ()); - reply = (char *) xmalloc (get_remote_packet_size ()); - old_chain = make_cleanup (free_current_contents, &reply); - reply_size = get_remote_packet_size (); + gdb::char_vector reply (get_remote_packet_size ()); /* Invite target to request symbol lookups. */ putpkt ("qSymbol::"); - getpkt (&reply, &reply_size, 0); + getpkt (&reply, 0); packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]); - while (startswith (reply, "qSymbol:")) + while (startswith (reply.data (), "qSymbol:")) { struct bound_minimal_symbol sym; @@ -4944,10 +4949,8 @@ remote_target::remote_check_symbols () } putpkt (msg.data ()); - getpkt (&reply, &reply_size, 0); + getpkt (&reply, 0); } - - do_cleanups (old_chain); } static struct serial * @@ -4984,7 +4987,7 @@ remote_target::set_permissions () { struct remote_state *rs = get_remote_state (); - xsnprintf (rs->buf, get_remote_packet_size (), "QAllow:" + xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAllow:" "WriteReg:%x;WriteMem:%x;" "InsertBreak:%x;InsertTrace:%x;" "InsertFastTrace:%x;Stop:%x", @@ -4992,12 +4995,13 @@ remote_target::set_permissions () may_insert_breakpoints, may_insert_tracepoints, may_insert_fast_tracepoints, may_stop); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 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); + if (strcmp (rs->buf.data (), "OK") != 0) + warning (_("Remote refused setting permissions with: %s"), + rs->buf.data ()); } /* This type describes each known response to the qSupported @@ -5291,21 +5295,21 @@ remote_target::remote_query_supported () q = "qSupported:" + q; putpkt (q.c_str ()); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); /* If an error occured, warn, but do not return - just reset the buffer to empty and go on to disable features. */ if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported]) == PACKET_ERROR) { - warning (_("Remote failure reply: %s"), rs->buf); + warning (_("Remote failure reply: %s"), rs->buf.data ()); rs->buf[0] = 0; } } memset (seen, 0, sizeof (seen)); - next = rs->buf; + next = rs->buf.data (); while (*next) { enum packet_support is_supported; @@ -5382,11 +5386,8 @@ remote_target::remote_query_supported () buffer size also. We delay this until after parsing the entire qSupported packet, because this is the same buffer we were parsing. */ - if (rs->buf_size < rs->explicit_packet_size) - { - rs->buf_size = rs->explicit_packet_size; - rs->buf = (char *) xrealloc (rs->buf, rs->buf_size); - } + if (rs->buf.size () < rs->explicit_packet_size) + rs->buf.resize (rs->explicit_packet_size); /* Handle the defaults for unmentioned features. */ for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++) @@ -5649,12 +5650,12 @@ remote_target::remote_detach_pid (int pid) set_general_process (); if (remote_multi_process_p (rs)) - xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid); + xsnprintf (rs->buf.data (), get_remote_packet_size (), "D;%x", pid); else - strcpy (rs->buf, "D"); + strcpy (rs->buf.data (), "D"); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (rs->buf[0] == 'O' && rs->buf[1] == 'K') ; @@ -5832,9 +5833,9 @@ extended_remote_target::attach (const char *args, int from_tty) gdb_flush (gdb_stdout); } - xsnprintf (rs->buf, get_remote_packet_size (), "vAttach;%x", pid); + xsnprintf (rs->buf.data (), get_remote_packet_size (), "vAttach;%x", pid); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vAttach])) @@ -5843,13 +5844,13 @@ extended_remote_target::attach (const char *args, int from_tty) if (!target_is_non_stop_p ()) { /* Save the reply for later. */ - wait_status = (char *) alloca (strlen (rs->buf) + 1); - strcpy (wait_status, rs->buf); + wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1); + strcpy (wait_status, rs->buf.data ()); } - else if (strcmp (rs->buf, "OK") != 0) + else if (strcmp (rs->buf.data (), "OK") != 0) error (_("Attaching to %s failed with: %s"), target_pid_to_str (ptid_t (pid)), - rs->buf); + rs->buf.data ()); break; case PACKET_UNKNOWN: error (_("This target does not support attaching to a process")); @@ -5911,7 +5912,7 @@ extended_remote_target::attach (const char *args, int from_tty) else { gdb_assert (wait_status != NULL); - strcpy (rs->buf, wait_status); + strcpy (rs->buf.data (), wait_status); rs->cached_wait_status = 1; } } @@ -5946,10 +5947,10 @@ remote_target::remote_vcont_probe () remote_state *rs = get_remote_state (); char *buf; - strcpy (rs->buf, "vCont?"); + strcpy (rs->buf.data (), "vCont?"); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); - buf = rs->buf; + getpkt (&rs->buf, 0); + buf = rs->buf.data (); /* Make sure that the features we assume are supported. */ if (startswith (buf, "vCont")) @@ -5988,7 +5989,7 @@ remote_target::remote_vcont_probe () buf[0] = 0; } - packet_ok (buf, &remote_protocol_packets[PACKET_vCont]); + packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCont]); } /* Helper function for building "vCont" resumptions. Write a @@ -6128,7 +6129,7 @@ remote_target::remote_resume_with_hc (ptid_t ptid, int step, for (thread_info *thread : all_non_exited_threads ()) resume_clear_thread_private_info (thread); - buf = rs->buf; + buf = rs->buf.data (); if (::execution_direction == EXEC_REVERSE) { /* We don't pass signals to the target in reverse exec mode. */ @@ -6184,8 +6185,8 @@ remote_target::remote_resume_with_vcont (ptid_t ptid, int step, if (packet_support (PACKET_vCont) == PACKET_DISABLE) return 0; - p = rs->buf; - endp = rs->buf + get_remote_packet_size (); + p = rs->buf.data (); + endp = p + get_remote_packet_size (); /* If we could generate a wider range of packets, we'd have to worry about overflowing BUF. Should there be a generic @@ -6226,7 +6227,7 @@ remote_target::remote_resume_with_vcont (ptid_t ptid, int step, append_resumption (p, endp, ptid, step, siggnal); } - gdb_assert (strlen (rs->buf) < get_remote_packet_size ()); + gdb_assert (strlen (rs->buf.data ()) < get_remote_packet_size ()); putpkt (rs->buf); if (target_is_non_stop_p ()) @@ -6234,9 +6235,10 @@ remote_target::remote_resume_with_vcont (ptid_t ptid, int step, /* In non-stop, the stub replies to vCont with "OK". The stop reply will be reported asynchronously by means of a `%Stop' notification. */ - getpkt (&rs->buf, &rs->buf_size, 0); - if (strcmp (rs->buf, "OK") != 0) - error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf); + getpkt (&rs->buf, 0); + if (strcmp (rs->buf.data (), "OK") != 0) + error (_("Unexpected vCont reply in non-stop mode: %s"), + rs->buf.data ()); } return 1; @@ -6367,8 +6369,8 @@ vcont_builder::restart () { struct remote_state *rs = m_remote->get_remote_state (); - m_p = rs->buf; - m_endp = rs->buf + m_remote->get_remote_packet_size (); + m_p = rs->buf.data (); + m_endp = m_p + m_remote->get_remote_packet_size (); m_p += xsnprintf (m_p, m_endp - m_p, "vCont"); m_first_action = m_p; } @@ -6386,9 +6388,9 @@ vcont_builder::flush () rs = m_remote->get_remote_state (); m_remote->putpkt (rs->buf); - m_remote->getpkt (&rs->buf, &rs->buf_size, 0); - if (strcmp (rs->buf, "OK") != 0) - error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf); + m_remote->getpkt (&rs->buf, 0); + if (strcmp (rs->buf.data (), "OK") != 0) + error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf.data ()); } /* The largest action is range-stepping, with its two addresses. This @@ -6609,8 +6611,8 @@ void remote_target::remote_stop_ns (ptid_t ptid) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; - char *endp = rs->buf + get_remote_packet_size (); + char *p = rs->buf.data (); + char *endp = p + get_remote_packet_size (); if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN) remote_vcont_probe (); @@ -6647,9 +6649,10 @@ remote_target::remote_stop_ns (ptid_t ptid) /* In non-stop, we get an immediate OK reply. The stop reply will come in asynchronously by notification. */ putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); - if (strcmp (rs->buf, "OK") != 0) - error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), rs->buf); + getpkt (&rs->buf, 0); + if (strcmp (rs->buf.data (), "OK") != 0) + error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), + rs->buf.data ()); } /* All-stop version of target_interrupt. Sends a break or a ^C to @@ -6682,15 +6685,15 @@ void remote_target::remote_interrupt_ns () { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; - char *endp = rs->buf + get_remote_packet_size (); + char *p = rs->buf.data (); + char *endp = p + get_remote_packet_size (); xsnprintf (p, endp - p, "vCtrlC"); /* In non-stop, we get an immediate OK reply. The stop reply will come in asynchronously by notification. */ putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC])) { @@ -6699,7 +6702,7 @@ remote_target::remote_interrupt_ns () case PACKET_UNKNOWN: error (_("No support for interrupting the remote target.")); case PACKET_ERROR: - error (_("Interrupting target failed: %s"), rs->buf); + error (_("Interrupting target failed: %s"), rs->buf.data ()); } } @@ -7609,16 +7612,17 @@ remote_target::remote_notif_get_pending_events (notif_client *nc) nc->name); /* acknowledge */ - nc->ack (this, nc, rs->buf, rs->notif_state->pending_event[nc->id]); + nc->ack (this, nc, rs->buf.data (), + rs->notif_state->pending_event[nc->id]); rs->notif_state->pending_event[nc->id] = NULL; while (1) { - getpkt (&rs->buf, &rs->buf_size, 0); - if (strcmp (rs->buf, "OK") == 0) + getpkt (&rs->buf, 0); + if (strcmp (rs->buf.data (), "OK") == 0) break; else - remote_notif_ack (this, nc, rs->buf); + remote_notif_ack (this, nc, rs->buf.data ()); } } else @@ -7705,8 +7709,7 @@ remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int optio /* If in non-stop mode, get out of getpkt even if a notification is received. */ - ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size, - 0 /* forever */, &is_notif); + ret = getpkt_or_notif_sane (&rs->buf, 0 /* forever */, &is_notif); while (1) { if (ret != -1 && !is_notif) @@ -7716,13 +7719,13 @@ remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int optio /* We're out of sync with the target now. Did it continue or not? We can't tell which thread it was in non-stop, so just ignore this. */ - warning (_("Remote failure reply: %s"), rs->buf); + warning (_("Remote failure reply: %s"), rs->buf.data ()); break; case 'O': /* Console output. */ - remote_console_output (rs->buf + 1); + remote_console_output (&rs->buf[1]); break; default: - warning (_("Invalid remote reply: %s"), rs->buf); + warning (_("Invalid remote reply: %s"), rs->buf.data ()); break; } @@ -7745,8 +7748,7 @@ remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int optio } /* Otherwise do a blocking wait. */ - ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size, - 1 /* forever */, &is_notif); + ret = getpkt_or_notif_sane (&rs->buf, 1 /* forever */, &is_notif); } } @@ -7790,8 +7792,7 @@ remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options) _never_ wait for ever -> test on target_is_async_p(). However, before we do that we need to ensure that the caller knows how to take the target into/out of async mode. */ - ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size, - forever, &is_notif); + ret = getpkt_or_notif_sane (&rs->buf, forever, &is_notif); /* GDB gets a notification. Return to core as this event is not interesting. */ @@ -7802,7 +7803,7 @@ remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options) return minus_one_ptid; } - buf = rs->buf; + buf = rs->buf.data (); /* Assume that the target has acknowledged Ctrl-C unless we receive an 'F' or 'O' packet. */ @@ -7840,7 +7841,7 @@ remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options) stop_reply = (struct stop_reply *) remote_notif_parse (this, ¬if_client_stop, - rs->buf); + rs->buf.data ()); event_ptid = process_stop_reply (stop_reply, status); break; @@ -7940,16 +7941,16 @@ remote_target::fetch_register_using_p (struct regcache *regcache, if (reg->pnum == -1) return 0; - p = rs->buf; + p = rs->buf.data (); *p++ = 'p'; p += hexnumstr (p, reg->pnum); *p++ = '\0'; putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); - buf = rs->buf; + buf = rs->buf.data (); - switch (packet_ok (buf, &remote_protocol_packets[PACKET_p])) + switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_p])) { case PACKET_OK: break; @@ -7992,12 +7993,12 @@ remote_target::send_g_packet () struct remote_state *rs = get_remote_state (); int buf_len; - xsnprintf (rs->buf, get_remote_packet_size (), "g"); + xsnprintf (rs->buf.data (), get_remote_packet_size (), "g"); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (packet_check_result (rs->buf) == PACKET_ERROR) error (_("Could not read registers; remote failure reply '%s'"), - rs->buf); + rs->buf.data ()); /* 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 @@ -8010,14 +8011,14 @@ remote_target::send_g_packet () if (remote_debug) fprintf_unfiltered (gdb_stdlog, "Bad register packet; fetching a new packet\n"); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); } - buf_len = strlen (rs->buf); + buf_len = strlen (rs->buf.data ()); /* Sanity check the received packet. */ if (buf_len % 2 != 0) - error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf); + error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf.data ()); return buf_len / 2; } @@ -8032,12 +8033,14 @@ remote_target::process_g_packet (struct regcache *regcache) char *p; char *regs; - buf_len = strlen (rs->buf); + buf_len = strlen (rs->buf.data ()); /* Further sanity checks, with knowledge of the architecture. */ if (buf_len > 2 * rsa->sizeof_g_packet) error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d " - "bytes): %s"), rsa->sizeof_g_packet, buf_len / 2, rs->buf); + "bytes): %s"), + rsa->sizeof_g_packet, buf_len / 2, + rs->buf.data ()); /* Save the size of the packet sent to us by the target. It is used as a heuristic when determining the max size of packets that the @@ -8087,7 +8090,7 @@ remote_target::process_g_packet (struct regcache *regcache) hex characters. Suck them all up, then supply them to the register cacheing/storage mechanism. */ - p = rs->buf; + p = rs->buf.data (); for (i = 0; i < rsa->sizeof_g_packet; i++) { if (p[0] == 0 || p[1] == 0) @@ -8109,13 +8112,13 @@ remote_target::process_g_packet (struct regcache *regcache) if (r->in_g_packet) { - if ((r->offset + reg_size) * 2 > strlen (rs->buf)) + if ((r->offset + reg_size) * 2 > strlen (rs->buf.data ())) /* This shouldn't happen - we adjusted in_g_packet above. */ internal_error (__FILE__, __LINE__, _("unexpected end of 'g' packet reply")); else if (rs->buf[r->offset * 2] == 'x') { - gdb_assert (r->offset * 2 < strlen (rs->buf)); + gdb_assert (r->offset * 2 < strlen (rs->buf.data ())); /* The register isn't available, mark it as such (at the same time setting the value to zero). */ regcache->raw_supply (r->regnum, NULL); @@ -8240,7 +8243,7 @@ remote_target::store_register_using_P (const struct regcache *regcache, struct gdbarch *gdbarch = regcache->arch (); struct remote_state *rs = get_remote_state (); /* Try storing a single register. */ - char *buf = rs->buf; + char *buf = rs->buf.data (); gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum)); char *p; @@ -8255,7 +8258,7 @@ remote_target::store_register_using_P (const struct regcache *regcache, regcache->raw_collect (reg->regnum, regp); bin2hex (regp, p, register_size (gdbarch, reg->regnum)); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P])) { @@ -8263,7 +8266,7 @@ remote_target::store_register_using_P (const struct regcache *regcache, return 1; case PACKET_ERROR: error (_("Could not write register \"%s\"; remote failure reply '%s'"), - gdbarch_register_name (gdbarch, reg->regnum), rs->buf); + gdbarch_register_name (gdbarch, reg->regnum), rs->buf.data ()); case PACKET_UNKNOWN: return 0; default: @@ -8300,14 +8303,14 @@ remote_target::store_registers_using_G (const struct regcache *regcache) /* Command describes registers byte by byte, each byte encoded as two hex characters. */ - p = rs->buf; + p = rs->buf.data (); *p++ = 'G'; bin2hex (regs, p, rsa->sizeof_g_packet); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (packet_check_result (rs->buf) == PACKET_ERROR) error (_("Could not write registers; remote failure reply '%s'"), - rs->buf); + rs->buf.data ()); } /* Store register REGNUM, or all registers if REGNUM == -1, from the contents @@ -8450,7 +8453,7 @@ remote_target::check_binary_download (CORE_ADDR addr) { char *p; - p = rs->buf; + p = rs->buf.data (); *p++ = 'X'; p += hexnumstr (p, (ULONGEST) addr); *p++ = ','; @@ -8458,8 +8461,8 @@ remote_target::check_binary_download (CORE_ADDR addr) *p++ = ':'; *p = '\0'; - putpkt_binary (rs->buf, (int) (p - rs->buf)); - getpkt (&rs->buf, &rs->buf_size, 0); + putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ())); + getpkt (&rs->buf, 0); if (rs->buf[0] == '\0') { @@ -8568,8 +8571,8 @@ remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr, /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */ - strcat (rs->buf, header); - p = rs->buf + strlen (header); + strcat (rs->buf.data (), header); + p = rs->buf.data () + strlen (header); /* Compute a best guess of the number of bytes actually transfered. */ if (packet_format == 'X') @@ -8669,8 +8672,8 @@ remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr, units_written = todo_units; } - putpkt_binary (rs->buf, (int) (p - rs->buf)); - getpkt (&rs->buf, &rs->buf_size, 0); + putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ())); + getpkt (&rs->buf, 0); if (rs->buf[0] == 'E') return TARGET_XFER_E_IO; @@ -8756,21 +8759,21 @@ remote_target::remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, /* Construct "m"<memaddr>","<len>". */ memaddr = remote_address_masked (memaddr); - p = rs->buf; + p = rs->buf.data (); *p++ = 'm'; p += hexnumstr (p, (ULONGEST) memaddr); *p++ = ','; p += hexnumstr (p, (ULONGEST) todo_units); *p = '\0'; putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (rs->buf[0] == 'E' && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2]) && rs->buf[3] == '\0') return TARGET_XFER_E_IO; /* Reply describes memory byte by byte, each byte encoded as two hex characters. */ - p = rs->buf; + p = rs->buf.data (); decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size); /* Return what we have. Let higher layers handle partial reads. */ *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size); @@ -8911,7 +8914,7 @@ remote_target::remote_send_printf (const char *format, ...) va_start (ap, format); rs->buf[0] = '\0'; - int size = vsnprintf (rs->buf, max_size, format, ap); + int size = vsnprintf (rs->buf.data (), max_size, format, ap); va_end (ap); @@ -8922,7 +8925,7 @@ remote_target::remote_send_printf (const char *format, ...) error (_("Communication problem with target.")); rs->buf[0] = '\0'; - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); return packet_check_result (rs->buf); } @@ -9267,18 +9270,18 @@ remote_target::putpkt_binary (const char *buf, int cnt) for an ack. */ /* We've found the start of a notification. Now collect the data. */ - val = read_frame (&rs->buf, &rs->buf_size); + val = read_frame (&rs->buf); if (val >= 0) { if (remote_debug) { - std::string str = escape_buffer (rs->buf, val); + std::string str = escape_buffer (rs->buf.data (), val); fprintf_unfiltered (gdb_stdlog, " Notification received: %s\n", str.c_str ()); } - handle_notification (rs->notif_state, rs->buf); + handle_notification (rs->notif_state, rs->buf.data ()); /* We're in sync now, rewait for the ack. */ tcount = 0; } @@ -9292,7 +9295,7 @@ remote_target::putpkt_binary (const char *buf, int cnt) fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: "); } fputc_unfiltered (ch & 0177, gdb_stdlog); - fprintf_unfiltered (gdb_stdlog, "%s", rs->buf); + fprintf_unfiltered (gdb_stdlog, "%s", rs->buf.data ()); } } continue; @@ -9369,19 +9372,19 @@ remote_target::skip_frame () /* Come here after finding the start of the frame. Collect the rest into *BUF, verifying the checksum, length, and handling run-length compression. NUL terminate the buffer. If there is not enough room, - expand *BUF using xrealloc. + expand *BUF. Returns -1 on error, number of characters in buffer (ignoring the trailing NULL) on success. (could be extended to return one of the SERIAL status indications). */ long -remote_target::read_frame (char **buf_p, long *sizeof_buf) +remote_target::read_frame (gdb::char_vector *buf_p) { unsigned char csum; long bc; int c; - char *buf = *buf_p; + char *buf = buf_p->data (); struct remote_state *rs = get_remote_state (); csum = 0; @@ -9464,12 +9467,11 @@ remote_target::read_frame (char **buf_p, long *sizeof_buf) if (repeat > 0 && repeat <= 255 && bc > 0) { - if (bc + repeat - 1 >= *sizeof_buf - 1) + if (bc + repeat - 1 >= buf_p->size () - 1) { /* Make some more room in the buffer. */ - *sizeof_buf += repeat; - *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf); - buf = *buf_p; + buf_p->resize (buf_p->size () + repeat); + buf = buf_p->data (); } memset (&buf[bc], buf[bc - 1], repeat); @@ -9482,12 +9484,11 @@ remote_target::read_frame (char **buf_p, long *sizeof_buf) return -1; } default: - if (bc >= *sizeof_buf - 1) + if (bc >= buf_p->size () - 1) { /* Make some more room in the buffer. */ - *sizeof_buf *= 2; - *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf); - buf = *buf_p; + buf_p->resize (buf_p->size () * 2); + buf = buf_p->data (); } buf[bc++] = c; @@ -9498,36 +9499,35 @@ remote_target::read_frame (char **buf_p, long *sizeof_buf) } /* Read a packet from the remote machine, with error checking, and - store it in *BUF. Resize *BUF using xrealloc if necessary to hold - the result, and update *SIZEOF_BUF. If FOREVER, wait forever - rather than timing out; this is used (in synchronous mode) to wait - for a target that is is executing user code to stop. */ + store it in *BUF. Resize *BUF if necessary to hold the result. If + FOREVER, wait forever rather than timing out; this is used (in + synchronous mode) to wait for a target that is is executing user + code to stop. */ /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we don't have to change all the calls to getpkt to deal with the return value, because at the moment I don't know what the right thing to do it for those. */ void -remote_target::getpkt (char **buf, long *sizeof_buf, int forever) +remote_target::getpkt (gdb::char_vector *buf, int forever) { - getpkt_sane (buf, sizeof_buf, forever); + getpkt_sane (buf, forever); } /* Read a packet from the remote machine, with error checking, and - store it in *BUF. Resize *BUF using xrealloc if necessary to hold - the result, and update *SIZEOF_BUF. If FOREVER, wait forever - rather than timing out; this is used (in synchronous mode) to wait - for a target that is is executing user code to stop. If FOREVER == - 0, this function is allowed to time out gracefully and return an - indication of this to the caller. Otherwise return the number of - bytes read. If EXPECTING_NOTIF, consider receiving a notification - enough reason to return to the caller. *IS_NOTIF is an output - boolean that indicates whether *BUF holds a notification or not - (a regular packet). */ + store it in *BUF. Resize *BUF if necessary to hold the result. If + FOREVER, wait forever rather than timing out; this is used (in + synchronous mode) to wait for a target that is is executing user + code to stop. If FOREVER == 0, this function is allowed to time + out gracefully and return an indication of this to the caller. + Otherwise return the number of bytes read. If EXPECTING_NOTIF, + consider receiving a notification enough reason to return to the + caller. *IS_NOTIF is an output boolean that indicates whether *BUF + holds a notification or not (a regular packet). */ int -remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, +remote_target::getpkt_or_notif_sane_1 (gdb::char_vector *buf, int forever, int expecting_notif, int *is_notif) { @@ -9541,7 +9541,7 @@ remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, previously cached response. */ rs->cached_wait_status = 0; - strcpy (*buf, "timeout"); + strcpy (buf->data (), "timeout"); if (forever) timeout = watchdog > 0 ? watchdog : -1; @@ -9594,7 +9594,7 @@ remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, { /* We've found the start of a packet or notification. Now collect the data. */ - val = read_frame (buf, sizeof_buf); + val = read_frame (buf); if (val >= 0) break; } @@ -9620,7 +9620,7 @@ remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, if (remote_debug) { std::string str - = escape_buffer (*buf, + = escape_buffer (buf->data (), std::min (val, REMOTE_DEBUG_MAX_CHAR)); fprintf_unfiltered (gdb_stdlog, "Packet received: %s", @@ -9649,7 +9649,7 @@ remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, if (remote_debug) { - std::string str = escape_buffer (*buf, val); + std::string str = escape_buffer (buf->data (), val); fprintf_unfiltered (gdb_stdlog, " Notification received: %s\n", @@ -9658,7 +9658,7 @@ remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, if (is_notif != NULL) *is_notif = 1; - handle_notification (rs->notif_state, *buf); + handle_notification (rs->notif_state, buf->data ()); /* Notifications require no acknowledgement. */ @@ -9669,17 +9669,16 @@ remote_target::getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, } int -remote_target::getpkt_sane (char **buf, long *sizeof_buf, int forever) +remote_target::getpkt_sane (gdb::char_vector *buf, int forever) { - return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 0, NULL); + return getpkt_or_notif_sane_1 (buf, forever, 0, NULL); } int -remote_target::getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever, +remote_target::getpkt_or_notif_sane (gdb::char_vector *buf, int forever, int *is_notif) { - return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 1, - is_notif); + return getpkt_or_notif_sane_1 (buf, forever, 1, is_notif); } /* Kill any new fork children of process PID that haven't been @@ -9780,9 +9779,9 @@ remote_target::remote_vkill (int pid) remote_state *rs = get_remote_state (); /* Tell the remote target to detach. */ - xsnprintf (rs->buf, get_remote_packet_size (), "vKill;%x", pid); + xsnprintf (rs->buf.data (), get_remote_packet_size (), "vKill;%x", pid); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vKill])) @@ -9888,7 +9887,7 @@ remote_target::mourn_inferior () /* Check whether the target is running now - some remote stubs automatically restart after kill. */ putpkt ("?"); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (rs->buf[0] == 'S' || rs->buf[0] == 'T') { @@ -9914,8 +9913,8 @@ remote_target::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); + xsnprintf (rs->buf.data (), get_remote_packet_size (), + "QDisableRandomization:%x", val); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') @@ -9936,12 +9935,12 @@ remote_target::extended_remote_run (const std::string &args) if (packet_support (PACKET_vRun) == PACKET_DISABLE) return -1; - strcpy (rs->buf, "vRun;"); - len = strlen (rs->buf); + strcpy (rs->buf.data (), "vRun;"); + len = strlen (rs->buf.data ()); if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ()) error (_("Remote file name too long for run packet")); - len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len, + len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf.data () + len, strlen (remote_exec_file)); if (!args.empty ()) @@ -9954,7 +9953,7 @@ remote_target::extended_remote_run (const std::string &args) if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ()) error (_("Argument list too long for run packet")); rs->buf[len++] = ';'; - len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len, + len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf.data () + len, strlen (argv[i])); } } @@ -9962,7 +9961,7 @@ remote_target::extended_remote_run (const std::string &args) rs->buf[len++] = '\0'; putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun])) { @@ -10000,12 +9999,12 @@ remote_target::send_environment_packet (const char *action, std::string encoded_value = bin2hex ((const gdb_byte *) value, strlen (value)); - xsnprintf (rs->buf, get_remote_packet_size (), + xsnprintf (rs->buf.data (), get_remote_packet_size (), "%s:%s", packet, encoded_value.c_str ()); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); - if (strcmp (rs->buf, "OK") != 0) + getpkt (&rs->buf, 0); + if (strcmp (rs->buf.data (), "OK") != 0) warning (_("Unable to %s environment variable '%s' on remote."), action, value); } @@ -10020,8 +10019,8 @@ remote_target::extended_remote_environment_support () if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE) { putpkt ("QEnvironmentReset"); - getpkt (&rs->buf, &rs->buf_size, 0); - if (strcmp (rs->buf, "OK") != 0) + getpkt (&rs->buf, 0); + if (strcmp (rs->buf.data (), "OK") != 0) warning (_("Unable to reset environment on remote.")); } @@ -10053,26 +10052,26 @@ remote_target::extended_remote_set_inferior_cwd () std::string hexpath = bin2hex ((const gdb_byte *) inferior_cwd, strlen (inferior_cwd)); - xsnprintf (rs->buf, get_remote_packet_size (), + xsnprintf (rs->buf.data (), get_remote_packet_size (), "QSetWorkingDir:%s", hexpath.c_str ()); } else { /* An empty inferior_cwd means that the user wants us to reset the remote server's inferior's cwd. */ - xsnprintf (rs->buf, get_remote_packet_size (), + xsnprintf (rs->buf.data (), get_remote_packet_size (), "QSetWorkingDir:"); } putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_QSetWorkingDir]) != PACKET_OK) error (_("\ Remote replied unexpectedly while setting the inferior's working\n\ directory: %s"), - rs->buf); + rs->buf.data ()); } } @@ -10106,14 +10105,14 @@ extended_remote_target::create_inferior (const char *exec_file, remote inferior using a shell. */ if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE) { - xsnprintf (rs->buf, get_remote_packet_size (), + xsnprintf (rs->buf.data (), get_remote_packet_size (), "QStartupWithShell:%d", startup_with_shell ? 1 : 0); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); - if (strcmp (rs->buf, "OK") != 0) + getpkt (&rs->buf, 0); + if (strcmp (rs->buf.data (), "OK") != 0) error (_("\ Remote replied unexpectedly while setting startup-with-shell: %s"), - rs->buf); + rs->buf.data ()); } extended_remote_environment_support (); @@ -10136,7 +10135,7 @@ Remote replied unexpectedly while setting startup-with-shell: %s"), } /* vRun's success return is a stop reply. */ - stop_reply = run_worked ? rs->buf : NULL; + stop_reply = run_worked ? rs->buf.data () : NULL; add_current_inferior_and_thread (stop_reply); /* Get updated offsets, if the stub uses qOffsets. */ @@ -10222,8 +10221,8 @@ remote_target::insert_breakpoint (struct gdbarch *gdbarch, set_general_process (); rs = get_remote_state (); - p = rs->buf; - endbuf = rs->buf + get_remote_packet_size (); + p = rs->buf.data (); + endbuf = p + get_remote_packet_size (); *(p++) = 'Z'; *(p++) = '0'; @@ -10239,7 +10238,7 @@ remote_target::insert_breakpoint (struct gdbarch *gdbarch, remote_add_target_side_commands (gdbarch, bp_tgt, p); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0])) { @@ -10271,8 +10270,8 @@ remote_target::remove_breakpoint (struct gdbarch *gdbarch, if (packet_support (PACKET_Z0) != PACKET_DISABLE) { - char *p = rs->buf; - char *endbuf = rs->buf + get_remote_packet_size (); + char *p = rs->buf.data (); + char *endbuf = p + get_remote_packet_size (); /* Make sure the remote is pointing at the right process, if necessary. */ @@ -10288,7 +10287,7 @@ remote_target::remove_breakpoint (struct gdbarch *gdbarch, xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); return (rs->buf[0] == 'E'); } @@ -10321,7 +10320,7 @@ remote_target::insert_watchpoint (CORE_ADDR addr, int len, enum target_hw_bp_type type, struct expression *cond) { struct remote_state *rs = get_remote_state (); - char *endbuf = rs->buf + get_remote_packet_size (); + char *endbuf = rs->buf.data () + get_remote_packet_size (); char *p; enum Z_packet_type packet = watchpoint_to_Z_packet (type); @@ -10333,14 +10332,14 @@ remote_target::insert_watchpoint (CORE_ADDR addr, int len, if (!gdbarch_has_global_breakpoints (target_gdbarch ())) set_general_process (); - xsnprintf (rs->buf, endbuf - rs->buf, "Z%x,", packet); - p = strchr (rs->buf, '\0'); + xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "Z%x,", packet); + p = strchr (rs->buf.data (), '\0'); addr = remote_address_masked (addr); p += hexnumstr (p, (ULONGEST) addr); xsnprintf (p, endbuf - p, ",%x", len); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) { @@ -10370,7 +10369,7 @@ remote_target::remove_watchpoint (CORE_ADDR addr, int len, enum target_hw_bp_type type, struct expression *cond) { struct remote_state *rs = get_remote_state (); - char *endbuf = rs->buf + get_remote_packet_size (); + char *endbuf = rs->buf.data () + get_remote_packet_size (); char *p; enum Z_packet_type packet = watchpoint_to_Z_packet (type); @@ -10382,13 +10381,13 @@ remote_target::remove_watchpoint (CORE_ADDR addr, int len, if (!gdbarch_has_global_breakpoints (target_gdbarch ())) set_general_process (); - xsnprintf (rs->buf, endbuf - rs->buf, "z%x,", packet); - p = strchr (rs->buf, '\0'); + xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "z%x,", packet); + p = strchr (rs->buf.data (), '\0'); addr = remote_address_masked (addr); p += hexnumstr (p, (ULONGEST) addr); xsnprintf (p, endbuf - p, ",%x", len); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet])) { @@ -10533,8 +10532,8 @@ remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch, set_general_process (); rs = get_remote_state (); - p = rs->buf; - endbuf = rs->buf + get_remote_packet_size (); + p = rs->buf.data (); + endbuf = p + get_remote_packet_size (); *(p++) = 'Z'; *(p++) = '1'; @@ -10551,14 +10550,14 @@ remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch, remote_add_target_side_commands (gdbarch, bp_tgt, p); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) { case PACKET_ERROR: if (rs->buf[1] == '.') { - message = strchr (rs->buf + 2, '.'); + message = strchr (&rs->buf[2], '.'); if (message) error (_("Remote failure reply: %s"), message + 1); } @@ -10579,8 +10578,8 @@ remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch, { CORE_ADDR addr; struct remote_state *rs = get_remote_state (); - char *p = rs->buf; - char *endbuf = rs->buf + get_remote_packet_size (); + char *p = rs->buf.data (); + char *endbuf = p + get_remote_packet_size (); if (packet_support (PACKET_Z1) == PACKET_DISABLE) return -1; @@ -10599,7 +10598,7 @@ remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch, xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1])) { @@ -10632,7 +10631,7 @@ remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size set_general_process (); /* FIXME: assumes lma can fit into long. */ - xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx", + xsnprintf (rs->buf.data (), get_remote_packet_size (), "qCRC:%lx,%lx", (long) lma, (long) size); putpkt (rs->buf); @@ -10640,7 +10639,7 @@ remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size reply. */ host_crc = xcrc32 (data, size, 0xffffffff); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qCRC]); @@ -10752,7 +10751,7 @@ remote_target::remote_write_qxfer (const char *object_name, return TARGET_XFER_E_IO; /* Insert header. */ - i = snprintf (rs->buf, max_size, + i = snprintf (rs->buf.data (), max_size, "qXfer:%s:write:%s:%s:", object_name, annex ? annex : "", phex_nz (offset, sizeof offset)); @@ -10760,14 +10759,14 @@ remote_target::remote_write_qxfer (const char *object_name, /* Escape as much data as fits into rs->buf. */ buf_len = remote_escape_output - (writebuf, len, 1, (gdb_byte *) rs->buf + i, &max_size, max_size); + (writebuf, len, 1, (gdb_byte *) rs->buf.data () + i, &max_size, max_size); - if (putpkt_binary (rs->buf, i + buf_len) < 0 - || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0 + if (putpkt_binary (rs->buf.data (), i + buf_len) < 0 + || getpkt_sane (&rs->buf, 0) < 0 || packet_ok (rs->buf, packet) != PACKET_OK) return TARGET_XFER_E_IO; - unpack_varlen_hex (rs->buf, &n); + unpack_varlen_hex (rs->buf.data (), &n); *xfered_len = n; return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; @@ -10817,7 +10816,8 @@ remote_target::remote_read_qxfer (const char *object_name, the target is free to respond with slightly less data. We subtract five to account for the response type and the protocol frame. */ n = std::min<LONGEST> (get_remote_packet_size () - 5, len); - snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s", + snprintf (rs->buf.data (), get_remote_packet_size () - 4, + "qXfer:%s:read:%s:%s,%s", object_name, annex ? annex : "", phex_nz (offset, sizeof offset), phex_nz (n, sizeof n)); @@ -10826,12 +10826,12 @@ remote_target::remote_read_qxfer (const char *object_name, return TARGET_XFER_E_IO; rs->buf[0] = '\0'; - packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0); + packet_len = getpkt_sane (&rs->buf, 0); if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK) return TARGET_XFER_E_IO; if (rs->buf[0] != 'l' && rs->buf[0] != 'm') - error (_("Unknown remote qXfer reply: %s"), rs->buf); + error (_("Unknown remote qXfer reply: %s"), rs->buf.data ()); /* 'm' means there is (or at least might be) more data after this batch. That does not make sense unless there's at least one byte @@ -10840,7 +10840,7 @@ remote_target::remote_read_qxfer (const char *object_name, error (_("Remote qXfer reply contained no data.")); /* Got some data. */ - i = remote_unescape_input ((gdb_byte *) rs->buf + 1, + i = remote_unescape_input ((gdb_byte *) rs->buf.data () + 1, packet_len - 1, readbuf, n); /* 'l' is an EOF marker, possibly including a final block of data, @@ -11044,7 +11044,7 @@ remote_target::xfer_partial (enum target_object object, gdb_assert (annex != NULL); gdb_assert (readbuf != NULL); - p2 = rs->buf; + p2 = rs->buf.data (); *p2++ = 'q'; *p2++ = query_type; @@ -11068,8 +11068,8 @@ remote_target::xfer_partial (enum target_object object, if (i < 0) return TARGET_XFER_E_IO; - getpkt (&rs->buf, &rs->buf_size, 0); - strcpy ((char *) readbuf, rs->buf); + getpkt (&rs->buf, 0); + strcpy ((char *) readbuf, rs->buf.data ()); *xfered_len = strlen ((char *) readbuf); return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF; @@ -11129,7 +11129,7 @@ remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len, set_general_process (); /* Insert header. */ - i = snprintf (rs->buf, max_size, + i = snprintf (rs->buf.data (), max_size, "qSearch:memory:%s;%s;", phex_nz (start_addr, addr_size), phex_nz (search_space_len, sizeof (search_space_len))); @@ -11137,15 +11137,16 @@ remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len, /* Escape as much data as fits into rs->buf. */ escaped_pattern_len = - remote_escape_output (pattern, pattern_len, 1, (gdb_byte *) rs->buf + i, + remote_escape_output (pattern, pattern_len, 1, + (gdb_byte *) rs->buf.data () + i, &used_pattern_len, max_size); /* Bail if the pattern is too large. */ if (used_pattern_len != pattern_len) error (_("Pattern is too large to transmit to remote target.")); - if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0 - || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0 + if (putpkt_binary (rs->buf.data (), i + escaped_pattern_len) < 0 + || getpkt_sane (&rs->buf, 0) < 0 || packet_ok (rs->buf, packet) != PACKET_OK) { /* The request may not have worked because the command is not @@ -11164,12 +11165,12 @@ remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len, { found = 1; if (rs->buf[1] != ',') - error (_("Unknown qSearch:memory reply: %s"), rs->buf); - unpack_varlen_hex (rs->buf + 2, &found_addr); + error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ()); + unpack_varlen_hex (&rs->buf[2], &found_addr); *found_addrp = found_addr; } else - error (_("Unknown qSearch:memory reply: %s"), rs->buf); + error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ()); return found; } @@ -11178,7 +11179,7 @@ void remote_target::rcmd (const char *command, struct ui_file *outbuf) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; + char *p = rs->buf.data (); if (!rs->remote_desc) error (_("remote rcmd is only available after target open")); @@ -11188,10 +11189,10 @@ remote_target::rcmd (const char *command, struct ui_file *outbuf) command = ""; /* The query prefix. */ - strcpy (rs->buf, "qRcmd,"); - p = strchr (rs->buf, '\0'); + strcpy (rs->buf.data (), "qRcmd,"); + p = strchr (rs->buf.data (), '\0'); - if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/) + if ((strlen (rs->buf.data ()) + strlen (command) * 2 + 8/*misc*/) > get_remote_packet_size ()) error (_("\"monitor\" command ``%s'' is too long."), command); @@ -11209,7 +11210,7 @@ remote_target::rcmd (const char *command, struct ui_file *outbuf) /* XXX - see also remote_get_noisy_reply(). */ QUIT; /* Allow user to bail out with ^C. */ rs->buf[0] = '\0'; - if (getpkt_sane (&rs->buf, &rs->buf_size, 0) == -1) + if (getpkt_sane (&rs->buf, 0) == -1) { /* Timeout. Continue to (try to) read responses. This is better than stopping with an error, assuming the stub @@ -11218,7 +11219,7 @@ remote_target::rcmd (const char *command, struct ui_file *outbuf) an effect similar to stop on timeout. */ continue; } - buf = rs->buf; + buf = rs->buf.data (); if (buf[0] == '\0') error (_("Target does not support this command.")); if (buf[0] == 'O' && buf[1] != 'K') @@ -11280,9 +11281,9 @@ remote_target::packet_command (const char *args, int from_tty) remote_state *rs = get_remote_state (); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); puts_filtered ("received: "); - print_packet (rs->buf); + print_packet (rs->buf.data ()); puts_filtered ("\n"); } @@ -11493,8 +11494,8 @@ remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm, if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; - char *endp = rs->buf + get_remote_packet_size (); + char *p = rs->buf.data (); + char *endp = p + get_remote_packet_size (); enum packet_result result; strcpy (p, "qGetTLSAddr:"); @@ -11507,14 +11508,14 @@ remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm, *p++ = '\0'; putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTLSAddr]); if (result == PACKET_OK) { ULONGEST addr; - unpack_varlen_hex (rs->buf, &addr); + unpack_varlen_hex (rs->buf.data (), &addr); return addr; } else if (result == PACKET_UNKNOWN) @@ -11540,8 +11541,8 @@ remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr) if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; - char *endp = rs->buf + get_remote_packet_size (); + char *p = rs->buf.data (); + char *endp = p + get_remote_packet_size (); enum packet_result result; strcpy (p, "qGetTIBAddr:"); @@ -11550,13 +11551,13 @@ remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr) *p++ = '\0'; putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_qGetTIBAddr]); if (result == PACKET_OK) { ULONGEST val; - unpack_varlen_hex (rs->buf, &val); + unpack_varlen_hex (rs->buf.data (), &val); if (addr) *addr = (CORE_ADDR) val; return true; @@ -11811,8 +11812,8 @@ remote_target::remote_hostio_send_command (int command_bytes, int which_packet, return -1; } - putpkt_binary (rs->buf, command_bytes); - bytes_read = getpkt_sane (&rs->buf, &rs->buf_size, 0); + putpkt_binary (rs->buf.data (), command_bytes); + bytes_read = getpkt_sane (&rs->buf, 0); /* If it timed out, something is wrong. Don't try to parse the buffer. */ @@ -11834,7 +11835,7 @@ remote_target::remote_hostio_send_command (int command_bytes, int which_packet, break; } - if (remote_hostio_parse_result (rs->buf, &ret, remote_errno, + if (remote_hostio_parse_result (rs->buf.data (), &ret, remote_errno, &attachment_tmp)) { *remote_errno = FILEIO_EINVAL; @@ -11854,7 +11855,7 @@ remote_target::remote_hostio_send_command (int command_bytes, int which_packet, if (attachment_tmp != NULL) { *attachment = attachment_tmp; - *attachment_len = bytes_read - (*attachment - rs->buf); + *attachment_len = bytes_read - (*attachment - rs->buf.data ()); } return ret; @@ -11887,7 +11888,7 @@ remote_target::remote_hostio_set_filesystem (struct inferior *inf, { struct remote_state *rs = get_remote_state (); int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid; - char *p = rs->buf; + char *p = rs->buf.data (); int left = get_remote_packet_size () - 1; char arg[9]; int ret; @@ -11903,7 +11904,7 @@ remote_target::remote_hostio_set_filesystem (struct inferior *inf, xsnprintf (arg, sizeof (arg), "%x", required_pid); remote_buffer_add_string (&p, &left, arg); - ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_setfs, + ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_setfs, remote_errno, NULL, NULL); if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE) @@ -11923,7 +11924,7 @@ remote_target::remote_hostio_open (inferior *inf, const char *filename, int *remote_errno) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; + char *p = rs->buf.data (); int left = get_remote_packet_size () - 1; if (warn_if_slow) @@ -11956,7 +11957,7 @@ remote_target::remote_hostio_open (inferior *inf, const char *filename, remote_buffer_add_int (&p, &left, mode); - return remote_hostio_send_command (p - rs->buf, PACKET_vFile_open, + return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_open, remote_errno, NULL, NULL); } @@ -11976,7 +11977,7 @@ remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len, ULONGEST offset, int *remote_errno) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; + char *p = rs->buf.data (); int left = get_remote_packet_size (); int out_len; @@ -11991,9 +11992,10 @@ remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len, remote_buffer_add_string (&p, &left, ","); p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len, - get_remote_packet_size () - (p - rs->buf)); + (get_remote_packet_size () + - (p - rs->buf.data ()))); - return remote_hostio_send_command (p - rs->buf, PACKET_vFile_pwrite, + return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pwrite, remote_errno, NULL, NULL); } @@ -12012,7 +12014,7 @@ remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len, ULONGEST offset, int *remote_errno) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; + char *p = rs->buf.data (); char *attachment; int left = get_remote_packet_size (); int ret, attachment_len; @@ -12028,7 +12030,7 @@ remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len, remote_buffer_add_int (&p, &left, offset); - ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_pread, + ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pread, remote_errno, &attachment, &attachment_len); @@ -12121,7 +12123,7 @@ int remote_target::remote_hostio_close (int fd, int *remote_errno) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; + char *p = rs->buf.data (); int left = get_remote_packet_size () - 1; rs->readahead_cache.invalidate_fd (fd); @@ -12130,7 +12132,7 @@ remote_target::remote_hostio_close (int fd, int *remote_errno) remote_buffer_add_int (&p, &left, fd); - return remote_hostio_send_command (p - rs->buf, PACKET_vFile_close, + return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_close, remote_errno, NULL, NULL); } @@ -12147,7 +12149,7 @@ remote_target::remote_hostio_unlink (inferior *inf, const char *filename, int *remote_errno) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; + char *p = rs->buf.data (); int left = get_remote_packet_size () - 1; if (remote_hostio_set_filesystem (inf, remote_errno) != 0) @@ -12158,7 +12160,7 @@ remote_target::remote_hostio_unlink (inferior *inf, const char *filename, remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, strlen (filename)); - return remote_hostio_send_command (p - rs->buf, PACKET_vFile_unlink, + return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_unlink, remote_errno, NULL, NULL); } @@ -12176,7 +12178,7 @@ remote_target::fileio_readlink (struct inferior *inf, const char *filename, int *remote_errno) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; + char *p = rs->buf.data (); char *attachment; int left = get_remote_packet_size (); int len, attachment_len; @@ -12190,7 +12192,7 @@ remote_target::fileio_readlink (struct inferior *inf, const char *filename, remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename, strlen (filename)); - len = remote_hostio_send_command (p - rs->buf, PACKET_vFile_readlink, + len = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_readlink, remote_errno, &attachment, &attachment_len); @@ -12213,7 +12215,7 @@ int remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno) { struct remote_state *rs = get_remote_state (); - char *p = rs->buf; + char *p = rs->buf.data (); int left = get_remote_packet_size (); int attachment_len, ret; char *attachment; @@ -12224,7 +12226,7 @@ remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno) remote_buffer_add_int (&p, &left, fd); - ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_fstat, + ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_fstat, remote_errno, &attachment, &attachment_len); if (ret < 0) @@ -12737,7 +12739,7 @@ remote_target::trace_init () putpkt ("QTinit"); remote_get_noisy_reply (); - if (strcmp (rs->buf, "OK") != 0) + if (strcmp (rs->buf.data (), "OK") != 0) error (_("Target does not support this command.")); } @@ -12754,13 +12756,13 @@ remote_target::remote_download_command_source (int num, ULONGEST addr, for (cmd = cmds; cmd; cmd = cmd->next) { QUIT; /* Allow user to bail out with ^C. */ - strcpy (rs->buf, "QTDPsrc:"); + strcpy (rs->buf.data (), "QTDPsrc:"); encode_source_string (num, addr, "cmd", cmd->line, - rs->buf + strlen (rs->buf), - rs->buf_size - strlen (rs->buf)); + rs->buf.data () + strlen (rs->buf.data ()), + rs->buf.size () - strlen (rs->buf.data ())); putpkt (rs->buf); remote_get_noisy_reply (); - if (strcmp (rs->buf, "OK")) + if (strcmp (rs->buf.data (), "OK")) warning (_("Target does not support source download.")); if (cmd->control_type == while_control @@ -12769,13 +12771,13 @@ remote_target::remote_download_command_source (int num, ULONGEST addr, remote_download_command_source (num, addr, cmd->body_list_0.get ()); QUIT; /* Allow user to bail out with ^C. */ - strcpy (rs->buf, "QTDPsrc:"); + strcpy (rs->buf.data (), "QTDPsrc:"); encode_source_string (num, addr, "cmd", "end", - rs->buf + strlen (rs->buf), - rs->buf_size - strlen (rs->buf)); + rs->buf.data () + strlen (rs->buf.data ()), + rs->buf.size () - strlen (rs->buf.data ())); putpkt (rs->buf); remote_get_noisy_reply (); - if (strcmp (rs->buf, "OK")) + if (strcmp (rs->buf.data (), "OK")) warning (_("Target does not support source download.")); } } @@ -12923,7 +12925,7 @@ remote_target::download_tracepoint (struct bp_location *loc) putpkt (buf.data ()); remote_get_noisy_reply (); - if (strcmp (rs->buf, "OK")) + if (strcmp (rs->buf.data (), "OK")) error (_("Target does not support tracepoints.")); /* do_single_steps (t); */ @@ -12945,7 +12947,7 @@ remote_target::download_tracepoint (struct bp_location *loc) putpkt (buf.data ()); remote_get_noisy_reply (); - if (strcmp (rs->buf, "OK")) + if (strcmp (rs->buf.data (), "OK")) error (_("Error on target while setting tracepoints.")); } @@ -12968,7 +12970,7 @@ remote_target::download_tracepoint (struct bp_location *loc) putpkt (buf.data ()); remote_get_noisy_reply (); - if (strcmp (rs->buf, "OK")) + if (strcmp (rs->buf.data (), "OK")) error (_("Error on target while setting tracepoints.")); } @@ -12987,7 +12989,7 @@ remote_target::download_tracepoint (struct bp_location *loc) buf.size () - strlen (buf.data ())); putpkt (buf.data ()); remote_get_noisy_reply (); - if (strcmp (rs->buf, "OK")) + if (strcmp (rs->buf.data (), "OK")) warning (_("Target does not support source download.")); } if (b->cond_string) @@ -13003,7 +13005,7 @@ remote_target::download_tracepoint (struct bp_location *loc) buf.size () - strlen (buf.data ())); putpkt (buf.data ()); remote_get_noisy_reply (); - if (strcmp (rs->buf, "OK")) + if (strcmp (rs->buf.data (), "OK")) warning (_("Target does not support source download.")); } remote_download_command_source (b->number, loc->address, @@ -13045,19 +13047,20 @@ remote_target::download_trace_state_variable (const trace_state_variable &tsv) struct remote_state *rs = get_remote_state (); char *p; - xsnprintf (rs->buf, get_remote_packet_size (), "QTDV:%x:%s:%x:", + xsnprintf (rs->buf.data (), 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) + tsv.name.length () * 2 >= get_remote_packet_size ()) + p = rs->buf.data () + strlen (rs->buf.data ()); + if ((p - rs->buf.data ()) + tsv.name.length () * 2 + >= get_remote_packet_size ()) error (_("Trace state variable name too long for tsv definition packet")); p += 2 * bin2hex ((gdb_byte *) (tsv.name.data ()), p, tsv.name.length ()); *p++ = '\0'; putpkt (rs->buf); remote_get_noisy_reply (); - if (*rs->buf == '\0') + if (rs->buf[0] == '\0') error (_("Target does not support this command.")); - if (strcmp (rs->buf, "OK") != 0) + if (strcmp (rs->buf.data (), "OK") != 0) error (_("Error on target while downloading trace state variable.")); } @@ -13068,13 +13071,13 @@ remote_target::enable_tracepoint (struct bp_location *location) char addr_buf[40]; sprintf_vma (addr_buf, location->address); - xsnprintf (rs->buf, get_remote_packet_size (), "QTEnable:%x:%s", + xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTEnable:%x:%s", location->owner->number, addr_buf); putpkt (rs->buf); remote_get_noisy_reply (); - if (*rs->buf == '\0') + if (rs->buf[0] == '\0') error (_("Target does not support enabling tracepoints while a trace run is ongoing.")); - if (strcmp (rs->buf, "OK") != 0) + if (strcmp (rs->buf.data (), "OK") != 0) error (_("Error on target while enabling tracepoint.")); } @@ -13085,13 +13088,13 @@ remote_target::disable_tracepoint (struct bp_location *location) char addr_buf[40]; sprintf_vma (addr_buf, location->address); - xsnprintf (rs->buf, get_remote_packet_size (), "QTDisable:%x:%s", + xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDisable:%x:%s", location->owner->number, addr_buf); putpkt (rs->buf); remote_get_noisy_reply (); - if (*rs->buf == '\0') + if (rs->buf[0] == '\0') error (_("Target does not support disabling tracepoints while a trace run is ongoing.")); - if (strcmp (rs->buf, "OK") != 0) + if (strcmp (rs->buf.data (), "OK") != 0) error (_("Error on target while disabling tracepoint.")); } @@ -13110,8 +13113,8 @@ remote_target::trace_set_readonly_regions () struct remote_state *rs = get_remote_state (); - strcpy (rs->buf, "QTro"); - offset = strlen (rs->buf); + strcpy (rs->buf.data (), "QTro"); + offset = strlen (rs->buf.data ()); for (s = exec_bfd->sections; s; s = s->next) { char tmp1[40], tmp2[40]; @@ -13128,21 +13131,21 @@ remote_target::trace_set_readonly_regions () sprintf_vma (tmp1, vma); sprintf_vma (tmp2, vma + size); sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2); - if (offset + sec_length + 1 > rs->buf_size) + if (offset + sec_length + 1 > rs->buf.size ()) { if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE) warning (_("\ Too many sections for read-only sections definition packet.")); break; } - xsnprintf (rs->buf + offset, rs->buf_size - offset, ":%s,%s", + xsnprintf (rs->buf.data () + offset, rs->buf.size () - offset, ":%s,%s", tmp1, tmp2); offset += sec_length; } if (anysecs) { putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); } } @@ -13153,10 +13156,10 @@ remote_target::trace_start () putpkt ("QTStart"); remote_get_noisy_reply (); - if (*rs->buf == '\0') + if (rs->buf[0] == '\0') error (_("Target does not support this command.")); - if (strcmp (rs->buf, "OK") != 0) - error (_("Bogus reply from target: %s"), rs->buf); + if (strcmp (rs->buf.data (), "OK") != 0) + error (_("Bogus reply from target: %s"), rs->buf.data ()); } int @@ -13202,7 +13205,7 @@ remote_target::get_trace_status (struct trace_status *ts) ts->filename = NULL; if (*p++ != 'T') - error (_("Bogus trace status reply from target: %s"), rs->buf); + error (_("Bogus trace status reply from target: %s"), rs->buf.data ()); /* Function 'parse_trace_status' sets default value of each field of 'ts' at first, so we don't have to do it here. */ @@ -13231,7 +13234,7 @@ remote_target::get_tracepoint_status (struct breakpoint *bp, any status. */ if (tp->number_on_target == 0) continue; - xsnprintf (rs->buf, size, "qTP:%x:%s", tp->number_on_target, + xsnprintf (rs->buf.data (), size, "qTP:%x:%s", tp->number_on_target, phex_nz (loc->address, 0)); putpkt (rs->buf); reply = remote_get_noisy_reply (); @@ -13246,7 +13249,7 @@ remote_target::get_tracepoint_status (struct breakpoint *bp, { utp->hit_count = 0; utp->traceframe_usage = 0; - xsnprintf (rs->buf, size, "qTP:%x:%s", utp->number, + xsnprintf (rs->buf.data (), size, "qTP:%x:%s", utp->number, phex_nz (utp->addr, 0)); putpkt (rs->buf); reply = remote_get_noisy_reply (); @@ -13265,10 +13268,10 @@ remote_target::trace_stop () putpkt ("QTStop"); remote_get_noisy_reply (); - if (*rs->buf == '\0') + if (rs->buf[0] == '\0') error (_("Target does not support this command.")); - if (strcmp (rs->buf, "OK") != 0) - error (_("Bogus reply from target: %s"), rs->buf); + if (strcmp (rs->buf.data (), "OK") != 0) + error (_("Bogus reply from target: %s"), rs->buf.data ()); } int @@ -13277,7 +13280,7 @@ remote_target::trace_find (enum trace_find_type type, int num, int *tpp) { struct remote_state *rs = get_remote_state (); - char *endbuf = rs->buf + get_remote_packet_size (); + char *endbuf = rs->buf.data () + get_remote_packet_size (); char *p, *reply; int target_frameno = -1, target_tracept = -1; @@ -13287,7 +13290,7 @@ remote_target::trace_find (enum trace_find_type type, int num, if (type != tfind_number) set_remote_traceframe (); - p = rs->buf; + p = rs->buf.data (); strcpy (p, "QTFrame:"); p = strchr (p, '\0'); switch (type) @@ -13362,7 +13365,7 @@ remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val) set_remote_traceframe (); - xsnprintf (rs->buf, get_remote_packet_size (), "qTV:%x", tsvnum); + xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTV:%x", tsvnum); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (reply && *reply) @@ -13383,10 +13386,11 @@ remote_target::save_trace_data (const char *filename) struct remote_state *rs = get_remote_state (); char *p, *reply; - p = rs->buf; + p = rs->buf.data (); strcpy (p, "QTSave:"); p += strlen (p); - if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ()) + if ((p - rs->buf.data ()) + strlen (filename) * 2 + >= get_remote_packet_size ()) error (_("Remote file name too long for trace save packet")); p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename)); *p++ = '\0'; @@ -13412,7 +13416,7 @@ remote_target::get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) char *p; int rslt; - p = rs->buf; + p = rs->buf.data (); strcpy (p, "qTBuffer:"); p += strlen (p); p += hexnumstr (p, offset); @@ -13451,7 +13455,8 @@ remote_target::set_disconnected_tracing (int val) { char *reply; - xsnprintf (rs->buf, get_remote_packet_size (), "QTDisconnected:%x", val); + xsnprintf (rs->buf.data (), get_remote_packet_size (), + "QTDisconnected:%x", val); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') @@ -13480,7 +13485,8 @@ remote_target::set_circular_trace_buffer (int val) struct remote_state *rs = get_remote_state (); char *reply; - xsnprintf (rs->buf, get_remote_packet_size (), "QTBuffer:circular:%x", val); + xsnprintf (rs->buf.data (), get_remote_packet_size (), + "QTBuffer:circular:%x", val); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') @@ -13520,7 +13526,7 @@ remote_target::get_min_fast_tracepoint_insn_len () /* Make sure the remote is pointing at the right process. */ set_general_process (); - xsnprintf (rs->buf, get_remote_packet_size (), "qTMinFTPILen"); + xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTMinFTPILen"); putpkt (rs->buf); reply = remote_get_noisy_reply (); if (*reply == '\0') @@ -13541,8 +13547,8 @@ remote_target::set_trace_buffer_size (LONGEST val) if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE) { struct remote_state *rs = get_remote_state (); - char *buf = rs->buf; - char *endbuf = rs->buf + get_remote_packet_size (); + char *buf = rs->buf.data (); + char *endbuf = buf + get_remote_packet_size (); enum packet_result result; gdb_assert (val >= 0 || val == -1); @@ -13562,7 +13568,7 @@ remote_target::set_trace_buffer_size (LONGEST val) &remote_protocol_packets[PACKET_QTBuffer_size]); if (result != PACKET_OK) - warning (_("Bogus reply from target: %s"), rs->buf); + warning (_("Bogus reply from target: %s"), rs->buf.data ()); } } @@ -13572,8 +13578,8 @@ remote_target::set_trace_notes (const char *user, const char *notes, { struct remote_state *rs = get_remote_state (); char *reply; - char *buf = rs->buf; - char *endbuf = rs->buf + get_remote_packet_size (); + char *buf = rs->buf.data (); + char *endbuf = buf + get_remote_packet_size (); int nbytes; buf += xsnprintf (buf, endbuf - buf, "QTNotes:"); @@ -13620,11 +13626,11 @@ remote_target::use_agent (bool use) struct remote_state *rs = get_remote_state (); /* If the stub supports QAgent. */ - xsnprintf (rs->buf, get_remote_packet_size (), "QAgent:%d", use); + xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAgent:%d", use); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); - if (strcmp (rs->buf, "OK") == 0) + if (strcmp (rs->buf.data (), "OK") == 0) { ::use_agent = use; return true; @@ -13667,7 +13673,7 @@ remote_target::btrace_sync_conf (const btrace_config *conf) char *buf, *pos, *endbuf; rs = get_remote_state (); - buf = rs->buf; + buf = rs->buf.data (); endbuf = buf + get_remote_packet_size (); packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size]; @@ -13679,7 +13685,7 @@ remote_target::btrace_sync_conf (const btrace_config *conf) conf->bts.size); putpkt (buf); - getpkt (&buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (packet_ok (buf, packet) == PACKET_ERROR) { @@ -13701,7 +13707,7 @@ remote_target::btrace_sync_conf (const btrace_config *conf) conf->pt.size); putpkt (buf); - getpkt (&buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (packet_ok (buf, packet) == PACKET_ERROR) { @@ -13789,8 +13795,8 @@ remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf) struct btrace_target_info *tinfo = NULL; struct packet_config *packet = NULL; struct remote_state *rs = get_remote_state (); - char *buf = rs->buf; - char *endbuf = rs->buf + get_remote_packet_size (); + char *buf = rs->buf.data (); + char *endbuf = buf + get_remote_packet_size (); switch (conf->format) { @@ -13812,13 +13818,13 @@ remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf) buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (packet_ok (rs->buf, packet) == PACKET_ERROR) { if (rs->buf[0] == 'E' && rs->buf[1] == '.') error (_("Could not enable branch tracing for %s: %s"), - target_pid_to_str (ptid), rs->buf + 2); + target_pid_to_str (ptid), &rs->buf[2]); else error (_("Could not enable branch tracing for %s."), target_pid_to_str (ptid)); @@ -13850,8 +13856,8 @@ remote_target::disable_btrace (struct btrace_target_info *tinfo) { struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off]; struct remote_state *rs = get_remote_state (); - char *buf = rs->buf; - char *endbuf = rs->buf + get_remote_packet_size (); + char *buf = rs->buf.data (); + char *endbuf = buf + get_remote_packet_size (); if (packet_config_support (packet) != PACKET_ENABLE) error (_("Target does not support branch tracing.")); @@ -13860,13 +13866,13 @@ remote_target::disable_btrace (struct btrace_target_info *tinfo) buf += xsnprintf (buf, endbuf - buf, "%s", packet->name); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); if (packet_ok (rs->buf, packet) == PACKET_ERROR) { if (rs->buf[0] == 'E' && rs->buf[1] == '.') error (_("Could not disable branch tracing for %s: %s"), - target_pid_to_str (tinfo->ptid), rs->buf + 2); + target_pid_to_str (tinfo->ptid), &rs->buf[2]); else error (_("Could not disable branch tracing for %s."), target_pid_to_str (tinfo->ptid)); @@ -14133,19 +14139,19 @@ remote_target::thread_events (int enable) if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE) return; - xsnprintf (rs->buf, size, "QThreadEvents:%x", enable ? 1 : 0); + xsnprintf (rs->buf.data (), size, "QThreadEvents:%x", enable ? 1 : 0); putpkt (rs->buf); - getpkt (&rs->buf, &rs->buf_size, 0); + getpkt (&rs->buf, 0); switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_QThreadEvents])) { case PACKET_OK: - if (strcmp (rs->buf, "OK") != 0) - error (_("Remote refused setting thread events: %s"), rs->buf); + if (strcmp (rs->buf.data (), "OK") != 0) + error (_("Remote refused setting thread events: %s"), rs->buf.data ()); break; case PACKET_ERROR: - warning (_("Remote failure reply: %s"), rs->buf); + warning (_("Remote failure reply: %s"), rs->buf.data ()); break; case PACKET_UNKNOWN: break; @@ -14211,15 +14217,15 @@ remote_target::upload_tracepoints (struct uploaded_tp **utpp) /* Ask for a first packet of tracepoint definition. */ putpkt ("qTfP"); - getpkt (&rs->buf, &rs->buf_size, 0); - p = rs->buf; + getpkt (&rs->buf, 0); + p = rs->buf.data (); while (*p && *p != 'l') { parse_tracepoint_definition (p, utpp); /* Ask for another packet of tracepoint definition. */ putpkt ("qTsP"); - getpkt (&rs->buf, &rs->buf_size, 0); - p = rs->buf; + getpkt (&rs->buf, 0); + p = rs->buf.data (); } return 0; } @@ -14232,15 +14238,15 @@ remote_target::upload_trace_state_variables (struct uploaded_tsv **utsvp) /* Ask for a first packet of variable definition. */ putpkt ("qTfV"); - getpkt (&rs->buf, &rs->buf_size, 0); - p = rs->buf; + getpkt (&rs->buf, 0); + p = rs->buf.data (); while (*p && *p != 'l') { parse_tsv_definition (p, utsvp); /* Ask for another packet of variable definition. */ putpkt ("qTsV"); - getpkt (&rs->buf, &rs->buf_size, 0); - p = rs->buf; + getpkt (&rs->buf, 0); + p = rs->buf.data (); } return 0; } |