// 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