public:

LogCodesTask(base::Mutex* mutex, LogCodesTask** task_slot, Isolate* isolate,

WasmEngine* engine)

: mutex_(mutex),

task_slot_(task_slot),

isolate_(isolate),

engine_(engine) {

DCHECK_NOT_NULL(task_slot);

DCHECK_NOT_NULL(isolate);

}

~LogCodesTask() override {

// If the platform deletes this task before executing it, we also deregister

// it to avoid use-after-free from still-running background threads.

if (!cancelled()) DeregisterTask();

}

void Run() override {

if (cancelled()) return;

DeregisterTask();

engine_->LogOutstandingCodesForIsolate(isolate_);

}

void Cancel() {

// Cancel will only be called on Isolate shutdown, which happens on the

// Isolate's foreground thread. Thus no synchronization needed.

isolate_ = nullptr;

}

bool cancelled() const { return isolate_ == nullptr; }

void DeregisterTask() {

// The task will only be deregistered from the foreground thread (executing

// this task or calling its destructor), thus we do not need synchronization

// on this field access.

if (task_slot_ == nullptr) return; // already deregistered.

// Remove this task from the {IsolateInfo} in the engine. The next

// logging request will allocate and schedule a new task.

base::MutexGuard guard(mutex_);

DCHECK_EQ(this, *task_slot_);

*task_slot_ = nullptr;

task_slot_ = nullptr;

}

private:

// The mutex of the WasmEngine.

base::Mutex* const mutex_;

// The slot in the WasmEngine where this LogCodesTask is stored. This is

// cleared by this task before execution or on task destruction.

LogCodesTask** task_slot_;

Isolate* isolate_;

WasmEngine* const engine_;

class ArchivedThreadsVisitor : public ThreadVisitor {

void VisitThread(Isolate* isolate, ThreadLocalTop* top) override {

// Archived threads are rarely used, and not combined with Wasm at the

// moment. Implement this and test it properly once we have a use case for

// that.

FATAL("archived threads in combination with wasm not supported");

}

} archived_threads_visitor;

isolate->thread_manager()->IterateArchivedThreads(&archived_threads_visitor);

public:

explicit WasmGCForegroundTask(Isolate* isolate)

: CancelableTask(isolate->cancelable_task_manager()), isolate_(isolate) {}

void RunInternal() final {

// The stack can contain live frames, for instance when this is invoked

// during a pause or a breakpoint.

GetWasmEngine()->ReportLiveCodeFromStackForGC(isolate_);

}

private:

Isolate* isolate_;

public:

explicit WeakScriptHandle(Handle<Script> script) : script_id_(script->id()) {

DCHECK(script->name().IsString() || script->name().IsUndefined());

if (script->name().IsString()) {

std::unique_ptr<char[]> source_url =

String::cast(script->name()).ToCString();

// Convert from {unique_ptr} to {shared_ptr}.

source_url_ = {source_url.release(), source_url.get_deleter()};

}

auto global_handle =

script->GetIsolate()->global_handles()->Create(*script);

location_ = std::make_unique<Address*>(global_handle.location());

GlobalHandles::MakeWeak(location_.get());

}

// Usually the destructor of this class should always be called after the weak

// callback because the Script keeps the NativeModule alive. So we expect the

// handle to be destroyed and the location to be reset already.

// We cannot check this because of one exception. When the native module is

// freed during isolate shutdown, the destructor will be called

// first, and the callback will never be called.

~WeakScriptHandle() = default;

WeakScriptHandle(WeakScriptHandle&&) V8_NOEXCEPT = default;

Handle<Script> handle() const { return Handle<Script>(*location_); }

int script_id() const { return script_id_; }

const std::shared_ptr<const char>& source_url() const { return source_url_; }

private:

// Store the location in a unique_ptr so that its address stays the same even

// when this object is moved/copied.

std::unique_ptr<Address*> location_;

// Store the script ID independent of the weak handle, such that it's always

// available.

int script_id_;

// Similar for the source URL. We cannot dereference the Handle from arbitrary

// threads, but we need the URL available for code logging.

// The shared pointer is kept alive by unlogged code, even if this entry is

// collected in the meantime.

// TODO(chromium:1132260): Revisit this for huge URLs.

std::shared_ptr<const char> source_url_;

ModuleOrigin origin, base::Vector<const uint8_t> wire_bytes) {

if (origin != kWasmOrigin) return nullptr;

base::MutexGuard lock(&mutex_);

size_t prefix_hash = PrefixHash(wire_bytes);

NativeModuleCache::Key key{prefix_hash, wire_bytes};

while (true) {

auto it = map_.find(key);

if (it == map_.end()) {

// Even though this exact key is not in the cache, there might be a

// matching prefix hash indicating that a streaming compilation is

// currently compiling a module with the same prefix. {OnFinishedStream}

// happens on the main thread too, so waiting for streaming compilation to

// finish would create a deadlock. Instead, compile the module twice and

// handle the conflict in {UpdateNativeModuleCache}.

// Insert a {nullopt} entry to let other threads know that this

// {NativeModule} is already being created on another thread.

auto p = map_.emplace(key, base::nullopt);

USE(p);

DCHECK(p.second);

return nullptr;

}

if (it->second.has_value()) {

if (auto shared_native_module = it->second.value().lock()) {

DCHECK_EQ(shared_native_module->wire_bytes(), wire_bytes);

return shared_native_module;

}

}

// TODO(11858): This deadlocks in predictable mode, because there is only a

// single thread.

cache_cv_.Wait(&mutex_);

}

base::MutexGuard lock(&mutex_);

auto it = map_.lower_bound(Key{prefix_hash, {}});

if (it != map_.end() && it->first.prefix_hash == prefix_hash) {

DCHECK_IMPLIES(!it->first.bytes.empty(),

PrefixHash(it->first.bytes) == prefix_hash);

return false;

}

Key key{prefix_hash, {}};

DCHECK_EQ(0, map_.count(key));

map_.emplace(key, base::nullopt);

return true;

base::MutexGuard lock(&mutex_);

Key key{prefix_hash, {}};

DCHECK_EQ(1, map_.count(key));

map_.erase(key);

cache_cv_.NotifyAll();

std::shared_ptr<NativeModule> native_module, bool error) {

DCHECK_NOT_NULL(native_module);

if (native_module->module()->origin != kWasmOrigin) return native_module;

base::Vector<const uint8_t> wire_bytes = native_module->wire_bytes();

DCHECK(!wire_bytes.empty());

size_t prefix_hash = PrefixHash(native_module->wire_bytes());

base::MutexGuard lock(&mutex_);

map_.erase(Key{prefix_hash, {}});

const Key key{prefix_hash, wire_bytes};

auto it = map_.find(key);

if (it != map_.end()) {

if (it->second.has_value()) {

auto conflicting_module = it->second.value().lock();

if (conflicting_module != nullptr) {

DCHECK_EQ(conflicting_module->wire_bytes(), wire_bytes);

return conflicting_module;

}

}

map_.erase(it);

}

if (!error) {

// The key now points to the new native module's owned copy of the bytes,

// so that it stays valid until the native module is freed and erased from

// the map.

auto p = map_.emplace(

key, base::Optional<std::weak_ptr<NativeModule>>(native_module));

USE(p);

DCHECK(p.second);

}

cache_cv_.NotifyAll();

return native_module;

if (native_module->module()->origin != kWasmOrigin) return;

// Happens in some tests where bytes are set directly.

if (native_module->wire_bytes().empty()) return;

base::MutexGuard lock(&mutex_);

size_t prefix_hash = PrefixHash(native_module->wire_bytes());

map_.erase(Key{prefix_hash, native_module->wire_bytes()});

cache_cv_.NotifyAll();

return StringHasher::HashSequentialString(

reinterpret_cast<const char*>(bytes.begin()), bytes.length(),

kZeroHashSeed);

// Compute the hash as a combined hash of the sections up to the code section

// header, to mirror the way streaming compilation does it.

Decoder decoder(wire_bytes.begin(), wire_bytes.end());

decoder.consume_bytes(8, "module header");

size_t hash = NativeModuleCache::WireBytesHash(wire_bytes.SubVector(0, 8));

SectionCode section_id = SectionCode::kUnknownSectionCode;

while (decoder.ok() && decoder.more()) {

section_id = static_cast<SectionCode>(decoder.consume_u8());

uint32_t section_size = decoder.consume_u32v("section size");

if (section_id == SectionCode::kCodeSectionCode) {

uint32_t num_functions = decoder.consume_u32v("num functions");

// If {num_functions} is 0, the streaming decoder skips the section. Do

// the same here to ensure hashes are consistent.

if (num_functions != 0) {

hash = base::hash_combine(hash, section_size);

}

break;

}

const uint8_t* payload_start = decoder.pc();

decoder.consume_bytes(section_size, "section payload");

size_t section_hash = NativeModuleCache::WireBytesHash(

base::Vector<const uint8_t>(payload_start, section_size));

hash = base::hash_combine(hash, section_hash);

}

return hash;

: log_codes(WasmCode::ShouldBeLogged(isolate)),

async_counters(isolate->async_counters()),

wrapper_compilation_barrier_(std::make_shared<OperationsBarrier>()) {

v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);

v8::Platform* platform = V8::GetCurrentPlatform();

foreground_task_runner = platform->GetForegroundTaskRunner(v8_isolate);

const ModuleWireBytes& bytes) {

TRACE_EVENT0("v8.wasm", "wasm.SyncValidate");

// TODO(titzer): remove dependency on the isolate.

if (bytes.start() == nullptr || bytes.length() == 0) return false;

ModuleResult result = DecodeWasmModule(

enabled, bytes.start(), bytes.end(), true, kWasmOrigin,

isolate->counters(), isolate->metrics_recorder(),

isolate->GetOrRegisterRecorderContextId(isolate->native_context()),

DecodingMethod::kSync, allocator());

return result.ok();

Isolate* isolate, ErrorThrower* thrower, const ModuleWireBytes& bytes,

base::Vector<const byte> asm_js_offset_table_bytes,

Handle<HeapNumber> uses_bitset, LanguageMode language_mode) {

int compilation_id = next_compilation_id_.fetch_add(1);

TRACE_EVENT1("v8.wasm", "wasm.SyncCompileTranslatedAsmJs", "id",

compilation_id);

ModuleOrigin origin = language_mode == LanguageMode::kSloppy

? kAsmJsSloppyOrigin

: kAsmJsStrictOrigin;

ModuleResult result = DecodeWasmModule(

WasmFeatures::ForAsmjs(), bytes.start(), bytes.end(), false, origin,

isolate->counters(), isolate->metrics_recorder(),

isolate->GetOrRegisterRecorderContextId(isolate->native_context()),

DecodingMethod::kSync, allocator());

if (result.failed()) {

// This happens once in a while when we have missed some limit check

// in the asm parser. Output an error message to help diagnose, but crash.

std::cout << result.error().message();

UNREACHABLE();

}

result.value()->asm_js_offset_information =

std::make_unique<AsmJsOffsetInformation>(asm_js_offset_table_bytes);

// Transfer ownership of the WasmModule to the {Managed<WasmModule>} generated

// in {CompileToNativeModule}.

Handle<FixedArray> export_wrappers;

std::shared_ptr<NativeModule> native_module = CompileToNativeModule(

isolate, WasmFeatures::ForAsmjs(), thrower, std::move(result).value(),

bytes, &export_wrappers, compilation_id);

if (!native_module) return {};

return AsmWasmData::New(isolate, std::move(native_module), export_wrappers,

uses_bitset);

Isolate* isolate, Handle<AsmWasmData> asm_wasm_data,

Handle<Script> script) {

std::shared_ptr<NativeModule> native_module =

asm_wasm_data->managed_native_module().get();

Handle<FixedArray> export_wrappers =

handle(asm_wasm_data->export_wrappers(), isolate);

Handle<WasmModuleObject> module_object = WasmModuleObject::New(

isolate, std::move(native_module), script, export_wrappers);

return module_object;

Isolate* isolate, const WasmFeatures& enabled, ErrorThrower* thrower,

const ModuleWireBytes& bytes) {

int compilation_id = next_compilation_id_.fetch_add(1);

TRACE_EVENT1("v8.wasm", "wasm.SyncCompile", "id", compilation_id);

ModuleResult result = DecodeWasmModule(

enabled, bytes.start(), bytes.end(), false, kWasmOrigin,

isolate->counters(), isolate->metrics_recorder(),

isolate->GetOrRegisterRecorderContextId(isolate->native_context()),

DecodingMethod::kSync, allocator());

if (result.failed()) {

thrower->CompileFailed(result.error());

return {};

}

// Transfer ownership of the WasmModule to the {Managed<WasmModule>} generated

// in {CompileToNativeModule}.

Handle<FixedArray> export_wrappers;

std::shared_ptr<NativeModule> native_module = CompileToNativeModule(

isolate, enabled, thrower, std::move(result).value(), bytes,

&export_wrappers, compilation_id);

if (!native_module) return {};

#ifdef DEBUG

// Ensure that code GC will check this isolate for live code.

{

base::MutexGuard lock(&mutex_);

DCHECK_EQ(1, isolates_.count(isolate));

DCHECK_EQ(1, isolates_[isolate]->native_modules.count(native_module.get()));

DCHECK_EQ(1, native_modules_.count(native_module.get()));

DCHECK_EQ(1, native_modules_[native_module.get()]->isolates.count(isolate));

}

#endif

constexpr base::Vector<const char> kNoSourceUrl;

Handle<Script> script =

GetOrCreateScript(isolate, native_module, kNoSourceUrl);

native_module->LogWasmCodes(isolate, *script);

// Create the compiled module object and populate with compiled functions

// and information needed at instantiation time. This object needs to be

// serializable. Instantiation may occur off a deserialized version of this

// object.

Handle<WasmModuleObject> module_object = WasmModuleObject::New(

isolate, std::move(native_module), script, export_wrappers);

// Finish the Wasm script now and make it public to the debugger.

isolate->debug()->OnAfterCompile(script);

return module_object;

Isolate* isolate, ErrorThrower* thrower,

Handle<WasmModuleObject> module_object, MaybeHandle<JSReceiver> imports,

MaybeHandle<JSArrayBuffer> memory) {

TRACE_EVENT0("v8.wasm", "wasm.SyncInstantiate");

return InstantiateToInstanceObject(isolate, thrower, module_object, imports,

memory);

Isolate* isolate, std::unique_ptr<InstantiationResultResolver> resolver,

Handle<WasmModuleObject> module_object, MaybeHandle<JSReceiver> imports) {

ErrorThrower thrower(isolate, "WebAssembly.instantiate()");

TRACE_EVENT0("v8.wasm", "wasm.AsyncInstantiate");

// Instantiate a TryCatch so that caught exceptions won't progagate out.

// They will still be set as pending exceptions on the isolate.

// TODO(clemensb): Avoid TryCatch, use Execution::TryCall internally to invoke

// start function and report thrown exception explicitly via out argument.

v8::TryCatch catcher(reinterpret_cast<v8::Isolate*>(isolate));

catcher.SetVerbose(false);

catcher.SetCaptureMessage(false);

MaybeHandle<WasmInstanceObject> instance_object = SyncInstantiate(

isolate, &thrower, module_object, imports, Handle<JSArrayBuffer>::null());

if (!instance_object.is_null()) {

resolver->OnInstantiationSucceeded(instance_object.ToHandleChecked());

return;

}

if (isolate->has_pending_exception()) {

// The JS code executed during instantiation has thrown an exception.

// We have to move the exception to the promise chain.

Handle<Object> exception(isolate->pending_exception(), isolate);

isolate->clear_pending_exception();

*isolate->external_caught_exception_address() = false;

resolver->OnInstantiationFailed(exception);

thrower.Reset();

} else {

DCHECK(thrower.error());

resolver->OnInstantiationFailed(thrower.Reify());

}

Isolate* isolate, const WasmFeatures& enabled,

std::shared_ptr<CompilationResultResolver> resolver,

const ModuleWireBytes& bytes, bool is_shared,

const char* api_method_name_for_errors) {

int compilation_id = next_compilation_id_.fetch_add(1);

TRACE_EVENT1("v8.wasm", "wasm.AsyncCompile", "id", compilation_id);

if (!FLAG_wasm_async_compilation) {

// Asynchronous compilation disabled; fall back on synchronous compilation.

ErrorThrower thrower(isolate, api_method_name_for_errors);

MaybeHandle<WasmModuleObject> module_object;

if (is_shared) {

// Make a copy of the wire bytes to avoid concurrent modification.

std::unique_ptr<uint8_t[]> copy(new uint8_t[bytes.length()]);

memcpy(copy.get(), bytes.start(), bytes.length());

ModuleWireBytes bytes_copy(copy.get(), copy.get() + bytes.length());

module_object = SyncCompile(isolate, enabled, &thrower, bytes_copy);

} else {

// The wire bytes are not shared, OK to use them directly.

module_object = SyncCompile(isolate, enabled, &thrower, bytes);

}

if (thrower.error()) {

resolver->OnCompilationFailed(thrower.Reify());

return;

}

Handle<WasmModuleObject> module = module_object.ToHandleChecked();

resolver->OnCompilationSucceeded(module);

return;

}

if (FLAG_wasm_test_streaming) {

std::shared_ptr<StreamingDecoder> streaming_decoder =

StartStreamingCompilation(

isolate, enabled, handle(isolate->context(), isolate),

api_method_name_for_errors, std::move(resolver));

streaming_decoder->OnBytesReceived(bytes.module_bytes());

streaming_decoder->Finish();

return;

}

// Make a copy of the wire bytes in case the user program changes them

// during asynchronous compilation.

std::unique_ptr<byte[]> copy(new byte[bytes.length()]);

memcpy(copy.get(), bytes.start(), bytes.length());

AsyncCompileJob* job = CreateAsyncCompileJob(

isolate, enabled, std::move(copy), bytes.length(),

handle(isolate->context(), isolate), api_method_name_for_errors,

std::move(resolver), compilation_id);

job->Start();

Isolate* isolate, const WasmFeatures& enabled, Handle<Context> context,

const char* api_method_name,

std::shared_ptr<CompilationResultResolver> resolver) {

int compilation_id = next_compilation_id_.fetch_add(1);

TRACE_EVENT1("v8.wasm", "wasm.StartStreamingCompilation", "id",

compilation_id);

if (FLAG_wasm_async_compilation) {

AsyncCompileJob* job = CreateAsyncCompileJob(

isolate, enabled, std::unique_ptr<byte[]>(nullptr), 0, context,

api_method_name, std::move(resolver), compilation_id);

return job->CreateStreamingDecoder();

}

return StreamingDecoder::CreateSyncStreamingDecoder(

isolate, enabled, context, api_method_name, std::move(resolver));

uint32_t function_index, ExecutionTier tier) {

// Note we assume that "one-off" compilations can discard detected features.

WasmFeatures detected = WasmFeatures::None();

WasmCompilationUnit::CompileWasmFunction(

isolate, native_module, &detected,

&native_module->module()->functions[function_index], tier);

std::vector<std::shared_ptr<NativeModule>> native_modules;

{

base::MutexGuard lock(&mutex_);

if (isolates_[isolate]->keep_tiered_down) return;

isolates_[isolate]->keep_tiered_down = true;

for (auto* native_module : isolates_[isolate]->native_modules) {

native_module->SetTieringState(kTieredDown);

DCHECK_EQ(1, native_modules_.count(native_module));

if (auto shared_ptr = native_modules_[native_module]->weak_ptr.lock()) {

native_modules.emplace_back(std::move(shared_ptr));

}

}

}

for (auto& native_module : native_modules) {

native_module->RecompileForTiering();

}

// Only trigger recompilation after releasing the mutex, otherwise we risk

// deadlocks because of lock inversion. The bool tells whether the module

// needs recompilation for tier up.

std::vector<std::pair<std::shared_ptr<NativeModule>, bool>> native_modules;

{

base::MutexGuard lock(&mutex_);

isolates_[isolate]->keep_tiered_down = false;

auto test_can_tier_up = [this](NativeModule* native_module) {

DCHECK_EQ(1, native_modules_.count(native_module));

for (auto* isolate : native_modules_[native_module]->isolates) {

DCHECK_EQ(1, isolates_.count(isolate));

if (isolates_[isolate]->keep_tiered_down) return false;

}

return true;

};

for (auto* native_module : isolates_[isolate]->native_modules) {

DCHECK_EQ(1, native_modules_.count(native_module));

auto shared_ptr = native_modules_[native_module]->weak_ptr.lock();

if (!shared_ptr) continue; // The module is not used any more.

if (!native_module->IsTieredDown()) continue;

// Only start tier-up if no other isolate needs this module in tiered

// down state.

bool tier_up = test_can_tier_up(native_module);

if (tier_up) native_module->SetTieringState(kTieredUp);

native_modules.emplace_back(std::move(shared_ptr), tier_up);

}

}

for (auto& entry : native_modules) {

auto& native_module = entry.first;

bool tier_up = entry.second;

// Remove all breakpoints set by this isolate.

if (native_module->HasDebugInfo()) {

native_module->GetDebugInfo()->RemoveIsolate(isolate);

}

if (tier_up) native_module->RecompileForTiering();

}

std::shared_ptr<NativeModule> native_module,

base::Vector<const char> source_url) {

Handle<Script> script =

isolate->factory()->NewScript(isolate->factory()->undefined_value());

script->set_compilation_state(Script::COMPILATION_STATE_COMPILED);

script->set_context_data(isolate->native_context()->debug_context_id());

script->set_type(Script::TYPE_WASM);

base::Vector<const uint8_t> wire_bytes = native_module->wire_bytes();

// The source URL of the script is

// - the original source URL if available (from the streaming API),

// - wasm://wasm/<module name>-<hash> if a module name has been set, or

// - wasm://wasm/<hash> otherwise.

const WasmModule* module = native_module->module();

Handle<String> url_str;

if (!source_url.empty()) {

url_str = isolate->factory()

->NewStringFromUtf8(source_url, AllocationType::kOld)

.ToHandleChecked();

} else {

int hash = StringHasher::HashSequentialString(

reinterpret_cast<const char*>(wire_bytes.begin()), wire_bytes.length(),

kZeroHashSeed);

base::EmbeddedVector<char, 32> buffer;

if (module->name.is_empty()) {

// Build the URL in the form "wasm://wasm/<hash>".

int url_len = SNPrintF(buffer, "wasm://wasm/%08x", hash);

DCHECK(url_len >= 0 && url_len < buffer.length());

url_str = isolate->factory()

->NewStringFromUtf8(buffer.SubVector(0, url_len),

AllocationType::kOld)

.ToHandleChecked();

} else {

// Build the URL in the form "wasm://wasm/<module name>-<hash>".

int hash_len = SNPrintF(buffer, "-%08x", hash);

DCHECK(hash_len >= 0 && hash_len < buffer.length());

Handle<String> prefix =

isolate->factory()->NewStringFromStaticChars("wasm://wasm/");

Handle<String> module_name =

WasmModuleObject::ExtractUtf8StringFromModuleBytes(

isolate, wire_bytes, module->name, kNoInternalize);

Handle<String> hash_str =

isolate->factory()

->NewStringFromUtf8(buffer.SubVector(0, hash_len))

.ToHandleChecked();

// Concatenate the three parts.

url_str = isolate->factory()

->NewConsString(prefix, module_name)

.ToHandleChecked();

url_str = isolate->factory()

->NewConsString(url_str, hash_str)

.ToHandleChecked();

}

}

script->set_name(*url_str);

const WasmDebugSymbols& debug_symbols = module->debug_symbols;

if (debug_symbols.type == WasmDebugSymbols::Type::SourceMap &&

!debug_symbols.external_url.is_empty()) {

base::Vector<const char> external_url =

ModuleWireBytes(wire_bytes).GetNameOrNull(debug_symbols.external_url);

MaybeHandle<String> src_map_str = isolate->factory()->NewStringFromUtf8(

external_url, AllocationType::kOld);

script->set_source_mapping_url(*src_map_str.ToHandleChecked());

}

// Use the given shared {NativeModule}, but increase its reference count by

// allocating a new {Managed<T>} that the {Script} references.

size_t code_size_estimate = native_module->committed_code_space();

size_t memory_estimate =

code_size_estimate +

wasm::WasmCodeManager::EstimateNativeModuleMetaDataSize(module);

Handle<Managed<wasm::NativeModule>> managed_native_module =

Managed<wasm::NativeModule>::FromSharedPtr(isolate, memory_estimate,

std::move(native_module));

script->set_wasm_managed_native_module(*managed_native_module);

script->set_wasm_breakpoint_infos(ReadOnlyRoots(isolate).empty_fixed_array());

script->set_wasm_weak_instance_list(

ReadOnlyRoots(isolate).empty_weak_array_list());

return script;

Isolate* isolate, std::shared_ptr<NativeModule> shared_native_module,

base::Vector<const char> source_url) {

NativeModule* native_module = shared_native_module.get();

ModuleWireBytes wire_bytes(native_module->wire_bytes());

Handle<Script> script =

GetOrCreateScript(isolate, shared_native_module, source_url);

Handle<FixedArray> export_wrappers;

CompileJsToWasmWrappers(isolate, native_module->module(), &export_wrappers);

Handle<WasmModuleObject> module_object = WasmModuleObject::New(

isolate, std::move(shared_native_module), script, export_wrappers);

{

base::MutexGuard lock(&mutex_);

DCHECK_EQ(1, isolates_.count(isolate));

isolates_[isolate]->native_modules.insert(native_module);

DCHECK_EQ(1, native_modules_.count(native_module));

native_modules_[native_module]->isolates.insert(isolate);

}

// Finish the Wasm script now and make it public to the debugger.

isolate->debug()->OnAfterCompile(script);

return module_object;

base::MutexGuard guard(&mutex_);

if (compilation_stats_ != nullptr) {

StdoutStream os;

os << AsPrintableStatistics{*compilation_stats_.get(), false} << std::endl;

}

compilation_stats_.reset();

AsyncCompileJob* job) {

base::MutexGuard guard(&mutex_);

auto item = async_compile_jobs_.find(job);

DCHECK(item != async_compile_jobs_.end());

std::unique_ptr<AsyncCompileJob> result = std::move(item->second);

async_compile_jobs_.erase(item);

return result;

base::MutexGuard guard(&mutex_);

DCHECK_EQ(1, isolates_.count(isolate));

for (auto& entry : async_compile_jobs_) {

if (entry.first->isolate() == isolate) return true;

}

return false;

// Under the mutex get all jobs to delete. Then delete them without holding

// the mutex, such that deletion can reenter the WasmEngine.

std::vector<std::unique_ptr<AsyncCompileJob>> jobs_to_delete;

{

base::MutexGuard guard(&mutex_);

for (auto it = async_compile_jobs_.begin();

it != async_compile_jobs_.end();) {

if (!it->first->context().is_identical_to(context)) {

++it;

continue;

}

jobs_to_delete.push_back(std::move(it->second));

it = async_compile_jobs_.erase(it);

}

}

// Under the mutex get all jobs to delete. Then delete them without holding

// the mutex, such that deletion can reenter the WasmEngine.

std::vector<std::unique_ptr<AsyncCompileJob>> jobs_to_delete;

std::vector<std::weak_ptr<NativeModule>> modules_in_isolate;

std::shared_ptr<OperationsBarrier> wrapper_compilation_barrier;

{

base::MutexGuard guard(&mutex_);

for (auto it = async_compile_jobs_.begin();

it != async_compile_jobs_.end();) {

if (it->first->isolate() != isolate) {

++it;

continue;

}

jobs_to_delete.push_back(std::move(it->second));

it = async_compile_jobs_.erase(it);

}

DCHECK_EQ(1, isolates_.count(isolate));

auto* isolate_info = isolates_[isolate].get();

wrapper_compilation_barrier = isolate_info->wrapper_compilation_barrier_;

for (auto* native_module : isolate_info->native_modules) {

DCHECK_EQ(1, native_modules_.count(native_module));

modules_in_isolate.emplace_back(native_modules_[native_module]->weak_ptr);

}

}

// All modules that have not finished initial compilation yet cannot be

// shared with other isolates. Hence we cancel their compilation. In

// particular, this will cancel wrapper compilation which is bound to this

// isolate (this would be a UAF otherwise).

for (auto& weak_module : modules_in_isolate) {

if (auto shared_module = weak_module.lock()) {

shared_module->compilation_state()->CancelInitialCompilation();

}

}

// After cancelling, wait for all current wrapper compilation to actually

// finish.

wrapper_compilation_barrier->CancelAndWait();

base::MutexGuard guard(&mutex_);

auto isolate_info_it = isolates_.find(isolate);

if (isolate_info_it == isolates_.end()) return {};

return isolate_info_it->second->wrapper_compilation_barrier_->TryLock();

base::MutexGuard guard(&mutex_);

DCHECK_EQ(0, isolates_.count(isolate));

isolates_.emplace(isolate, std::make_unique<IsolateInfo>(isolate));

// Install sampling GC callback.