: m_moduleInformation(plan.takeModuleInformation())

, m_ipintCallees(IPIntCallees::createFromVector(plan.takeCallees()))

, m_wasmToJSExitStubs(plan.takeWasmToJSExitStubs())

{

#if ENABLE(WEBASSEMBLY_DEBUGGER)

if (Options::enableWasmDebugger()) [[unlikely]]

Wasm::DebugServer::singleton().trackModule(*this);

#endif

{

ASSERT(!plan.hasWork());

if (plan.failed())

return std::unexpected<String>(plan.errorMessage());

return Module::ValidationResult(Module::create(plan));

{

return createSharedTask<Plan::CallbackType>([callback = WTF::move(callback)] (Plan& plan) {

ASSERT(!plan.hasWork());

callback->run(makeValidationResult(static_cast<IPIntPlan&>(plan)));

});

{

Ref<IPIntPlan> plan = adoptRef(*new IPIntPlan(vm, WTF::move(source), CompilerMode::Validation, Plan::dontFinalize()));

Wasm::ensureWorklist().enqueue(plan.get());

plan->waitForCompletion();

return makeValidationResult(plan.get());

{

Ref<Plan> plan = adoptRef(*new IPIntPlan(vm, WTF::move(source), CompilerMode::Validation, makeValidationCallback(WTF::move(callback))));

Wasm::ensureWorklist().enqueue(WTF::move(plan));

{

RefPtr<CalleeGroup> calleeGroup;

Locker locker { m_lock };

calleeGroup = m_calleeGroups[static_cast<uint8_t>(mode)];

// If a previous attempt at a compile errored out, let's try again.

// Compilations from valid modules can fail because OOM and cancellation.

// It's worth retrying.

// FIXME: We might want to back off retrying at some point:

// https://bugs.webkit.org/show_bug.cgi?id=170607

if (!calleeGroup || (calleeGroup->compilationFinished() && !calleeGroup->runnable())) {

m_calleeGroups[static_cast<uint8_t>(mode)] = calleeGroup = CalleeGroup::createFromIPInt(vm, mode, const_cast<ModuleInformation&>(moduleInformation()), m_ipintCallees.copyRef());

}

return calleeGroup.releaseNonNull();

{

Ref<CalleeGroup> calleeGroup = getOrCreateCalleeGroup(vm, mode);

calleeGroup->waitUntilFinished();

return calleeGroup;

{

Ref<CalleeGroup> calleeGroup = getOrCreateCalleeGroup(vm, mode);

calleeGroup->compileAsync(vm, WTF::move(task));

{

Locker locker { m_lock };

ASSERT(m_calleeGroups[static_cast<uint8_t>(initialMode)]);

const CalleeGroup& initialBlock = *m_calleeGroups[static_cast<uint8_t>(initialMode)];

for (unsigned i = 0; i < numberOfMemoryModes; i++) {

if (i == static_cast<uint8_t>(initialMode))

continue;

// We should only try to copy the group here if it hasn't already been created.

// If it exists but is not runnable, it should get compiled during module evaluation.

if (auto& group = m_calleeGroups[i]; !group)

group = CalleeGroup::createFromExisting(static_cast<MemoryMode>(i), initialBlock);

}

{

auto anchor = Wasm::InstanceAnchor::create(*this, instance);

WTF::storeStoreFence();

m_anchors.add(anchor.get());

return anchor;

{

auto result = makeUnique<MergedProfile>(callee);

for (Ref anchor : m_anchors) {

RefPtr<BaselineData> data;

{

Locker locker { anchor->m_lock };

if (JSWebAssemblyInstance* instance = anchor->instance())

data = instance->baselineData(callee.functionIndex());

}

if (!data)

continue;

result->merge(*this, callee, *data);

}

return result;