{

RELEASE_ASSERT(state.stopReason.has_value());

switch (*state.stopReason) {

case DebugState::Reason::Interrupted:

return { signalStopString(SIGSTOP), "signal"_s };

case DebugState::Reason::Breakpoint:

return { signalStopString(SIGTRAP), "breakpoint"_s };

case DebugState::Reason::Step:

return { signalStopString(SIGTRAP), "trace"_s };

case DebugState::Reason::WasmTrap:

return { signalStopString(SIGTRAP), "exception"_s };

}

RELEASE_ASSERT_NOT_REACHED();

: m_debugServer(debugServer)

, m_moduleManager(instanceManager)

, m_breakpointManager(makeUnique<BreakpointManager>())

{

{

auto info = VMManager::info();

dataLogLnIf(Options::verboseWasmDebugger(), "[stopTheWorld] debuggee:", RawPointer(&debuggee), " event:", event, " ", info);

{

Locker locker { m_lock };

switch (event) {

case StopTheWorldEvent::WasmStepIntoSiteReached:

RELEASE_ASSERT(m_debuggee == info.targetVM && info.targetVM == info.servingVM && info.worldMode == VMManager::Mode::RunOne);

break;

case StopTheWorldEvent::WasmProgramStop:

RELEASE_ASSERT(info.worldMode != VMManager::Mode::Stopped);

break;

default:

RELEASE_ASSERT_NOT_REACHED();

break;

}

// Wait for previous resume all to prevent reenter notifyVMStop.

while (m_awaitingResumeNotification)

m_debuggeeContinue.wait(m_lock);

m_debuggee = &debuggee;

}

VMManager::requestStopAll(VMManager::StopReason::WasmDebugger);

VMManager::singleton().notifyVMStop(debuggee, event);

{

VM& debuggee = instance->vm();

if (exceptionType == Wasm::ExceptionType::Unreachable) {

VirtualAddress address = VirtualAddress::toVirtual(instance, callee->functionIndex(), pc);

if (auto action = m_breakpointManager->trapActionFor(pc, address)) {

if (action->stopType) {

debuggee.debugState()->setBreakpointStopData(*action->stopType, address, action->displacedOpcode, pc, mc, stack, callee, instance, callFrame);

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][handleDebuggerTrapIfNeeded] Breakpoint with ", *debuggee.debugState()->stopData);

stopTheWorld(debuggee, StopTheWorldEvent::WasmProgramStop);

} else {

// A sibling instance's site patched this byte, and a site only speaks for the

// instance it names.

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][handleDebuggerTrapIfNeeded] No site for ", address, ", resuming through the patch");

}

// The patch displaced Unreachable only where the bytecode really is an `unreachable`,

// so fall through and report that trap too: returning it here would throw a trap LLDB

// was never told about. Otherwise resuming dispatches the displaced opcode.

if (action->displacedOpcode != OpType::Unreachable)

return action->displacedOpcode;

}

}

if (!m_debugServer.hasSentLibraryList())

return OpType::Unreachable; // Throw; LLDB has no module list to resolve a stop against

if (exceptionType == Wasm::ExceptionType::StackOverflow || exceptionType == Wasm::ExceptionType::Termination) {

// Prologue trap: pc/mc/stack are caller's, not the overflowing function's.

// handleTrapsIfNeeded() may have already processed a NeedStopTheWorld trap,

// serving a debugger stop and clearing stopData via clearStop(); re-establish

// prologue context if needed.

if (!debuggee.debugState()->stopData)

debuggee.debugState()->setPrologueStopData(instance, callee, callFrame);

debuggee.debugState()->stopReason = DebugState::Reason::WasmTrap;

debuggee.debugState()->stopData->wasmTrapType = exceptionType;

} else

debuggee.debugState()->setTrapStopData(callee, instance, callFrame, pc, mc, stack, exceptionType);

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][handleDebuggerTrapIfNeeded] Wasm trap at ", *debuggee.debugState()->stopData);

stopTheWorld(debuggee, StopTheWorldEvent::WasmProgramStop);

return OpType::Unreachable; // Throw; trap was reported, now propagate it

{

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][Stop] Start with event:", event);

auto notifyDebuggerOfStop = [&]() WTF_REQUIRES_LOCK(m_lock) {

if (m_debuggerState == DebuggerState::ContinueRequested) {

sendStopReply(locker);

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][Stop] Sent a stop reply and waiting...");

} else {

RELEASE_ASSERT(requiresStopConfirmation());

m_debuggerContinue.notifyOne(); // Notify debugger that code stopped.

}

};

// Handle stop event and notify debugger

switch (event) {

case StopTheWorldEvent::VMStopped:

case StopTheWorldEvent::VMCreated:

case StopTheWorldEvent::VMActivated:

case StopTheWorldEvent::AtomicsWaitBlocked:

RELEASE_ASSERT(m_debuggerState == DebuggerState::InterruptRequested || m_debuggerState == DebuggerState::SwitchRequested);

m_breakpointManager->clearAllOneTimeBreakpoints();

notifyDebuggerOfStop();

break;

case StopTheWorldEvent::WasmProgramStop:

RELEASE_ASSERT(m_debuggerState == DebuggerState::StepRequested || m_debuggerState == DebuggerState::ContinueRequested || m_debuggerState == DebuggerState::SwitchRequested);

// FIXME: For module-load stops (isNewModuleLoad), step breakpoints should be preserved

// so the in-progress step can complete after LLDB resumes. Clearing them here silently

// cancels any active step. This also affects future LLDB expression evaluation, which can

// trigger module loads internally and should not interrupt a step.

m_breakpointManager->clearAllOneTimeBreakpoints();

notifyDebuggerOfStop();

break;

case StopTheWorldEvent::WasmStepIntoSiteReached:

RELEASE_ASSERT(m_debuggerState == DebuggerState::StepRequested);

m_debuggerContinue.notifyOne(); // Notify that breakpoint is set.

break;

default:

RELEASE_ASSERT_NOT_REACHED();

}

// Wait for debugger command

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][Stop] Waiting for debugger command...");

m_debuggeeContinue.wait(locker); // Wait for resume mode to be set.

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][Stop] Unblocked and running...");

// Determine resume mode

if (m_debuggerState == DebuggerState::SwitchRequested)

return ResumeMode::Switch;

// Defer debugger notification until after VMs resume to prevent interrupt() race.

if (m_debuggerState == DebuggerState::ContinueRequested)

m_awaitingResumeNotification = true;

return (m_debuggerState == DebuggerState::StepRequested) ? ResumeMode::One : ResumeMode::All;

{

dataLogLnIf(Options::verboseWasmDebugger(), "[STW] handleStopTheWorld() begin with event:", event, " debuggee:", RawPointer(&debuggee));

Locker locker { m_lock };

selectDebuggeeIfNeeded(debuggee);

RELEASE_ASSERT(m_debuggee);

// If debuggee differs from candidate, switch to debuggee.

if (m_debuggee != &debuggee) {

dataLogLnIf(Options::verboseWasmDebugger(), "[STW] Context switch to debuggee VM");

return STW_CONTEXT_SWITCH(m_debuggee);

}

// Stop the code and let debugger decide resume mode.

ExecutionHandler::ResumeMode mode = stopCode(locker, event);

switch (mode) {

case ExecutionHandler::ResumeMode::One:

return STW_RESUME_ONE(m_debuggee);

case ExecutionHandler::ResumeMode::All:

m_debuggee = nullptr;

return STW_RESUME_ALL();

case ExecutionHandler::ResumeMode::Switch:

RELEASE_ASSERT(m_debuggee != &debuggee);

RELEASE_ASSERT(debuggee.debugState()->isStopped);

RELEASE_ASSERT(m_debuggee->debugState()->isStopped);

return STW_CONTEXT_SWITCH(m_debuggee);

}

RELEASE_ASSERT_NOT_REACHED();

return STW_RESUME_ALL();

{

if (m_debuggee) {

dataLogLnIf(Options::verboseWasmDebugger(), "[STW] Already have debuggee VM:", RawPointer(m_debuggee));

return;

}

// Prefer any non-system call.

// FIXME: We should prioritize with WASM traps > non-system calls > system calls.

VM* selectedVM = nullptr;

VMManager::forEachVM([&](VM& vm) {

auto* debugState = vm.debugState();

if (vm.debugState()->isStopped && !debugState->isStoppedAtSystemCall()) {

selectedVM = &vm;

return IterationStatus::Done;

}

return IterationStatus::Continue;

});

m_debuggee = selectedVM ? selectedVM : &fallbackVM;

dataLogLnIf(Options::verboseWasmDebugger(), "[STW] Selected debuggee VM:", RawPointer(m_debuggee));

{

dataLogLnIf(Options::verboseWasmDebugger(), "[STW] Callback invoked with event:", event);

auto& server = DebugServer::singleton();

if (!server.isConnected()) {

dataLogLnIf(Options::verboseWasmDebugger(), "[STW] Not connected, resuming all");

return STW_RESUME_ALL();

}

return server.execution().handleStopTheWorld(debuggee, event);

{

Locker locker { m_lock };

if (takeAwaitingResumeNotification()) {

dataLogLnIf(Options::verboseWasmDebugger(), "[PostResume] Notify debugger to continue");

m_debuggerContinue.notifyOne(); // Notify that resume is complete.

m_debuggeeContinue.notifyAll(); // Release resume barrier for VMs blocked in stopTheWorld().

}

{

auto& server = DebugServer::singleton();

if (!server.isConnected()) {

dataLogLnIf(Options::verboseWasmDebugger(), "[STW][PostResume] Not connected, resuming all");

return;

}

server.execution().handlePostResume();

{

Locker locker { m_lock };

resumeImpl(locker);

{

RELEASE_ASSERT(Thread::currentSingleton().uid() == debugServerThreadId());

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Continue] Start");

RELEASE_ASSERT(debuggeeState()->isStopped);

m_debuggerState = DebuggerState::ContinueRequested;

m_debuggeeContinue.notifyOne(); // Notify debuggee VM with resume all command.

// Wait for resume to complete to prevent interrupt() from acquiring lock before VMs resume.

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Continue] Notified code to continue and waiting...");

m_debuggerContinue.wait(locker); // Wait for resume to complete.

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Continue] Confirmed that code is running...");

{

vm.debugState()->isNewModuleLoad = true;

stopTheWorld(vm, StopTheWorldEvent::WasmProgramStop);

{

RELEASE_ASSERT(Thread::currentSingleton().uid() == debugServerThreadId());

Locker locker { m_lock };

VM* newDebuggee = findVM(vmId);

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][SwitchVM] current debuggee=", RawPointer(m_debuggee), " new debuggee=", RawPointer(newDebuggee));

if (m_debuggee == newDebuggee)

return;

RELEASE_ASSERT(debuggeeState()->isStopped);

m_debuggee = newDebuggee;

m_debuggerState = DebuggerState::SwitchRequested;

m_debuggeeContinue.notifyOne(); // Notify to switch VM context.

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][SwitchVM] Notified code to continue and switch VM, waiting...");

m_debuggerContinue.wait(locker); // Wait for new debuggee VM to stop.

RELEASE_ASSERT(debuggeeState()->isStopped);

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][SwitchVM] Code is stopped");

{

RELEASE_ASSERT(Thread::currentSingleton().uid() == debugServerThreadId());

Locker locker { m_lock };

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Interrupt] Start");

// LLDB implements interrupt flood prevention: once LLDB sends the first interrupt packet,

// no matter how many Ctrl+C the user types, LLDB will not send additional interrupt packets

// until it receives a stop reply. This prevents packet flooding and ensures clean protocol behavior.

// Our WebKit implementation handles each interrupt request by activating StopWorld via VM traps.

{

RELEASE_ASSERT(!m_debuggee || !debuggeeState()->isStopped);

m_debuggerState = DebuggerState::InterruptRequested;

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Interrupt] Calling VMManager::requestStopAll()...");

VMManager::singleton().requestStopAll(VMManager::StopReason::WasmDebugger);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Interrupt] VMManager::requestStopAll() returned");

}

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Interrupt] Notified code to stop, waiting...");

m_debuggerContinue.wait(locker); // Wait for debuggee VM to stop.

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Interrupt] Wait completed, sending stop reply...");

sendStopReply(locker);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Interrupt] Code is stopped and debugger replied");

{

RELEASE_ASSERT(Thread::currentSingleton().uid() == debugServerThreadId());

Locker locker { m_lock };

auto* state = debuggeeState();

RELEASE_ASSERT(m_debuggerState == DebuggerState::Replied && state->isStopped);

bool resumeAll = false;

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

// There is no valid next WASM instruction to step to in either case.

// For traps (including StackOverflow at prologue), execution unwinds back to JS —

// resuming all is the right behavior.

resumeAll = true;

} else if (state->isStoppedAtBytecode())

resumeAll = stepAtBytecode(locker, state);

else {

RELEASE_ASSERT(state->isStoppedAtPrologue());

setStepBreakpointAtEntry(state->stopData->callee.get(), state->stopData->instance->moduleInformation());

}

if (resumeAll) {

resumeImpl(locker);

return;

}

RELEASE_ASSERT(m_breakpointManager->hasOneTimeBreakpoints());

m_debuggerState = DebuggerState::StepRequested;

m_debuggeeContinue.notifyOne(); // Notify to resume until next breakpoint.

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Step] Notified code to continue and expected a stop, waiting...");

m_debuggerContinue.wait(locker); // Wait for one-time breakpoint hit.

sendStopReply(locker);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Step] Code is stopped and debugger replied");

{

RELEASE_ASSERT(state->isStoppedAtBytecode());

auto& stopData = *state->stopData;

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Step] Start with ", stopData);

uint8_t* currentPC = stopData.pc;

auto setStepBreakpoint = [&](const uint8_t* nextPC) WTF_REQUIRES_LOCK(m_lock) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][Step][SetOneTimeBreakpoint] current PC=", RawPointer(currentPC), "(", stopData.address, "), next PC=", RawPointer(nextPC));

m_breakpointManager->setStepBreakpoint(stopData.instance->moduleInformation(), const_cast<uint8_t*>(nextPC));

{

if (!callerVM.debugState()->takeStepIntoCall())

return;

[&]() {

Locker locker { m_lock };

RELEASE_ASSERT(m_debuggee == &callerVM);

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][StepIntoEvent] Start for call");

RELEASE_ASSERT(m_debuggerState == DebuggerState::StepRequested);

RELEASE_ASSERT(calleeInstance);

if (!boxedCallee.isNativeCallee())

return;

RefPtr wasmCallee = downcast<Wasm::Callee>(boxedCallee.asNativeCallee());

if (wasmCallee->compilationMode() != Wasm::CompilationMode::IPIntMode)

return;

RELEASE_ASSERT(&calleeInstance->vm() == &callerVM);

setStepBreakpointAtEntry(downcast<IPIntCallee>(wasmCallee.get()), calleeInstance->moduleInformation());

}();

stopTheWorld(callerVM, StopTheWorldEvent::WasmStepIntoSiteReached);

{

if (!throwVM.debugState()->takeStepIntoThrow())

return;

[&]() {

Locker locker { m_lock };

RELEASE_ASSERT(m_debuggee == &throwVM);

dataLogLnIf(Options::verboseWasmDebugger(), "[Code][StepIntoEvent] Start for throw");

RELEASE_ASSERT(m_debuggerState == DebuggerState::StepRequested);

if (!throwVM.callFrameForCatch)

return;

if (!throwVM.callFrameForCatch->callee().isNativeCallee())

return;

RefPtr wasmCallee = downcast<Wasm::Callee>(throwVM.callFrameForCatch->callee().asNativeCallee());

if (wasmCallee->compilationMode() != Wasm::CompilationMode::IPIntMode)

return;

RefPtr catchCallee = downcast<IPIntCallee>(wasmCallee.get());

ASSERT(std::holds_alternative<uintptr_t>(throwVM.targetInterpreterPCForThrow));

uintptr_t handlerOffset = std::get<uintptr_t>(throwVM.targetInterpreterPCForThrow);

const uint8_t* handlerPC = catchCallee->bytecode() + handlerOffset;

if (m_breakpointManager->originalOpcodeAt(handlerPC) == Wasm::OpType::TryTable && throwVM.targetInterpreterMetadataPCForThrow) {

const uint8_t* metadataPtr = catchCallee->metadata() + throwVM.targetInterpreterMetadataPCForThrow;

metadataPtr += sizeof(IPInt::CatchMetadata);

const IPInt::BlockMetadata* blockMetadata = reinterpret_cast<const IPInt::BlockMetadata*>(metadataPtr);

handlerPC = handlerPC + blockMetadata->deltaPC;

}

JSWebAssemblyInstance* catchInstance = throwVM.callFrameForCatch->wasmInstance();

RELEASE_ASSERT(&catchInstance->vm() == &throwVM);

m_breakpointManager->setStepBreakpoint(catchInstance->moduleInformation(), const_cast<uint8_t*>(handlerPC));

}();

stopTheWorld(throwVM, StopTheWorldEvent::WasmStepIntoSiteReached);

{

VirtualAddress::Type addressType = address.type();

if (addressType == VirtualAddress::Type::Module)

return true;

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Breakpoint must be in module code region, got type: ", static_cast<int>(addressType));

sendErrorReply(ProtocolError::InvalidAddress);

return false;

{

if (packet.isEmpty())

return;

// Parse packet format: Z0,<address>,<length>

if (packet.isEmpty() || packet[0] != 'Z') {

sendErrorReply(ProtocolError::InvalidPacket);

return;

}

StringView params = packet.substring(1);

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

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

sendErrorReply(ProtocolError::InvalidPacket);

return;

}

auto parsedAddress = parseHexStrict(parts[1]);

if (!parsedAddress) {

sendErrorReply(ProtocolError::InvalidPacket);

return;

}

uint32_t type = parseDecimal(parts[0]);

VirtualAddress address = VirtualAddress(*parsedAddress);

uint32_t length = parseDecimal(parts[2]);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][SetBreakpoint] Setting breakpoint: type=", static_cast<int>(type), ", address=", address, ", length=", length);

// Only support type 0 (software breakpoint)

if (type) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][SetBreakpoint] Unsupported breakpoint type: ", static_cast<int>(type));

sendErrorReply(ProtocolError::UnknownCommand);

return;

}

if (!requireModuleAddress(address))

return;

JSWebAssemblyInstance* instance = m_moduleManager.jsInstance(address.instanceId());

if (!instance) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] No live instance for ", address);

sendErrorReply(ProtocolError::InvalidAddress);

return;

}

uint8_t* pc = address.toPhysicalPC(*instance);

if (!pc) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] No module bytecode at ", address);

sendErrorReply(ProtocolError::InvalidAddress);

return;

}

if (!instance->moduleInformation().isInstructionStart(address.offset())) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Not an instruction boundary: ", address);

sendErrorReply(ProtocolError::InvalidAddress);

return;

}

// Idempotent: LLDB sends one Z0 per instance for shared bytecode. The address is

// recorded so the patch survives until all sites referring to it are removed.

m_breakpointManager->setBreakpointAt(address, instance->moduleInformation(), pc);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger][SetBreakpoint] Successfully set breakpoint at ", address, " (physical: ", RawPointer(pc), ")");

sendReplyOK();

{

if (packet.isEmpty())

return;

// Format: z0,<address>,<length>

if (packet.isEmpty() || packet[0] != 'z') {

sendErrorReply(ProtocolError::InvalidPacket);

return;

}

StringView params = packet.substring(1);

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

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

sendErrorReply(ProtocolError::InvalidPacket);

return;

}

auto parsedAddress = parseHexStrict(parts[1]);

if (!parsedAddress) {

sendErrorReply(ProtocolError::InvalidPacket);

return;

}

uint32_t type = parseDecimal(parts[0]);

VirtualAddress address = VirtualAddress(*parsedAddress);

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Removing breakpoint: type=", static_cast<int>(type), ", address=", address);

// Only support type 0 (software breakpoint)

if (type) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Unsupported breakpoint type for removal: ", static_cast<int>(type));

sendErrorReply(ProtocolError::UnknownCommand);

return;

}

if (!requireModuleAddress(address))

return;

// Resolved from the installed address so removal works even after an instance is collected.

if (!m_breakpointManager->removeBreakpointAt(address))

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] No breakpoint to remove at ", address);

sendReplyOK();

{

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

// Parse the thread ID

StringView threadIdStr = packet.substring(strlen("qThreadStopInfo"));

auto vmId = parseHexStrict(threadIdStr);

if (!vmId) {

sendErrorReply(ProtocolError::InvalidPacket);

return;

}

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Handling qThreadStopInfo for thread: ", *vmId);

Locker locker { m_lock };

sendStopReplyForThread(locker, *vmId);

{

if (state.isStoppedAtSystemCall())

return VirtualAddress(VirtualAddress::INVALID_BASE).value();

RELEASE_ASSERT(state.stopData);

return state.stopData->address;

{

StringView stateName;

if (state.isStoppedAtPrologue())

stateName = "wasm-prologue"_s;

else if (state.isStoppedAtBytecode())

stateName = "wasm-call"_s;

else {

RELEASE_ASSERT(state.isStoppedAtSystemCall());

stateName = "system-call"_s;

}

return makeString(stateName, " tid:0x"_s, hex(vmId, Lowercase));

uint64_t vmId;

uint64_t pc;

String name;

StringView stopReason;

{

VM* vm = findVM(vmId);

if (!vm) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] sendStopReplyForThread: thread ", vmId, " not found");

sendReplyImpl(locker, getErrorReply(ProtocolError::InvalidAddress));

return;

}

DebugState* state = vm->debugState();

if (!state) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] sendStopReplyForThread: thread ", vmId, " not found");

sendReplyImpl(locker, getErrorReply(ProtocolError::InvalidAddress));

return;

}

RELEASE_ASSERT(state->isStopped);

// Collect all stopped threads; swap event thread to index 0 so thread-pcs[i] aligns with threads[i].

Vector<ThreadInfo> allThreads;

VMManager::forEachVM([&](VM& vm) {

auto* state = vm.debugState();

if (!state->isStopped)

return IterationStatus::Continue;

uint64_t tid = vm.identifier().toUInt64();

allThreads.append({ tid, getStopPC(*state), getThreadName(*state, tid), stopReasonToInfo(*state).reasonSuffix });

if (tid == vmId)

std::swap(allThreads[0], allThreads.last());

return IterationStatus::Continue;

});

// A "passive thread" is a VM that was collaterally stopped when the world was halted (its

// stopReason set to Interrupted by setStopped()), as opposed to the debuggee thread that

// actually triggered the stop event (breakpoint/step/trap/interrupt/new-module-load).

// Passive threads get signal 0 so LLDB's ShouldSelect() returns false for them, allowing

// the event thread to win thread selection in HandleProcessStateChangedEvent.

bool isPassiveThread = state->stopReason == DebugState::Reason::Interrupted && m_debuggee && vmId != m_debuggee->identifier().toUInt64();

auto stopInfo = isPassiveThread

? StopReasonInfo { signalStopString(0), "signal"_s }

: stopReasonToInfo(*state);

// Build packet with target thread

StringBuilder reply;

reply.append(stopInfo.reasonString);

reply.append("thread:"_s, hex(vmId, Lowercase), ';');

reply.append("name:"_s, getThreadName(*state, vmId), ';');

// All thread IDs

reply.append("threads:"_s);

for (size_t i = 0; i < allThreads.size(); ++i) {

if (i > 0)

reply.append(',');

reply.append(hex(allThreads[i].vmId, Lowercase));

}

reply.append(';');

// All thread PCs

reply.append("thread-pcs:"_s);

for (size_t i = 0; i < allThreads.size(); ++i) {

if (i > 0)

reply.append(',');

reply.append(hex(allThreads[i].pc, 16, Lowercase));

}

reply.append(';');

reply.append("00:"_s, toNativeEndianHex(getStopPC(*state)), ';');

reply.append("reason:"_s, stopInfo.reasonSuffix, ';');

// Sweeps collected instances, so drain what they left behind before using the result. The

// world is stopped here, which is what makes unpatching bytecode safe.

bool requeryLibraries = m_moduleManager.needsLibraryRequery();

for (uint32_t instanceId : m_moduleManager.takeCollectedInstanceIds())

m_breakpointManager->removeSitesForInstance(instanceId);

// Prompt LLDB to re-query libraries on new instances or instance teardown.

// Gated on hasSentLibraryList() to avoid sending library:; in the ? reply before the initial

// qXfer:libraries:read handshake completes.

if (requeryLibraries && m_debugServer.hasSentLibraryList()) {

reply.append("library:;"_s);

// Include a human-readable description only for dedicated new-instance-load stops.

if (state->isNewModuleLoad) {

RELEASE_ASSERT(state->isStoppedAtSystemCall());

reply.append("description:"_s);

StringBuilder description;

description.append("loaded new wasm module instance with ids: "_s);

auto ids = m_moduleManager.unnotifiedInstanceIds();

for (size_t i = 0; i < ids.size(); ++i) {

if (i)

description.append(", "_s);

description.append(ids[i]);

}

for (UChar c : StringView(description.toString()).codeUnits())

reply.append(hex(static_cast<uint8_t>(c), 2, Lowercase));

reply.append(';');

}

}

// For trap stops, include a hex-encoded description so LLDB can display the trap reason.

if (state->isStoppedDueToWasmTrap()) {

reply.append("description:"_s);

for (UChar c : StringView(Wasm::errorMessageForExceptionType(*state->stopData->wasmTrapType)).codeUnits())

reply.append(hex(static_cast<uint8_t>(c), 2, Lowercase));

reply.append(';');

}

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Sending stop reply: target thread="_s, hex(vmId), ", total threads="_s, allThreads.size(), ", packet="_s, reply.toString());

sendReplyImpl(locker, reply.toString());

{

Locker locker { m_lock };

sendReplyImpl(locker, reply);

{

uint8_t checksum = 0;

for (auto character : reply.codeUnits())

checksum += character;

String packet = makeString('$', reply, '#', hex(checksum, 2, Lowercase));

#if ENABLE(REMOTE_INSPECTOR)

if (m_debugServer.isRWIMode()) {

RELEASE_ASSERT(!!m_debugServer.m_rwiResponseHandler);

if (m_debugServer.m_rwiResponseHandler(packet)) {

m_debuggerState = DebuggerState::Replied;

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Sent reply via RWI: ", packet);

} else

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Failed to send packet via RWI: ", packet);

return;

}

#endif

auto packetData = packet.utf8();

int sent = static_cast<int>(send(m_debugServer.m_clientSocket, packetData.legacyCStringPointer(), packetData.length(), 0));

if (sent < 0)

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Failed to send packet: ", packetData.legacyCStringPointer(), " sent: ", sent);

else {

m_debuggerState = DebuggerState::Replied;

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Sent reply: ", packetData.legacyCStringPointer());

}

{

Locker locker { m_lock };

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] Handling client disconnection in ExecutionHandler");

// Clear before resuming: resumeImpl() transiently releases m_lock, and the

// VM must not re-hit a breakpoint in that window.

m_breakpointManager->clearAllBreakpoints();

if (m_debuggee && debuggeeState()->isStopped)

resumeImpl(locker);

m_debuggerState = DebuggerState::Replied;

takeAwaitingResumeNotification();

m_debuggee = nullptr;

{

Locker locker { m_lock };

VM* targetVM = m_debuggee;

RELEASE_ASSERT(targetVM);

if (targetVM->identifier().toUInt64() != vmId)

targetVM = findVM(vmId);

if (!targetVM) {

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] callStackStringFor: thread ", vmId, " not found");

return String();

}

auto* state = targetVM->debugState();

RELEASE_ASSERT(state->isStopped);

if (state->stopData) {

auto& stopData = *state->stopData;

RELEASE_ASSERT(stopData.callFrame);

Vector<FrameInfo> frames = collectCallStack(stopData.address, stopData.callFrame, *targetVM);

StringBuilder result;

for (const auto& frame : frames)

result.append(toNativeEndianHex(frame.address));

dataLogLnIf(Options::verboseWasmDebugger(), "[Debugger] callStackStringFor: collected ", frames.size(), " frames");

return result.toString();

}

uint64_t pc = getStopPC(*state);

return toNativeEndianHex(pc);