[wasm] Add initial stack switching data structures

Add initial stack memory, jump buffer and continuation objects.

R=ahaas@chromium.org
CC=fgm@chromium.org

Bug: v8:12191
Change-Id: I0c6bde4e5f15e9c539e5e8af1a3b84e5cb5bc9a9
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3220342
Commit-Queue: Thibaud Michaud <thibaudm@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Cr-Commit-Position: refs/heads/main@{#77400}

BUILD.bazel

@@ -2198,6 +2198,7 @@ filegroup(
             "src/wasm/signature-map.h",
             "src/wasm/simd-shuffle.cc",
             "src/wasm/simd-shuffle.h",
+            "src/wasm/stacks.h",
             "src/wasm/streaming-decoder.cc",
             "src/wasm/streaming-decoder.h",
             "src/wasm/struct-types.h",

BUILD.gn

@@ -3442,6 +3442,7 @@ v8_header_set("v8_internal_headers") {
       "src/wasm/object-access.h",
       "src/wasm/signature-map.h",
       "src/wasm/simd-shuffle.h",
+      "src/wasm/stacks.h",
       "src/wasm/streaming-decoder.h",
       "src/wasm/struct-types.h",
       "src/wasm/value-type.h",

src/diagnostics/objects-printer.cc

@@ -1839,6 +1839,14 @@ void WasmArray::WasmArrayPrint(std::ostream& os) {
   os << "\n";
 }
 
+void WasmContinuationObject::WasmContinuationObjectPrint(std::ostream& os) {
+  PrintHeader(os, "WasmContinuationObject");
+  os << "\n - parent: " << parent();
+  os << "\n - jmpbuf: " << jmpbuf();
+  os << "\n - stack: " << stack();
+  os << "\n";
+}
+
 void WasmInstanceObject::WasmInstanceObjectPrint(std::ostream& os) {
   JSObjectPrintHeader(os, *this, "WasmInstanceObject");
   os << "\n - module_object: " << Brief(module_object());

src/objects/objects-definitions.h

@@ -151,6 +151,8 @@ namespace internal {
   V(_, TEMPLATE_OBJECT_DESCRIPTION_TYPE, TemplateObjectDescription,            \
     template_object_description)                                               \
   V(_, TUPLE2_TYPE, Tuple2, tuple2)                                            \
+  IF_WASM(V, _, WASM_CONTINUATION_OBJECT_TYPE, WasmContinuationObject,         \
+          wasm_continuation_object)                                            \
   IF_WASM(V, _, WASM_EXCEPTION_TAG_TYPE, WasmExceptionTag, wasm_exception_tag) \
   IF_WASM(V, _, WASM_INDIRECT_FUNCTION_TABLE_TYPE, WasmIndirectFunctionTable,  \
           wasm_indirect_function_table)

src/wasm/stacks.h

@@ -0,0 +1,76 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_WASM_STACKS_H_
+#define V8_WASM_STACKS_H_
+
+#if !V8_ENABLE_WEBASSEMBLY
+#error This header should only be included if WebAssembly is enabled.
+#endif  // !V8_ENABLE_WEBASSEMBLY
+
+#include "src/base/build_config.h"
+#include "src/common/globals.h"
+#include "src/execution/isolate.h"
+#include "src/utils/allocation.h"
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+
+struct JumpBuffer {
+  void* sp;
+  void* fp;
+  void* stack_limit;
+  // TODO(thibaudm/fgm): Add general-purpose registers.
+};
+
+constexpr int kJmpBufSpOffset = offsetof(JumpBuffer, sp);
+constexpr int kJmpBufFpOffset = offsetof(JumpBuffer, fp);
+constexpr int kJmpBufStackLimitOffset = offsetof(JumpBuffer, stack_limit);
+
+class StackMemory {
+ public:
+  static StackMemory* New() { return new StackMemory(); }
+
+  // Returns a non-owning view of the current stack.
+  static StackMemory* GetCurrentStackView(Isolate* isolate) {
+    byte* limit =
+        *reinterpret_cast<byte**>(isolate->stack_guard()->address_of_jslimit());
+    return new StackMemory(limit);
+  }
+
+  ~StackMemory() {
+    PageAllocator* allocator = GetPlatformPageAllocator();
+    if (owned_) allocator->DecommitPages(limit_, size_);
+  }
+
+  void* limit() { return limit_; }
+  void* base() { return limit_ + size_; }
+
+  // Track external memory usage for Managed<StackMemory> objects.
+  size_t owned_size() { return sizeof(StackMemory) + (owned_ ? size_ : 0); }
+
+ private:
+  // This constructor allocates a new stack segment.
+  StackMemory() : owned_(true) {
+    PageAllocator* allocator = GetPlatformPageAllocator();
+    size_ = allocator->AllocatePageSize();
+    // TODO(thibaudm): Leave space for runtime functions.
+    limit_ = static_cast<byte*>(allocator->AllocatePages(
+        nullptr, size_, size_, PageAllocator::kReadWrite));
+  }
+
+  // Overload to represent a view of the libc stack.
+  explicit StackMemory(byte* limit) : limit_(limit), size_(0), owned_(false) {}
+
+  byte* limit_;
+  size_t size_;
+  bool owned_;
+};
+
+}  // namespace wasm
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_WASM_STACKS_H_

src/wasm/wasm-objects-inl.h

@@ -50,6 +50,7 @@ TQ_OBJECT_CONSTRUCTORS_IMPL(WasmFunctionData)
 TQ_OBJECT_CONSTRUCTORS_IMPL(WasmTypeInfo)
 TQ_OBJECT_CONSTRUCTORS_IMPL(WasmStruct)
 TQ_OBJECT_CONSTRUCTORS_IMPL(WasmArray)
+TQ_OBJECT_CONSTRUCTORS_IMPL(WasmContinuationObject)
 
 CAST_ACCESSOR(WasmInstanceObject)
 

src/wasm/wasm-objects.cc

@@ -1832,6 +1832,40 @@ void DecodeI64ExceptionValue(Handle<FixedArray> encoded_values,
   *value = (static_cast<uint64_t>(msb) << 32) | static_cast<uint64_t>(lsb);
 }
 
+// static
+Handle<WasmContinuationObject> WasmContinuationObject::New(
+    Isolate* isolate, std::unique_ptr<wasm::StackMemory> stack,
+    HeapObject parent) {
+  Handle<WasmContinuationObject> result = Handle<WasmContinuationObject>::cast(
+      isolate->factory()->NewStruct(WASM_CONTINUATION_OBJECT_TYPE));
+  auto jmpbuf = std::make_unique<wasm::JumpBuffer>();
+  jmpbuf->stack_limit = stack->limit();
+  jmpbuf->fp = stack->base();
+  jmpbuf->sp = stack->base();
+  Handle<Foreign> managed_stack = Managed<wasm::StackMemory>::FromUniquePtr(
+      isolate, stack->owned_size(), std::move(stack));
+  Handle<Foreign> managed_jmpbuf = Managed<wasm::JumpBuffer>::FromUniquePtr(
+      isolate, sizeof(wasm::JumpBuffer), std::move(jmpbuf));
+  result->set_stack(*managed_stack);
+  result->set_jmpbuf(*managed_jmpbuf);
+  result->set_parent(parent);
+  return result;
+}
+
+// static
+Handle<WasmContinuationObject> WasmContinuationObject::New(
+    Isolate* isolate, std::unique_ptr<wasm::StackMemory> stack) {
+  auto parent = ReadOnlyRoots(isolate).undefined_value();
+  return New(isolate, std::move(stack), parent);
+}
+
+// static
+Handle<WasmContinuationObject> WasmContinuationObject::New(
+    Isolate* isolate, WasmContinuationObject parent) {
+  auto stack = std::unique_ptr<wasm::StackMemory>(wasm::StackMemory::New());
+  return New(isolate, std::move(stack), parent);
+}
+
 #ifdef DEBUG
 
 namespace {

src/wasm/wasm-objects.h

@@ -19,6 +19,7 @@
 #include "src/objects/js-function.h"
 #include "src/objects/js-objects.h"
 #include "src/objects/objects.h"
+#include "src/wasm/stacks.h"
 #include "src/wasm/struct-types.h"
 #include "src/wasm/value-type.h"
 
@@ -960,6 +961,24 @@ class WasmArray : public TorqueGeneratedWasmArray<WasmArray, WasmObject> {
   TQ_OBJECT_CONSTRUCTORS(WasmArray)
 };
 
+class WasmContinuationObject
+    : public TorqueGeneratedWasmContinuationObject<WasmContinuationObject,
+                                                   Struct> {
+ public:
+  static Handle<WasmContinuationObject> New(
+      Isolate* isolate, std::unique_ptr<wasm::StackMemory> stack);
+  static Handle<WasmContinuationObject> New(Isolate* isolate,
+                                            WasmContinuationObject parent);
+
+  DECL_PRINTER(WasmContinuationObject)
+  TQ_OBJECT_CONSTRUCTORS(WasmContinuationObject)
+
+ private:
+  static Handle<WasmContinuationObject> New(
+      Isolate* isolate, std::unique_ptr<wasm::StackMemory> stack,
+      HeapObject parent);
+};
+
 #undef DECL_OPTIONAL_ACCESSORS
 
 namespace wasm {

src/wasm/wasm-objects.tq

@@ -63,6 +63,12 @@ extern class WasmIndirectFunctionTable extends Struct {
   refs: FixedArray;
 }
 
+extern class WasmContinuationObject extends Struct {
+  stack: Foreign;
+  jmpbuf: Foreign;
+  parent: WasmContinuationObject|Undefined;
+}
+
 extern class WasmExceptionTag extends Struct {
   // Note that this index is only useful for debugging purposes and it is not
   // unique across modules. The GC however does not allow objects without at

tools/v8heapconst.py

@@ -78,83 +78,84 @@ INSTANCE_TYPES = {
   114: "STACK_FRAME_INFO_TYPE",
   115: "TEMPLATE_OBJECT_DESCRIPTION_TYPE",
   116: "TUPLE2_TYPE",
-  117: "WASM_EXCEPTION_TAG_TYPE",
+  117: "WASM_CONTINUATION_OBJECT_TYPE",
-  118: "WASM_INDIRECT_FUNCTION_TABLE_TYPE",
+  118: "WASM_EXCEPTION_TAG_TYPE",
-  119: "FIXED_ARRAY_TYPE",
+  119: "WASM_INDIRECT_FUNCTION_TABLE_TYPE",
-  120: "HASH_TABLE_TYPE",
+  120: "FIXED_ARRAY_TYPE",
-  121: "EPHEMERON_HASH_TABLE_TYPE",
+  121: "HASH_TABLE_TYPE",
-  122: "GLOBAL_DICTIONARY_TYPE",
+  122: "EPHEMERON_HASH_TABLE_TYPE",
-  123: "NAME_DICTIONARY_TYPE",
+  123: "GLOBAL_DICTIONARY_TYPE",
-  124: "NUMBER_DICTIONARY_TYPE",
+  124: "NAME_DICTIONARY_TYPE",
-  125: "ORDERED_HASH_MAP_TYPE",
+  125: "NUMBER_DICTIONARY_TYPE",
-  126: "ORDERED_HASH_SET_TYPE",
+  126: "ORDERED_HASH_MAP_TYPE",
-  127: "ORDERED_NAME_DICTIONARY_TYPE",
+  127: "ORDERED_HASH_SET_TYPE",
-  128: "SIMPLE_NUMBER_DICTIONARY_TYPE",
+  128: "ORDERED_NAME_DICTIONARY_TYPE",
-  129: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
+  129: "SIMPLE_NUMBER_DICTIONARY_TYPE",
-  130: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
+  130: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
-  131: "SCRIPT_CONTEXT_TABLE_TYPE",
+  131: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
-  132: "BYTE_ARRAY_TYPE",
+  132: "SCRIPT_CONTEXT_TABLE_TYPE",
-  133: "BYTECODE_ARRAY_TYPE",
+  133: "BYTE_ARRAY_TYPE",
-  134: "FIXED_DOUBLE_ARRAY_TYPE",
+  134: "BYTECODE_ARRAY_TYPE",
-  135: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
+  135: "FIXED_DOUBLE_ARRAY_TYPE",
-  136: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
+  136: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
-  137: "AWAIT_CONTEXT_TYPE",
+  137: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
-  138: "BLOCK_CONTEXT_TYPE",
+  138: "AWAIT_CONTEXT_TYPE",
-  139: "CATCH_CONTEXT_TYPE",
+  139: "BLOCK_CONTEXT_TYPE",
-  140: "DEBUG_EVALUATE_CONTEXT_TYPE",
+  140: "CATCH_CONTEXT_TYPE",
-  141: "EVAL_CONTEXT_TYPE",
+  141: "DEBUG_EVALUATE_CONTEXT_TYPE",
-  142: "FUNCTION_CONTEXT_TYPE",
+  142: "EVAL_CONTEXT_TYPE",
-  143: "MODULE_CONTEXT_TYPE",
+  143: "FUNCTION_CONTEXT_TYPE",
-  144: "NATIVE_CONTEXT_TYPE",
+  144: "MODULE_CONTEXT_TYPE",
-  145: "SCRIPT_CONTEXT_TYPE",
+  145: "NATIVE_CONTEXT_TYPE",
-  146: "WITH_CONTEXT_TYPE",
+  146: "SCRIPT_CONTEXT_TYPE",
-  147: "EXPORTED_SUB_CLASS_BASE_TYPE",
+  147: "WITH_CONTEXT_TYPE",
-  148: "EXPORTED_SUB_CLASS_TYPE",
+  148: "EXPORTED_SUB_CLASS_BASE_TYPE",
-  149: "EXPORTED_SUB_CLASS2_TYPE",
+  149: "EXPORTED_SUB_CLASS_TYPE",
-  150: "SMALL_ORDERED_HASH_MAP_TYPE",
+  150: "EXPORTED_SUB_CLASS2_TYPE",
-  151: "SMALL_ORDERED_HASH_SET_TYPE",
+  151: "SMALL_ORDERED_HASH_MAP_TYPE",
-  152: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
+  152: "SMALL_ORDERED_HASH_SET_TYPE",
-  153: "DESCRIPTOR_ARRAY_TYPE",
+  153: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
-  154: "STRONG_DESCRIPTOR_ARRAY_TYPE",
+  154: "DESCRIPTOR_ARRAY_TYPE",
-  155: "SOURCE_TEXT_MODULE_TYPE",
+  155: "STRONG_DESCRIPTOR_ARRAY_TYPE",
-  156: "SYNTHETIC_MODULE_TYPE",
+  156: "SOURCE_TEXT_MODULE_TYPE",
-  157: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE",
+  157: "SYNTHETIC_MODULE_TYPE",
-  158: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE",
+  158: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE",
-  159: "WEAK_FIXED_ARRAY_TYPE",
+  159: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE",
-  160: "TRANSITION_ARRAY_TYPE",
+  160: "WEAK_FIXED_ARRAY_TYPE",
-  161: "CALL_REF_DATA_TYPE",
+  161: "TRANSITION_ARRAY_TYPE",
-  162: "CELL_TYPE",
+  162: "CALL_REF_DATA_TYPE",
-  163: "CODE_TYPE",
+  163: "CELL_TYPE",
-  164: "CODE_DATA_CONTAINER_TYPE",
+  164: "CODE_TYPE",
-  165: "COVERAGE_INFO_TYPE",
+  165: "CODE_DATA_CONTAINER_TYPE",
-  166: "EMBEDDER_DATA_ARRAY_TYPE",
+  166: "COVERAGE_INFO_TYPE",
-  167: "FEEDBACK_METADATA_TYPE",
+  167: "EMBEDDER_DATA_ARRAY_TYPE",
-  168: "FEEDBACK_VECTOR_TYPE",
+  168: "FEEDBACK_METADATA_TYPE",
-  169: "FILLER_TYPE",
+  169: "FEEDBACK_VECTOR_TYPE",
-  170: "FREE_SPACE_TYPE",
+  170: "FILLER_TYPE",
-  171: "INTERNAL_CLASS_TYPE",
+  171: "FREE_SPACE_TYPE",
-  172: "INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE",
+  172: "INTERNAL_CLASS_TYPE",
-  173: "MAP_TYPE",
+  173: "INTERNAL_CLASS_WITH_STRUCT_ELEMENTS_TYPE",
-  174: "MEGA_DOM_HANDLER_TYPE",
+  174: "MAP_TYPE",
-  175: "ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE",
+  175: "MEGA_DOM_HANDLER_TYPE",
-  176: "PREPARSE_DATA_TYPE",
+  176: "ON_HEAP_BASIC_BLOCK_PROFILER_DATA_TYPE",
-  177: "PROPERTY_ARRAY_TYPE",
+  177: "PREPARSE_DATA_TYPE",
-  178: "PROPERTY_CELL_TYPE",
+  178: "PROPERTY_ARRAY_TYPE",
-  179: "SCOPE_INFO_TYPE",
+  179: "PROPERTY_CELL_TYPE",
-  180: "SHARED_FUNCTION_INFO_TYPE",
+  180: "SCOPE_INFO_TYPE",
-  181: "SMI_BOX_TYPE",
+  181: "SHARED_FUNCTION_INFO_TYPE",
-  182: "SMI_PAIR_TYPE",
+  182: "SMI_BOX_TYPE",
-  183: "SORT_STATE_TYPE",
+  183: "SMI_PAIR_TYPE",
-  184: "SWISS_NAME_DICTIONARY_TYPE",
+  184: "SORT_STATE_TYPE",
-  185: "WEAK_ARRAY_LIST_TYPE",
+  185: "SWISS_NAME_DICTIONARY_TYPE",
-  186: "WEAK_CELL_TYPE",
+  186: "WEAK_ARRAY_LIST_TYPE",
-  187: "WASM_ARRAY_TYPE",
+  187: "WEAK_CELL_TYPE",
-  188: "WASM_STRUCT_TYPE",
+  188: "WASM_ARRAY_TYPE",
-  189: "JS_PROXY_TYPE",
+  189: "WASM_STRUCT_TYPE",
+  190: "JS_PROXY_TYPE",
   1057: "JS_OBJECT_TYPE",
-  190: "JS_GLOBAL_OBJECT_TYPE",
+  191: "JS_GLOBAL_OBJECT_TYPE",
-  191: "JS_GLOBAL_PROXY_TYPE",
+  192: "JS_GLOBAL_PROXY_TYPE",
-  192: "JS_MODULE_NAMESPACE_TYPE",
+  193: "JS_MODULE_NAMESPACE_TYPE",
   1040: "JS_SPECIAL_API_OBJECT_TYPE",
   1041: "JS_PRIMITIVE_WRAPPER_TYPE",
   1058: "JS_API_OBJECT_TYPE",
@@ -248,81 +249,81 @@ INSTANCE_TYPES = {
 
 # List of known V8 maps.
 KNOWN_MAPS = {
-  ("read_only_space", 0x02119): (173, "MetaMap"),
+  ("read_only_space", 0x02119): (174, "MetaMap"),
   ("read_only_space", 0x02141): (67, "NullMap"),
-  ("read_only_space", 0x02169): (154, "StrongDescriptorArrayMap"),
+  ("read_only_space", 0x02169): (155, "StrongDescriptorArrayMap"),
-  ("read_only_space", 0x02191): (159, "WeakFixedArrayMap"),
+  ("read_only_space", 0x02191): (160, "WeakFixedArrayMap"),
   ("read_only_space", 0x021d1): (100, "EnumCacheMap"),
-  ("read_only_space", 0x02205): (119, "FixedArrayMap"),
+  ("read_only_space", 0x02205): (120, "FixedArrayMap"),
   ("read_only_space", 0x02251): (8, "OneByteInternalizedStringMap"),
-  ("read_only_space", 0x0229d): (170, "FreeSpaceMap"),
+  ("read_only_space", 0x0229d): (171, "FreeSpaceMap"),
-  ("read_only_space", 0x022c5): (169, "OnePointerFillerMap"),
+  ("read_only_space", 0x022c5): (170, "OnePointerFillerMap"),
-  ("read_only_space", 0x022ed): (169, "TwoPointerFillerMap"),
+  ("read_only_space", 0x022ed): (170, "TwoPointerFillerMap"),
   ("read_only_space", 0x02315): (67, "UninitializedMap"),
   ("read_only_space", 0x0238d): (67, "UndefinedMap"),
   ("read_only_space", 0x023d1): (66, "HeapNumberMap"),
   ("read_only_space", 0x02405): (67, "TheHoleMap"),
   ("read_only_space", 0x02465): (67, "BooleanMap"),
-  ("read_only_space", 0x02509): (132, "ByteArrayMap"),
+  ("read_only_space", 0x02509): (133, "ByteArrayMap"),
-  ("read_only_space", 0x02531): (119, "FixedCOWArrayMap"),
+  ("read_only_space", 0x02531): (120, "FixedCOWArrayMap"),
-  ("read_only_space", 0x02559): (120, "HashTableMap"),
+  ("read_only_space", 0x02559): (121, "HashTableMap"),
   ("read_only_space", 0x02581): (64, "SymbolMap"),
   ("read_only_space", 0x025a9): (40, "OneByteStringMap"),
-  ("read_only_space", 0x025d1): (179, "ScopeInfoMap"),
+  ("read_only_space", 0x025d1): (180, "ScopeInfoMap"),
-  ("read_only_space", 0x025f9): (180, "SharedFunctionInfoMap"),
+  ("read_only_space", 0x025f9): (181, "SharedFunctionInfoMap"),
-  ("read_only_space", 0x02621): (163, "CodeMap"),
+  ("read_only_space", 0x02621): (164, "CodeMap"),
-  ("read_only_space", 0x02649): (162, "CellMap"),
+  ("read_only_space", 0x02649): (163, "CellMap"),
-  ("read_only_space", 0x02671): (178, "GlobalPropertyCellMap"),
+  ("read_only_space", 0x02671): (179, "GlobalPropertyCellMap"),
   ("read_only_space", 0x02699): (70, "ForeignMap"),
-  ("read_only_space", 0x026c1): (160, "TransitionArrayMap"),
+  ("read_only_space", 0x026c1): (161, "TransitionArrayMap"),
   ("read_only_space", 0x026e9): (45, "ThinOneByteStringMap"),
-  ("read_only_space", 0x02711): (168, "FeedbackVectorMap"),
+  ("read_only_space", 0x02711): (169, "FeedbackVectorMap"),
   ("read_only_space", 0x02749): (67, "ArgumentsMarkerMap"),
   ("read_only_space", 0x027a9): (67, "ExceptionMap"),
   ("read_only_space", 0x02805): (67, "TerminationExceptionMap"),
   ("read_only_space", 0x0286d): (67, "OptimizedOutMap"),
   ("read_only_space", 0x028cd): (67, "StaleRegisterMap"),
-  ("read_only_space", 0x0292d): (131, "ScriptContextTableMap"),
+  ("read_only_space", 0x0292d): (132, "ScriptContextTableMap"),
-  ("read_only_space", 0x02955): (129, "ClosureFeedbackCellArrayMap"),
+  ("read_only_space", 0x02955): (130, "ClosureFeedbackCellArrayMap"),
-  ("read_only_space", 0x0297d): (167, "FeedbackMetadataArrayMap"),
+  ("read_only_space", 0x0297d): (168, "FeedbackMetadataArrayMap"),
-  ("read_only_space", 0x029a5): (119, "ArrayListMap"),
+  ("read_only_space", 0x029a5): (120, "ArrayListMap"),
   ("read_only_space", 0x029cd): (65, "BigIntMap"),
-  ("read_only_space", 0x029f5): (130, "ObjectBoilerplateDescriptionMap"),
+  ("read_only_space", 0x029f5): (131, "ObjectBoilerplateDescriptionMap"),
-  ("read_only_space", 0x02a1d): (133, "BytecodeArrayMap"),
+  ("read_only_space", 0x02a1d): (134, "BytecodeArrayMap"),
-  ("read_only_space", 0x02a45): (164, "CodeDataContainerMap"),
+  ("read_only_space", 0x02a45): (165, "CodeDataContainerMap"),
-  ("read_only_space", 0x02a6d): (165, "CoverageInfoMap"),
+  ("read_only_space", 0x02a6d): (166, "CoverageInfoMap"),
-  ("read_only_space", 0x02a95): (134, "FixedDoubleArrayMap"),
+  ("read_only_space", 0x02a95): (135, "FixedDoubleArrayMap"),
-  ("read_only_space", 0x02abd): (122, "GlobalDictionaryMap"),
+  ("read_only_space", 0x02abd): (123, "GlobalDictionaryMap"),
   ("read_only_space", 0x02ae5): (101, "ManyClosuresCellMap"),
-  ("read_only_space", 0x02b0d): (174, "MegaDomHandlerMap"),
+  ("read_only_space", 0x02b0d): (175, "MegaDomHandlerMap"),
-  ("read_only_space", 0x02b35): (119, "ModuleInfoMap"),
+  ("read_only_space", 0x02b35): (120, "ModuleInfoMap"),
-  ("read_only_space", 0x02b5d): (123, "NameDictionaryMap"),
+  ("read_only_space", 0x02b5d): (124, "NameDictionaryMap"),
   ("read_only_space", 0x02b85): (101, "NoClosuresCellMap"),
-  ("read_only_space", 0x02bad): (124, "NumberDictionaryMap"),
+  ("read_only_space", 0x02bad): (125, "NumberDictionaryMap"),
   ("read_only_space", 0x02bd5): (101, "OneClosureCellMap"),
-  ("read_only_space", 0x02bfd): (125, "OrderedHashMapMap"),
+  ("read_only_space", 0x02bfd): (126, "OrderedHashMapMap"),
-  ("read_only_space", 0x02c25): (126, "OrderedHashSetMap"),
+  ("read_only_space", 0x02c25): (127, "OrderedHashSetMap"),
-  ("read_only_space", 0x02c4d): (127, "OrderedNameDictionaryMap"),
+  ("read_only_space", 0x02c4d): (128, "OrderedNameDictionaryMap"),
-  ("read_only_space", 0x02c75): (176, "PreparseDataMap"),
+  ("read_only_space", 0x02c75): (177, "PreparseDataMap"),
-  ("read_only_space", 0x02c9d): (177, "PropertyArrayMap"),
+  ("read_only_space", 0x02c9d): (178, "PropertyArrayMap"),
   ("read_only_space", 0x02cc5): (97, "SideEffectCallHandlerInfoMap"),
   ("read_only_space", 0x02ced): (97, "SideEffectFreeCallHandlerInfoMap"),
   ("read_only_space", 0x02d15): (97, "NextCallSideEffectFreeCallHandlerInfoMap"),
-  ("read_only_space", 0x02d3d): (128, "SimpleNumberDictionaryMap"),
+  ("read_only_space", 0x02d3d): (129, "SimpleNumberDictionaryMap"),
-  ("read_only_space", 0x02d65): (150, "SmallOrderedHashMapMap"),
+  ("read_only_space", 0x02d65): (151, "SmallOrderedHashMapMap"),
-  ("read_only_space", 0x02d8d): (151, "SmallOrderedHashSetMap"),
+  ("read_only_space", 0x02d8d): (152, "SmallOrderedHashSetMap"),
-  ("read_only_space", 0x02db5): (152, "SmallOrderedNameDictionaryMap"),
+  ("read_only_space", 0x02db5): (153, "SmallOrderedNameDictionaryMap"),
-  ("read_only_space", 0x02ddd): (155, "SourceTextModuleMap"),
+  ("read_only_space", 0x02ddd): (156, "SourceTextModuleMap"),
-  ("read_only_space", 0x02e05): (184, "SwissNameDictionaryMap"),
+  ("read_only_space", 0x02e05): (185, "SwissNameDictionaryMap"),
-  ("read_only_space", 0x02e2d): (156, "SyntheticModuleMap"),
+  ("read_only_space", 0x02e2d): (157, "SyntheticModuleMap"),
   ("read_only_space", 0x02e55): (72, "WasmCapiFunctionDataMap"),
   ("read_only_space", 0x02e7d): (73, "WasmExportedFunctionDataMap"),
   ("read_only_space", 0x02ea5): (74, "WasmJSFunctionDataMap"),
   ("read_only_space", 0x02ecd): (75, "WasmTypeInfoMap"),
-  ("read_only_space", 0x02ef5): (185, "WeakArrayListMap"),
+  ("read_only_space", 0x02ef5): (186, "WeakArrayListMap"),
-  ("read_only_space", 0x02f1d): (121, "EphemeronHashTableMap"),
+  ("read_only_space", 0x02f1d): (122, "EphemeronHashTableMap"),
-  ("read_only_space", 0x02f45): (166, "EmbedderDataArrayMap"),
+  ("read_only_space", 0x02f45): (167, "EmbedderDataArrayMap"),
-  ("read_only_space", 0x02f6d): (186, "WeakCellMap"),
+  ("read_only_space", 0x02f6d): (187, "WeakCellMap"),
   ("read_only_space", 0x02f95): (32, "StringMap"),
   ("read_only_space", 0x02fbd): (41, "ConsOneByteStringMap"),
   ("read_only_space", 0x02fe5): (33, "ConsStringMap"),
@@ -375,34 +376,35 @@ KNOWN_MAPS = {
   ("read_only_space", 0x0609d): (114, "StackFrameInfoMap"),
   ("read_only_space", 0x060c5): (115, "TemplateObjectDescriptionMap"),
   ("read_only_space", 0x060ed): (116, "Tuple2Map"),
-  ("read_only_space", 0x06115): (117, "WasmExceptionTagMap"),
+  ("read_only_space", 0x06115): (117, "WasmContinuationObjectMap"),
-  ("read_only_space", 0x0613d): (118, "WasmIndirectFunctionTableMap"),
+  ("read_only_space", 0x0613d): (118, "WasmExceptionTagMap"),
-  ("read_only_space", 0x06165): (136, "SloppyArgumentsElementsMap"),
+  ("read_only_space", 0x06165): (119, "WasmIndirectFunctionTableMap"),
-  ("read_only_space", 0x0618d): (153, "DescriptorArrayMap"),
+  ("read_only_space", 0x0618d): (137, "SloppyArgumentsElementsMap"),
-  ("read_only_space", 0x061b5): (158, "UncompiledDataWithoutPreparseDataMap"),
+  ("read_only_space", 0x061b5): (154, "DescriptorArrayMap"),
-  ("read_only_space", 0x061dd): (157, "UncompiledDataWithPreparseDataMap"),
+  ("read_only_space", 0x061dd): (159, "UncompiledDataWithoutPreparseDataMap"),
-  ("read_only_space", 0x06205): (175, "OnHeapBasicBlockProfilerDataMap"),
+  ("read_only_space", 0x06205): (158, "UncompiledDataWithPreparseDataMap"),
-  ("read_only_space", 0x0622d): (171, "InternalClassMap"),
+  ("read_only_space", 0x0622d): (176, "OnHeapBasicBlockProfilerDataMap"),
-  ("read_only_space", 0x06255): (182, "SmiPairMap"),
+  ("read_only_space", 0x06255): (172, "InternalClassMap"),
-  ("read_only_space", 0x0627d): (181, "SmiBoxMap"),
+  ("read_only_space", 0x0627d): (183, "SmiPairMap"),
-  ("read_only_space", 0x062a5): (147, "ExportedSubClassBaseMap"),
+  ("read_only_space", 0x062a5): (182, "SmiBoxMap"),
-  ("read_only_space", 0x062cd): (148, "ExportedSubClassMap"),
+  ("read_only_space", 0x062cd): (148, "ExportedSubClassBaseMap"),
-  ("read_only_space", 0x062f5): (68, "AbstractInternalClassSubclass1Map"),
+  ("read_only_space", 0x062f5): (149, "ExportedSubClassMap"),
-  ("read_only_space", 0x0631d): (69, "AbstractInternalClassSubclass2Map"),
+  ("read_only_space", 0x0631d): (68, "AbstractInternalClassSubclass1Map"),
-  ("read_only_space", 0x06345): (135, "InternalClassWithSmiElementsMap"),
+  ("read_only_space", 0x06345): (69, "AbstractInternalClassSubclass2Map"),
-  ("read_only_space", 0x0636d): (172, "InternalClassWithStructElementsMap"),
+  ("read_only_space", 0x0636d): (136, "InternalClassWithSmiElementsMap"),
-  ("read_only_space", 0x06395): (149, "ExportedSubClass2Map"),
+  ("read_only_space", 0x06395): (173, "InternalClassWithStructElementsMap"),
-  ("read_only_space", 0x063bd): (183, "SortStateMap"),
+  ("read_only_space", 0x063bd): (150, "ExportedSubClass2Map"),
-  ("read_only_space", 0x063e5): (161, "CallRefDataMap"),
+  ("read_only_space", 0x063e5): (184, "SortStateMap"),
-  ("read_only_space", 0x0640d): (90, "AllocationSiteWithWeakNextMap"),
+  ("read_only_space", 0x0640d): (162, "CallRefDataMap"),
-  ("read_only_space", 0x06435): (90, "AllocationSiteWithoutWeakNextMap"),
+  ("read_only_space", 0x06435): (90, "AllocationSiteWithWeakNextMap"),
-  ("read_only_space", 0x0645d): (81, "LoadHandler1Map"),
+  ("read_only_space", 0x0645d): (90, "AllocationSiteWithoutWeakNextMap"),
-  ("read_only_space", 0x06485): (81, "LoadHandler2Map"),
+  ("read_only_space", 0x06485): (81, "LoadHandler1Map"),
-  ("read_only_space", 0x064ad): (81, "LoadHandler3Map"),
+  ("read_only_space", 0x064ad): (81, "LoadHandler2Map"),
-  ("read_only_space", 0x064d5): (82, "StoreHandler0Map"),
+  ("read_only_space", 0x064d5): (81, "LoadHandler3Map"),
-  ("read_only_space", 0x064fd): (82, "StoreHandler1Map"),
+  ("read_only_space", 0x064fd): (82, "StoreHandler0Map"),
-  ("read_only_space", 0x06525): (82, "StoreHandler2Map"),
+  ("read_only_space", 0x06525): (82, "StoreHandler1Map"),
-  ("read_only_space", 0x0654d): (82, "StoreHandler3Map"),
+  ("read_only_space", 0x0654d): (82, "StoreHandler2Map"),
+  ("read_only_space", 0x06575): (82, "StoreHandler3Map"),
   ("map_space", 0x02119): (1057, "ExternalMap"),
   ("map_space", 0x02141): (2114, "JSMessageObjectMap"),
 }