Upgrade V8 to 8.8.278.14
Bug: 162604069
Bug: 167389063
Test: gts-tradefed run gts-dev --module GtsGmscoreHostTestCases
--test com.google.android.gts.devicepolicy.DeviceOwnerTest#testProxyPacProxyTest
Test: m -j proxy_resolver_v8_unittest && adb sync && adb shell \
/data/nativetest/proxy_resolver_v8_unittest/proxy_resolver_v8_unittest
Merged-In: Ifb09923b9d7f6d8990fb062d7dc0294edf2c098e
Change-Id: Ifb09923b9d7f6d8990fb062d7dc0294edf2c098e
(cherry picked from commit 9580a23bc5b8874a0979001d3595d027cbb68128)
diff --git a/src/debug/wasm/gdb-server/packet.cc b/src/debug/wasm/gdb-server/packet.cc
new file mode 100644
index 0000000..f8306c4
--- /dev/null
+++ b/src/debug/wasm/gdb-server/packet.cc
@@ -0,0 +1,364 @@
+// Copyright 2020 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/debug/wasm/gdb-server/packet.h"
+#include "src/debug/wasm/gdb-server/gdb-remote-util.h"
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+namespace gdb_server {
+
+Packet::Packet() {
+ seq_ = -1;
+ Clear();
+}
+
+void Packet::Clear() {
+ data_.clear();
+ read_index_ = 0;
+}
+
+void Packet::Rewind() { read_index_ = 0; }
+
+bool Packet::EndOfPacket() const { return (read_index_ >= GetPayloadSize()); }
+
+void Packet::AddRawChar(char ch) { data_.push_back(ch); }
+
+void Packet::AddWord8(uint8_t byte) {
+ char seq[2];
+ UInt8ToHex(byte, seq);
+ AddRawChar(seq[0]);
+ AddRawChar(seq[1]);
+}
+
+void Packet::AddBlock(const void* ptr, uint32_t len) {
+ DCHECK(ptr);
+
+ const char* p = (const char*)ptr;
+
+ for (uint32_t offs = 0; offs < len; offs++) {
+ AddWord8(p[offs]);
+ }
+}
+
+void Packet::AddString(const char* str) {
+ DCHECK(str);
+
+ while (*str) {
+ AddRawChar(*str);
+ str++;
+ }
+}
+
+void Packet::AddHexString(const char* str) {
+ DCHECK(str);
+
+ while (*str) {
+ AddWord8(*str);
+ str++;
+ }
+}
+
+void Packet::AddNumberSep(uint64_t val, char sep) {
+ char out[sizeof(val) * 2];
+ char temp[2];
+
+ // Check for -1 optimization
+ if (val == static_cast<uint64_t>(-1)) {
+ AddRawChar('-');
+ AddRawChar('1');
+ } else {
+ int nibbles = 0;
+
+ // In the GDB remote protocol numbers are formatted as big-endian hex
+ // strings. Leading zeros can be skipped.
+ // For example the value 0x00001234 is formatted as "1234".
+ for (size_t a = 0; a < sizeof(val); a++) {
+ uint8_t byte = static_cast<uint8_t>(val & 0xFF);
+
+ // Stream in with bytes reversed, starting with the least significant.
+ // So if we have the value 0x00001234, we store 4, then 3, 2, 1.
+ // Note that the characters are later reversed to be in big-endian order.
+ UInt8ToHex(byte, temp);
+ out[nibbles++] = temp[1];
+ out[nibbles++] = temp[0];
+
+ // Get the next 8 bits;
+ val >>= 8;
+
+ // Suppress leading zeros, so we are done when val hits zero
+ if (val == 0) {
+ break;
+ }
+ }
+
+ // Strip the high zero for this byte if present.
+ if ((nibbles > 1) && (out[nibbles - 1] == '0')) nibbles--;
+
+ // Now write it out reverse to correct the order
+ while (nibbles) {
+ nibbles--;
+ AddRawChar(out[nibbles]);
+ }
+ }
+
+ // If we asked for a separator, insert it
+ if (sep) AddRawChar(sep);
+}
+
+bool Packet::GetNumberSep(uint64_t* val, char* sep) {
+ uint64_t out = 0;
+ char ch;
+ if (!GetRawChar(&ch)) {
+ return false;
+ }
+
+ // Numbers are formatted as a big-endian hex strings.
+ // The literals "0" and "-1" as special cases.
+
+ // Check for -1
+ if (ch == '-') {
+ if (!GetRawChar(&ch)) {
+ return false;
+ }
+
+ if (ch == '1') {
+ *val = (uint64_t)-1;
+
+ ch = 0;
+ GetRawChar(&ch);
+ if (sep) {
+ *sep = ch;
+ }
+ return true;
+ }
+ return false;
+ }
+
+ do {
+ uint8_t nib;
+
+ // Check for separator
+ if (!NibbleToUInt8(ch, &nib)) {
+ break;
+ }
+
+ // Add this nibble.
+ out = (out << 4) + nib;
+
+ // Get the next character (if availible)
+ ch = 0;
+ if (!GetRawChar(&ch)) {
+ break;
+ }
+ } while (1);
+
+ // Set the value;
+ *val = out;
+
+ // Add the separator if the user wants it...
+ if (sep != nullptr) *sep = ch;
+
+ return true;
+}
+
+bool Packet::GetRawChar(char* ch) {
+ DCHECK(ch != nullptr);
+
+ if (read_index_ >= GetPayloadSize()) return false;
+
+ *ch = data_[read_index_++];
+
+ // Check for RLE X*N, where X is the value, N is the reps.
+ if (*ch == '*') {
+ if (read_index_ < 2) {
+ TRACE_GDB_REMOTE("Unexpected RLE at start of packet.\n");
+ return false;
+ }
+
+ if (read_index_ >= GetPayloadSize()) {
+ TRACE_GDB_REMOTE("Unexpected EoP during RLE.\n");
+ return false;
+ }
+
+ // GDB does not use "CTRL" characters in the stream, so the
+ // number of reps is encoded as the ASCII value beyond 28
+ // (which when you add a min rep size of 4, forces the rep
+ // character to be ' ' (32) or greater).
+ int32_t cnt = (data_[read_index_] - 28);
+ if (cnt < 3) {
+ TRACE_GDB_REMOTE("Unexpected RLE length.\n");
+ return false;
+ }
+
+ // We have just read '*' and incremented the read pointer,
+ // so here is the old state, and expected new state.
+ //
+ // Assume N = 5, we grow by N - size of encoding (3).
+ //
+ // OldP: R W
+ // OldD: 012X*N89 = 8 chars
+ // Size: 012X*N89__ = 10 chars
+ // Move: 012X*__N89 = 10 chars
+ // Fill: 012XXXXX89 = 10 chars
+ // NewP: R W (shifted 5 - 3)
+
+ // First, store the remaining characters to the right into a temp string.
+ std::string right = data_.substr(read_index_ + 1);
+ // Discard the '*' we just read
+ data_.erase(read_index_ - 1);
+ // Append (N-1) 'X' chars
+ *ch = data_[read_index_ - 2];
+ data_.append(cnt - 1, *ch);
+ // Finally, append the remaining characters
+ data_.append(right);
+ }
+ return true;
+}
+
+bool Packet::GetWord8(uint8_t* value) {
+ DCHECK(value);
+
+ // Get two ASCII hex values and convert them to ints
+ char seq[2];
+ if (!GetRawChar(&seq[0]) || !GetRawChar(&seq[1])) {
+ return false;
+ }
+ return HexToUInt8(seq, value);
+}
+
+bool Packet::GetBlock(void* ptr, uint32_t len) {
+ DCHECK(ptr);
+
+ uint8_t* p = reinterpret_cast<uint8_t*>(ptr);
+ bool res = true;
+
+ for (uint32_t offs = 0; offs < len; offs++) {
+ res = GetWord8(&p[offs]);
+ if (false == res) {
+ break;
+ }
+ }
+
+ return res;
+}
+
+bool Packet::GetString(std::string* str) {
+ if (EndOfPacket()) {
+ return false;
+ }
+
+ *str = data_.substr(read_index_);
+ read_index_ = GetPayloadSize();
+ return true;
+}
+
+bool Packet::GetHexString(std::string* str) {
+ // Decode a string encoded as a series of 2-hex digit pairs.
+
+ if (EndOfPacket()) {
+ return false;
+ }
+
+ // Pull values until we hit a separator
+ str->clear();
+ char ch1;
+ while (GetRawChar(&ch1)) {
+ uint8_t nib1;
+ if (!NibbleToUInt8(ch1, &nib1)) {
+ read_index_--;
+ break;
+ }
+ char ch2;
+ uint8_t nib2;
+ if (!GetRawChar(&ch2) || !NibbleToUInt8(ch2, &nib2)) {
+ return false;
+ }
+ *str += static_cast<char>((nib1 << 4) + nib2);
+ }
+ return true;
+}
+
+const char* Packet::GetPayload() const { return data_.c_str(); }
+
+size_t Packet::GetPayloadSize() const { return data_.size(); }
+
+bool Packet::GetSequence(int32_t* ch) const {
+ DCHECK(ch);
+
+ if (seq_ != -1) {
+ *ch = seq_;
+ return true;
+ }
+
+ return false;
+}
+
+void Packet::ParseSequence() {
+ size_t saved_read_index = read_index_;
+ unsigned char seq;
+ char ch;
+ if (GetWord8(&seq) && GetRawChar(&ch)) {
+ if (ch == ':') {
+ SetSequence(seq);
+ return;
+ }
+ }
+ // No sequence number present, so reset to original position.
+ read_index_ = saved_read_index;
+}
+
+void Packet::SetSequence(int32_t val) { seq_ = val; }
+
+void Packet::SetError(ErrDef error) {
+ Clear();
+ AddRawChar('E');
+ AddWord8(static_cast<uint8_t>(error));
+}
+
+std::string Packet::GetPacketData() const {
+ char chars[2];
+ const char* ptr = GetPayload();
+ size_t size = GetPayloadSize();
+
+ std::stringstream outstr;
+
+ // Signal start of response
+ outstr << '$';
+
+ char run_xsum = 0;
+
+ // If there is a sequence, send as two nibble 8bit value + ':'
+ int32_t seq;
+ if (GetSequence(&seq)) {
+ UInt8ToHex(seq, chars);
+ outstr << chars[0];
+ run_xsum += chars[0];
+ outstr << chars[1];
+ run_xsum += chars[1];
+
+ outstr << ':';
+ run_xsum += ':';
+ }
+
+ // Send the main payload
+ for (size_t offs = 0; offs < size; ++offs) {
+ outstr << ptr[offs];
+ run_xsum += ptr[offs];
+ }
+
+ // Send XSUM as two nibble 8bit value preceeded by '#'
+ outstr << '#';
+ UInt8ToHex(run_xsum, chars);
+ outstr << chars[0];
+ outstr << chars[1];
+
+ return outstr.str();
+}
+
+} // namespace gdb_server
+} // namespace wasm
+} // namespace internal
+} // namespace v8