AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[AsmJs] Avoid allocation of WasmModuleObject until instantiation.

Browse Source 
Moves allocation of the WasmModuleObject for asm.js code out of SyncCompileTranslatedAsmJS
since that is called when we are compiling the native context independent SharedFunctionInfo
and the WasmModuleObject requires a native context. Instead save the members required to
create the object in the AsmWasmData and create it during module instantiation. Note:
since the Wasm module is an implementation detail for asm_wasm code and isn't exposed,
this doeesn't have semantic change for asm.js code.

As part of this change, the AsmWasmData is changed from a FixedArray to a dedicated
struct. Some logic is also moved from module-compiler to wasm-engine to make the
seperation between Wasm SyncCompile and AsmJS SyncCompile more clear.

BUG=chromium:900535,v8:8395

Change-Id: Ia48469c095b0688f210aa86e7430c9ab4ea4b26b
Reviewed-on: https://chromium-review.googlesource.com/c/1345509
Commit-Queue: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57704}
This commit is contained in:
Ross McIlroy 2018-11-21 21:19:18 +00:00 committed by Commit Bot
parent 54f92d52c6
commit ccd8073c7b
25 changed files with 416 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/asmjs/asm-js.cc
View File

@ -36,11 +36,6 @@ namespace internal {
const char* const AsmJs::kSingleFunctionName = "__single_function__";
namespace {
enum WasmDataEntries {
kWasmDataCompiledModule,
kWasmDataUsesBitSet,
kWasmDataEntryCount,
};
Handle<Object> StdlibMathMember(Isolate* isolate, Handle<JSReceiver> stdlib,
Handle<Name> name) {
@ -282,23 +277,19 @@ UnoptimizedCompilationJob::Status AsmJsCompilationJob::FinalizeJobImpl(
Handle<HeapNumber> uses_bitset =
isolate->factory()->NewHeapNumberFromBits(stdlib_uses_.ToIntegral());
// The result is a compiled module and serialized standard library uses.
wasm::ErrorThrower thrower(isolate, "AsmJs::Compile");
Handle<WasmModuleObject> compiled =
Handle<AsmWasmData> result =
isolate->wasm_engine()
->SyncCompileTranslatedAsmJs(
isolate, &thrower,
wasm::ModuleWireBytes(module_->begin(), module_->end()),
parse_info()->script(),
Vector<const byte>(asm_offsets_->begin(), asm_offsets_->size()))
Vector<const byte>(asm_offsets_->begin(), asm_offsets_->size()),
uses_bitset)
.ToHandleChecked();
DCHECK(!thrower.error());
compile_time_ = compile_timer.Elapsed().InMillisecondsF();
// The result is a compiled module and serialized standard library uses.
Handle<FixedArray> result =
isolate->factory()->NewFixedArray(kWasmDataEntryCount);
result->set(kWasmDataCompiledModule, *compiled);
result->set(kWasmDataUsesBitSet, *uses_bitset);
compilation_info()->SetAsmWasmData(result);
RecordHistograms(isolate);
@ -354,17 +345,20 @@ inline bool IsValidAsmjsMemorySize(size_t size) {
MaybeHandle<Object> AsmJs::InstantiateAsmWasm(Isolate* isolate,
Handle<SharedFunctionInfo> shared,
Handle<FixedArray> wasm_data,
Handle<AsmWasmData> wasm_data,
Handle<JSReceiver> stdlib,
Handle<JSReceiver> foreign,
Handle<JSArrayBuffer> memory) {
base::ElapsedTimer instantiate_timer;
instantiate_timer.Start();
Handle<HeapNumber> uses_bitset(
HeapNumber::cast(wasm_data->get(kWasmDataUsesBitSet)), isolate);
Handle<WasmModuleObject> module(
WasmModuleObject::cast(wasm_data->get(kWasmDataCompiledModule)), isolate);
Handle<HeapNumber> uses_bitset(wasm_data->uses_bitset(), isolate);
Handle<Script> script(Script::cast(shared->script()), isolate);
// Allocate the WasmModuleObject.
Handle<WasmModuleObject> module =
isolate->wasm_engine()->FinalizeTranslatedAsmJs(isolate, wasm_data,
script);
// TODO(mstarzinger): The position currently points to the module definition
// but should instead point to the instantiation site (more intuitive).
int position = shared->StartPosition();

3
src/asmjs/asm-js.h
View File

@ -13,6 +13,7 @@ namespace v8 {
namespace internal {
class AccountingAllocator;
class AsmWasmData;
class FunctionLiteral;
class JSArrayBuffer;
class ParseInfo;
@ -27,7 +28,7 @@ class AsmJs {
AccountingAllocator* allocator);
static MaybeHandle<Object> InstantiateAsmWasm(Isolate* isolate,
Handle<SharedFunctionInfo>,
Handle<FixedArray> wasm_data,
Handle<AsmWasmData> wasm_data,
Handle<JSReceiver> stdlib,
Handle<JSReceiver> foreign,
Handle<JSArrayBuffer> memory);

10
src/code-stub-assembler.cc
View File

@ -13260,20 +13260,20 @@ TNode<Code> CodeStubAssembler::GetSharedFunctionInfoCode(
int32_t case_values[] = {BYTECODE_ARRAY_TYPE,
WASM_EXPORTED_FUNCTION_DATA_TYPE,
FIXED_ARRAY_TYPE,
ASM_WASM_DATA_TYPE,
UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE,
UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE,
FUNCTION_TEMPLATE_INFO_TYPE};
Label check_is_bytecode_array(this);
Label check_is_exported_function_data(this);
Label check_is_fixed_array(this);
Label check_is_asm_wasm_data(this);
Label check_is_uncompiled_data_without_pre_parsed_scope(this);
Label check_is_uncompiled_data_with_pre_parsed_scope(this);
Label check_is_function_template_info(this);
Label check_is_interpreter_data(this);
Label* case_labels[] = {&check_is_bytecode_array,
&check_is_exported_function_data,
&check_is_fixed_array,
&check_is_asm_wasm_data,
&check_is_uncompiled_data_without_pre_parsed_scope,
&check_is_uncompiled_data_with_pre_parsed_scope,
&check_is_function_template_info};
@ -13292,8 +13292,8 @@ TNode<Code> CodeStubAssembler::GetSharedFunctionInfoCode(
CAST(sfi_data), WasmExportedFunctionData::kWrapperCodeOffset));
Goto(&done);
// IsFixedArray: Instantiate using AsmWasmData
BIND(&check_is_fixed_array);
// IsAsmWasmData: Instantiate using AsmWasmData
BIND(&check_is_asm_wasm_data);
sfi_code = HeapConstant(BUILTIN_CODE(isolate(), InstantiateAsmJs));
Goto(&done);

1
src/compiler/code-assembler.h
View File

@ -28,6 +28,7 @@ namespace v8 {
namespace internal {
// Forward declarations.
class AsmWasmData;
class CallInterfaceDescriptor;
class Callable;
class Factory;

1
src/compiler/types.cc
View File

@ -333,6 +333,7 @@ Type::bitset BitsetType::Lub(const MapRefLike& map) {
#undef FIXED_TYPED_ARRAY_CASE
case FILLER_TYPE:
case ACCESS_CHECK_INFO_TYPE:
case ASM_WASM_DATA_TYPE:
case CALL_HANDLER_INFO_TYPE:
case INTERCEPTOR_INFO_TYPE:
case OBJECT_TEMPLATE_INFO_TYPE:

9
src/objects-debug.cc
View File

@ -1740,6 +1740,15 @@ void ArrayBoilerplateDescription::ArrayBoilerplateDescriptionVerify(
VerifyObjectField(isolate, kConstantElementsOffset);
}
void AsmWasmData::AsmWasmDataVerify(Isolate* isolate) {
CHECK(IsAsmWasmData());
VerifyObjectField(isolate, kManagedNativeModuleOffset);
VerifyObjectField(isolate, kExportWrappersOffset);
VerifyObjectField(isolate, kAsmJsOffsetTableOffset);
CHECK(uses_bitset()->IsHeapNumber());
VerifyObjectField(isolate, kUsesBitsetOffset);
}
void WasmDebugInfo::WasmDebugInfoVerify(Isolate* isolate) {
CHECK(IsWasmDebugInfo());
VerifyObjectField(isolate, kInstanceOffset);

2
src/objects-definitions.h
View File

@ -96,6 +96,7 @@ namespace internal {
V(ACCESSOR_PAIR_TYPE) \
V(ALIASED_ARGUMENTS_ENTRY_TYPE) \
V(ALLOCATION_MEMENTO_TYPE) \
V(ASM_WASM_DATA_TYPE) \
V(ASYNC_GENERATOR_REQUEST_TYPE) \
V(DEBUG_INFO_TYPE) \
V(FUNCTION_TEMPLATE_INFO_TYPE) \
@ -315,6 +316,7 @@ namespace internal {
V(_, ALIASED_ARGUMENTS_ENTRY_TYPE, AliasedArgumentsEntry, \
aliased_arguments_entry) \
V(_, ALLOCATION_MEMENTO_TYPE, AllocationMemento, allocation_memento) \
V(_, ASM_WASM_DATA_TYPE, AsmWasmData, asm_wasm_data) \
V(_, ASYNC_GENERATOR_REQUEST_TYPE, AsyncGeneratorRequest, \
async_generator_request) \
V(_, DEBUG_INFO_TYPE, DebugInfo, debug_info) \

9
src/objects-printer.cc
View File

@ -1786,6 +1786,15 @@ void ArrayBoilerplateDescription::ArrayBoilerplateDescriptionPrint(
os << "\n";
}
void AsmWasmData::AsmWasmDataPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "AsmWasmData");
os << "\n - native module: " << Brief(managed_native_module());
os << "\n - export_wrappers: " << Brief(export_wrappers());
os << "\n - offset table: " << Brief(asm_js_offset_table());
os << "\n - uses bitset: " << uses_bitset()->value();
os << "\n";
}
void WasmDebugInfo::WasmDebugInfoPrint(std::ostream& os) { // NOLINT
HeapObject::PrintHeader(os, "WasmDebugInfo");
os << "\n - wasm_instance: " << Brief(wasm_instance());

4
src/objects.cc
View File

@ -13824,8 +13824,8 @@ Code SharedFunctionInfo::GetCode() const {
// Having a bytecode array means we are a compiled, interpreted function.
DCHECK(HasBytecodeArray());
return isolate->builtins()->builtin(Builtins::kInterpreterEntryTrampoline);
} else if (data->IsFixedArray()) {
// Having a fixed array means we are an asm.js/wasm function.
} else if (data->IsAsmWasmData()) {
// Having AsmWasmData means we are an asm.js/wasm function.
DCHECK(HasAsmWasmData());
return isolate->builtins()->builtin(Builtins::kInstantiateAsmJs);
} else if (data->IsUncompiledData()) {

2
src/objects.h
View File

@ -140,6 +140,7 @@
// - SharedFunctionInfo
// - Struct
// - AccessorInfo
// - AsmWasmData
// - PromiseReaction
// - PromiseCapability
// - AccessorPair
@ -391,6 +392,7 @@ enum InstanceType : uint16_t {
ACCESSOR_PAIR_TYPE,
ALIASED_ARGUMENTS_ENTRY_TYPE,
ALLOCATION_MEMENTO_TYPE,
ASM_WASM_DATA_TYPE,
ASYNC_GENERATOR_REQUEST_TYPE,
DEBUG_INFO_TYPE,
FUNCTION_TEMPLATE_INFO_TYPE,

9
src/objects/shared-function-info-inl.h
View File

@ -12,6 +12,7 @@
#include "src/objects/debug-objects-inl.h"
#include "src/objects/scope-info.h"
#include "src/objects/templates.h"
#include "src/wasm/wasm-objects-inl.h"
// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"
@ -456,15 +457,15 @@ void SharedFunctionInfo::set_interpreter_data(
}
bool SharedFunctionInfo::HasAsmWasmData() const {
return function_data()->IsFixedArray();
return function_data()->IsAsmWasmData();
}
FixedArray* SharedFunctionInfo::asm_wasm_data() const {
AsmWasmData* SharedFunctionInfo::asm_wasm_data() const {
DCHECK(HasAsmWasmData());
return FixedArray::cast(function_data());
return AsmWasmData::cast(function_data());
}
void SharedFunctionInfo::set_asm_wasm_data(FixedArray* data) {
void SharedFunctionInfo::set_asm_wasm_data(AsmWasmData* data) {
DCHECK(function_data() == Smi::FromEnum(Builtins::kCompileLazy) ||
HasUncompiledData() || HasAsmWasmData());
set_function_data(data);

7
src/objects/shared-function-info.h
View File

@ -17,6 +17,7 @@
namespace v8 {
namespace internal {
class AsmWasmData;
class BytecodeArray;
class CoverageInfo;
class DebugInfo;
@ -281,7 +282,7 @@ class SharedFunctionInfo : public HeapObject, public NeverReadOnlySpaceObject {
// - a BytecodeArray for the interpreter [HasBytecodeArray()].
// - a InterpreterData with the BytecodeArray and a copy of the
// interpreter trampoline [HasInterpreterData()]
// - a FixedArray with Asm->Wasm conversion [HasAsmWasmData()].
// - an AsmWasmData with Asm->Wasm conversion [HasAsmWasmData()].
// - a Smi containing the builtin id [HasBuiltinId()]
// - a UncompiledDataWithoutPreParsedScope for lazy compilation
// [HasUncompiledDataWithoutPreParsedScope()]
@ -303,8 +304,8 @@ class SharedFunctionInfo : public HeapObject, public NeverReadOnlySpaceObject {
inline BytecodeArray* GetDebugBytecodeArray() const;
inline void SetDebugBytecodeArray(BytecodeArray* bytecode);
inline bool HasAsmWasmData() const;
inline FixedArray* asm_wasm_data() const;
inline void set_asm_wasm_data(FixedArray* data);
inline AsmWasmData* asm_wasm_data() const;
inline void set_asm_wasm_data(AsmWasmData* data);
// A brief note to clear up possible confusion:
// builtin_id corresponds to the auto-generated

2
src/runtime/runtime-compiler.cc
View File

@ -123,7 +123,7 @@ RUNTIME_FUNCTION(Runtime_InstantiateAsmJs) {
}
if (function->shared()->HasAsmWasmData()) {
Handle<SharedFunctionInfo> shared(function->shared(), isolate);
Handle<FixedArray> data(shared->asm_wasm_data(), isolate);
Handle<AsmWasmData> data(shared->asm_wasm_data(), isolate);
MaybeHandle<Object> result = AsmJs::InstantiateAsmWasm(
isolate, shared, data, stdlib, foreign, memory);
if (!result.is_null()) {

9
src/unoptimized-compilation-info.h
View File

@ -17,6 +17,7 @@
namespace v8 {
namespace internal {
class AsmWasmData;
class CoverageInfo;
class DeclarationScope;
class FunctionLiteral;
@ -83,8 +84,8 @@ class V8_EXPORT_PRIVATE UnoptimizedCompilationInfo final {
}
bool has_asm_wasm_data() const { return !asm_wasm_data_.is_null(); }
Handle<FixedArray> asm_wasm_data() const { return asm_wasm_data_; }
void SetAsmWasmData(Handle<FixedArray> asm_wasm_data) {
Handle<AsmWasmData> asm_wasm_data() const { return asm_wasm_data_; }
void SetAsmWasmData(Handle<AsmWasmData> asm_wasm_data) {
asm_wasm_data_ = asm_wasm_data;
}
@ -123,8 +124,8 @@ class V8_EXPORT_PRIVATE UnoptimizedCompilationInfo final {
// Holds the bytecode array generated by the interpreter.
Handle<BytecodeArray> bytecode_array_;
// Holds the asm_wasm array generated by the asmjs compiler.
Handle<FixedArray> asm_wasm_data_;
// Holds the asm_wasm data struct generated by the asmjs compiler.
Handle<AsmWasmData> asm_wasm_data_;
// Holds the feedback vector spec generated during compilation
FeedbackVectorSpec feedback_vector_spec_;

79
src/wasm/module-compiler.cc
View File

@ -683,8 +683,7 @@ void FinishCompilationUnits(CompilationStateImpl* compilation_state) {
}
}
void CompileInParallel(Isolate* isolate, NativeModule* native_module,
Handle<WasmModuleObject> module_object) {
void CompileInParallel(Isolate* isolate, NativeModule* native_module) {
// Data structures for the parallel compilation.
//-----------------------------------------------------------------------
@ -831,9 +830,8 @@ void ValidateSequentially(Isolate* isolate, NativeModule* native_module,
}
void CompileNativeModule(Isolate* isolate, ErrorThrower* thrower,
Handle<WasmModuleObject> module_object,
const WasmModule* wasm_module) {
NativeModule* const native_module = module_object->native_module();
const WasmModule* wasm_module,
NativeModule* native_module) {
ModuleWireBytes wire_bytes(native_module->wire_bytes());
if (compile_lazy(wasm_module)) {
@ -858,7 +856,7 @@ void CompileNativeModule(Isolate* isolate, ErrorThrower* thrower,
V8::GetCurrentPlatform()->NumberOfWorkerThreads() > 0;
if (compile_parallel) {
CompileInParallel(isolate, native_module, module_object);
CompileInParallel(isolate, native_module);
} else {
CompileSequentially(isolate, native_module, thrower);
}
@ -965,11 +963,10 @@ class BackgroundCompileTask : public CancelableTask {
} // namespace
MaybeHandle<WasmModuleObject> CompileToModuleObject(
std::unique_ptr<NativeModule> CompileToNativeModule(
Isolate* isolate, const WasmFeatures& enabled, ErrorThrower* thrower,
std::shared_ptr<const WasmModule> module, const ModuleWireBytes& wire_bytes,
Handle<Script> asm_js_script,
Vector<const byte> asm_js_offset_table_bytes) {
Handle<FixedArray>* export_wrappers_out) {
const WasmModule* wasm_module = module.get();
TimedHistogramScope wasm_compile_module_time_scope(SELECT_WASM_COUNTER(
isolate->counters(), wasm_module->origin, wasm_compile, module_time));
@ -978,53 +975,36 @@ MaybeHandle<WasmModuleObject> CompileToModuleObject(
if (wasm_module->has_shared_memory) {
isolate->CountUsage(v8::Isolate::UseCounterFeature::kWasmSharedMemory);
}
int export_wrapper_size = static_cast<int>(module->num_exported_functions);
// Create heap objects for script, module bytes and asm.js offset table to
// be stored in the module object.
Handle<Script> script;
Handle<ByteArray> asm_js_offset_table;
if (asm_js_script.is_null()) {
script = CreateWasmScript(isolate, wire_bytes, wasm_module->source_map_url);
} else {
script = asm_js_script;
asm_js_offset_table =
isolate->factory()->NewByteArray(asm_js_offset_table_bytes.length());
asm_js_offset_table->copy_in(0, asm_js_offset_table_bytes.start(),
asm_js_offset_table_bytes.length());
}
// TODO(wasm): only save the sections necessary to deserialize a
// {WasmModule}. E.g. function bodies could be omitted.
OwnedVector<uint8_t> wire_bytes_copy =
OwnedVector<uint8_t>::Of(wire_bytes.module_bytes());
// Create the module object.
// TODO(clemensh): For the same module (same bytes / same hash), we should
// only have one WasmModuleObject. Otherwise, we might only set
// breakpoints on a (potentially empty) subset of the instances.
// Create and compile the native module.
size_t code_size_estimate =
wasm::WasmCodeManager::EstimateNativeModuleCodeSize(module.get());
// 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, enabled, std::move(module), std::move(wire_bytes_copy), script,
asm_js_offset_table);
CompileNativeModule(isolate, thrower, module_object, wasm_module);
// Create a new {NativeModule} first.
auto native_module = isolate->wasm_engine()->code_manager()->NewNativeModule(
isolate, enabled, code_size_estimate,
wasm::NativeModule::kCanAllocateMoreMemory, 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 {};
// Compile JS->wasm wrappers for exported functions.
CompileJsToWasmWrappers(isolate, module_object);
// If we created a wasm script, finish it now and make it public to the
// debugger.
if (asm_js_script.is_null()) {
isolate->debug()->OnAfterCompile(script);
}
*export_wrappers_out =
isolate->factory()->NewFixedArray(export_wrapper_size, TENURED);
CompileJsToWasmWrappers(isolate, native_module.get(), *export_wrappers_out);
// Log the code within the generated module for profiling.
module_object->native_module()->LogWasmCodes(isolate);
native_module->LogWasmCodes(isolate);
return module_object;
return native_module;
}
InstanceBuilder::InstanceBuilder(Isolate* isolate, ErrorThrower* thrower,
@ -1125,7 +1105,7 @@ MaybeHandle<WasmInstanceObject> InstanceBuilder::Build() {
// Recompile all functions in this native module.
ErrorThrower thrower(isolate_, "recompile");
CompileNativeModule(isolate_, &thrower, module_object_, module_);
CompileNativeModule(isolate_, &thrower, module_, native_module);
if (thrower.error()) {
return {};
}
@ -2741,7 +2721,9 @@ class AsyncCompileJob::CompileWrappers : public CompileStep {
void RunInForeground(AsyncCompileJob* job) override {
TRACE_COMPILE("(5) Compile wrappers...\n");
// Compile JS->wasm wrappers for exported functions.
CompileJsToWasmWrappers(job->isolate_, job->module_object_);
CompileJsToWasmWrappers(
job->isolate_, job->module_object_->native_module(),
handle(job->module_object_->export_wrappers(), job->isolate_));
job->DoSync<FinishModule>();
}
};
@ -3220,13 +3202,12 @@ void CompilationStateImpl::NotifyOnEvent(CompilationEvent event,
if (callback_) callback_(event, error_result);
}
void CompileJsToWasmWrappers(Isolate* isolate,
Handle<WasmModuleObject> module_object) {
void CompileJsToWasmWrappers(Isolate* isolate, NativeModule* native_module,
Handle<FixedArray> export_wrappers) {
JSToWasmWrapperCache js_to_wasm_cache;
int wrapper_index = 0;
Handle<FixedArray> export_wrappers(module_object->export_wrappers(), isolate);
NativeModule* native_module = module_object->native_module();
const WasmModule* module = native_module->module();
// TODO(6792): Wrappers below are allocated with {Factory::NewCode}. As an
// optimization we keep the code space unlocked to avoid repeated unlocking
// because many such wrapper are allocated in sequence below.

8
src/wasm/module-compiler.h
View File

@ -37,10 +37,10 @@ class NativeModule;
class WasmCode;
struct WasmModule;
MaybeHandle<WasmModuleObject> CompileToModuleObject(
std::unique_ptr<NativeModule> CompileToNativeModule(
Isolate* isolate, const WasmFeatures& enabled, ErrorThrower* thrower,
std::shared_ptr<const WasmModule> module, const ModuleWireBytes& wire_bytes,
Handle<Script> asm_js_script, Vector<const byte> asm_js_offset_table_bytes);
Handle<FixedArray>* export_wrappers_out);
MaybeHandle<WasmInstanceObject> InstantiateToInstanceObject(
Isolate* isolate, ErrorThrower* thrower,
@ -48,8 +48,8 @@ MaybeHandle<WasmInstanceObject> InstantiateToInstanceObject(
MaybeHandle<JSArrayBuffer> memory);
V8_EXPORT_PRIVATE
void CompileJsToWasmWrappers(Isolate* isolate,
Handle<WasmModuleObject> module_object);
void CompileJsToWasmWrappers(Isolate* isolate, NativeModule* native_module,
Handle<FixedArray> export_wrappers);
V8_EXPORT_PRIVATE Handle<Script> CreateWasmScript(
Isolate* isolate, const ModuleWireBytes& wire_bytes,

78
src/wasm/wasm-engine.cc
View File

@ -38,20 +38,50 @@ bool WasmEngine::SyncValidate(Isolate* isolate, const WasmFeatures& enabled,
return result.ok();
}
MaybeHandle<WasmModuleObject> WasmEngine::SyncCompileTranslatedAsmJs(
MaybeHandle<AsmWasmData> WasmEngine::SyncCompileTranslatedAsmJs(
Isolate* isolate, ErrorThrower* thrower, const ModuleWireBytes& bytes,
Handle<Script> asm_js_script,
Vector<const byte> asm_js_offset_table_bytes) {
Vector<const byte> asm_js_offset_table_bytes,
Handle<HeapNumber> uses_bitset) {
ModuleResult result =
DecodeWasmModule(kAsmjsWasmFeatures, bytes.start(), bytes.end(), false,
kAsmJsOrigin, isolate->counters(), allocator());
CHECK(!result.failed());
// Transfer ownership of the WasmModule to the {Managed<WasmModule>} generated
// in {CompileToModuleObject}.
return CompileToModuleObject(isolate, kAsmjsWasmFeatures, thrower,
std::move(result).value(), bytes, asm_js_script,
asm_js_offset_table_bytes);
// in {CompileToNativeModule}.
Handle<FixedArray> export_wrappers;
std::unique_ptr<NativeModule> native_module =
CompileToNativeModule(isolate, kAsmjsWasmFeatures, thrower,
std::move(result).value(), bytes, &export_wrappers);
if (!native_module) return {};
// Create heap objects for asm.js offset table to be stored in the module
// object.
Handle<ByteArray> asm_js_offset_table =
isolate->factory()->NewByteArray(asm_js_offset_table_bytes.length());
asm_js_offset_table->copy_in(0, asm_js_offset_table_bytes.start(),
asm_js_offset_table_bytes.length());
return AsmWasmData::New(isolate, std::move(native_module), export_wrappers,
asm_js_offset_table, uses_bitset);
}
Handle<WasmModuleObject> WasmEngine::FinalizeTranslatedAsmJs(
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);
size_t code_size_estimate =
wasm::WasmCodeManager::EstimateNativeModuleCodeSize(
native_module->module());
Handle<WasmModuleObject> module_object =
WasmModuleObject::New(isolate, std::move(native_module), script,
export_wrappers, code_size_estimate);
module_object->set_asm_js_offset_table(asm_wasm_data->asm_js_offset_table());
return module_object;
}
MaybeHandle<WasmModuleObject> WasmEngine::SyncCompile(
@ -67,9 +97,34 @@ MaybeHandle<WasmModuleObject> WasmEngine::SyncCompile(
// Transfer ownership of the WasmModule to the {Managed<WasmModule>} generated
// in {CompileToModuleObject}.
return CompileToModuleObject(isolate, enabled, thrower,
std::move(result).value(), bytes,
Handle<Script>(), Vector<const byte>());
Handle<FixedArray> export_wrappers;
std::unique_ptr<NativeModule> native_module =
CompileToNativeModule(isolate, enabled, thrower,
std::move(result).value(), bytes, &export_wrappers);
if (!native_module) return {};
Handle<Script> script =
CreateWasmScript(isolate, bytes, native_module->module()->source_map_url);
size_t code_size_estimate =
wasm::WasmCodeManager::EstimateNativeModuleCodeSize(
native_module->module());
// Create the module object.
// TODO(clemensh): For the same module (same bytes / same hash), we should
// only have one WasmModuleObject. Otherwise, we might only set
// breakpoints on a (potentially empty) subset of the instances.
// 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, code_size_estimate);
// Finish the Wasm script now and make it public to the debugger.
isolate->debug()->OnAfterCompile(script);
return module_object;
}
MaybeHandle<WasmInstanceObject> WasmEngine::SyncInstantiate(
@ -194,7 +249,8 @@ Handle<WasmModuleObject> WasmEngine::ImportNativeModule(
size_t code_size = shared_module->committed_code_space();
Handle<WasmModuleObject> module_object = WasmModuleObject::New(
isolate, std::move(shared_module), script, code_size);
CompileJsToWasmWrappers(isolate, module_object);
CompileJsToWasmWrappers(isolate, module_object->native_module(),
handle(module_object->export_wrappers(), isolate));
return module_object;
}

10
src/wasm/wasm-engine.h
View File

@ -16,6 +16,7 @@
namespace v8 {
namespace internal {
class AsmWasmData;
class CodeTracer;
class CompilationStatistics;
class WasmInstanceObject;
@ -56,10 +57,13 @@ class V8_EXPORT_PRIVATE WasmEngine {
// Synchronously compiles the given bytes that represent a translated
// asm.js module.
MaybeHandle<WasmModuleObject> SyncCompileTranslatedAsmJs(
MaybeHandle<AsmWasmData> SyncCompileTranslatedAsmJs(
Isolate* isolate, ErrorThrower* thrower, const ModuleWireBytes& bytes,
Handle<Script> asm_js_script,
Vector<const byte> asm_js_offset_table_bytes);
Vector<const byte> asm_js_offset_table_bytes,
Handle<HeapNumber> uses_bitset);
Handle<WasmModuleObject> FinalizeTranslatedAsmJs(
Isolate* isolate, Handle<AsmWasmData> asm_wasm_data,
Handle<Script> script);
// Synchronously compiles the given bytes that represent an encoded WASM
// module.

8
src/wasm/wasm-objects-inl.h
View File

@ -29,6 +29,7 @@ CAST_ACCESSOR(WasmInstanceObject)
CAST_ACCESSOR(WasmMemoryObject)
CAST_ACCESSOR(WasmModuleObject)
CAST_ACCESSOR(WasmTableObject)
CAST_ACCESSOR(AsmWasmData)
#define OPTIONAL_ACCESSORS(holder, name, type, offset) \
bool holder::has_##name() { \
@ -240,6 +241,13 @@ uint32_t WasmTableObject::current_length() { return functions()->length(); }
bool WasmMemoryObject::has_maximum_pages() { return maximum_pages() >= 0; }
// AsmWasmData
ACCESSORS(AsmWasmData, managed_native_module, Managed<wasm::NativeModule>,
kManagedNativeModuleOffset)
ACCESSORS(AsmWasmData, export_wrappers, FixedArray, kExportWrappersOffset)
ACCESSORS(AsmWasmData, asm_js_offset_table, ByteArray, kAsmJsOffsetTableOffset)
ACCESSORS(AsmWasmData, uses_bitset, HeapNumber, kUsesBitsetOffset)
#include "src/objects/object-macros-undef.h"
} // namespace internal

30
src/wasm/wasm-objects.cc
View File

@ -205,6 +205,16 @@ Handle<WasmModuleObject> WasmModuleObject::New(
int export_wrapper_size = static_cast<int>(module->num_exported_functions);
Handle<FixedArray> export_wrappers =
isolate->factory()->NewFixedArray(export_wrapper_size, TENURED);
return New(isolate, std::move(native_module), script, export_wrappers,
code_size_estimate);
}
// static
Handle<WasmModuleObject> WasmModuleObject::New(
Isolate* isolate, std::shared_ptr<wasm::NativeModule> native_module,
Handle<Script> script, Handle<FixedArray> export_wrappers,
size_t code_size_estimate) {
const WasmModule* module = native_module->module();
// Use the given shared {NativeModule}, but increase its reference count by
// allocating a new {Managed<T>} that the {WasmModuleObject} references.
@ -1426,6 +1436,26 @@ wasm::FunctionSig* WasmExportedFunction::sig() {
return instance()->module()->functions[function_index()].sig;
}
Handle<AsmWasmData> AsmWasmData::New(
Isolate* isolate, std::shared_ptr<wasm::NativeModule> native_module,
Handle<FixedArray> export_wrappers, Handle<ByteArray> asm_js_offset_table,
Handle<HeapNumber> uses_bitset) {
const WasmModule* module = native_module->module();
size_t memory_estimate =
wasm::WasmCodeManager::EstimateNativeModuleCodeSize(module) +
wasm::WasmCodeManager::EstimateNativeModuleNonCodeSize(module);
Handle<Managed<wasm::NativeModule>> managed_native_module =
Managed<wasm::NativeModule>::FromSharedPtr(isolate, memory_estimate,
std::move(native_module));
Handle<AsmWasmData> result = Handle<AsmWasmData>::cast(
isolate->factory()->NewStruct(ASM_WASM_DATA_TYPE, TENURED));
result->set_managed_native_module(*managed_native_module);
result->set_export_wrappers(*export_wrappers);
result->set_asm_js_offset_table(*asm_js_offset_table);
result->set_uses_bitset(*uses_bitset);
return result;
}
#undef TRACE
#undef TRACE_IFT
} // namespace internal

33
src/wasm/wasm-objects.h
View File

@ -146,6 +146,10 @@ class WasmModuleObject : public JSObject {
static Handle<WasmModuleObject> New(
Isolate* isolate, std::shared_ptr<wasm::NativeModule> native_module,
Handle<Script> script, size_t code_size_estimate);
static Handle<WasmModuleObject> New(
Isolate* isolate, std::shared_ptr<wasm::NativeModule> native_module,
Handle<Script> script, Handle<FixedArray> export_wrappers,
size_t code_size_estimate);
// Set a breakpoint on the given byte position inside the given module.
// This will affect all live and future instances of the module.
@ -640,6 +644,35 @@ class WasmDebugInfo : public Struct, public NeverReadOnlySpaceObject {
wasm::FunctionSig*);
};
class AsmWasmData : public Struct {
public:
static Handle<AsmWasmData> New(
Isolate* isolate, std::shared_ptr<wasm::NativeModule> native_module,
Handle<FixedArray> export_wrappers, Handle<ByteArray> asm_js_offset_table,
Handle<HeapNumber> uses_bitset);
DECL_ACCESSORS(managed_native_module, Managed<wasm::NativeModule>)
DECL_ACCESSORS(export_wrappers, FixedArray)
DECL_ACCESSORS(asm_js_offset_table, ByteArray)
DECL_ACCESSORS(uses_bitset, HeapNumber)
DECL_CAST(AsmWasmData)
DECL_PRINTER(AsmWasmData)
DECL_VERIFIER(AsmWasmData)
// Layout description.
#define ASM_WASM_DATA_FIELDS(V) \
V(kManagedNativeModuleOffset, kPointerSize) \
V(kExportWrappersOffset, kPointerSize) \
V(kAsmJsOffsetTableOffset, kPointerSize) \
V(kUsesBitsetOffset, kPointerSize) \
/* Total size. */ \
V(kSize, 0)
DEFINE_FIELD_OFFSET_CONSTANTS(Struct::kHeaderSize, ASM_WASM_DATA_FIELDS)
#undef ASM_WASM_DATA_FIELDS
};
#undef DECL_OPTIONAL_ACCESSORS
} // namespace internal

3
src/wasm/wasm-serialization.cc
View File

@ -573,7 +573,8 @@ MaybeHandle<WasmModuleObject> DeserializeNativeModule(
Reader reader(data + kVersionSize);
if (!deserializer.Read(&reader)) return {};
CompileJsToWasmWrappers(isolate, module_object);
CompileJsToWasmWrappers(isolate, native_module,
handle(module_object->export_wrappers(), isolate));
// Log the code within the generated module for profiling.
native_module->LogWasmCodes(isolate);

12
test/common/wasm/wasm-module-runner.cc
View File

@ -143,12 +143,16 @@ int32_t CompileAndRunAsmWasmModule(Isolate* isolate, const byte* module_start,
const byte* module_end) {
HandleScope scope(isolate);
ErrorThrower thrower(isolate, "CompileAndRunAsmWasmModule");
MaybeHandle<WasmModuleObject> module =
MaybeHandle<AsmWasmData> data =
isolate->wasm_engine()->SyncCompileTranslatedAsmJs(
isolate, &thrower, ModuleWireBytes(module_start, module_end),
Handle<Script>::null(), Vector<const byte>());
DCHECK_EQ(thrower.error(), module.is_null());
if (module.is_null()) return -1;
Vector<const byte>(), Handle<HeapNumber>());
DCHECK_EQ(thrower.error(), data.is_null());
if (data.is_null()) return -1;
MaybeHandle<WasmModuleObject> module =
isolate->wasm_engine()->FinalizeTranslatedAsmJs(
isolate, data.ToHandleChecked(), Handle<Script>::null());
MaybeHandle<WasmInstanceObject> instance =
isolate->wasm_engine()->SyncInstantiate(

10
test/mjsunit/parallel-compile-tasks.js
View File

@ -58,3 +58,13 @@ assertEquals(c(314), 315);
(function() {
class foo {};
}); // Don't call IIFE so that it is compiled during idle time
// http://crbug.com/900535
(function() {
"use asm";
function bar(i, j) {
i = i|0;
j = j|0;
}
return {bar: bar};
}); // Don't call IIFE so that it is compiled during idle time

312
tools/v8heapconst.py
View File

@ -59,76 +59,77 @@ INSTANCE_TYPES = {
155: "ACCESSOR_PAIR_TYPE",
156: "ALIASED_ARGUMENTS_ENTRY_TYPE",
157: "ALLOCATION_MEMENTO_TYPE",
158: "ASYNC_GENERATOR_REQUEST_TYPE",
159: "DEBUG_INFO_TYPE",
160: "FUNCTION_TEMPLATE_INFO_TYPE",
161: "INTERCEPTOR_INFO_TYPE",
162: "INTERPRETER_DATA_TYPE",
163: "MODULE_INFO_ENTRY_TYPE",
164: "MODULE_TYPE",
165: "OBJECT_TEMPLATE_INFO_TYPE",
166: "PROMISE_CAPABILITY_TYPE",
167: "PROMISE_REACTION_TYPE",
168: "PROTOTYPE_INFO_TYPE",
169: "SCRIPT_TYPE",
170: "STACK_FRAME_INFO_TYPE",
171: "TUPLE2_TYPE",
172: "TUPLE3_TYPE",
173: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE",
174: "WASM_DEBUG_INFO_TYPE",
175: "WASM_EXPORTED_FUNCTION_DATA_TYPE",
176: "CALLABLE_TASK_TYPE",
177: "CALLBACK_TASK_TYPE",
178: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE",
179: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE",
180: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE",
181: "WEAK_FACTORY_CLEANUP_JOB_TASK_TYPE",
182: "ALLOCATION_SITE_TYPE",
183: "EMBEDDER_DATA_ARRAY_TYPE",
184: "FIXED_ARRAY_TYPE",
185: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
186: "HASH_TABLE_TYPE",
187: "ORDERED_HASH_MAP_TYPE",
188: "ORDERED_HASH_SET_TYPE",
189: "ORDERED_NAME_DICTIONARY_TYPE",
190: "NAME_DICTIONARY_TYPE",
191: "GLOBAL_DICTIONARY_TYPE",
192: "NUMBER_DICTIONARY_TYPE",
193: "SIMPLE_NUMBER_DICTIONARY_TYPE",
194: "STRING_TABLE_TYPE",
195: "EPHEMERON_HASH_TABLE_TYPE",
196: "SCOPE_INFO_TYPE",
197: "SCRIPT_CONTEXT_TABLE_TYPE",
198: "AWAIT_CONTEXT_TYPE",
199: "BLOCK_CONTEXT_TYPE",
200: "CATCH_CONTEXT_TYPE",
201: "DEBUG_EVALUATE_CONTEXT_TYPE",
202: "EVAL_CONTEXT_TYPE",
203: "FUNCTION_CONTEXT_TYPE",
204: "MODULE_CONTEXT_TYPE",
205: "NATIVE_CONTEXT_TYPE",
206: "SCRIPT_CONTEXT_TYPE",
207: "WITH_CONTEXT_TYPE",
208: "WEAK_FIXED_ARRAY_TYPE",
209: "DESCRIPTOR_ARRAY_TYPE",
210: "TRANSITION_ARRAY_TYPE",
211: "CALL_HANDLER_INFO_TYPE",
212: "CELL_TYPE",
213: "CODE_DATA_CONTAINER_TYPE",
214: "FEEDBACK_CELL_TYPE",
215: "FEEDBACK_VECTOR_TYPE",
216: "LOAD_HANDLER_TYPE",
217: "PRE_PARSED_SCOPE_DATA_TYPE",
218: "PROPERTY_ARRAY_TYPE",
219: "PROPERTY_CELL_TYPE",
220: "SHARED_FUNCTION_INFO_TYPE",
221: "SMALL_ORDERED_HASH_MAP_TYPE",
222: "SMALL_ORDERED_HASH_SET_TYPE",
223: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
224: "STORE_HANDLER_TYPE",
225: "UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE",
226: "UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE",
227: "WEAK_ARRAY_LIST_TYPE",
158: "ASM_WASM_DATA_TYPE",
159: "ASYNC_GENERATOR_REQUEST_TYPE",
160: "DEBUG_INFO_TYPE",
161: "FUNCTION_TEMPLATE_INFO_TYPE",
162: "INTERCEPTOR_INFO_TYPE",
163: "INTERPRETER_DATA_TYPE",
164: "MODULE_INFO_ENTRY_TYPE",
165: "MODULE_TYPE",
166: "OBJECT_TEMPLATE_INFO_TYPE",
167: "PROMISE_CAPABILITY_TYPE",
168: "PROMISE_REACTION_TYPE",
169: "PROTOTYPE_INFO_TYPE",
170: "SCRIPT_TYPE",
171: "STACK_FRAME_INFO_TYPE",
172: "TUPLE2_TYPE",
173: "TUPLE3_TYPE",
174: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE",
175: "WASM_DEBUG_INFO_TYPE",
176: "WASM_EXPORTED_FUNCTION_DATA_TYPE",
177: "CALLABLE_TASK_TYPE",
178: "CALLBACK_TASK_TYPE",
179: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE",
180: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE",
181: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE",
182: "WEAK_FACTORY_CLEANUP_JOB_TASK_TYPE",
183: "ALLOCATION_SITE_TYPE",
184: "EMBEDDER_DATA_ARRAY_TYPE",
185: "FIXED_ARRAY_TYPE",
186: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
187: "HASH_TABLE_TYPE",
188: "ORDERED_HASH_MAP_TYPE",
189: "ORDERED_HASH_SET_TYPE",
190: "ORDERED_NAME_DICTIONARY_TYPE",
191: "NAME_DICTIONARY_TYPE",
192: "GLOBAL_DICTIONARY_TYPE",
193: "NUMBER_DICTIONARY_TYPE",
194: "SIMPLE_NUMBER_DICTIONARY_TYPE",
195: "STRING_TABLE_TYPE",
196: "EPHEMERON_HASH_TABLE_TYPE",
197: "SCOPE_INFO_TYPE",
198: "SCRIPT_CONTEXT_TABLE_TYPE",
199: "AWAIT_CONTEXT_TYPE",
200: "BLOCK_CONTEXT_TYPE",
201: "CATCH_CONTEXT_TYPE",
202: "DEBUG_EVALUATE_CONTEXT_TYPE",
203: "EVAL_CONTEXT_TYPE",
204: "FUNCTION_CONTEXT_TYPE",
205: "MODULE_CONTEXT_TYPE",
206: "NATIVE_CONTEXT_TYPE",
207: "SCRIPT_CONTEXT_TYPE",
208: "WITH_CONTEXT_TYPE",
209: "WEAK_FIXED_ARRAY_TYPE",
210: "DESCRIPTOR_ARRAY_TYPE",
211: "TRANSITION_ARRAY_TYPE",
212: "CALL_HANDLER_INFO_TYPE",
213: "CELL_TYPE",
214: "CODE_DATA_CONTAINER_TYPE",
215: "FEEDBACK_CELL_TYPE",
216: "FEEDBACK_VECTOR_TYPE",
217: "LOAD_HANDLER_TYPE",
218: "PRE_PARSED_SCOPE_DATA_TYPE",
219: "PROPERTY_ARRAY_TYPE",
220: "PROPERTY_CELL_TYPE",
221: "SHARED_FUNCTION_INFO_TYPE",
222: "SMALL_ORDERED_HASH_MAP_TYPE",
223: "SMALL_ORDERED_HASH_SET_TYPE",
224: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
225: "STORE_HANDLER_TYPE",
226: "UNCOMPILED_DATA_WITHOUT_PRE_PARSED_SCOPE_TYPE",
227: "UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_TYPE",
228: "WEAK_ARRAY_LIST_TYPE",
1024: "JS_PROXY_TYPE",
1025: "JS_GLOBAL_OBJECT_TYPE",
1026: "JS_GLOBAL_PROXY_TYPE",
@ -193,8 +194,8 @@ KNOWN_MAPS = {
("RO_SPACE", 0x00139): (138, "FreeSpaceMap"),
("RO_SPACE", 0x00189): (132, "MetaMap"),
("RO_SPACE", 0x00209): (131, "NullMap"),
("RO_SPACE", 0x00279): (209, "DescriptorArrayMap"),
("RO_SPACE", 0x002d9): (208, "WeakFixedArrayMap"),
("RO_SPACE", 0x00279): (210, "DescriptorArrayMap"),
("RO_SPACE", 0x002d9): (209, "WeakFixedArrayMap"),
("RO_SPACE", 0x00329): (152, "OnePointerFillerMap"),
("RO_SPACE", 0x00379): (152, "TwoPointerFillerMap"),
("RO_SPACE", 0x003f9): (131, "UninitializedMap"),
@ -204,70 +205,70 @@ KNOWN_MAPS = {
("RO_SPACE", 0x005e9): (131, "TheHoleMap"),
("RO_SPACE", 0x00691): (131, "BooleanMap"),
("RO_SPACE", 0x00769): (136, "ByteArrayMap"),
("RO_SPACE", 0x007b9): (184, "FixedArrayMap"),
("RO_SPACE", 0x00809): (184, "FixedCOWArrayMap"),
("RO_SPACE", 0x00859): (186, "HashTableMap"),
("RO_SPACE", 0x007b9): (185, "FixedArrayMap"),
("RO_SPACE", 0x00809): (185, "FixedCOWArrayMap"),
("RO_SPACE", 0x00859): (187, "HashTableMap"),
("RO_SPACE", 0x008a9): (128, "SymbolMap"),
("RO_SPACE", 0x008f9): (72, "OneByteStringMap"),
("RO_SPACE", 0x00949): (196, "ScopeInfoMap"),
("RO_SPACE", 0x00999): (220, "SharedFunctionInfoMap"),
("RO_SPACE", 0x00949): (197, "ScopeInfoMap"),
("RO_SPACE", 0x00999): (221, "SharedFunctionInfoMap"),
("RO_SPACE", 0x009e9): (133, "CodeMap"),
("RO_SPACE", 0x00a39): (203, "FunctionContextMap"),
("RO_SPACE", 0x00a89): (212, "CellMap"),
("RO_SPACE", 0x00ad9): (219, "GlobalPropertyCellMap"),
("RO_SPACE", 0x00a39): (204, "FunctionContextMap"),
("RO_SPACE", 0x00a89): (213, "CellMap"),
("RO_SPACE", 0x00ad9): (220, "GlobalPropertyCellMap"),
("RO_SPACE", 0x00b29): (135, "ForeignMap"),
("RO_SPACE", 0x00b79): (210, "TransitionArrayMap"),
("RO_SPACE", 0x00bc9): (215, "FeedbackVectorMap"),
("RO_SPACE", 0x00b79): (211, "TransitionArrayMap"),
("RO_SPACE", 0x00bc9): (216, "FeedbackVectorMap"),
("RO_SPACE", 0x00c69): (131, "ArgumentsMarkerMap"),
("RO_SPACE", 0x00d09): (131, "ExceptionMap"),
("RO_SPACE", 0x00da9): (131, "TerminationExceptionMap"),
("RO_SPACE", 0x00e51): (131, "OptimizedOutMap"),
("RO_SPACE", 0x00ef1): (131, "StaleRegisterMap"),
("RO_SPACE", 0x00f61): (205, "NativeContextMap"),
("RO_SPACE", 0x00fb1): (204, "ModuleContextMap"),
("RO_SPACE", 0x01001): (202, "EvalContextMap"),
("RO_SPACE", 0x01051): (206, "ScriptContextMap"),
("RO_SPACE", 0x010a1): (198, "AwaitContextMap"),
("RO_SPACE", 0x010f1): (199, "BlockContextMap"),
("RO_SPACE", 0x01141): (200, "CatchContextMap"),
("RO_SPACE", 0x01191): (207, "WithContextMap"),
("RO_SPACE", 0x011e1): (201, "DebugEvaluateContextMap"),
("RO_SPACE", 0x01231): (197, "ScriptContextTableMap"),
("RO_SPACE", 0x00f61): (206, "NativeContextMap"),
("RO_SPACE", 0x00fb1): (205, "ModuleContextMap"),
("RO_SPACE", 0x01001): (203, "EvalContextMap"),
("RO_SPACE", 0x01051): (207, "ScriptContextMap"),
("RO_SPACE", 0x010a1): (199, "AwaitContextMap"),
("RO_SPACE", 0x010f1): (200, "BlockContextMap"),
("RO_SPACE", 0x01141): (201, "CatchContextMap"),
("RO_SPACE", 0x01191): (208, "WithContextMap"),
("RO_SPACE", 0x011e1): (202, "DebugEvaluateContextMap"),
("RO_SPACE", 0x01231): (198, "ScriptContextTableMap"),
("RO_SPACE", 0x01281): (151, "FeedbackMetadataArrayMap"),
("RO_SPACE", 0x012d1): (184, "ArrayListMap"),
("RO_SPACE", 0x012d1): (185, "ArrayListMap"),
("RO_SPACE", 0x01321): (130, "BigIntMap"),
("RO_SPACE", 0x01371): (185, "ObjectBoilerplateDescriptionMap"),
("RO_SPACE", 0x01371): (186, "ObjectBoilerplateDescriptionMap"),
("RO_SPACE", 0x013c1): (137, "BytecodeArrayMap"),
("RO_SPACE", 0x01411): (213, "CodeDataContainerMap"),
("RO_SPACE", 0x01411): (214, "CodeDataContainerMap"),
("RO_SPACE", 0x01461): (150, "FixedDoubleArrayMap"),
("RO_SPACE", 0x014b1): (191, "GlobalDictionaryMap"),
("RO_SPACE", 0x01501): (214, "ManyClosuresCellMap"),
("RO_SPACE", 0x01551): (184, "ModuleInfoMap"),
("RO_SPACE", 0x014b1): (192, "GlobalDictionaryMap"),
("RO_SPACE", 0x01501): (215, "ManyClosuresCellMap"),
("RO_SPACE", 0x01551): (185, "ModuleInfoMap"),
("RO_SPACE", 0x015a1): (134, "MutableHeapNumberMap"),
("RO_SPACE", 0x015f1): (190, "NameDictionaryMap"),
("RO_SPACE", 0x01641): (214, "NoClosuresCellMap"),
("RO_SPACE", 0x01691): (214, "NoFeedbackCellMap"),
("RO_SPACE", 0x016e1): (192, "NumberDictionaryMap"),
("RO_SPACE", 0x01731): (214, "OneClosureCellMap"),
("RO_SPACE", 0x01781): (187, "OrderedHashMapMap"),
("RO_SPACE", 0x017d1): (188, "OrderedHashSetMap"),
("RO_SPACE", 0x01821): (189, "OrderedNameDictionaryMap"),
("RO_SPACE", 0x01871): (217, "PreParsedScopeDataMap"),
("RO_SPACE", 0x018c1): (218, "PropertyArrayMap"),
("RO_SPACE", 0x01911): (211, "SideEffectCallHandlerInfoMap"),
("RO_SPACE", 0x01961): (211, "SideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x019b1): (211, "NextCallSideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x01a01): (193, "SimpleNumberDictionaryMap"),
("RO_SPACE", 0x01a51): (184, "SloppyArgumentsElementsMap"),
("RO_SPACE", 0x01aa1): (221, "SmallOrderedHashMapMap"),
("RO_SPACE", 0x01af1): (222, "SmallOrderedHashSetMap"),
("RO_SPACE", 0x01b41): (223, "SmallOrderedNameDictionaryMap"),
("RO_SPACE", 0x01b91): (194, "StringTableMap"),
("RO_SPACE", 0x01be1): (225, "UncompiledDataWithoutPreParsedScopeMap"),
("RO_SPACE", 0x01c31): (226, "UncompiledDataWithPreParsedScopeMap"),
("RO_SPACE", 0x01c81): (227, "WeakArrayListMap"),
("RO_SPACE", 0x01cd1): (195, "EphemeronHashTableMap"),
("RO_SPACE", 0x01d21): (183, "EmbedderDataArrayMap"),
("RO_SPACE", 0x015f1): (191, "NameDictionaryMap"),
("RO_SPACE", 0x01641): (215, "NoClosuresCellMap"),
("RO_SPACE", 0x01691): (215, "NoFeedbackCellMap"),
("RO_SPACE", 0x016e1): (193, "NumberDictionaryMap"),
("RO_SPACE", 0x01731): (215, "OneClosureCellMap"),
("RO_SPACE", 0x01781): (188, "OrderedHashMapMap"),
("RO_SPACE", 0x017d1): (189, "OrderedHashSetMap"),
("RO_SPACE", 0x01821): (190, "OrderedNameDictionaryMap"),
("RO_SPACE", 0x01871): (218, "PreParsedScopeDataMap"),
("RO_SPACE", 0x018c1): (219, "PropertyArrayMap"),
("RO_SPACE", 0x01911): (212, "SideEffectCallHandlerInfoMap"),
("RO_SPACE", 0x01961): (212, "SideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x019b1): (212, "NextCallSideEffectFreeCallHandlerInfoMap"),
("RO_SPACE", 0x01a01): (194, "SimpleNumberDictionaryMap"),
("RO_SPACE", 0x01a51): (185, "SloppyArgumentsElementsMap"),
("RO_SPACE", 0x01aa1): (222, "SmallOrderedHashMapMap"),
("RO_SPACE", 0x01af1): (223, "SmallOrderedHashSetMap"),
("RO_SPACE", 0x01b41): (224, "SmallOrderedNameDictionaryMap"),
("RO_SPACE", 0x01b91): (195, "StringTableMap"),
("RO_SPACE", 0x01be1): (226, "UncompiledDataWithoutPreParsedScopeMap"),
("RO_SPACE", 0x01c31): (227, "UncompiledDataWithPreParsedScopeMap"),
("RO_SPACE", 0x01c81): (228, "WeakArrayListMap"),
("RO_SPACE", 0x01cd1): (196, "EphemeronHashTableMap"),
("RO_SPACE", 0x01d21): (184, "EmbedderDataArrayMap"),
("RO_SPACE", 0x01d71): (106, "NativeSourceStringMap"),
("RO_SPACE", 0x01dc1): (64, "StringMap"),
("RO_SPACE", 0x01e11): (73, "ConsOneByteStringMap"),
@ -301,44 +302,45 @@ KNOWN_MAPS = {
("RO_SPACE", 0x026d1): (149, "FixedBigUint64ArrayMap"),
("RO_SPACE", 0x02721): (148, "FixedBigInt64ArrayMap"),
("RO_SPACE", 0x02771): (131, "SelfReferenceMarkerMap"),
("RO_SPACE", 0x027d9): (171, "Tuple2Map"),
("RO_SPACE", 0x02879): (173, "ArrayBoilerplateDescriptionMap"),
("RO_SPACE", 0x02bb9): (161, "InterceptorInfoMap"),
("RO_SPACE", 0x027d9): (172, "Tuple2Map"),
("RO_SPACE", 0x02879): (174, "ArrayBoilerplateDescriptionMap"),
("RO_SPACE", 0x02bb9): (162, "InterceptorInfoMap"),
("RO_SPACE", 0x050d9): (153, "AccessCheckInfoMap"),
("RO_SPACE", 0x05129): (154, "AccessorInfoMap"),
("RO_SPACE", 0x05179): (155, "AccessorPairMap"),
("RO_SPACE", 0x051c9): (156, "AliasedArgumentsEntryMap"),
("RO_SPACE", 0x05219): (157, "AllocationMementoMap"),
("RO_SPACE", 0x05269): (158, "AsyncGeneratorRequestMap"),
("RO_SPACE", 0x052b9): (159, "DebugInfoMap"),
("RO_SPACE", 0x05309): (160, "FunctionTemplateInfoMap"),
("RO_SPACE", 0x05359): (162, "InterpreterDataMap"),
("RO_SPACE", 0x053a9): (163, "ModuleInfoEntryMap"),
("RO_SPACE", 0x053f9): (164, "ModuleMap"),
("RO_SPACE", 0x05449): (165, "ObjectTemplateInfoMap"),
("RO_SPACE", 0x05499): (166, "PromiseCapabilityMap"),
("RO_SPACE", 0x054e9): (167, "PromiseReactionMap"),
("RO_SPACE", 0x05539): (168, "PrototypeInfoMap"),
("RO_SPACE", 0x05589): (169, "ScriptMap"),
("RO_SPACE", 0x055d9): (170, "StackFrameInfoMap"),
("RO_SPACE", 0x05629): (172, "Tuple3Map"),
("RO_SPACE", 0x05679): (174, "WasmDebugInfoMap"),
("RO_SPACE", 0x056c9): (175, "WasmExportedFunctionDataMap"),
("RO_SPACE", 0x05719): (176, "CallableTaskMap"),
("RO_SPACE", 0x05769): (177, "CallbackTaskMap"),
("RO_SPACE", 0x057b9): (178, "PromiseFulfillReactionJobTaskMap"),
("RO_SPACE", 0x05809): (179, "PromiseRejectReactionJobTaskMap"),
("RO_SPACE", 0x05859): (180, "PromiseResolveThenableJobTaskMap"),
("RO_SPACE", 0x058a9): (181, "WeakFactoryCleanupJobTaskMap"),
("RO_SPACE", 0x058f9): (182, "AllocationSiteWithWeakNextMap"),
("RO_SPACE", 0x05949): (182, "AllocationSiteWithoutWeakNextMap"),
("RO_SPACE", 0x05999): (216, "LoadHandler1Map"),
("RO_SPACE", 0x059e9): (216, "LoadHandler2Map"),
("RO_SPACE", 0x05a39): (216, "LoadHandler3Map"),
("RO_SPACE", 0x05a89): (224, "StoreHandler0Map"),
("RO_SPACE", 0x05ad9): (224, "StoreHandler1Map"),
("RO_SPACE", 0x05b29): (224, "StoreHandler2Map"),
("RO_SPACE", 0x05b79): (224, "StoreHandler3Map"),
("RO_SPACE", 0x05269): (158, "AsmWasmDataMap"),
("RO_SPACE", 0x052b9): (159, "AsyncGeneratorRequestMap"),
("RO_SPACE", 0x05309): (160, "DebugInfoMap"),
("RO_SPACE", 0x05359): (161, "FunctionTemplateInfoMap"),
("RO_SPACE", 0x053a9): (163, "InterpreterDataMap"),
("RO_SPACE", 0x053f9): (164, "ModuleInfoEntryMap"),
("RO_SPACE", 0x05449): (165, "ModuleMap"),
("RO_SPACE", 0x05499): (166, "ObjectTemplateInfoMap"),
("RO_SPACE", 0x054e9): (167, "PromiseCapabilityMap"),
("RO_SPACE", 0x05539): (168, "PromiseReactionMap"),
("RO_SPACE", 0x05589): (169, "PrototypeInfoMap"),
("RO_SPACE", 0x055d9): (170, "ScriptMap"),
("RO_SPACE", 0x05629): (171, "StackFrameInfoMap"),
("RO_SPACE", 0x05679): (173, "Tuple3Map"),
("RO_SPACE", 0x056c9): (175, "WasmDebugInfoMap"),
("RO_SPACE", 0x05719): (176, "WasmExportedFunctionDataMap"),
("RO_SPACE", 0x05769): (177, "CallableTaskMap"),
("RO_SPACE", 0x057b9): (178, "CallbackTaskMap"),
("RO_SPACE", 0x05809): (179, "PromiseFulfillReactionJobTaskMap"),
("RO_SPACE", 0x05859): (180, "PromiseRejectReactionJobTaskMap"),
("RO_SPACE", 0x058a9): (181, "PromiseResolveThenableJobTaskMap"),
("RO_SPACE", 0x058f9): (182, "WeakFactoryCleanupJobTaskMap"),
("RO_SPACE", 0x05949): (183, "AllocationSiteWithWeakNextMap"),
("RO_SPACE", 0x05999): (183, "AllocationSiteWithoutWeakNextMap"),
("RO_SPACE", 0x059e9): (217, "LoadHandler1Map"),
("RO_SPACE", 0x05a39): (217, "LoadHandler2Map"),
("RO_SPACE", 0x05a89): (217, "LoadHandler3Map"),
("RO_SPACE", 0x05ad9): (225, "StoreHandler0Map"),
("RO_SPACE", 0x05b29): (225, "StoreHandler1Map"),
("RO_SPACE", 0x05b79): (225, "StoreHandler2Map"),
("RO_SPACE", 0x05bc9): (225, "StoreHandler3Map"),
("MAP_SPACE", 0x00139): (1057, "ExternalMap"),
("MAP_SPACE", 0x00189): (1073, "JSMessageObjectMap"),
}