{

Locker locker { m_lock };

// IDs are never reused, so the address space bounds how many instances one session may

// create. Fail here rather than deep inside VirtualAddress::encode().

RELEASE_ASSERT(m_nextInstanceId <= VirtualAddress::MAX_ID, "Wasm debugger ran out of instance IDs");

uint32_t instanceId = m_nextInstanceId++;

RefPtr<InstanceAnchor> anchor = jsInstance->anchor();

RELEASE_ASSERT(anchor, "Instance must have an anchor");

const auto& moduleInfo = jsInstance->moduleInformation();

RELEASE_ASSERT(moduleInfo.debugInfo && !moduleInfo.debugInfo->source.isEmpty(), "Instance must have module source");

amortizedCleanupIfNeeded();

m_instanceIdToInstance.set(instanceId, ThreadSafeWeakPtr { *anchor });

jsInstance->setDebugId(instanceId);

m_unnotifiedInstanceIds.add(instanceId);

dataLogLnIf(Options::verboseWasmDebugger(), "[ModuleManager][registerInstance] - registered instance with ID: ", instanceId, " of module: ", RawPointer(&jsInstance->module()));

{

Locker locker { m_lock };

// Sweep here rather than leaving it to the amortized cleanup, which only runs on unrelated

// traffic and may never run at all: a collected instance would then keep its library in

// LLDB's list forever. This runs once per stop reply, over the live instances.

sweepDeadInstances();

return !m_unnotifiedInstanceIds.isEmpty() || m_hasPendingLibraryRemovals;

{

Locker locker { m_lock };

m_unnotifiedInstanceIds.clear();

m_hasPendingLibraryRemovals = false;

{

Locker locker { m_lock };

Vector<uint32_t> result;

result.reserveInitialCapacity(m_unnotifiedInstanceIds.size());

for (uint32_t id : m_unnotifiedInstanceIds)

result.append(id);

std::sort(result.begin(), result.end());

return result;

{

Locker locker { m_lock };

return std::exchange(m_collectedInstanceIds, { });

{

Locker locker { m_lock };

StringBuilder xml;

xml.append("<?xml version=\"1.0\"?>\n"_s);

xml.append("<library-list>\n"_s);

auto appendXMLEscaped = [](StringBuilder& builder, const String& value) {

for (UChar c : StringView(value).codeUnits()) {

switch (c) {

case '&':

builder.append("&amp;"_s);

break;

case '<':

builder.append("&lt;"_s);

break;

case '>':

builder.append("&gt;"_s);

break;

case '"':

builder.append("&quot;"_s);

break;

default:

builder.append(c);

break;

}

}

};

// Report libraries in instance-id order so the list LLDB sees is stable across requeries.

Vector<std::pair<uint32_t, RefPtr<InstanceAnchor>>> liveInstances;

liveInstances.reserveInitialCapacity(m_instanceIdToInstance.size());

for (const auto& pair : m_instanceIdToInstance) {

if (RefPtr<InstanceAnchor> anchor = pair.value.get())

liveInstances.append({ pair.key, WTF::move(anchor) });

}

std::sort(liveInstances.begin(), liveInstances.end(), [](const auto& a, const auto& b) {

return a.first < b.first;

});

unsigned libraryCount = 0;

for (const auto& [instanceId, anchor] : liveInstances) {

Locker anchorLocker { anchor->m_lock };

JSWebAssemblyInstance* instance = anchor->instance();

if (!instance)

continue;

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

const auto& debugInfo = moduleInfo.debugInfo;

VirtualAddress moduleBaseAddress = VirtualAddress::createModule(instanceId);

// Instance IDs are unique across every module, so suffixing with one is enough to keep

// library names distinct even when two modules declare the same name. Both halves are

// fixed for the life of the instance, so a library is never renamed.

// FIXME: The name carries no module identity, so two modules declaring the same name look

// like two instances of one. Fold in a hash of the module's bytes or its build_id section

// — `<name>#<hash>@<instance>` — cached on ModuleDebugInfo, since this runs per qXfer chunk.

String libraryName = moduleInfo.declaredName();

if (libraryName.isEmpty()) {

// No name to qualify: the base address already names the instance uniquely.

libraryName = makeString("0x"_s, moduleBaseAddress.hex(), ".wasm"_s);

} else

libraryName = makeString(libraryName, '@', instanceId);

xml.append(" <library name=\""_s);

appendXMLEscaped(xml, libraryName);

xml.append("\">\n"_s);

xml.append(" <section address=\"0x"_s);

xml.append(moduleBaseAddress.hex());

xml.append("\"/>\n"_s);

xml.append(" </library>\n"_s);

libraryCount++;

dataLogLnIf(Options::verboseWasmDebugger(), "[ModuleManager][generateLibrariesXML] - added instance '", libraryName, "' ID: ", instanceId, " at ", moduleBaseAddress, " size: 0x", hex(debugInfo->source.size(), Lowercase));

}

xml.append("</library-list>\n"_s);

String result = xml.toString();

dataLogLnIf(Options::verboseWasmDebugger(), "[ModuleManager][generateLibrariesXML] - generated library list XML: ", libraryCount, " instances, ", result.length(), " characters");

return result;

{

Locker locker { m_lock };

return m_nextInstanceId;

{

Vector<uint32_t> deadIds;

for (const auto& pair : m_instanceIdToInstance) {

if (!pair.value.get())

deadIds.append(pair.key);

}

for (uint32_t instanceId : deadIds) {

m_instanceIdToInstance.remove(instanceId);

m_collectedInstanceIds.append(instanceId);

// A collected instance drops a library from the list, so LLDB has to requery — unless it

// was never told the instance existed, in which case there is nothing for it to drop.

if (!m_unnotifiedInstanceIds.remove(instanceId))

m_hasPendingLibraryRemovals = true;

}

// The budget is sized off the surviving instance count, so it belongs with the sweep and has

// to follow the removals above.

m_operationCountSinceLastCleanup = 0;

m_maxOperationCountWithoutCleanup = std::min(std::numeric_limits<unsigned>::max() / 2, static_cast<unsigned>(m_instanceIdToInstance.size())) * 2;

{

if (++m_operationCountSinceLastCleanup > m_maxOperationCountWithoutCleanup)

sweepDeadInstances();