: m_queryHandler(makeUnique<QueryHandler>(*this))

, m_memoryHandler(makeUnique<MemoryHandler>(*this))

{

{

// Guard against concurrent start() calls from $.agent.start() workers in the jsc shell

// and against the createAndBindServerSocket() race below.

static Lock initLock;

Locker locker { initLock };

if (isInService())

return true;

if (!createAndBindServerSocket())

return false;

RELEASE_ASSERT(isSocketValid(m_serverSocket));

m_moduleManager = makeUnique<ModuleManager>();

m_executionHandler = makeUnique<ExecutionHandler>(*this, *m_moduleManager);

setIsInService();

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Wasm Debug Server listening. Connect with: lldb -o 'gdb-remote localhost:", m_port, "'");

startAcceptThread();

return true;

{

m_moduleManager = makeUnique<ModuleManager>();

m_executionHandler = makeUnique<ExecutionHandler>(*this, *m_moduleManager);

m_rwiResponseHandler = WTF::move(rwiResponseHandler);

setIsInService();

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Wasm Debug Server started in RWI mode (WorkQueue-based)");

{

// 1. Create socket

m_serverSocket = socket(AF_INET, SOCK_STREAM, 0);

if (!isSocketValid(m_serverSocket)) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Failed to create socket");

return false;

}

// 2. Set socket options for better reusability

int opt = 1;

#if OS(WINDOWS)

const char* optPtr = reinterpret_cast<const char*>(&opt);

#else

const void* optPtr = &opt;

#endif

if (setsockopt(m_serverSocket, SOL_SOCKET, SO_REUSEADDR, optPtr, sizeof(opt)) < 0) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Warning: Failed to set SO_REUSEADDR");

// Continue anyway, this is not critical

}

// 3. Bind to address and port

sockaddr_in address;

address.sin_family = AF_INET;

address.sin_addr.s_addr = htonl(INADDR_LOOPBACK); // Bind to localhost only

address.sin_port = htons(m_port);

SocketAddress bindAddress(address);

if (bind(m_serverSocket, &bindAddress.generic, sizeof(sockaddr_in)) < 0) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Failed to bind socket to port ", m_port);

closeSocket(m_serverSocket);

return false;

}

// 4. Start listening

if (listen(m_serverSocket, 1) < 0) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Failed to listen on socket");

closeSocket(m_serverSocket);

return false;

}

return true;

{

m_acceptThread = WTF::Thread::create("WasmDebugServer", [this]() {

m_executionHandler->setDebugServerThreadId(Thread::currentSingleton().uid());

while (isInService()) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Waiting for client connections...");

SocketAddress clientAddress;

socklen_t clientLen = sizeof(clientAddress.in);

SocketType clientSocket = accept(m_serverSocket, &clientAddress.generic, &clientLen);

if (isSocketValid(clientSocket)) {

m_clientSocket = clientSocket;

handleClient();

} else

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Accept failed, continuing...");

}

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Accept thread exiting");

});

{

ASSERT(&socket == &m_serverSocket || &socket == &m_clientSocket);

if (isSocketValid(socket)) {

#if OS(WINDOWS)

::closesocket(socket);

#else

::close(socket);

#endif

socket = invalidSocketValue;

}

{

// Reset to the init state without stopping the debug server.

m_hasSentLibraryList.store(false, std::memory_order_release);

m_hasContinued.store(false, std::memory_order_release);

m_noAckMode = false;

m_packetParser.reset();

// m_hasSentLibraryList=false before reset() gates new traps; socket closed after so

// isConnected() stays true for wasmDebuggerOnResumeCallback() during resumeImpl().

m_executionHandler->reset();

closeSocket(m_clientSocket);

{

dataLog("[Debugger] recv() returned ", buffer.size(), " bytes: ");

GDBPacketParser::dumpBuffer(buffer);

dataLogLn();

{

RELEASE_ASSERT(isSocketValid(m_clientSocket));

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Client connected (TCP socket mode), starting handler - process continues running normally");

// Send initial acknowledgment - client expects this immediately.

sendAck();

m_packetParser.reset();

constexpr size_t RECV_BUFFER_SIZE = 4096;

std::array<char, RECV_BUFFER_SIZE> recvBuffer;

while (true) {

auto bytesRead = recv(m_clientSocket, recvBuffer.data(), RECV_BUFFER_SIZE, 0);

if (bytesRead <= 0) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Client disconnected (bytesRead=", bytesRead, ")");

break;

}

if (Options::verboseWasmDebugger())

dumpReceivedBytes({ byteCast<uint8_t>(recvBuffer.data()), static_cast<size_t>(bytesRead) });

for (std::ptrdiff_t i = 0; i < bytesRead; i++) {

auto result = m_packetParser.processByte(static_cast<uint8_t>(recvBuffer[i]));

switch (result) {

case GDBPacketParser::ParseResult::CompletePacket: {

StringView packet = m_packetParser.getCompletedPacket();

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Complete packet received: ", packet);

handlePacket(packet);

break;

}

case GDBPacketParser::ParseResult::Error:

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Parse error - disconnecting client");

goto clientDisconnect;

case GDBPacketParser::ParseResult::Incomplete:

break;

}

}

if (!m_packetParser.isIdle())

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] After recv: incomplete packet (", m_packetParser, ")");

}

clientDisconnect:

// FIXME: Currently client disconnect, kill, and quit commands just stop the client session only for easy debugging purposes.

// Eventually we need to introduce various stop states, e.g., termination.

reset();

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Client disconnected (TCP socket mode)");

{

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

#if ENABLE(REMOTE_INSPECTOR)

if (isRWIMode())

m_executionHandler->setDebugServerThreadId(Thread::currentSingleton().uid());

#endif

sendAck();

if (packet.isEmpty()) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Empty packet received");

sendErrorReply(ProtocolError::InvalidPacket);

return;

}

if (packet.length() == 1 && packet[0] == 0x03) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Received Ctrl+C interrupt - triggering stack overflow");

m_executionHandler->interrupt();

return;

}

switch (packet[0]) {

case 'q':

case 'Q':

case 'j':

// Handle all query packets (q*, Q*) and JSON packets (j*)

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Routing query packet to QueryHandler");

m_queryHandler->handleGeneralQuery(packet);

break;

// See reference [3] in wasm/debugger/README.md

case 'm':

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Routing memory read packet to MemoryHandler");

m_memoryHandler->read(packet);

break;

case 'M':

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Routing memory write packet to MemoryHandler");

m_memoryHandler->write(packet);

break;

case 'c':

case 'C':

// 'C' is ContinueWithSignal — LLDB sends C<sig> instead of 'c' when resuming from a

// signal stop (e.g. T05/SIGTRAP). Signal re-delivery is a ptrace concept; we have no

// OS-level signal injection so the signal number is irrelevant — treat identically to 'c'.

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Routing continue packet to ExecutionHandler");

m_executionHandler->resume();

m_hasContinued.store(true, std::memory_order_release);

break;

case 's':

case 'S':

// 'S' is StepWithSignal — same reasoning as 'C': signal re-delivery does not apply

// to our WASM VM, so ignore the signal number and treat identically to plain 's'.

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Routing step packet to ExecutionHandler");

m_executionHandler->step();

break;

case 'Z':

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Routing set breakpoint packet to ExecutionHandler");

m_executionHandler->setBreakpoint(packet);

break;

case 'z':

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Routing remove breakpoint packet to ExecutionHandler");

m_executionHandler->removeBreakpoint(packet);

break;

case 'H':

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Routing thread management packet to handleThreadManagement");

handleThreadManagement(packet);

break;

case '?':

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Routing halt reason query to ExecutionHandler");

m_executionHandler->interrupt();

break;

case 'k':

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Kill request");

// FIXME: Currently just closes the debug session without actually terminating the WebAssembly process.

// Per GDB Remote Protocol, kill should terminate the target process if possible.

reset();

break;

case 'D':

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Detach request");

sendReplyOK();

reset();

break;

default:

sendReplyNotSupported(packet);

}

{

// Send '+' ACK character to acknowledge packet receipt

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

if (m_noAckMode)

return;

sendReply("+"_s);

{

// Send 'OK' reply to indicate successful completion

// Reference: [3] and [4] in wasm/debugger/README.md

sendReply("OK"_s);

{

// Send empty reply to indicate feature/command not supported

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

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

sendReply(""_s);

{

// Send 'E NN' error reply with specific error code

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

sendReply(getErrorReply(error));

{

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Processing thread management packet (Hg, Hc, Hp): ", packet);

if (packet.length() < 2) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Invalid H packet - too short");

sendErrorReply(ProtocolError::InvalidPacket);

return;

}

char operation = packet[1];

StringView threadSpec = packet.substring(2);

switch (operation) {

case 'c': {

// Hc<thread-id>: Set thread for step and continue operations

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Hc (set continue thread): ", threadSpec);

if (threadSpec == "-1" || threadSpec == "0") {

// -1 = all threads, 0 = any thread: 's' steps the debuggee, 'c' resumes every VM.

execution().setContinueDebuggeeOnly(false);

sendReplyOK();

} else if (auto threadId = parseHexStrict(threadSpec)) {

// Switch the debuggee to this VM, and run only it on the next 'c', until the next Hc.

if (execution().switchTarget(*threadId)) {

execution().setContinueDebuggeeOnly(true);

sendReplyOK();

} else

sendErrorReply(ProtocolError::InvalidPacket);

} else

sendErrorReply(ProtocolError::InvalidPacket);

break;

}

case 'g': {

// Hg<thread-id>: set the thread for register/memory/variable reads.

// FIXME: support this in a follow-up — route the reads to the named VM so a non-current

// thread's variables can be read; E02 makes LLDB fall back to the debuggee (wrong thread).

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Hg (set general thread): ", threadSpec);

sendErrorReply(ProtocolError::InvalidAddress);

break;

}

default:

sendReplyNotSupported(packet);

break;

}

{

if (!m_moduleManager)

return;

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Tracking WebAssembly instance: ", RawPointer(instance));

// Instantiation, not compilation, is what the debugger tracks, for two reasons:

// 1. Module::create covers both the synchronous and streaming-async compilation paths.

// In the async path the JS thread is not at a JS safepoint when the module is created,

// so a stop-the-world request would only fire at the next safepoint — too late for the

// debugger to intercept the load. By the time trackInstance is called the JS thread is

// back at a safepoint and we can stop immediately.

// 2. A Module can be compiled speculatively without ever being instantiated (e.g. via

// WebAssembly.compile). Only when a JSWebAssemblyInstance is created do we know the

// module will actually be used, making this the right moment to notify LLDB.

// Every instance is a library of its own, so a second instance of a known module is a load

// LLDB has to hear about too.

m_moduleManager->registerInstance(instance);

if (hasSentLibraryList())

m_executionHandler->notifyDebuggerOfNewInstance(instance->vm());

{

if (!isInService())

return false;

#if ENABLE(REMOTE_INSPECTOR)

if (isRWIMode())

return true;

#endif

return isSocketValid(m_clientSocket);