From 3d2159462c9a591c2df44847dea741aab4e0b217 Mon Sep 17 00:00:00 2001 From: Clemens Hammacher Date: Wed, 11 Sep 2019 16:31:23 +0200 Subject: [PATCH] [wasm] Allocate one far jump table per code space This moves the code to allocate the far jump table from {SetRuntimeStubs} to {AddCodeSpace} to allocate one such table per code space. Also, the {runtime_stub_table_} and {runtime_stub_entries_} fields do not make sense any more now and are replaced by calls to {GetNearRuntimeStubEntry} and {GetRuntimeStubId}. R=mstarzinger@chromium.org Bug: v8:9477 Change-Id: Ie1f5c9d4eb282270337a684c34f097d8077fdfbb Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1795348 Commit-Queue: Clemens Hammacher Reviewed-by: Michael Starzinger Cr-Commit-Position: refs/heads/master@{#63700} --- src/base/platform/mutex.h | 1 + src/wasm/jump-table-assembler.h | 6 + src/wasm/module-compiler.cc | 2 - src/wasm/wasm-code-manager.cc | 186 ++++++++++-------- src/wasm/wasm-code-manager.h | 36 ++-- src/wasm/wasm-serialization.cc | 21 +- .../wasm/test-wasm-import-wrapper-cache.cc | 4 +- test/cctest/wasm/wasm-run-utils.cc | 1 - 8 files changed, 135 insertions(+), 122 deletions(-) diff --git a/src/base/platform/mutex.h b/src/base/platform/mutex.h index c48cf8d339..5b3b31ec1e 100644 --- a/src/base/platform/mutex.h +++ b/src/base/platform/mutex.h @@ -290,6 +290,7 @@ class LockGuard final { }; using MutexGuard = LockGuard; +using RecursiveMutexGuard = LockGuard; enum MutexSharedType : bool { kShared = true, kExclusive = false }; diff --git a/src/wasm/jump-table-assembler.h b/src/wasm/jump-table-assembler.h index 9b3345f3fd..52e69d06bc 100644 --- a/src/wasm/jump-table-assembler.h +++ b/src/wasm/jump-table-assembler.h @@ -85,6 +85,12 @@ class V8_EXPORT_PRIVATE JumpTableAssembler : public MacroAssembler { return slot_index * kFarJumpTableSlotSize; } + // Translate a far jump table offset to the index into the table. + static uint32_t FarJumpSlotOffsetToIndex(uint32_t offset) { + DCHECK_EQ(0, offset % kFarJumpTableSlotSize); + return offset / kFarJumpTableSlotSize; + } + // Determine the size of a far jump table containing the given number of // slots. static constexpr uint32_t SizeForNumberOfFarJumpSlots( diff --git a/src/wasm/module-compiler.cc b/src/wasm/module-compiler.cc index 07fb58e765..a73265560f 100644 --- a/src/wasm/module-compiler.cc +++ b/src/wasm/module-compiler.cc @@ -1370,7 +1370,6 @@ std::shared_ptr CompileToNativeModule( auto native_module = isolate->wasm_engine()->NewNativeModule( isolate, enabled, std::move(module)); native_module->SetWireBytes(std::move(wire_bytes_copy)); - native_module->SetRuntimeStubs(isolate); CompileNativeModule(isolate, thrower, wasm_module, native_module.get()); if (thrower->error()) return {}; @@ -1509,7 +1508,6 @@ void AsyncCompileJob::CreateNativeModule( native_module_ = isolate_->wasm_engine()->NewNativeModule( isolate_, enabled_features_, std::move(module)); native_module_->SetWireBytes({std::move(bytes_copy_), wire_bytes_.length()}); - native_module_->SetRuntimeStubs(isolate_); if (stream_) stream_->NotifyNativeModuleCreated(native_module_); } diff --git a/src/wasm/wasm-code-manager.cc b/src/wasm/wasm-code-manager.cc index 7f1a11b2cf..a15e730238 100644 --- a/src/wasm/wasm-code-manager.cc +++ b/src/wasm/wasm-code-manager.cc @@ -244,7 +244,6 @@ void WasmCode::Validate() const { CHECK_NOT_NULL(code); #ifdef V8_EMBEDDED_BUILTINS CHECK_EQ(WasmCode::kJumpTable, code->kind()); - CHECK_EQ(native_module()->runtime_stub_table_, code); CHECK(code->contains(target)); #else CHECK_EQ(WasmCode::kRuntimeStub, code->kind()); @@ -539,7 +538,7 @@ Vector WasmCodeAllocator::AllocateForCode(NativeModule* native_module, Vector WasmCodeAllocator::AllocateForCodeInRegion( NativeModule* native_module, size_t size, base::AddressRegion region) { - base::MutexGuard lock(&mutex_); + base::RecursiveMutexGuard lock(&mutex_); DCHECK_EQ(code_manager_, native_module->engine()->code_manager()); DCHECK_LT(0, size); v8::PageAllocator* page_allocator = GetPlatformPageAllocator(); @@ -614,7 +613,7 @@ Vector WasmCodeAllocator::AllocateForCodeInRegion( } bool WasmCodeAllocator::SetExecutable(bool executable) { - base::MutexGuard lock(&mutex_); + base::RecursiveMutexGuard lock(&mutex_); if (is_executable_ == executable) return true; TRACE_HEAP("Setting module %p as executable: %d.\n", this, executable); @@ -677,7 +676,7 @@ void WasmCodeAllocator::FreeCode(Vector codes) { freed_code_size_.fetch_add(code_size); // Merge {freed_regions} into {freed_code_space_} and discard full pages. - base::MutexGuard guard(&mutex_); + base::RecursiveMutexGuard guard(&mutex_); PageAllocator* allocator = GetPlatformPageAllocator(); size_t commit_page_size = allocator->CommitPageSize(); for (auto region : freed_regions.regions()) { @@ -701,7 +700,7 @@ void WasmCodeAllocator::FreeCode(Vector codes) { } base::AddressRegion WasmCodeAllocator::GetSingleCodeRegion() const { - base::MutexGuard lock(&mutex_); + base::RecursiveMutexGuard lock(&mutex_); DCHECK_EQ(1, owned_code_space_.size()); return owned_code_space_[0].region(); } @@ -822,8 +821,8 @@ WasmCode* NativeModule::AddCodeForTesting(Handle code) { code->InstructionStart(); int mode_mask = RelocInfo::kApplyMask | RelocInfo::ModeMask(RelocInfo::WASM_STUB_CALL); - Address constant_pool_start = - reinterpret_cast
(dst_code_bytes.begin()) + constant_pool_offset; + Address dst_code_addr = reinterpret_cast
(dst_code_bytes.begin()); + Address constant_pool_start = dst_code_addr + constant_pool_offset; RelocIterator orig_it(*code, mode_mask); for (RelocIterator it(dst_code_bytes, reloc_info.as_vector(), constant_pool_start, mode_mask); @@ -832,8 +831,8 @@ WasmCode* NativeModule::AddCodeForTesting(Handle code) { if (RelocInfo::IsWasmStubCall(mode)) { uint32_t stub_call_tag = orig_it.rinfo()->wasm_call_tag(); DCHECK_LT(stub_call_tag, WasmCode::kRuntimeStubCount); - Address entry = runtime_stub_entry( - static_cast(stub_call_tag)); + Address entry = GetNearRuntimeStubEntry( + static_cast(stub_call_tag), dst_code_addr); it.rinfo()->set_wasm_stub_call_address(entry, SKIP_ICACHE_FLUSH); } else { it.rinfo()->apply(delta); @@ -885,13 +884,13 @@ void NativeModule::UseLazyStub(uint32_t func_index) { JumpTableAssembler::GenerateLazyCompileTable( lazy_compile_table_->instruction_start(), num_slots, module_->num_imported_functions, - runtime_stub_entry(WasmCode::kWasmCompileLazy)); + GetNearRuntimeStubEntry(WasmCode::kWasmCompileLazy, + lazy_compile_table_->instruction_start())); } // Add jump table entry for jump to the lazy compile stub. uint32_t slot_index = func_index - module_->num_imported_functions; DCHECK_NULL(code_table_[slot_index]); - DCHECK_NE(runtime_stub_entry(WasmCode::kWasmCompileLazy), kNullAddress); Address lazy_compile_target = lazy_compile_table_->instruction_start() + JumpTableAssembler::LazyCompileSlotIndexToOffset(slot_index); @@ -899,56 +898,6 @@ void NativeModule::UseLazyStub(uint32_t func_index) { PatchJumpTablesLocked(func_index, lazy_compile_target); } -// TODO(mstarzinger): Remove {Isolate} parameter once {V8_EMBEDDED_BUILTINS} -// was removed and embedded builtins are no longer optional. -void NativeModule::SetRuntimeStubs(Isolate* isolate) { -#ifndef V8_EMBEDDED_BUILTINS - FATAL( - "WebAssembly is not supported in no-embed builds. no-embed builds are " - "deprecated. See\n" - " - https://groups.google.com/d/msg/v8-users/9F53xqBjpkI/9WmKSbcWBAAJ\n" - " - https://crbug.com/v8/8519\n" - " - https://crbug.com/v8/8531\n"); -#endif // V8_EMBEDDED_BUILTINS - DCHECK_EQ(kNullAddress, runtime_stub_entries_[0]); // Only called once. - WasmCodeRefScope code_ref_scope; - base::AddressRegion single_code_space_region; - { - base::MutexGuard guard(&allocation_mutex_); - DCHECK_EQ(1, code_space_data_.size()); - single_code_space_region = code_space_data_[0].region; - } - int num_function_slots = - NumWasmFunctionsInFarJumpTable(module_->num_declared_functions); - WasmCode* jump_table = CreateEmptyJumpTableInRegion( - JumpTableAssembler::SizeForNumberOfFarJumpSlots( - WasmCode::kRuntimeStubCount, num_function_slots), - single_code_space_region); - Address base = jump_table->instruction_start(); - EmbeddedData embedded_data = EmbeddedData::FromBlob(); -#define RUNTIME_STUB(Name) Builtins::k##Name, -#define RUNTIME_STUB_TRAP(Name) RUNTIME_STUB(ThrowWasm##Name) - Builtins::Name wasm_runtime_stubs[WasmCode::kRuntimeStubCount] = { - WASM_RUNTIME_STUB_LIST(RUNTIME_STUB, RUNTIME_STUB_TRAP)}; -#undef RUNTIME_STUB -#undef RUNTIME_STUB_TRAP - Address builtin_address[WasmCode::kRuntimeStubCount]; - for (int i = 0; i < WasmCode::kRuntimeStubCount; ++i) { - Builtins::Name builtin = wasm_runtime_stubs[i]; - CHECK(embedded_data.ContainsBuiltin(builtin)); - builtin_address[i] = embedded_data.InstructionStartOfBuiltin(builtin); - runtime_stub_entries_[i] = - base + JumpTableAssembler::FarJumpSlotIndexToOffset(i); - } - JumpTableAssembler::GenerateFarJumpTable( - base, builtin_address, WasmCode::kRuntimeStubCount, num_function_slots); - DCHECK_NULL(runtime_stub_table_); - // TODO(clemensh): Store this as "far jump table" (instead of "runtime stub - // table") per code space. - runtime_stub_table_ = jump_table; - DCHECK_NE(kNullAddress, runtime_stub_entries_[0]); -} - std::unique_ptr NativeModule::AddCode( uint32_t index, const CodeDesc& desc, uint32_t stack_slots, uint32_t tagged_parameter_slots, @@ -995,8 +944,8 @@ std::unique_ptr NativeModule::AddCodeWithCodeSpace( int mode_mask = RelocInfo::kApplyMask | RelocInfo::ModeMask(RelocInfo::WASM_CALL) | RelocInfo::ModeMask(RelocInfo::WASM_STUB_CALL); - Address constant_pool_start = - reinterpret_cast
(dst_code_bytes.begin()) + constant_pool_offset; + Address code_start = reinterpret_cast
(dst_code_bytes.begin()); + Address constant_pool_start = code_start + constant_pool_offset; for (RelocIterator it(dst_code_bytes, reloc_info.as_vector(), constant_pool_start, mode_mask); !it.done(); it.next()) { @@ -1008,8 +957,8 @@ std::unique_ptr NativeModule::AddCodeWithCodeSpace( } else if (RelocInfo::IsWasmStubCall(mode)) { uint32_t stub_call_tag = it.rinfo()->wasm_call_tag(); DCHECK_LT(stub_call_tag, WasmCode::kRuntimeStubCount); - Address entry = runtime_stub_entry( - static_cast(stub_call_tag)); + Address entry = GetNearRuntimeStubEntry( + static_cast(stub_call_tag), code_start); it.rinfo()->set_wasm_stub_call_address(entry, SKIP_ICACHE_FLUSH); } else { it.rinfo()->apply(delta); @@ -1204,6 +1153,17 @@ void NativeModule::PatchJumpTablesLocked(uint32_t func_index, Address target) { } void NativeModule::AddCodeSpace(base::AddressRegion region) { +#ifndef V8_EMBEDDED_BUILTINS + // The far jump table contains far jumps to the embedded builtins. This + // requires a build with embedded builtins enabled. + FATAL( + "WebAssembly is not supported in no-embed builds. no-embed builds are " + "deprecated. See\n" + " - https://groups.google.com/d/msg/v8-users/9F53xqBjpkI/9WmKSbcWBAAJ\n" + " - https://crbug.com/v8/8519\n" + " - https://crbug.com/v8/8531\n"); +#endif // V8_EMBEDDED_BUILTINS + // Each code space must be at least twice as large as the overhead per code // space. Otherwise, we are wasting too much memory. DCHECK_GE(region.size(), @@ -1230,15 +1190,17 @@ void NativeModule::AddCodeSpace(base::AddressRegion region) { WasmCodeRefScope code_ref_scope; WasmCode* jump_table = nullptr; + WasmCode* far_jump_table = nullptr; const uint32_t num_wasm_functions = module_->num_declared_functions; const bool has_functions = num_wasm_functions > 0; - bool is_first_code_space; - { - base::MutexGuard guard(&allocation_mutex_); - is_first_code_space = code_space_data_.empty(); - } + const bool is_first_code_space = code_space_data_.empty(); + // TODO(clemensh): Avoid additional jump table if the code space is close + // enough to another existing code space. const bool needs_jump_table = - has_functions && is_first_code_space && !implicit_alloc_disabled; + has_functions && + (kNeedsFarJumpsBetweenCodeSpaces || is_first_code_space) && + !implicit_alloc_disabled; + const bool needs_far_jump_table = !implicit_alloc_disabled; if (needs_jump_table) { jump_table = CreateEmptyJumpTableInRegion( @@ -1246,10 +1208,35 @@ void NativeModule::AddCodeSpace(base::AddressRegion region) { CHECK(region.contains(jump_table->instruction_start())); } + if (needs_far_jump_table) { + int num_function_slots = NumWasmFunctionsInFarJumpTable(num_wasm_functions); + far_jump_table = CreateEmptyJumpTableInRegion( + JumpTableAssembler::SizeForNumberOfFarJumpSlots( + WasmCode::kRuntimeStubCount, num_function_slots), + region); + CHECK(region.contains(far_jump_table->instruction_start())); + EmbeddedData embedded_data = EmbeddedData::FromBlob(); +#define RUNTIME_STUB(Name) Builtins::k##Name, +#define RUNTIME_STUB_TRAP(Name) RUNTIME_STUB(ThrowWasm##Name) + Builtins::Name stub_names[WasmCode::kRuntimeStubCount] = { + WASM_RUNTIME_STUB_LIST(RUNTIME_STUB, RUNTIME_STUB_TRAP)}; +#undef RUNTIME_STUB +#undef RUNTIME_STUB_TRAP + Address builtin_addresses[WasmCode::kRuntimeStubCount]; + for (int i = 0; i < WasmCode::kRuntimeStubCount; ++i) { + Builtins::Name builtin = stub_names[i]; + CHECK(embedded_data.ContainsBuiltin(builtin)); + builtin_addresses[i] = embedded_data.InstructionStartOfBuiltin(builtin); + } + JumpTableAssembler::GenerateFarJumpTable( + far_jump_table->instruction_start(), builtin_addresses, + WasmCode::kRuntimeStubCount, num_function_slots); + } + if (is_first_code_space) main_jump_table_ = jump_table; base::MutexGuard guard(&allocation_mutex_); - code_space_data_.push_back(CodeSpaceData{region, jump_table}); + code_space_data_.push_back(CodeSpaceData{region, jump_table, far_jump_table}); } namespace { @@ -1305,6 +1292,19 @@ Address NativeModule::GetCallTargetForFunction(uint32_t func_index) const { return main_jump_table_->instruction_start() + slot_offset; } +Address NativeModule::GetNearRuntimeStubEntry(WasmCode::RuntimeStubId index, + Address near_to) const { + base::MutexGuard guard(&allocation_mutex_); + for (auto& code_space_data : code_space_data_) { + if (code_space_data.region.contains(near_to)) { + auto offset = JumpTableAssembler::FarJumpSlotIndexToOffset(index); + DCHECK_GT(code_space_data.far_jump_table->instructions().size(), offset); + return code_space_data.far_jump_table->instruction_start() + offset; + } + } + FATAL("near_to is not part of a code space"); +} + uint32_t NativeModule::GetFunctionIndexFromJumpTableSlot( Address slot_address) const { DCHECK(is_jump_table_slot(slot_address)); @@ -1315,16 +1315,40 @@ uint32_t NativeModule::GetFunctionIndexFromJumpTableSlot( return module_->num_imported_functions + slot_idx; } -const char* NativeModule::GetRuntimeStubName(Address runtime_stub_entry) const { -#define RETURN_NAME(Name) \ - if (runtime_stub_entries_[WasmCode::k##Name] == runtime_stub_entry) { \ - return #Name; \ +WasmCode::RuntimeStubId NativeModule::GetRuntimeStubId(Address target) const { + base::MutexGuard guard(&allocation_mutex_); + + for (auto& code_space_data : code_space_data_) { + if (code_space_data.far_jump_table->contains(target)) { + uint32_t offset = static_cast( + target - code_space_data.far_jump_table->instruction_start()); + uint32_t index = JumpTableAssembler::FarJumpSlotOffsetToIndex(offset); + if (index >= WasmCode::kRuntimeStubCount) continue; + if (JumpTableAssembler::FarJumpSlotIndexToOffset(index) != offset) { + continue; + } + return static_cast(index); + } } -#define RETURN_NAME_TRAP(Name) RETURN_NAME(ThrowWasm##Name) - WASM_RUNTIME_STUB_LIST(RETURN_NAME, RETURN_NAME_TRAP) -#undef RETURN_NAME_TRAP -#undef RETURN_NAME - return ""; + + // Invalid address. + return WasmCode::kRuntimeStubCount; +} + +const char* NativeModule::GetRuntimeStubName(Address target) const { + WasmCode::RuntimeStubId stub_id = GetRuntimeStubId(target); + +#define RUNTIME_STUB_NAME(Name) #Name, +#define RUNTIME_STUB_NAME_TRAP(Name) "ThrowWasm" #Name, + constexpr const char* runtime_stub_names[] = {WASM_RUNTIME_STUB_LIST( + RUNTIME_STUB_NAME, RUNTIME_STUB_NAME_TRAP) ""}; +#undef RUNTIME_STUB_NAME +#undef RUNTIME_STUB_NAME_TRAP + STATIC_ASSERT(arraysize(runtime_stub_names) == + WasmCode::kRuntimeStubCount + 1); + + DCHECK_GT(arraysize(runtime_stub_names), stub_id); + return runtime_stub_names[stub_id]; } NativeModule::~NativeModule() { diff --git a/src/wasm/wasm-code-manager.h b/src/wasm/wasm-code-manager.h index b1e95db4fb..6ae22bffb9 100644 --- a/src/wasm/wasm-code-manager.h +++ b/src/wasm/wasm-code-manager.h @@ -318,7 +318,10 @@ class WasmCodeAllocator { // The engine-wide wasm code manager. WasmCodeManager* const code_manager_; - mutable base::Mutex mutex_; + // TODO(clemensh): Try to make this non-recursive again. It's recursive + // currently because {AllocateForCodeInRegion} might create a new code space, + // which recursively calls {AllocateForCodeInRegion} for the jump table. + mutable base::RecursiveMutex mutex_; ////////////////////////////////////////////////////////////////////////////// // Protected by {mutex_}: @@ -392,11 +395,6 @@ class V8_EXPORT_PRIVATE NativeModule final { // table with trampolines accordingly. void UseLazyStub(uint32_t func_index); - // Initializes all runtime stubs by setting up entry addresses in the runtime - // stub table. It must be called exactly once per native module before adding - // other WasmCode so that runtime stub ids can be resolved during relocation. - void SetRuntimeStubs(Isolate* isolate); - // Creates a snapshot of the current state of the code table. This is useful // to get a consistent view of the table (e.g. used by the serializer). std::vector SnapshotCodeTable() const; @@ -407,13 +405,6 @@ class V8_EXPORT_PRIVATE NativeModule final { void SetWasmSourceMap(std::unique_ptr source_map); WasmModuleSourceMap* GetWasmSourceMap() const; - Address runtime_stub_entry(WasmCode::RuntimeStubId index) const { - DCHECK_LT(index, WasmCode::kRuntimeStubCount); - Address entry_address = runtime_stub_entries_[index]; - DCHECK_NE(kNullAddress, entry_address); - return entry_address; - } - Address jump_table_start() const { return main_jump_table_ ? main_jump_table_->instruction_start() : kNullAddress; @@ -429,6 +420,12 @@ class V8_EXPORT_PRIVATE NativeModule final { // the first jump table). Address GetCallTargetForFunction(uint32_t func_index) const; + // Get a runtime stub entry (which is a far jump table slot) within near-call + // distance to {near_to}. Fails if {near_to} is not part of any code space of + // this module. + Address GetNearRuntimeStubEntry(WasmCode::RuntimeStubId index, + Address near_to) const; + // Reverse lookup from a given call target (i.e. a jump table slot as the // above {GetCallTargetForFunction} returns) to a function index. uint32_t GetFunctionIndexFromJumpTableSlot(Address slot_address) const; @@ -479,7 +476,11 @@ class V8_EXPORT_PRIVATE NativeModule final { const WasmFeatures& enabled_features() const { return enabled_features_; } - const char* GetRuntimeStubName(Address runtime_stub_entry) const; + // Returns the runtime stub id that corresponds to the given address (which + // must be a far jump table slot). Returns {kRuntimeStubCount} on failure. + WasmCode::RuntimeStubId GetRuntimeStubId(Address runtime_stub_target) const; + + const char* GetRuntimeStubName(Address runtime_stub_target) const; // Sample the current code size of this modules to the given counters. enum CodeSamplingTime : int8_t { kAfterBaseline, kAfterTopTier, kSampling }; @@ -508,6 +509,7 @@ class V8_EXPORT_PRIVATE NativeModule final { struct CodeSpaceData { base::AddressRegion region; WasmCode* jump_table; + WasmCode* far_jump_table; }; // Private constructor, called via {WasmCodeManager::NewNativeModule()}. @@ -577,12 +579,6 @@ class V8_EXPORT_PRIVATE NativeModule final { // {WireBytesStorage}, held by background compile tasks. std::shared_ptr> wire_bytes_; - // Contains entry points for runtime stub calls via {WASM_STUB_CALL}. - Address runtime_stub_entries_[WasmCode::kRuntimeStubCount] = {kNullAddress}; - - // Jump table used for runtime stubs (i.e. trampolines to embedded builtins). - WasmCode* runtime_stub_table_ = nullptr; - // Jump table used by external calls (from JS). Wasm calls use one of the jump // tables stored in {code_space_data_}. WasmCode* main_jump_table_ = nullptr; diff --git a/src/wasm/wasm-serialization.cc b/src/wasm/wasm-serialization.cc index 81460b9fe2..f7f25e9ea7 100644 --- a/src/wasm/wasm-serialization.cc +++ b/src/wasm/wasm-serialization.cc @@ -289,9 +289,6 @@ class V8_EXPORT_PRIVATE NativeModuleSerializer { Vector code_table_; bool write_called_; - // Reverse lookup tables for embedded addresses. - std::map wasm_stub_targets_lookup_; - DISALLOW_COPY_AND_ASSIGN(NativeModuleSerializer); }; @@ -301,11 +298,6 @@ NativeModuleSerializer::NativeModuleSerializer( DCHECK_NOT_NULL(native_module_); // TODO(mtrofin): persist the export wrappers. Ideally, we'd only persist // the unique ones, i.e. the cache. - for (uint32_t i = 0; i < WasmCode::kRuntimeStubCount; ++i) { - Address addr = native_module_->runtime_stub_entry( - static_cast(i)); - wasm_stub_targets_lookup_.insert(std::make_pair(addr, i)); - } } size_t NativeModuleSerializer::MeasureCode(const WasmCode* code) const { @@ -400,10 +392,9 @@ void NativeModuleSerializer::WriteCode(const WasmCode* code, Writer* writer) { SetWasmCalleeTag(iter.rinfo(), tag); } break; case RelocInfo::WASM_STUB_CALL: { - Address orig_target = orig_iter.rinfo()->wasm_stub_call_address(); - auto stub_iter = wasm_stub_targets_lookup_.find(orig_target); - DCHECK(stub_iter != wasm_stub_targets_lookup_.end()); - uint32_t tag = stub_iter->second; + Address target = orig_iter.rinfo()->wasm_stub_call_address(); + uint32_t tag = native_module_->GetRuntimeStubId(target); + DCHECK_GT(WasmCode::kRuntimeStubCount, tag); SetWasmCalleeTag(iter.rinfo(), tag); } break; case RelocInfo::EXTERNAL_REFERENCE: { @@ -564,8 +555,9 @@ bool NativeModuleDeserializer::ReadCode(uint32_t fn_index, Reader* reader) { case RelocInfo::WASM_STUB_CALL: { uint32_t tag = GetWasmCalleeTag(iter.rinfo()); DCHECK_LT(tag, WasmCode::kRuntimeStubCount); - Address target = native_module_->runtime_stub_entry( - static_cast(tag)); + Address target = native_module_->GetNearRuntimeStubEntry( + static_cast(tag), + code->instruction_start()); iter.rinfo()->set_wasm_stub_call_address(target, SKIP_ICACHE_FLUSH); break; } @@ -628,7 +620,6 @@ MaybeHandle DeserializeNativeModule( auto shared_native_module = isolate->wasm_engine()->NewNativeModule( isolate, enabled_features, std::move(decode_result.value())); shared_native_module->SetWireBytes(OwnedVector::Of(wire_bytes_vec)); - shared_native_module->SetRuntimeStubs(isolate); Handle export_wrappers; CompileJsToWasmWrappers(isolate, shared_native_module->module(), diff --git a/test/cctest/wasm/test-wasm-import-wrapper-cache.cc b/test/cctest/wasm/test-wasm-import-wrapper-cache.cc index 299c039698..15267215e1 100644 --- a/test/cctest/wasm/test-wasm-import-wrapper-cache.cc +++ b/test/cctest/wasm/test-wasm-import-wrapper-cache.cc @@ -22,10 +22,8 @@ std::shared_ptr NewModule(Isolate* isolate) { std::shared_ptr module(new WasmModule); bool can_request_more = false; size_t size = 16384; - auto native_module = isolate->wasm_engine()->NewNativeModule( + return isolate->wasm_engine()->NewNativeModule( isolate, kAllWasmFeatures, size, can_request_more, std::move(module)); - native_module->SetRuntimeStubs(isolate); - return native_module; } TEST(CacheHit) { diff --git a/test/cctest/wasm/wasm-run-utils.cc b/test/cctest/wasm/wasm-run-utils.cc index 26aeedceaf..a2ec08c8fa 100644 --- a/test/cctest/wasm/wasm-run-utils.cc +++ b/test/cctest/wasm/wasm-run-utils.cc @@ -321,7 +321,6 @@ Handle TestingModuleBuilder::InitInstanceObject() { auto native_module = isolate_->wasm_engine()->NewNativeModule( isolate_, enabled_features_, test_module_); native_module->SetWireBytes(OwnedVector()); - native_module->SetRuntimeStubs(isolate_); Handle module_object = WasmModuleObject::New(isolate_, std::move(native_module), script);