{

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Handling query: ", packet);

if (packet.startsWith("QStartNoAckMode"_s))

handleStartNoAckMode();

else if (packet.startsWith("qSupported"_s))

handleSupported();

else if (packet.startsWith("QListThreadsInStopReply"_s))

handleListThreadsInStopReply();

else if (packet.startsWith("QEnableErrorStrings"_s))

handleEnableErrorStrings();

else if (packet.startsWith("qThreadStopInfo"_s))

handleThreadStopInfo(packet);

else if (packet.startsWith("qHostInfo"_s))

handleHostInfo();

else if (packet.startsWith("qProcessInfo"_s))

handleProcessInfo();

else if (packet.startsWith("qRegisterInfo"_s))

handleRegisterInfo(packet);

else if (packet.startsWith("qXfer:libraries:read::"_s))

handleLibrariesRead(packet);

else if (packet.startsWith("qWasmCallStack:"_s))

handleWasmCallStack(packet);

else if (packet.startsWith("qWasmLocal:"_s))

handleWasmLocal(packet);

else if (packet.startsWith("qWasmGlobal:"_s))

handleWasmGlobal(packet);

else if (packet.startsWith("qMemoryRegionInfo:"_s))

m_debugServer.m_memoryHandler->handleMemoryRegionInfo(packet);

else

m_debugServer.sendReplyNotSupported(packet);

{

// Format: qProcessInfo

// LLDB: Query process information for debugging context

// Reference: [8] in wasm/debugger/README.md

// WebAssembly Context: Provide WASM process info with simulated PID and WASI target

// This helps LLDB understand the WebAssembly execution environment

String tripleHex = stringToHex("wasm32-webkit-wasi"_s);

String processInfo = makeString(

"pid:1;"_s, // Process ID (simulated for WASM debugging)

"parent-pid:1;"_s, // Parent process ID (simulated)

"vendor:webkit;"_s, // WebKit/JavaScriptCore (identifies JSC's WASM debugger)

"ostype:wasi;"_s, // WASI (WebAssembly System Interface)

"arch:wasm32;"_s, // WebAssembly 32-bit architecture

"triple:"_s, tripleHex, ";"_s, // Target triple: wasm32-webkit-wasi (hex encoded)

"endian:little;"_s, // Little-endian byte order

"ptrsize:4;"_s // 32-bit pointers

);

m_debugServer.sendReply(processInfo);

{

// Format: qHostInfo

// LLDB: Query host system information for debugging setup

// Reference: [9] in wasm/debugger/README.md

// WebAssembly Context: Provide host info for WASM execution environment

// This tells LLDB about the WebAssembly runtime characteristics

String tripleHex = stringToHex("wasm32-webkit-wasi"_s);

String hostInfo = makeString(

"vendor:webkit;"_s, // WebKit/JavaScriptCore (identifies JSC's WASM debugger)

"ostype:wasi;"_s, // WASI (WebAssembly System Interface)

"arch:wasm32;"_s, // WebAssembly 32-bit architecture

"triple:"_s, tripleHex, ";"_s, // Target triple: wasm32-webkit-wasi-wasm (hex encoded)

"endian:little;"_s, // Little-endian byte order

"ptrsize:4;"_s // 32-bit pointers

);

m_debugServer.sendReply(hostInfo);

{

// Format: qRegisterInfo<hex-reg-id>

// LLDB: Query register information for specific register ID

// Reference: [10] in wasm/debugger/README.md

// WebAssembly Context: WASM only exposes PC register for debugging

// Other registers are internal to the WASM runtime and not accessible

StringView regNumStr = packet.substring(strlen("qRegisterInfo"));

int regNum = static_cast<int>(parseHex(regNumStr));

if (!regNum) {

// PC register definition for WebAssembly debugging

String registerInfo = makeString(

"name:pc;"_s, // Program Counter register name

"alt-name:pc;"_s, // Alternative name (same as primary)

"bitsize:64;"_s, // 64-bit register size

"offset:0;"_s, // Located at byte offset 0 in register context

"encoding:uint;"_s, // Interpret contents as unsigned integer

"format:hex;"_s, // Display in hexadecimal format by default

"set:General Purpose Registers;"_s, // Belongs to GP register group

"gcc:16;"_s, // GCC compiler register number

"dwarf:16;"_s, // DWARF debug info register number

"generic:pc;"_s // Generic register type (program counter)

);

m_debugServer.sendReply(registerInfo);

} else {

// Only PC register is supported - return error for all others

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Returning error for register ", regNum, " (only PC supported)");

m_debugServer.sendErrorReply(ProtocolError::InvalidRegister);

}

{

StringView offsetPart = packet.substring(strlen("qXfer:libraries:read::"));

// Use splitWithDelimiters for consistent parsing

auto parts = splitWithDelimiters(offsetPart, ","_s);

if (parts.size() != 2)

return false;

offset = parseHex(parts[0]);

maxSize = parseHex(parts[1]);

return true;

{

String xmlData = m_debugServer.m_moduleManager->generateLibrariesXML();

// Handle chunked response according to GDB Remote Protocol

// 'm' prefix = more data follows

// 'l' prefix = last chunk

if (offset >= xmlData.length()) {

response = "l"_s;

return true;

}

size_t availableData = xmlData.length() - offset;

size_t chunkSize = std::min(maxSize, availableData);

String chunk = xmlData.substring(offset, chunkSize);

bool isLastChunk = (offset + chunkSize >= xmlData.length());

StringBuilder result;

result.append(isLastChunk ? 'l' : 'm');

result.append(chunk);

response = result.toString();

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Chunked library response: ", (isLastChunk ? 'l' : 'm'), " offset=", offset, ", chunk_size=", chunkSize, ", total=", xmlData.length());

return true;

{

// Format: QStartNoAckMode

// LLDB: Ask to disable ACK mode - acknowledge this

// Reference: [6] in wasm/debugger/README.md

// OK - WASM debugger supports no-ACK mode for better performance

m_debugServer.sendReplyOK();

m_debugServer.m_noAckMode = true;

{

// Format: qSupported[:feature[;feature]...]

// LLDB: Query supported features and packet size

// Reference: [7] in wasm/debugger/README.md

// WebAssembly Context: We support qXfer:libraries:read+ to let LLDB discover WASM modules

// This allows LLDB to see loaded WebAssembly modules as "libraries" for debugging

String supportedFeatures = makeString(

"qXfer:libraries:read+;"_s, // Support library list transfer for WASM modules

"PacketSize=1000;"_s // Maximum packet size for data transfer

);

m_debugServer.sendReply(supportedFeatures);

{

// Format: QListThreadsInStopReply

// LLDB: Ask to include thread list in stop replies for better debugging

// Reference: [11] in wasm/debugger/README.md

// WebAssembly Context: WASM typically runs in single thread, so this is simple to support

// We can easily include our single main thread in stop replies

m_debugServer.sendReplyOK();

{

// Format: QEnableErrorStrings

// LLDB: Enable error strings in replies for better debugging experience

// Reference: [12] in wasm/debugger/README.md

// WebAssembly Context: Error strings help debug WASM execution issues

// Useful for reporting WASM trap conditions and runtime errors

m_debugServer.sendReplyOK();

{

// Format: qThreadStopInfo<thread-id>

// LLDB: Get stop info for specific thread (needed for frame variable)

// Reference: [13] in wasm/debugger/README.md

// WebAssembly Context: Provide stop reason for WASM thread

// Handled by execution handler for proper thread state management

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Handling qThreadStopInfo for frame variable support");

m_debugServer.execution().handleThreadStopInfo(packet);

{

// Format: qXfer:libraries:read::<offset>,<length>

// LLDB: Transfer library list XML for module discovery

// Reference: [14] in wasm/debugger/README.md

// WebAssembly Context: Provide WASM modules as "libraries" for LLDB

// This allows LLDB to discover and debug loaded WebAssembly modules

size_t offset, maxSize;

if (!parseLibrariesReadPacket(packet, offset, maxSize)) {

m_debugServer.sendErrorReply(ProtocolError::InvalidPacket);

return;

}

String response;

if (handleChunkedLibrariesResponse(offset, maxSize, response)) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Sending library list chunk: offset=", offset, ", maxSize=", maxSize);

m_debugServer.sendReply(response);

// Only mark modules notified and signal debugger-ready on the final chunk ('l' prefix).

if (response[0] == 'l') {

m_debugServer.m_isDebuggerReady.store(true, std::memory_order_release);

m_debugServer.moduleManager().notifyLibraryRequeryComplete();

}

} else {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Failed to generate library list chunk");

m_debugServer.sendErrorReply(ProtocolError::MemoryError);

}

{

// Format: qWasmCallStack:<thread-id-in-hex>

// LLDB: Get WebAssembly call stack information for disassembly display

// Reference: [15] in wasm/debugger/README.md

// WebAssembly Context: This packet is essential for LLDB to show proper WASM disassembly

// with source lines, instruction details, and frame information

auto strings = splitWithDelimiters(packet, ":"_s);

if (strings.size() != 2) {

m_debugServer.sendErrorReply(ProtocolError::InvalidPacket);

return;

}

StringView threadIdStr = strings[1];

uint64_t requestedThreadId = parseHex(threadIdStr);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] qWasmCallStack thread ID: ", requestedThreadId);

String response = m_debugServer.execution().callStackStringFor(requestedThreadId);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] qWasmCallStack response: ", response);

if (response.isEmpty()) {

m_debugServer.sendErrorReply(ProtocolError::InvalidPacket);

return;

}

m_debugServer.sendReply(response);

{

switch (kind) {

#define CREATE_CASE(name, id, b3type, inc, wasmName, width, ...) \

case TypeKind::name: \

return width;

FOR_EACH_WASM_TYPE(CREATE_CASE)

#undef CREATE_CASE

}

return 0;

{

// Format: qWasmLocal:<frame-index>;<variable-index>

// LLDB: Get value of WebAssembly local variable (function argument or local)

// Reference: [16] in wasm/debugger/README.md

// WebAssembly Context: Access function locals and parameters for debugging

// Return local value or address based on variable type

auto parts = splitWithDelimiters(packet, ":;"_s);

if (parts.size() != 3) {

m_debugServer.sendErrorReply(ProtocolError::InvalidPacket);

return;

}

uint32_t frameIndex = parseDecimal(parts[1]);

uint32_t localIndex = parseDecimal(parts[2]);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] qWasmLocal frame=", frameIndex, ", variable=", localIndex);

auto* state = m_debugServer.execution().debuggeeStateForTest();

if (state->isStoppedAtSystemCall() || state->isStoppedAtPrologue()) {

m_debugServer.sendErrorReply(ProtocolError::UnknownCommand);

return;

}

auto& stopData = *state->stopData;

CallFrame* localCallFrame = nullptr;

RefPtr<IPIntCallee> localCallee;

JSWebAssemblyInstance* instance = nullptr;

if (!frameIndex) {

localCallFrame = stopData.callFrame;

localCallee = stopData.callee;

instance = stopData.instance;

} else {

auto frames = collectCallStack(stopData.address, stopData.callFrame, stopData.instance->vm());

if (frameIndex >= frames.size() || !frames[frameIndex].isWasmFrame()) {

m_debugServer.sendErrorReply(ProtocolError::UnknownCommand);

return;

}

const auto& frameInfo = frames[frameIndex];

localCallFrame = frameInfo.wasmCallFrame;

localCallee = frameInfo.wasmCallee;

instance = frameInfo.wasmCallFrame->wasmInstance();

}

auto functionIndex = localCallee->functionIndex();

const auto& moduleInfo = instance->module().moduleInformation();

const Vector<Type>& localTypes = moduleInfo.debugInfo->ensureFunctionDebugInfo(functionIndex).locals;

if (localIndex >= localTypes.size()) {

m_debugServer.sendErrorReply(ProtocolError::InvalidPacket);

return;

}

IPInt::FrameAccess frame(localCallFrame, localCallee.get());

IPInt::IPIntLocal& local = *frame.localSlot(localIndex);

Type localType = localTypes[localIndex];

logWasmLocalValue(localIndex, local, localType);

String response;

uint32_t width = typeKindToWidth(localType.kind);

switch (width) {

case 32: {

response = toNativeEndianHex(local.i32);

break;

}

case 64: {

response = toNativeEndianHex(local.i64);

break;

}

case 128: {

RELEASE_ASSERT(localType.kind == TypeKind::V128, "Expected V128 for 128-bit type");

response = toNativeEndianHex(local.v128);

break;

}

default:

RELEASE_ASSERT(false, "Unsupported TypeKind bit size: ", width, " for TypeKind: ", localType.kind);

break;

}

m_debugServer.sendReply(response);

{

// Format: qWasmGlobal:<frame-index>;<variable-index>

// LLDB: Get value of WebAssembly global variable for a given frame's instance

// Reference: https://lldb.llvm.org/resources/lldbgdbremote.html#qwasmglobal

// WebAssembly Context: Globals are per-instance; the frame index identifies which

// WASM instance to read from, and variable-index is the global index within that instance.

auto parts = splitWithDelimiters(packet, ":;"_s);

if (parts.size() != 3) {

m_debugServer.sendErrorReply(ProtocolError::InvalidPacket);

return;

}

uint32_t frameIndex = parseDecimal(parts[1]);

uint32_t globalIndex = parseDecimal(parts[2]);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] qWasmGlobal frame=", frameIndex, ", global=", globalIndex);

auto* state = m_debugServer.execution().debuggeeStateForTest();

if (state->isStoppedAtSystemCall()) {

m_debugServer.sendErrorReply(ProtocolError::UnknownCommand);

return;

}

auto& stopData = *state->stopData;

JSWebAssemblyInstance* instance = nullptr;

if (!frameIndex)

instance = stopData.instance;

else {

auto frames = collectCallStack(stopData.address, stopData.callFrame, stopData.instance->vm());

if (frameIndex >= frames.size() || !frames[frameIndex].isWasmFrame()) {

m_debugServer.sendErrorReply(ProtocolError::UnknownCommand);

return;

}

instance = frames[frameIndex].wasmCallFrame->wasmInstance();

}

const auto& moduleInfo = instance->module().moduleInformation();

if (globalIndex >= moduleInfo.globalCount()) {

m_debugServer.sendErrorReply(ProtocolError::InvalidPacket);

return;

}

Type globalType = moduleInfo.global(globalIndex).type;

uint32_t width = typeKindToWidth(globalType.kind);

String response;

switch (width) {

case 32:

response = toNativeEndianHex(static_cast<uint32_t>(instance->loadI32Global(globalIndex)));

break;

case 64:

response = toNativeEndianHex(static_cast<uint64_t>(instance->loadI64Global(globalIndex)));

break;

case 128:

response = toNativeEndianHex(instance->loadV128Global(globalIndex));

break;

default:

RELEASE_ASSERT_NOT_REACHED();

break;

}

m_debugServer.sendReply(response);