From 32e48cf5106d78a251d1efeac73a427434051077 Mon Sep 17 00:00:00 2001 From: Michael Starzinger Date: Thu, 23 May 2019 15:55:59 +0200 Subject: [PATCH] [wasm] Support {WebAssembly.Function} object construction. This makes the WebAssembly function constructor return a proper function object. Note that the returned object is not yet callable, only the prototype structure is in place. R=jkummerow@chromium.org TEST=mjsunit/wasm/type-reflection BUG=v8:7742 Change-Id: If6a3d0ae7078b5526606eef1b8fd4815353b850b Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1627343 Commit-Queue: Michael Starzinger Reviewed-by: Jakob Kummerow Cr-Commit-Position: refs/heads/master@{#61792} --- src/builtins/base.tq | 2 + src/codegen/code-stub-assembler.cc | 9 + src/compiler/code-assembler.h | 1 + src/compiler/types.cc | 1 + src/diagnostics/objects-debug.cc | 5 +- src/diagnostics/objects-printer.cc | 6 + src/heap/factory.cc | 18 +- src/heap/factory.h | 6 +- src/objects/instance-type.h | 1 + src/objects/objects-definitions.h | 2 + src/objects/objects.cc | 7 + src/objects/shared-function-info-inl.h | 4 + src/objects/shared-function-info.h | 3 + src/wasm/wasm-js.cc | 8 +- src/wasm/wasm-objects-inl.h | 11 ++ src/wasm/wasm-objects.cc | 27 +++ src/wasm/wasm-objects.h | 34 ++++ test/mjsunit/wasm/type-reflection.js | 18 +- tools/v8heapconst.py | 246 +++++++++++++------------ 19 files changed, 280 insertions(+), 129 deletions(-) diff --git a/src/builtins/base.tq b/src/builtins/base.tq index 48c7c7392b..61e8600153 100644 --- a/src/builtins/base.tq +++ b/src/builtins/base.tq @@ -880,6 +880,8 @@ extern class WasmExportedFunctionData extends Struct { function_index: Smi; } +extern class WasmJSFunctionData extends Struct { wrapper_code: Code; } + extern class WasmCapiFunctionData extends Struct { call_target: RawPtr; embedder_data: RawPtr; diff --git a/src/codegen/code-stub-assembler.cc b/src/codegen/code-stub-assembler.cc index c2207ed917..cc3c1a0564 100644 --- a/src/codegen/code-stub-assembler.cc +++ b/src/codegen/code-stub-assembler.cc @@ -13511,6 +13511,7 @@ TNode CodeStubAssembler::GetSharedFunctionInfoCode( UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE, UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE, FUNCTION_TEMPLATE_INFO_TYPE, + WASM_JS_FUNCTION_DATA_TYPE, WASM_CAPI_FUNCTION_DATA_TYPE}; Label check_is_bytecode_array(this); Label check_is_exported_function_data(this); @@ -13519,6 +13520,7 @@ TNode CodeStubAssembler::GetSharedFunctionInfoCode( Label check_is_uncompiled_data_with_preparse_data(this); Label check_is_function_template_info(this); Label check_is_interpreter_data(this); + Label check_is_wasm_js_function_data(this); Label check_is_wasm_capi_function_data(this); Label* case_labels[] = {&check_is_bytecode_array, &check_is_exported_function_data, @@ -13526,6 +13528,7 @@ TNode CodeStubAssembler::GetSharedFunctionInfoCode( &check_is_uncompiled_data_without_preparse_data, &check_is_uncompiled_data_with_preparse_data, &check_is_function_template_info, + &check_is_wasm_js_function_data, &check_is_wasm_capi_function_data}; STATIC_ASSERT(arraysize(case_values) == arraysize(case_labels)); Switch(data_type, &check_is_interpreter_data, case_values, case_labels, @@ -13569,6 +13572,12 @@ TNode CodeStubAssembler::GetSharedFunctionInfoCode( CAST(sfi_data), InterpreterData::kInterpreterTrampolineOffset)); Goto(&done); + // IsWasmJSFunctionData: Use the wrapper code. + BIND(&check_is_wasm_js_function_data); + sfi_code = CAST( + LoadObjectField(CAST(sfi_data), WasmJSFunctionData::kWrapperCodeOffset)); + Goto(&done); + // IsWasmCapiFunctionData: Use the wrapper code. BIND(&check_is_wasm_capi_function_data); sfi_code = CAST(LoadObjectField(CAST(sfi_data), diff --git a/src/compiler/code-assembler.h b/src/compiler/code-assembler.h index d674947f35..45892dc45a 100644 --- a/src/compiler/code-assembler.h +++ b/src/compiler/code-assembler.h @@ -327,6 +327,7 @@ class WasmExceptionObject; class WasmExceptionTag; class WasmExportedFunctionData; class WasmGlobalObject; +class WasmJSFunctionData; class WasmMemoryObject; class WasmModuleObject; class WasmTableObject; diff --git a/src/compiler/types.cc b/src/compiler/types.cc index f30a9153d2..a73e2ed30b 100644 --- a/src/compiler/types.cc +++ b/src/compiler/types.cc @@ -357,6 +357,7 @@ Type::bitset BitsetType::Lub(const MapRefLike& map) { case WASM_DEBUG_INFO_TYPE: case WASM_EXCEPTION_TAG_TYPE: case WASM_EXPORTED_FUNCTION_DATA_TYPE: + case WASM_JS_FUNCTION_DATA_TYPE: case LOAD_HANDLER_TYPE: case STORE_HANDLER_TYPE: case ASYNC_GENERATOR_REQUEST_TYPE: diff --git a/src/diagnostics/objects-debug.cc b/src/diagnostics/objects-debug.cc index e4b915475f..db7e61c191 100644 --- a/src/diagnostics/objects-debug.cc +++ b/src/diagnostics/objects-debug.cc @@ -1047,7 +1047,8 @@ void SharedFunctionInfo::SharedFunctionInfoVerify(Isolate* isolate) { CHECK(HasWasmExportedFunctionData() || IsApiFunction() || HasBytecodeArray() || HasAsmWasmData() || HasBuiltinId() || HasUncompiledDataWithPreparseData() || - HasUncompiledDataWithoutPreparseData() || HasWasmCapiFunctionData()); + HasUncompiledDataWithoutPreparseData() || HasWasmJSFunctionData() || + HasWasmCapiFunctionData()); CHECK(script_or_debug_info().IsUndefined(isolate) || script_or_debug_info().IsScript() || HasDebugInfo()); @@ -1800,6 +1801,8 @@ USE_TORQUE_VERIFIER(FunctionTemplateRareData) USE_TORQUE_VERIFIER(WasmCapiFunctionData) +USE_TORQUE_VERIFIER(WasmJSFunctionData) + USE_TORQUE_VERIFIER(ObjectTemplateInfo) void AllocationSite::AllocationSiteVerify(Isolate* isolate) { diff --git a/src/diagnostics/objects-printer.cc b/src/diagnostics/objects-printer.cc index 5aed592a2d..22b8012eb4 100644 --- a/src/diagnostics/objects-printer.cc +++ b/src/diagnostics/objects-printer.cc @@ -1866,6 +1866,12 @@ void WasmExportedFunctionData::WasmExportedFunctionDataPrint( os << "\n"; } +void WasmJSFunctionData::WasmJSFunctionDataPrint(std::ostream& os) { // NOLINT + PrintHeader(os, "WasmJSFunctionData"); + os << "\n - wrapper_code: " << Brief(wrapper_code()); + os << "\n"; +} + void WasmModuleObject::WasmModuleObjectPrint(std::ostream& os) { // NOLINT PrintHeader(os, "WasmModuleObject"); os << "\n - module: " << module(); diff --git a/src/heap/factory.cc b/src/heap/factory.cc index b79c49337f..556cec289d 100644 --- a/src/heap/factory.cc +++ b/src/heap/factory.cc @@ -2412,7 +2412,7 @@ Handle Factory::NewFunction(const NewFunctionArgs& args) { Handle context(isolate()->native_context()); Handle map = args.GetMap(isolate()); Handle info = - NewSharedFunctionInfo(args.name_, args.maybe_exported_function_data_, + NewSharedFunctionInfo(args.name_, args.maybe_wasm_function_data_, args.maybe_builtin_id_, kNormalFunction); // Proper language mode in shared function info will be set later. @@ -4224,7 +4224,21 @@ NewFunctionArgs NewFunctionArgs::ForWasm( NewFunctionArgs args; args.name_ = name; args.maybe_map_ = map; - args.maybe_exported_function_data_ = exported_function_data; + args.maybe_wasm_function_data_ = exported_function_data; + args.language_mode_ = LanguageMode::kSloppy; + args.prototype_mutability_ = MUTABLE; + + return args; +} + +// static +NewFunctionArgs NewFunctionArgs::ForWasm( + Handle name, Handle js_function_data, + Handle map) { + NewFunctionArgs args; + args.name_ = name; + args.maybe_map_ = map; + args.maybe_wasm_function_data_ = js_function_data; args.language_mode_ = LanguageMode::kSloppy; args.prototype_mutability_ = MUTABLE; diff --git a/src/heap/factory.h b/src/heap/factory.h index bb8447bb5f..596fb9eacb 100644 --- a/src/heap/factory.h +++ b/src/heap/factory.h @@ -67,6 +67,7 @@ class UncompiledDataWithoutPreparseData; class UncompiledDataWithPreparseData; class WasmCapiFunctionData; class WasmExportedFunctionData; +class WasmJSFunctionData; class WeakCell; struct SourceRange; template @@ -1113,6 +1114,9 @@ class NewFunctionArgs final { static NewFunctionArgs ForWasm( Handle name, Handle exported_function_data, Handle map); + static NewFunctionArgs ForWasm(Handle name, + Handle js_function_data, + Handle map); V8_EXPORT_PRIVATE static NewFunctionArgs ForBuiltin(Handle name, Handle map, int builtin_id); @@ -1141,7 +1145,7 @@ class NewFunctionArgs final { Handle name_; MaybeHandle maybe_map_; - MaybeHandle maybe_exported_function_data_; + MaybeHandle maybe_wasm_function_data_; bool should_create_and_set_initial_map_ = false; InstanceType type_; diff --git a/src/objects/instance-type.h b/src/objects/instance-type.h index ad480114e9..16f6d51202 100644 --- a/src/objects/instance-type.h +++ b/src/objects/instance-type.h @@ -179,6 +179,7 @@ enum InstanceType : uint16_t { WASM_DEBUG_INFO_TYPE, WASM_EXCEPTION_TAG_TYPE, WASM_EXPORTED_FUNCTION_DATA_TYPE, + WASM_JS_FUNCTION_DATA_TYPE, CALLABLE_TASK_TYPE, // FIRST_MICROTASK_TYPE CALLBACK_TASK_TYPE, diff --git a/src/objects/objects-definitions.h b/src/objects/objects-definitions.h index 26c59547d1..ccb9619ae1 100644 --- a/src/objects/objects-definitions.h +++ b/src/objects/objects-definitions.h @@ -119,6 +119,7 @@ namespace internal { V(WASM_DEBUG_INFO_TYPE) \ V(WASM_EXCEPTION_TAG_TYPE) \ V(WASM_EXPORTED_FUNCTION_DATA_TYPE) \ + V(WASM_JS_FUNCTION_DATA_TYPE) \ \ V(CALLABLE_TASK_TYPE) \ V(CALLBACK_TASK_TYPE) \ @@ -342,6 +343,7 @@ namespace internal { V(_, WASM_EXCEPTION_TAG_TYPE, WasmExceptionTag, wasm_exception_tag) \ V(_, WASM_EXPORTED_FUNCTION_DATA_TYPE, WasmExportedFunctionData, \ wasm_exported_function_data) \ + V(_, WASM_JS_FUNCTION_DATA_TYPE, WasmJSFunctionData, wasm_js_function_data) \ V(_, CALLABLE_TASK_TYPE, CallableTask, callable_task) \ V(_, CALLBACK_TASK_TYPE, CallbackTask, callback_task) \ V(_, PROMISE_FULFILL_REACTION_JOB_TASK_TYPE, PromiseFulfillReactionJobTask, \ diff --git a/src/objects/objects.cc b/src/objects/objects.cc index 3382879485..5969435539 100644 --- a/src/objects/objects.cc +++ b/src/objects/objects.cc @@ -4919,6 +4919,8 @@ Code SharedFunctionInfo::GetCode() const { DCHECK(code.IsCode()); DCHECK(code.is_interpreter_trampoline_builtin()); return code; + } else if (data.IsWasmJSFunctionData()) { + return wasm_js_function_data().wrapper_code(); } else if (data.IsWasmCapiFunctionData()) { return wasm_capi_function_data().wrapper_code(); } @@ -4931,6 +4933,11 @@ WasmExportedFunctionData SharedFunctionInfo::wasm_exported_function_data() return WasmExportedFunctionData::cast(function_data()); } +WasmJSFunctionData SharedFunctionInfo::wasm_js_function_data() const { + DCHECK(HasWasmJSFunctionData()); + return WasmJSFunctionData::cast(function_data()); +} + WasmCapiFunctionData SharedFunctionInfo::wasm_capi_function_data() const { DCHECK(HasWasmCapiFunctionData()); return WasmCapiFunctionData::cast(function_data()); diff --git a/src/objects/shared-function-info-inl.h b/src/objects/shared-function-info-inl.h index 12e8fff5cb..f5413ce1de 100644 --- a/src/objects/shared-function-info-inl.h +++ b/src/objects/shared-function-info-inl.h @@ -663,6 +663,10 @@ bool SharedFunctionInfo::HasWasmExportedFunctionData() const { return function_data().IsWasmExportedFunctionData(); } +bool SharedFunctionInfo::HasWasmJSFunctionData() const { + return function_data().IsWasmJSFunctionData(); +} + bool SharedFunctionInfo::HasWasmCapiFunctionData() const { return function_data().IsWasmCapiFunctionData(); } diff --git a/src/objects/shared-function-info.h b/src/objects/shared-function-info.h index 211d693a26..a3b84ee46e 100644 --- a/src/objects/shared-function-info.h +++ b/src/objects/shared-function-info.h @@ -34,6 +34,7 @@ class DebugInfo; class IsCompiledScope; class WasmCapiFunctionData; class WasmExportedFunctionData; +class WasmJSFunctionData; // Data collected by the pre-parser storing information about scopes and inner // functions. @@ -368,6 +369,8 @@ class SharedFunctionInfo : public HeapObject { inline bool HasUncompiledDataWithoutPreparseData() const; inline bool HasWasmExportedFunctionData() const; WasmExportedFunctionData wasm_exported_function_data() const; + inline bool HasWasmJSFunctionData() const; + WasmJSFunctionData wasm_js_function_data() const; inline bool HasWasmCapiFunctionData() const; WasmCapiFunctionData wasm_capi_function_data() const; diff --git a/src/wasm/wasm-js.cc b/src/wasm/wasm-js.cc index f49c17c2f6..ba07bb6070 100644 --- a/src/wasm/wasm-js.cc +++ b/src/wasm/wasm-js.cc @@ -1466,8 +1466,12 @@ void WebAssemblyFunction(const v8::FunctionCallbackInfo& args) { return; } - // TODO(7742): Implement ability to construct. - UNIMPLEMENTED(); + i::wasm::FunctionSig* sig = builder.Build(); + i::Handle callable = + Utils::OpenHandle(*args[1].As()); + i::Handle result = + i::WasmJSFunction::New(i_isolate, sig, callable); + args.GetReturnValue().Set(Utils::ToLocal(result)); } constexpr const char* kName_WasmGlobalObject = "WebAssembly.Global"; diff --git a/src/wasm/wasm-objects-inl.h b/src/wasm/wasm-objects-inl.h index 64b291752c..1d0d394a47 100644 --- a/src/wasm/wasm-objects-inl.h +++ b/src/wasm/wasm-objects-inl.h @@ -308,6 +308,17 @@ SMI_ACCESSORS(WasmExportedFunctionData, jump_table_offset, kJumpTableOffsetOffset) SMI_ACCESSORS(WasmExportedFunctionData, function_index, kFunctionIndexOffset) +// WasmJSFunction +WasmJSFunction::WasmJSFunction(Address ptr) : JSFunction(ptr) { + SLOW_DCHECK(IsWasmJSFunction(*this)); +} +CAST_ACCESSOR(WasmJSFunction) + +// WasmJSFunctionData +OBJECT_CONSTRUCTORS_IMPL(WasmJSFunctionData, Struct) +CAST_ACCESSOR(WasmJSFunctionData) +ACCESSORS(WasmJSFunctionData, wrapper_code, Code, kWrapperCodeOffset) + // WasmCapiFunction WasmCapiFunction::WasmCapiFunction(Address ptr) : JSFunction(ptr) { SLOW_DCHECK(IsWasmCapiFunction(*this)); diff --git a/src/wasm/wasm-objects.cc b/src/wasm/wasm-objects.cc index f2ed529bf1..2584116ef4 100644 --- a/src/wasm/wasm-objects.cc +++ b/src/wasm/wasm-objects.cc @@ -2133,6 +2133,33 @@ wasm::FunctionSig* WasmExportedFunction::sig() { return instance().module()->functions[function_index()].sig; } +// static +bool WasmJSFunction::IsWasmJSFunction(Object object) { + if (!object.IsJSFunction()) return false; + JSFunction js_function = JSFunction::cast(object); + return js_function.shared().HasWasmJSFunctionData(); +} + +Handle WasmJSFunction::New(Isolate* isolate, + wasm::FunctionSig* sig, + Handle callable) { + Handle function_data = + Handle::cast(isolate->factory()->NewStruct( + WASM_JS_FUNCTION_DATA_TYPE, AllocationType::kOld)); + // TODO(7742): Make this callable by using a proper wrapper code. + function_data->set_wrapper_code( + isolate->builtins()->builtin(Builtins::kIllegal)); + Handle name = isolate->factory()->Function_string(); + if (callable->IsJSFunction()) { + name = JSFunction::GetName(Handle::cast(callable)); + } + Handle function_map = isolate->wasm_exported_function_map(); + NewFunctionArgs args = + NewFunctionArgs::ForWasm(name, function_data, function_map); + Handle js_function = isolate->factory()->NewFunction(args); + return Handle::cast(js_function); +} + Address WasmCapiFunction::GetHostCallTarget() const { return shared().wasm_capi_function_data().call_target(); } diff --git a/src/wasm/wasm-objects.h b/src/wasm/wasm-objects.h index 25c8818d16..000d324b32 100644 --- a/src/wasm/wasm-objects.h +++ b/src/wasm/wasm-objects.h @@ -652,6 +652,7 @@ class WasmExceptionPackage : public JSReceiver { }; // A Wasm function that is wrapped and exported to JavaScript. +// Representation of WebAssembly.Function JavaScript-level object. class WasmExportedFunction : public JSFunction { public: WasmInstanceObject instance(); @@ -671,6 +672,19 @@ class WasmExportedFunction : public JSFunction { OBJECT_CONSTRUCTORS(WasmExportedFunction, JSFunction); }; +// A Wasm function that was created by wrapping a JavaScript callable. +// Representation of WebAssembly.Function JavaScript-level object. +class WasmJSFunction : public JSFunction { + public: + static bool IsWasmJSFunction(Object object); + + static Handle New(Isolate* isolate, wasm::FunctionSig* sig, + Handle callable); + + DECL_CAST(WasmJSFunction) + OBJECT_CONSTRUCTORS(WasmJSFunction, JSFunction); +}; + // An external function exposed to Wasm via the C/C++ API. class WasmCapiFunction : public JSFunction { public: @@ -735,6 +749,26 @@ class WasmExportedFunctionData : public Struct { OBJECT_CONSTRUCTORS(WasmExportedFunctionData, Struct); }; +// Information for a WasmJSFunction which is referenced as the function data of +// the SharedFunctionInfo underlying the function. For details please see the +// {SharedFunctionInfo::HasWasmJSFunctionData} predicate. +class WasmJSFunctionData : public Struct { + public: + DECL_ACCESSORS(wrapper_code, Code) + + DECL_CAST(WasmJSFunctionData) + + // Dispatched behavior. + DECL_PRINTER(WasmJSFunctionData) + DECL_VERIFIER(WasmJSFunctionData) + + // Layout description. + DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, + TORQUE_GENERATED_WASM_JSFUNCTION_DATA_FIELDS) + + OBJECT_CONSTRUCTORS(WasmJSFunctionData, Struct); +}; + class WasmDebugInfo : public Struct { public: NEVER_READ_ONLY_SPACE diff --git a/test/mjsunit/wasm/type-reflection.js b/test/mjsunit/wasm/type-reflection.js index d8b0bdcf2d..b76dcd21c6 100644 --- a/test/mjsunit/wasm/type-reflection.js +++ b/test/mjsunit/wasm/type-reflection.js @@ -197,9 +197,25 @@ load('test/mjsunit/wasm/wasm-module-builder.js'); assertThrows( () => new WebAssembly.Function({parameters:[], results:[]}, {}), TypeError, /Argument 1 must be a function/); + assertDoesNotThrow( + () => new WebAssembly.Function({parameters:[], results:[]}, _ => 0)); })(); -(function TestFunctionExportedFunctions() { +(function TestFunctionConstructedFunction() { + let fun = new WebAssembly.Function({parameters:[], results:[]}, _ => 0); + assertTrue(fun instanceof WebAssembly.Function); + assertTrue(fun instanceof Function); + assertTrue(fun instanceof Object); + assertSame(fun.__proto__, WebAssembly.Function.prototype); + assertSame(fun.__proto__.__proto__, Function.prototype); + assertSame(fun.__proto__.__proto__.__proto__, Object.prototype); + assertSame(fun.constructor, WebAssembly.Function); + assertEquals(typeof fun, 'function'); + // TODO(7742): Enable once it is callable. + // assertDoesNotThrow(() => fun()); +})(); + +(function TestFunctionExportedFunction() { let builder = new WasmModuleBuilder(); builder.addFunction("fun", kSig_v_v).addBody([]).exportFunc(); let instance = builder.instantiate(); diff --git a/tools/v8heapconst.py b/tools/v8heapconst.py index d56fc2b26a..e8b0be587f 100644 --- a/tools/v8heapconst.py +++ b/tools/v8heapconst.py @@ -82,60 +82,61 @@ INSTANCE_TYPES = { 118: "WASM_DEBUG_INFO_TYPE", 119: "WASM_EXCEPTION_TAG_TYPE", 120: "WASM_EXPORTED_FUNCTION_DATA_TYPE", - 121: "CALLABLE_TASK_TYPE", - 122: "CALLBACK_TASK_TYPE", - 123: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE", - 124: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE", - 125: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE", - 126: "FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE", - 127: "ALLOCATION_SITE_TYPE", - 128: "EMBEDDER_DATA_ARRAY_TYPE", - 129: "FIXED_ARRAY_TYPE", - 130: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE", - 131: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE", - 132: "HASH_TABLE_TYPE", - 133: "ORDERED_HASH_MAP_TYPE", - 134: "ORDERED_HASH_SET_TYPE", - 135: "ORDERED_NAME_DICTIONARY_TYPE", - 136: "NAME_DICTIONARY_TYPE", - 137: "GLOBAL_DICTIONARY_TYPE", - 138: "NUMBER_DICTIONARY_TYPE", - 139: "SIMPLE_NUMBER_DICTIONARY_TYPE", - 140: "STRING_TABLE_TYPE", - 141: "EPHEMERON_HASH_TABLE_TYPE", - 142: "SCOPE_INFO_TYPE", - 143: "SCRIPT_CONTEXT_TABLE_TYPE", - 144: "AWAIT_CONTEXT_TYPE", - 145: "BLOCK_CONTEXT_TYPE", - 146: "CATCH_CONTEXT_TYPE", - 147: "DEBUG_EVALUATE_CONTEXT_TYPE", - 148: "EVAL_CONTEXT_TYPE", - 149: "FUNCTION_CONTEXT_TYPE", - 150: "MODULE_CONTEXT_TYPE", - 151: "NATIVE_CONTEXT_TYPE", - 152: "SCRIPT_CONTEXT_TYPE", - 153: "WITH_CONTEXT_TYPE", - 154: "WEAK_FIXED_ARRAY_TYPE", - 155: "TRANSITION_ARRAY_TYPE", - 156: "CALL_HANDLER_INFO_TYPE", - 157: "CELL_TYPE", - 158: "CODE_DATA_CONTAINER_TYPE", - 159: "DESCRIPTOR_ARRAY_TYPE", - 160: "FEEDBACK_CELL_TYPE", - 161: "FEEDBACK_VECTOR_TYPE", - 162: "LOAD_HANDLER_TYPE", - 163: "PREPARSE_DATA_TYPE", - 164: "PROPERTY_ARRAY_TYPE", - 165: "PROPERTY_CELL_TYPE", - 166: "SHARED_FUNCTION_INFO_TYPE", - 167: "SMALL_ORDERED_HASH_MAP_TYPE", - 168: "SMALL_ORDERED_HASH_SET_TYPE", - 169: "SMALL_ORDERED_NAME_DICTIONARY_TYPE", - 170: "STORE_HANDLER_TYPE", - 171: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE", - 172: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE", - 173: "WEAK_ARRAY_LIST_TYPE", - 174: "WEAK_CELL_TYPE", + 121: "WASM_JS_FUNCTION_DATA_TYPE", + 122: "CALLABLE_TASK_TYPE", + 123: "CALLBACK_TASK_TYPE", + 124: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE", + 125: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE", + 126: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE", + 127: "FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE", + 128: "ALLOCATION_SITE_TYPE", + 129: "EMBEDDER_DATA_ARRAY_TYPE", + 130: "FIXED_ARRAY_TYPE", + 131: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE", + 132: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE", + 133: "HASH_TABLE_TYPE", + 134: "ORDERED_HASH_MAP_TYPE", + 135: "ORDERED_HASH_SET_TYPE", + 136: "ORDERED_NAME_DICTIONARY_TYPE", + 137: "NAME_DICTIONARY_TYPE", + 138: "GLOBAL_DICTIONARY_TYPE", + 139: "NUMBER_DICTIONARY_TYPE", + 140: "SIMPLE_NUMBER_DICTIONARY_TYPE", + 141: "STRING_TABLE_TYPE", + 142: "EPHEMERON_HASH_TABLE_TYPE", + 143: "SCOPE_INFO_TYPE", + 144: "SCRIPT_CONTEXT_TABLE_TYPE", + 145: "AWAIT_CONTEXT_TYPE", + 146: "BLOCK_CONTEXT_TYPE", + 147: "CATCH_CONTEXT_TYPE", + 148: "DEBUG_EVALUATE_CONTEXT_TYPE", + 149: "EVAL_CONTEXT_TYPE", + 150: "FUNCTION_CONTEXT_TYPE", + 151: "MODULE_CONTEXT_TYPE", + 152: "NATIVE_CONTEXT_TYPE", + 153: "SCRIPT_CONTEXT_TYPE", + 154: "WITH_CONTEXT_TYPE", + 155: "WEAK_FIXED_ARRAY_TYPE", + 156: "TRANSITION_ARRAY_TYPE", + 157: "CALL_HANDLER_INFO_TYPE", + 158: "CELL_TYPE", + 159: "CODE_DATA_CONTAINER_TYPE", + 160: "DESCRIPTOR_ARRAY_TYPE", + 161: "FEEDBACK_CELL_TYPE", + 162: "FEEDBACK_VECTOR_TYPE", + 163: "LOAD_HANDLER_TYPE", + 164: "PREPARSE_DATA_TYPE", + 165: "PROPERTY_ARRAY_TYPE", + 166: "PROPERTY_CELL_TYPE", + 167: "SHARED_FUNCTION_INFO_TYPE", + 168: "SMALL_ORDERED_HASH_MAP_TYPE", + 169: "SMALL_ORDERED_HASH_SET_TYPE", + 170: "SMALL_ORDERED_NAME_DICTIONARY_TYPE", + 171: "STORE_HANDLER_TYPE", + 172: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE", + 173: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE", + 174: "WEAK_ARRAY_LIST_TYPE", + 175: "WEAK_CELL_TYPE", 1024: "JS_PROXY_TYPE", 1025: "JS_GLOBAL_OBJECT_TYPE", 1026: "JS_GLOBAL_PROXY_TYPE", @@ -199,8 +200,8 @@ KNOWN_MAPS = { ("read_only_space", 0x00139): (74, "FreeSpaceMap"), ("read_only_space", 0x00189): (68, "MetaMap"), ("read_only_space", 0x00209): (67, "NullMap"), - ("read_only_space", 0x00271): (159, "DescriptorArrayMap"), - ("read_only_space", 0x002d1): (154, "WeakFixedArrayMap"), + ("read_only_space", 0x00271): (160, "DescriptorArrayMap"), + ("read_only_space", 0x002d1): (155, "WeakFixedArrayMap"), ("read_only_space", 0x00321): (88, "OnePointerFillerMap"), ("read_only_space", 0x00371): (88, "TwoPointerFillerMap"), ("read_only_space", 0x003f1): (67, "UninitializedMap"), @@ -210,71 +211,71 @@ KNOWN_MAPS = { ("read_only_space", 0x005e1): (67, "TheHoleMap"), ("read_only_space", 0x00689): (67, "BooleanMap"), ("read_only_space", 0x00761): (72, "ByteArrayMap"), - ("read_only_space", 0x007b1): (129, "FixedArrayMap"), - ("read_only_space", 0x00801): (129, "FixedCOWArrayMap"), - ("read_only_space", 0x00851): (132, "HashTableMap"), + ("read_only_space", 0x007b1): (130, "FixedArrayMap"), + ("read_only_space", 0x00801): (130, "FixedCOWArrayMap"), + ("read_only_space", 0x00851): (133, "HashTableMap"), ("read_only_space", 0x008a1): (64, "SymbolMap"), ("read_only_space", 0x008f1): (40, "OneByteStringMap"), - ("read_only_space", 0x00941): (142, "ScopeInfoMap"), - ("read_only_space", 0x00991): (166, "SharedFunctionInfoMap"), + ("read_only_space", 0x00941): (143, "ScopeInfoMap"), + ("read_only_space", 0x00991): (167, "SharedFunctionInfoMap"), ("read_only_space", 0x009e1): (69, "CodeMap"), - ("read_only_space", 0x00a31): (149, "FunctionContextMap"), - ("read_only_space", 0x00a81): (157, "CellMap"), - ("read_only_space", 0x00ad1): (165, "GlobalPropertyCellMap"), + ("read_only_space", 0x00a31): (150, "FunctionContextMap"), + ("read_only_space", 0x00a81): (158, "CellMap"), + ("read_only_space", 0x00ad1): (166, "GlobalPropertyCellMap"), ("read_only_space", 0x00b21): (71, "ForeignMap"), - ("read_only_space", 0x00b71): (155, "TransitionArrayMap"), - ("read_only_space", 0x00bc1): (161, "FeedbackVectorMap"), + ("read_only_space", 0x00b71): (156, "TransitionArrayMap"), + ("read_only_space", 0x00bc1): (162, "FeedbackVectorMap"), ("read_only_space", 0x00c61): (67, "ArgumentsMarkerMap"), ("read_only_space", 0x00d01): (67, "ExceptionMap"), ("read_only_space", 0x00da1): (67, "TerminationExceptionMap"), ("read_only_space", 0x00e49): (67, "OptimizedOutMap"), ("read_only_space", 0x00ee9): (67, "StaleRegisterMap"), - ("read_only_space", 0x00f59): (151, "NativeContextMap"), - ("read_only_space", 0x00fa9): (150, "ModuleContextMap"), - ("read_only_space", 0x00ff9): (148, "EvalContextMap"), - ("read_only_space", 0x01049): (152, "ScriptContextMap"), - ("read_only_space", 0x01099): (144, "AwaitContextMap"), - ("read_only_space", 0x010e9): (145, "BlockContextMap"), - ("read_only_space", 0x01139): (146, "CatchContextMap"), - ("read_only_space", 0x01189): (153, "WithContextMap"), - ("read_only_space", 0x011d9): (147, "DebugEvaluateContextMap"), - ("read_only_space", 0x01229): (143, "ScriptContextTableMap"), - ("read_only_space", 0x01279): (131, "ClosureFeedbackCellArrayMap"), + ("read_only_space", 0x00f59): (152, "NativeContextMap"), + ("read_only_space", 0x00fa9): (151, "ModuleContextMap"), + ("read_only_space", 0x00ff9): (149, "EvalContextMap"), + ("read_only_space", 0x01049): (153, "ScriptContextMap"), + ("read_only_space", 0x01099): (145, "AwaitContextMap"), + ("read_only_space", 0x010e9): (146, "BlockContextMap"), + ("read_only_space", 0x01139): (147, "CatchContextMap"), + ("read_only_space", 0x01189): (154, "WithContextMap"), + ("read_only_space", 0x011d9): (148, "DebugEvaluateContextMap"), + ("read_only_space", 0x01229): (144, "ScriptContextTableMap"), + ("read_only_space", 0x01279): (132, "ClosureFeedbackCellArrayMap"), ("read_only_space", 0x012c9): (87, "FeedbackMetadataArrayMap"), - ("read_only_space", 0x01319): (129, "ArrayListMap"), + ("read_only_space", 0x01319): (130, "ArrayListMap"), ("read_only_space", 0x01369): (66, "BigIntMap"), - ("read_only_space", 0x013b9): (130, "ObjectBoilerplateDescriptionMap"), + ("read_only_space", 0x013b9): (131, "ObjectBoilerplateDescriptionMap"), ("read_only_space", 0x01409): (73, "BytecodeArrayMap"), - ("read_only_space", 0x01459): (158, "CodeDataContainerMap"), + ("read_only_space", 0x01459): (159, "CodeDataContainerMap"), ("read_only_space", 0x014a9): (86, "FixedDoubleArrayMap"), - ("read_only_space", 0x014f9): (137, "GlobalDictionaryMap"), - ("read_only_space", 0x01549): (160, "ManyClosuresCellMap"), - ("read_only_space", 0x01599): (129, "ModuleInfoMap"), + ("read_only_space", 0x014f9): (138, "GlobalDictionaryMap"), + ("read_only_space", 0x01549): (161, "ManyClosuresCellMap"), + ("read_only_space", 0x01599): (130, "ModuleInfoMap"), ("read_only_space", 0x015e9): (70, "MutableHeapNumberMap"), - ("read_only_space", 0x01639): (136, "NameDictionaryMap"), - ("read_only_space", 0x01689): (160, "NoClosuresCellMap"), - ("read_only_space", 0x016d9): (138, "NumberDictionaryMap"), - ("read_only_space", 0x01729): (160, "OneClosureCellMap"), - ("read_only_space", 0x01779): (133, "OrderedHashMapMap"), - ("read_only_space", 0x017c9): (134, "OrderedHashSetMap"), - ("read_only_space", 0x01819): (135, "OrderedNameDictionaryMap"), - ("read_only_space", 0x01869): (163, "PreparseDataMap"), - ("read_only_space", 0x018b9): (164, "PropertyArrayMap"), - ("read_only_space", 0x01909): (156, "SideEffectCallHandlerInfoMap"), - ("read_only_space", 0x01959): (156, "SideEffectFreeCallHandlerInfoMap"), - ("read_only_space", 0x019a9): (156, "NextCallSideEffectFreeCallHandlerInfoMap"), - ("read_only_space", 0x019f9): (139, "SimpleNumberDictionaryMap"), - ("read_only_space", 0x01a49): (129, "SloppyArgumentsElementsMap"), - ("read_only_space", 0x01a99): (167, "SmallOrderedHashMapMap"), - ("read_only_space", 0x01ae9): (168, "SmallOrderedHashSetMap"), - ("read_only_space", 0x01b39): (169, "SmallOrderedNameDictionaryMap"), - ("read_only_space", 0x01b89): (140, "StringTableMap"), - ("read_only_space", 0x01bd9): (171, "UncompiledDataWithoutPreparseDataMap"), - ("read_only_space", 0x01c29): (172, "UncompiledDataWithPreparseDataMap"), - ("read_only_space", 0x01c79): (173, "WeakArrayListMap"), - ("read_only_space", 0x01cc9): (141, "EphemeronHashTableMap"), - ("read_only_space", 0x01d19): (128, "EmbedderDataArrayMap"), - ("read_only_space", 0x01d69): (174, "WeakCellMap"), + ("read_only_space", 0x01639): (137, "NameDictionaryMap"), + ("read_only_space", 0x01689): (161, "NoClosuresCellMap"), + ("read_only_space", 0x016d9): (139, "NumberDictionaryMap"), + ("read_only_space", 0x01729): (161, "OneClosureCellMap"), + ("read_only_space", 0x01779): (134, "OrderedHashMapMap"), + ("read_only_space", 0x017c9): (135, "OrderedHashSetMap"), + ("read_only_space", 0x01819): (136, "OrderedNameDictionaryMap"), + ("read_only_space", 0x01869): (164, "PreparseDataMap"), + ("read_only_space", 0x018b9): (165, "PropertyArrayMap"), + ("read_only_space", 0x01909): (157, "SideEffectCallHandlerInfoMap"), + ("read_only_space", 0x01959): (157, "SideEffectFreeCallHandlerInfoMap"), + ("read_only_space", 0x019a9): (157, "NextCallSideEffectFreeCallHandlerInfoMap"), + ("read_only_space", 0x019f9): (140, "SimpleNumberDictionaryMap"), + ("read_only_space", 0x01a49): (130, "SloppyArgumentsElementsMap"), + ("read_only_space", 0x01a99): (168, "SmallOrderedHashMapMap"), + ("read_only_space", 0x01ae9): (169, "SmallOrderedHashSetMap"), + ("read_only_space", 0x01b39): (170, "SmallOrderedNameDictionaryMap"), + ("read_only_space", 0x01b89): (141, "StringTableMap"), + ("read_only_space", 0x01bd9): (172, "UncompiledDataWithoutPreparseDataMap"), + ("read_only_space", 0x01c29): (173, "UncompiledDataWithPreparseDataMap"), + ("read_only_space", 0x01c79): (174, "WeakArrayListMap"), + ("read_only_space", 0x01cc9): (142, "EphemeronHashTableMap"), + ("read_only_space", 0x01d19): (129, "EmbedderDataArrayMap"), + ("read_only_space", 0x01d69): (175, "WeakCellMap"), ("read_only_space", 0x01db9): (58, "NativeSourceStringMap"), ("read_only_space", 0x01e09): (32, "StringMap"), ("read_only_space", 0x01e59): (41, "ConsOneByteStringMap"), @@ -336,21 +337,22 @@ KNOWN_MAPS = { ("read_only_space", 0x05a89): (118, "WasmDebugInfoMap"), ("read_only_space", 0x05ad9): (119, "WasmExceptionTagMap"), ("read_only_space", 0x05b29): (120, "WasmExportedFunctionDataMap"), - ("read_only_space", 0x05b79): (121, "CallableTaskMap"), - ("read_only_space", 0x05bc9): (122, "CallbackTaskMap"), - ("read_only_space", 0x05c19): (123, "PromiseFulfillReactionJobTaskMap"), - ("read_only_space", 0x05c69): (124, "PromiseRejectReactionJobTaskMap"), - ("read_only_space", 0x05cb9): (125, "PromiseResolveThenableJobTaskMap"), - ("read_only_space", 0x05d09): (126, "FinalizationGroupCleanupJobTaskMap"), - ("read_only_space", 0x05d59): (127, "AllocationSiteWithWeakNextMap"), - ("read_only_space", 0x05da9): (127, "AllocationSiteWithoutWeakNextMap"), - ("read_only_space", 0x05df9): (162, "LoadHandler1Map"), - ("read_only_space", 0x05e49): (162, "LoadHandler2Map"), - ("read_only_space", 0x05e99): (162, "LoadHandler3Map"), - ("read_only_space", 0x05ee9): (170, "StoreHandler0Map"), - ("read_only_space", 0x05f39): (170, "StoreHandler1Map"), - ("read_only_space", 0x05f89): (170, "StoreHandler2Map"), - ("read_only_space", 0x05fd9): (170, "StoreHandler3Map"), + ("read_only_space", 0x05b79): (121, "WasmJSFunctionDataMap"), + ("read_only_space", 0x05bc9): (122, "CallableTaskMap"), + ("read_only_space", 0x05c19): (123, "CallbackTaskMap"), + ("read_only_space", 0x05c69): (124, "PromiseFulfillReactionJobTaskMap"), + ("read_only_space", 0x05cb9): (125, "PromiseRejectReactionJobTaskMap"), + ("read_only_space", 0x05d09): (126, "PromiseResolveThenableJobTaskMap"), + ("read_only_space", 0x05d59): (127, "FinalizationGroupCleanupJobTaskMap"), + ("read_only_space", 0x05da9): (128, "AllocationSiteWithWeakNextMap"), + ("read_only_space", 0x05df9): (128, "AllocationSiteWithoutWeakNextMap"), + ("read_only_space", 0x05e49): (163, "LoadHandler1Map"), + ("read_only_space", 0x05e99): (163, "LoadHandler2Map"), + ("read_only_space", 0x05ee9): (163, "LoadHandler3Map"), + ("read_only_space", 0x05f39): (171, "StoreHandler0Map"), + ("read_only_space", 0x05f89): (171, "StoreHandler1Map"), + ("read_only_space", 0x05fd9): (171, "StoreHandler2Map"), + ("read_only_space", 0x06029): (171, "StoreHandler3Map"), ("map_space", 0x00139): (1057, "ExternalMap"), ("map_space", 0x00189): (1073, "JSMessageObjectMap"), }