WTF_MAKE_TZONE_ALLOCATED(DebugServer);

JS_EXPORT_PRIVATE static DebugServer& singleton();

#if OS(WINDOWS)

using SocketType = SOCKET;

static constexpr SocketType invalidSocketValue = INVALID_SOCKET;

#else

using SocketType = int;

static constexpr SocketType invalidSocketValue = -1;

#endif

static constexpr uint16_t defaultPort = 1234;

DebugServer();

~DebugServer() = default;

JS_EXPORT_PRIVATE bool start();

#if ENABLE(REMOTE_INSPECTOR)

// DebugServer supports two modes:

// 1. Direct TCP socket mode (JSC shell debugging)

// 2. Remote Web Inspector integration mode (WebKit debugging)

bool isRWIMode() const { return !!m_rwiResponseHandler; }

JS_EXPORT_PRIVATE void startRWI(Function<bool(const String&)>&& rwiResponseHandler);

#endif

void trackInstance(JSWebAssemblyInstance*);

void trackModule(Module&);

void untrackModule(Module&);

void setPort(uint64_t port) { m_port = port; }

// Returns true when a GDB remote client is present at the transport layer — either a TCP

// socket has been accepted or an RWI handler has been registered. This is a wire-level check

// only: the debugger may not have completed its startup sequence yet.

JS_EXPORT_PRIVATE bool NODELETE hasDebugger() const;

// Non-blocking check: returns true once the debugger has sent its first 'c' (continue).

// This is used for test only.

bool hasContinued() const { return m_hasContinued.load(std::memory_order_acquire); }

// True once the debugger has completed its startup exchange ('?' + first qXfer:libraries:read),

// which is the point at which we consider the debugger fully ready to handle breakpoints, traps, and new module loads.

bool isDebuggerReady() const

{

bool ready = m_isDebuggerReady.load(std::memory_order_acquire);

RELEASE_ASSERT(!ready || hasDebugger());

return ready;

}

JS_EXPORT_PRIVATE void handlePacket(StringView packet);

ExecutionHandler& execution() const

{

RELEASE_ASSERT(m_executionHandler);

return *m_executionHandler;

}

JS_EXPORT_PRIVATE ModuleManager& moduleManager() const;

JS_EXPORT_PRIVATE void reset();

bool isInService() const { return m_isInService.load(std::memory_order_acquire); }

void setIsInService() { m_isInService.store(true, std::memory_order_release); }

bool createAndBindServerSocket();

void startAcceptThread();

void acceptClientConnections();

void closeSocket(SocketType&);

void handleClient();

void handleThreadManagement(StringView packet);

void sendAck();

void sendReplyOK();

void sendReplyNotSupported(StringView packet);

void sendReply(StringView reply);

void sendErrorReply(ProtocolError);

bool isSocketValid(SocketType clientSocket) const

{

#if OS(WINDOWS)

return clientSocket != invalidSocketValue;

#else

return clientSocket >= 0;

#endif

}

friend class QueryHandler;

friend class MemoryHandler;

friend class RegisterHandler;

friend class ExecutionHandler;

// Set once on start()/startRWI() and never cleared — DebugServer is a process-lifetime singleton.

std::atomic<bool> m_isInService { false };

std::atomic<bool> m_hasContinued { false };

std::atomic<bool> m_isDebuggerReady { false };

uint16_t m_port { defaultPort };

SocketType m_serverSocket { invalidSocketValue };

SocketType m_clientSocket { invalidSocketValue };

RefPtr<Thread> m_acceptThread;

bool m_noAckMode { false };

std::unique_ptr<QueryHandler> m_queryHandler;

std::unique_ptr<MemoryHandler> m_memoryHandler;

std::unique_ptr<ExecutionHandler> m_executionHandler;

std::unique_ptr<ModuleManager> m_moduleManager;

GDBPacketParser m_packetParser;

#if ENABLE(REMOTE_INSPECTOR)

Function<bool(const String&)> m_rwiResponseHandler;

#endif