[stack trace] Introduce StackTraceFrame object

The StackTraceFrame object will be used in a future CL to replace
StackFrameInfo as the object returned by the inspector API, as well
as the object used in the stack_frame_cache.

The object itself is a simple wrapper around a reference to a
FrameArray plus an index, as well as a reference to a
StackFrameInfo object that will get lazily initialized.

This is the first step towards unifying stack trace representation
and collection.

R=jgruber@chromium.org

Bug: v8:8742
Change-Id: Iefc7d734fd274ffd164ddf6f43c226531aa26d4c
Reviewed-on: https://chromium-review.googlesource.com/c/1458017
Commit-Queue: Simon Zünd <szuend@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
Cr-Commit-Position: refs/heads/master@{#59544}

BUILD.gn

@@ -2324,6 +2324,7 @@ v8_source_set("v8_base") {
     "src/objects/slots-inl.h",
     "src/objects/slots.h",
     "src/objects/stack-frame-info-inl.h",
+    "src/objects/stack-frame-info.cc",
     "src/objects/stack-frame-info.h",
     "src/objects/string-comparator.cc",
     "src/objects/string-comparator.h",

src/compiler/types.cc

@@ -345,6 +345,7 @@ Type::bitset BitsetType::Lub(const MapRefLike& map) {
     case CLASS_POSITIONS_TYPE:
     case DEBUG_INFO_TYPE:
     case STACK_FRAME_INFO_TYPE:
+    case STACK_TRACE_FRAME_TYPE:
     case SMALL_ORDERED_HASH_MAP_TYPE:
     case SMALL_ORDERED_HASH_SET_TYPE:
     case SMALL_ORDERED_NAME_DICTIONARY_TYPE:

src/heap/factory.cc

@@ -3872,6 +3872,20 @@ Handle<BreakPoint> Factory::NewBreakPoint(int id, Handle<String> condition) {
   return new_break_point;
 }
 
+Handle<StackTraceFrame> Factory::NewStackTraceFrame(
+    Handle<FrameArray> frame_array, int index) {
+  Handle<StackTraceFrame> frame = Handle<StackTraceFrame>::cast(
+      NewStruct(STACK_TRACE_FRAME_TYPE, NOT_TENURED));
+  frame->set_frame_array(*frame_array);
+  frame->set_frame_index(index);
+  frame->set_frame_info(*undefined_value());
+
+  int id = isolate()->last_stack_frame_info_id() + 1;
+  isolate()->set_last_stack_frame_info_id(id);
+  frame->set_id(id);
+  return frame;
+}
+
 Handle<StackFrameInfo> Factory::NewStackFrameInfo() {
   Handle<StackFrameInfo> stack_frame_info = Handle<StackFrameInfo>::cast(
       NewStruct(STACK_FRAME_INFO_TYPE, NOT_TENURED));

src/heap/factory.h

@@ -62,6 +62,7 @@ class PromiseResolveThenableJobTask;
 class RegExpMatchInfo;
 class ScriptContextTable;
 class StackFrameInfo;
+class StackTraceFrame;
 class StoreHandler;
 class TemplateObjectDescription;
 class UncompiledDataWithoutPreparseData;
@@ -439,6 +440,8 @@ class V8_EXPORT_PRIVATE Factory {
 
   Handle<BreakPointInfo> NewBreakPointInfo(int source_position);
   Handle<BreakPoint> NewBreakPoint(int id, Handle<String> condition);
+  Handle<StackTraceFrame> NewStackTraceFrame(Handle<FrameArray> frame_array,
+                                             int index);
   Handle<StackFrameInfo> NewStackFrameInfo();
   Handle<StackFrameInfo> NewStackFrameInfo(Handle<FrameArray> frame_array,
                                            int index);

src/messages.cc

@@ -295,7 +295,7 @@ Handle<Object> StackFrameBase::GetEvalOrigin() {
 }
 
 int StackFrameBase::GetScriptId() const {
-  if (!HasScript()) return -1;
+  if (!HasScript()) return kNone;
   return GetScript()->id();
 }
 
@@ -467,7 +467,7 @@ Handle<Object> JSStackFrame::GetTypeName() {
 int JSStackFrame::GetLineNumber() {
   DCHECK_LE(0, GetPosition());
   if (HasScript()) return Script::GetLineNumber(GetScript(), GetPosition()) + 1;
-  return -1;
+  return kNone;
 }
 
 int JSStackFrame::GetColumnNumber() {
@@ -475,11 +475,11 @@ int JSStackFrame::GetColumnNumber() {
   if (HasScript()) {
     return Script::GetColumnNumber(GetScript(), GetPosition()) + 1;
   }
-  return -1;
+  return kNone;
 }
 
 int JSStackFrame::GetPromiseIndex() const {
-  return is_promise_all_ ? offset_ : -1;
+  return is_promise_all_ ? offset_ : kNone;
 }
 
 bool JSStackFrame::IsNative() {
@@ -521,14 +521,14 @@ void AppendFileLocation(Isolate* isolate, StackFrameBase* call_site,
   }
 
   int line_number = call_site->GetLineNumber();
-  if (line_number != -1) {
+  if (line_number != StackFrameBase::kNone) {
     builder->AppendCharacter(':');
     Handle<String> line_string = isolate->factory()->NumberToString(
         handle(Smi::FromInt(line_number), isolate), isolate);
     builder->AppendString(line_string);
 
     int column_number = call_site->GetColumnNumber();
-    if (column_number != -1) {
+    if (column_number != StackFrameBase::kNone) {
       builder->AppendCharacter(':');
       Handle<String> column_string = isolate->factory()->NumberToString(
           handle(Smi::FromInt(column_number), isolate), isolate);

src/messages.h

@@ -85,6 +85,9 @@ class StackFrameBase {
 
   virtual MaybeHandle<String> ToString() = 0;
 
+  // Used to signal that the requested field is unknown.
+  static const int kNone = -1;
+
  protected:
   StackFrameBase() = default;
   explicit StackFrameBase(Isolate* isolate) : isolate_(isolate) {}
@@ -161,9 +164,9 @@ class WasmStackFrame : public StackFrameBase {
 
   int GetPosition() const override;
   int GetLineNumber() override { return wasm_func_index_; }
-  int GetColumnNumber() override { return -1; }
+  int GetColumnNumber() override { return kNone; }
 
-  int GetPromiseIndex() const override { return -1; }
+  int GetPromiseIndex() const override { return kNone; }
 
   bool IsNative() override { return false; }
   bool IsToplevel() override { return false; }

src/objects-debug.cc

@@ -2054,6 +2054,14 @@ void DebugInfo::DebugInfoVerify(Isolate* isolate) {
   VerifyPointer(isolate, break_points());
 }
 
+void StackTraceFrame::StackTraceFrameVerify(Isolate* isolate) {
+  CHECK(IsStackTraceFrame());
+  VerifySmiField(kFrameIndexOffset);
+  VerifySmiField(kIdOffset);
+  VerifyPointer(isolate, frame_array());
+  VerifyPointer(isolate, frame_info());
+}
+
 void StackFrameInfo::StackFrameInfoVerify(Isolate* isolate) {
   CHECK(IsStackFrameInfo());
   VerifyPointer(isolate, script_name());

src/objects-definitions.h

@@ -112,6 +112,7 @@ namespace internal {
   V(PROTOTYPE_INFO_TYPE)                                           \
   V(SCRIPT_TYPE)                                                   \
   V(STACK_FRAME_INFO_TYPE)                                         \
+  V(STACK_TRACE_FRAME_TYPE)                                        \
   V(TUPLE2_TYPE)                                                   \
   V(TUPLE3_TYPE)                                                   \
   V(ARRAY_BOILERPLATE_DESCRIPTION_TYPE)                            \
@@ -338,6 +339,7 @@ namespace internal {
   V(_, PROTOTYPE_INFO_TYPE, PrototypeInfo, prototype_info)                    \
   V(_, SCRIPT_TYPE, Script, script)                                           \
   V(_, STACK_FRAME_INFO_TYPE, StackFrameInfo, stack_frame_info)               \
+  V(_, STACK_TRACE_FRAME_TYPE, StackTraceFrame, stack_trace_frame)            \
   V(_, TUPLE2_TYPE, Tuple2, tuple2)                                           \
   V(_, TUPLE3_TYPE, Tuple3, tuple3)                                           \
   V(_, ARRAY_BOILERPLATE_DESCRIPTION_TYPE, ArrayBoilerplateDescription,       \

src/objects-printer.cc

@@ -2207,6 +2207,12 @@ void DebugInfo::DebugInfoPrint(std::ostream& os) {  // NOLINT
   os << "\n - coverage_info: " << Brief(coverage_info());
 }
 
+void StackTraceFrame::StackTraceFramePrint(std::ostream& os) {  // NOLINT
+  PrintHeader(os, "StackTraceFrame");
+  os << "\n - frame_index: " << frame_index();
+  os << "\n - id: " << id();
+  os << "\n - frame_info: " << Brief(frame_info());
+}
 
 void StackFrameInfo::StackFrameInfoPrint(std::ostream& os) {  // NOLINT
   PrintHeader(os, "StackFrame");

src/objects.h

@@ -159,6 +159,7 @@
 //       - BreakPoint
 //       - BreakPointInfo
 //       - StackFrameInfo
+//       - StackTraceFrame
 //       - SourcePositionTableWithFrameCache
 //       - CodeCache
 //       - PrototypeInfo

src/objects/instance-type.h

@@ -185,6 +185,7 @@ enum InstanceType : uint16_t {
   PROTOTYPE_INFO_TYPE,
   SCRIPT_TYPE,
   STACK_FRAME_INFO_TYPE,
+  STACK_TRACE_FRAME_TYPE,
   TUPLE2_TYPE,
   TUPLE3_TYPE,
   ARRAY_BOILERPLATE_DESCRIPTION_TYPE,

src/objects/stack-frame-info-inl.h

@@ -8,6 +8,7 @@
 #include "src/objects/stack-frame-info.h"
 
 #include "src/heap/heap-write-barrier-inl.h"
+#include "src/objects/frame-array-inl.h"
 
 // Has to be the last include (doesn't have include guards):
 #include "src/objects/object-macros.h"
@@ -34,6 +35,15 @@ BOOL_ACCESSORS(StackFrameInfo, flag, is_constructor, kIsConstructorBit)
 BOOL_ACCESSORS(StackFrameInfo, flag, is_wasm, kIsWasmBit)
 SMI_ACCESSORS(StackFrameInfo, id, kIdOffset)
 
+OBJECT_CONSTRUCTORS_IMPL(StackTraceFrame, Struct)
+NEVER_READ_ONLY_SPACE_IMPL(StackTraceFrame)
+CAST_ACCESSOR(StackTraceFrame)
+
+ACCESSORS(StackTraceFrame, frame_array, Object, kFrameArrayOffset)
+SMI_ACCESSORS(StackTraceFrame, frame_index, kFrameIndexOffset)
+ACCESSORS(StackTraceFrame, frame_info, Object, kFrameInfoOffset)
+SMI_ACCESSORS(StackTraceFrame, id, kIdOffset)
+
 }  // namespace internal
 }  // namespace v8
 

src/objects/stack-frame-info.cc

+// Copyright 2019 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.
+
+#include "src/objects/stack-frame-info.h"
+
+#include "src/objects/stack-frame-info-inl.h"
+
+namespace v8 {
+namespace internal {
+
+int StackTraceFrame::GetLineNumber(Handle<StackTraceFrame> frame) {
+  if (frame->frame_info()->IsUndefined()) InitializeFrameInfo(frame);
+  int line = GetFrameInfo(frame)->line_number();
+  return line != StackFrameBase::kNone ? line : Message::kNoLineNumberInfo;
+}
+
+int StackTraceFrame::GetColumnNumber(Handle<StackTraceFrame> frame) {
+  if (frame->frame_info()->IsUndefined()) InitializeFrameInfo(frame);
+  int column = GetFrameInfo(frame)->column_number();
+  return column != StackFrameBase::kNone ? column : Message::kNoColumnInfo;
+}
+
+int StackTraceFrame::GetScriptId(Handle<StackTraceFrame> frame) {
+  if (frame->frame_info()->IsUndefined()) InitializeFrameInfo(frame);
+  int id = GetFrameInfo(frame)->script_id();
+  return id != StackFrameBase::kNone ? id : Message::kNoScriptIdInfo;
+}
+
+Handle<Object> StackTraceFrame::GetFileName(Handle<StackTraceFrame> frame) {
+  if (frame->frame_info()->IsUndefined()) InitializeFrameInfo(frame);
+  auto name = GetFrameInfo(frame)->script_name();
+  return handle(name, frame->GetIsolate());
+}
+
+Handle<Object> StackTraceFrame::GetScriptNameOrSourceUrl(
+    Handle<StackTraceFrame> frame) {
+  if (frame->frame_info()->IsUndefined()) InitializeFrameInfo(frame);
+  auto name = GetFrameInfo(frame)->script_name_or_source_url();
+  return handle(name, frame->GetIsolate());
+}
+
+Handle<Object> StackTraceFrame::GetFunctionName(Handle<StackTraceFrame> frame) {
+  if (frame->frame_info()->IsUndefined()) InitializeFrameInfo(frame);
+  auto name = GetFrameInfo(frame)->function_name();
+  return handle(name, frame->GetIsolate());
+}
+
+bool StackTraceFrame::IsEval(Handle<StackTraceFrame> frame) {
+  if (frame->frame_info()->IsUndefined()) InitializeFrameInfo(frame);
+  return GetFrameInfo(frame)->is_eval();
+}
+
+bool StackTraceFrame::IsConstructor(Handle<StackTraceFrame> frame) {
+  if (frame->frame_info()->IsUndefined()) InitializeFrameInfo(frame);
+  return GetFrameInfo(frame)->is_constructor();
+}
+
+bool StackTraceFrame::IsWasm(Handle<StackTraceFrame> frame) {
+  if (frame->frame_info()->IsUndefined()) InitializeFrameInfo(frame);
+  return GetFrameInfo(frame)->is_wasm();
+}
+
+Handle<StackFrameInfo> StackTraceFrame::GetFrameInfo(
+    Handle<StackTraceFrame> frame) {
+  return handle(StackFrameInfo::cast(frame->frame_info()), frame->GetIsolate());
+}
+
+void StackTraceFrame::InitializeFrameInfo(Handle<StackTraceFrame> frame) {
+  Isolate* isolate = frame->GetIsolate();
+  Handle<StackFrameInfo> frame_info = isolate->factory()->NewStackFrameInfo(
+      handle(FrameArray::cast(frame->frame_array()), isolate),
+      frame->frame_index());
+  frame->set_frame_info(*frame_info);
+
+  // After initializing, we no longer need to keep a reference
+  // to the frame_array.
+  frame->set_frame_array(ReadOnlyRoots(isolate).undefined_value());
+  frame->set_frame_index(-1);
+}
+
+}  // namespace internal
+}  // namespace v8

src/objects/stack-frame-info.h

@@ -13,6 +13,8 @@
 namespace v8 {
 namespace internal {
 
+class FrameArray;
+
 class StackFrameInfo : public Struct {
  public:
   NEVER_READ_ONLY_SPACE
@@ -59,6 +61,56 @@ class StackFrameInfo : public Struct {
   OBJECT_CONSTRUCTORS(StackFrameInfo, Struct);
 };
 
+// This class is used to lazily initialize a StackFrameInfo object from
+// a FrameArray plus an index.
+// The first time any of the Get* or Is* methods is called, a
+// StackFrameInfo object is allocated and all necessary information
+// retrieved.
+class StackTraceFrame : public Struct {
+ public:
+  NEVER_READ_ONLY_SPACE
+  DECL_ACCESSORS(frame_array, Object)
+  DECL_INT_ACCESSORS(frame_index)
+  DECL_ACCESSORS(frame_info, Object)
+  DECL_INT_ACCESSORS(id)
+
+  DECL_CAST(StackTraceFrame)
+
+  // Dispatched behavior.
+  DECL_PRINTER(StackTraceFrame)
+  DECL_VERIFIER(StackTraceFrame)
+
+  // Layout description.
+#define STACK_FRAME_FIELDS(V)       \
+  V(kFrameArrayOffset, kTaggedSize) \
+  V(kFrameIndexOffset, kTaggedSize) \
+  V(kFrameInfoOffset, kTaggedSize)  \
+  V(kIdOffset, kTaggedSize)         \
+  /* Total size. */                 \
+  V(kSize, 0)
+
+  DEFINE_FIELD_OFFSET_CONSTANTS(Struct::kHeaderSize, STACK_FRAME_FIELDS)
+#undef STACK_FRAME_FIELDS
+
+  static int GetLineNumber(Handle<StackTraceFrame> frame);
+  static int GetColumnNumber(Handle<StackTraceFrame> frame);
+  static int GetScriptId(Handle<StackTraceFrame> frame);
+
+  static Handle<Object> GetFileName(Handle<StackTraceFrame> frame);
+  static Handle<Object> GetScriptNameOrSourceUrl(Handle<StackTraceFrame> frame);
+  static Handle<Object> GetFunctionName(Handle<StackTraceFrame> frame);
+
+  static bool IsEval(Handle<StackTraceFrame> frame);
+  static bool IsConstructor(Handle<StackTraceFrame> frame);
+  static bool IsWasm(Handle<StackTraceFrame> frame);
+
+ private:
+  OBJECT_CONSTRUCTORS(StackTraceFrame, Struct);
+
+  static Handle<StackFrameInfo> GetFrameInfo(Handle<StackTraceFrame> frame);
+  static void InitializeFrameInfo(Handle<StackTraceFrame> frame);
+};
+
 }  // namespace internal
 }  // namespace v8
 

tools/v8heapconst.py

@@ -75,65 +75,66 @@ INSTANCE_TYPES = {
   171: "PROTOTYPE_INFO_TYPE",
   172: "SCRIPT_TYPE",
   173: "STACK_FRAME_INFO_TYPE",
-  174: "TUPLE2_TYPE",
-  175: "TUPLE3_TYPE",
-  176: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE",
-  177: "WASM_DEBUG_INFO_TYPE",
-  178: "WASM_EXCEPTION_TAG_TYPE",
-  179: "WASM_EXPORTED_FUNCTION_DATA_TYPE",
-  180: "CALLABLE_TASK_TYPE",
-  181: "CALLBACK_TASK_TYPE",
-  182: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE",
-  183: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE",
-  184: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE",
-  185: "FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE",
-  186: "ALLOCATION_SITE_TYPE",
-  187: "EMBEDDER_DATA_ARRAY_TYPE",
-  188: "FIXED_ARRAY_TYPE",
-  189: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
-  190: "HASH_TABLE_TYPE",
-  191: "ORDERED_HASH_MAP_TYPE",
-  192: "ORDERED_HASH_SET_TYPE",
-  193: "ORDERED_NAME_DICTIONARY_TYPE",
-  194: "NAME_DICTIONARY_TYPE",
-  195: "GLOBAL_DICTIONARY_TYPE",
-  196: "NUMBER_DICTIONARY_TYPE",
-  197: "SIMPLE_NUMBER_DICTIONARY_TYPE",
-  198: "STRING_TABLE_TYPE",
-  199: "EPHEMERON_HASH_TABLE_TYPE",
-  200: "SCOPE_INFO_TYPE",
-  201: "SCRIPT_CONTEXT_TABLE_TYPE",
-  202: "AWAIT_CONTEXT_TYPE",
-  203: "BLOCK_CONTEXT_TYPE",
-  204: "CATCH_CONTEXT_TYPE",
-  205: "DEBUG_EVALUATE_CONTEXT_TYPE",
-  206: "EVAL_CONTEXT_TYPE",
-  207: "FUNCTION_CONTEXT_TYPE",
-  208: "MODULE_CONTEXT_TYPE",
-  209: "NATIVE_CONTEXT_TYPE",
-  210: "SCRIPT_CONTEXT_TYPE",
-  211: "WITH_CONTEXT_TYPE",
-  212: "WEAK_FIXED_ARRAY_TYPE",
-  213: "TRANSITION_ARRAY_TYPE",
-  214: "CALL_HANDLER_INFO_TYPE",
-  215: "CELL_TYPE",
-  216: "CODE_DATA_CONTAINER_TYPE",
-  217: "DESCRIPTOR_ARRAY_TYPE",
-  218: "FEEDBACK_CELL_TYPE",
-  219: "FEEDBACK_VECTOR_TYPE",
-  220: "LOAD_HANDLER_TYPE",
-  221: "PREPARSE_DATA_TYPE",
-  222: "PROPERTY_ARRAY_TYPE",
-  223: "PROPERTY_CELL_TYPE",
-  224: "SHARED_FUNCTION_INFO_TYPE",
-  225: "SMALL_ORDERED_HASH_MAP_TYPE",
-  226: "SMALL_ORDERED_HASH_SET_TYPE",
-  227: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
-  228: "STORE_HANDLER_TYPE",
-  229: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE",
-  230: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE",
-  231: "WEAK_ARRAY_LIST_TYPE",
-  232: "WEAK_CELL_TYPE",
+  174: "STACK_TRACE_FRAME_TYPE",
+  175: "TUPLE2_TYPE",
+  176: "TUPLE3_TYPE",
+  177: "ARRAY_BOILERPLATE_DESCRIPTION_TYPE",
+  178: "WASM_DEBUG_INFO_TYPE",
+  179: "WASM_EXCEPTION_TAG_TYPE",
+  180: "WASM_EXPORTED_FUNCTION_DATA_TYPE",
+  181: "CALLABLE_TASK_TYPE",
+  182: "CALLBACK_TASK_TYPE",
+  183: "PROMISE_FULFILL_REACTION_JOB_TASK_TYPE",
+  184: "PROMISE_REJECT_REACTION_JOB_TASK_TYPE",
+  185: "PROMISE_RESOLVE_THENABLE_JOB_TASK_TYPE",
+  186: "FINALIZATION_GROUP_CLEANUP_JOB_TASK_TYPE",
+  187: "ALLOCATION_SITE_TYPE",
+  188: "EMBEDDER_DATA_ARRAY_TYPE",
+  189: "FIXED_ARRAY_TYPE",
+  190: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
+  191: "HASH_TABLE_TYPE",
+  192: "ORDERED_HASH_MAP_TYPE",
+  193: "ORDERED_HASH_SET_TYPE",
+  194: "ORDERED_NAME_DICTIONARY_TYPE",
+  195: "NAME_DICTIONARY_TYPE",
+  196: "GLOBAL_DICTIONARY_TYPE",
+  197: "NUMBER_DICTIONARY_TYPE",
+  198: "SIMPLE_NUMBER_DICTIONARY_TYPE",
+  199: "STRING_TABLE_TYPE",
+  200: "EPHEMERON_HASH_TABLE_TYPE",
+  201: "SCOPE_INFO_TYPE",
+  202: "SCRIPT_CONTEXT_TABLE_TYPE",
+  203: "AWAIT_CONTEXT_TYPE",
+  204: "BLOCK_CONTEXT_TYPE",
+  205: "CATCH_CONTEXT_TYPE",
+  206: "DEBUG_EVALUATE_CONTEXT_TYPE",
+  207: "EVAL_CONTEXT_TYPE",
+  208: "FUNCTION_CONTEXT_TYPE",
+  209: "MODULE_CONTEXT_TYPE",
+  210: "NATIVE_CONTEXT_TYPE",
+  211: "SCRIPT_CONTEXT_TYPE",
+  212: "WITH_CONTEXT_TYPE",
+  213: "WEAK_FIXED_ARRAY_TYPE",
+  214: "TRANSITION_ARRAY_TYPE",
+  215: "CALL_HANDLER_INFO_TYPE",
+  216: "CELL_TYPE",
+  217: "CODE_DATA_CONTAINER_TYPE",
+  218: "DESCRIPTOR_ARRAY_TYPE",
+  219: "FEEDBACK_CELL_TYPE",
+  220: "FEEDBACK_VECTOR_TYPE",
+  221: "LOAD_HANDLER_TYPE",
+  222: "PREPARSE_DATA_TYPE",
+  223: "PROPERTY_ARRAY_TYPE",
+  224: "PROPERTY_CELL_TYPE",
+  225: "SHARED_FUNCTION_INFO_TYPE",
+  226: "SMALL_ORDERED_HASH_MAP_TYPE",
+  227: "SMALL_ORDERED_HASH_SET_TYPE",
+  228: "SMALL_ORDERED_NAME_DICTIONARY_TYPE",
+  229: "STORE_HANDLER_TYPE",
+  230: "UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE",
+  231: "UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE",
+  232: "WEAK_ARRAY_LIST_TYPE",
+  233: "WEAK_CELL_TYPE",
   1024: "JS_PROXY_TYPE",
   1025: "JS_GLOBAL_OBJECT_TYPE",
   1026: "JS_GLOBAL_PROXY_TYPE",
@@ -197,8 +198,8 @@ KNOWN_MAPS = {
   ("RO_SPACE", 0x00139): (138, "FreeSpaceMap"),
   ("RO_SPACE", 0x00189): (132, "MetaMap"),
   ("RO_SPACE", 0x00209): (131, "NullMap"),
-  ("RO_SPACE", 0x00271): (217, "DescriptorArrayMap"),
-  ("RO_SPACE", 0x002d1): (212, "WeakFixedArrayMap"),
+  ("RO_SPACE", 0x00271): (218, "DescriptorArrayMap"),
+  ("RO_SPACE", 0x002d1): (213, "WeakFixedArrayMap"),
   ("RO_SPACE", 0x00321): (152, "OnePointerFillerMap"),
   ("RO_SPACE", 0x00371): (152, "TwoPointerFillerMap"),
   ("RO_SPACE", 0x003f1): (131, "UninitializedMap"),
@@ -208,71 +209,71 @@ KNOWN_MAPS = {
   ("RO_SPACE", 0x005e1): (131, "TheHoleMap"),
   ("RO_SPACE", 0x00689): (131, "BooleanMap"),
   ("RO_SPACE", 0x00761): (136, "ByteArrayMap"),
-  ("RO_SPACE", 0x007b1): (188, "FixedArrayMap"),
-  ("RO_SPACE", 0x00801): (188, "FixedCOWArrayMap"),
-  ("RO_SPACE", 0x00851): (190, "HashTableMap"),
+  ("RO_SPACE", 0x007b1): (189, "FixedArrayMap"),
+  ("RO_SPACE", 0x00801): (189, "FixedCOWArrayMap"),
+  ("RO_SPACE", 0x00851): (191, "HashTableMap"),
   ("RO_SPACE", 0x008a1): (128, "SymbolMap"),
   ("RO_SPACE", 0x008f1): (72, "OneByteStringMap"),
-  ("RO_SPACE", 0x00941): (200, "ScopeInfoMap"),
-  ("RO_SPACE", 0x00991): (224, "SharedFunctionInfoMap"),
+  ("RO_SPACE", 0x00941): (201, "ScopeInfoMap"),
+  ("RO_SPACE", 0x00991): (225, "SharedFunctionInfoMap"),
   ("RO_SPACE", 0x009e1): (133, "CodeMap"),
-  ("RO_SPACE", 0x00a31): (207, "FunctionContextMap"),
-  ("RO_SPACE", 0x00a81): (215, "CellMap"),
-  ("RO_SPACE", 0x00ad1): (223, "GlobalPropertyCellMap"),
+  ("RO_SPACE", 0x00a31): (208, "FunctionContextMap"),
+  ("RO_SPACE", 0x00a81): (216, "CellMap"),
+  ("RO_SPACE", 0x00ad1): (224, "GlobalPropertyCellMap"),
   ("RO_SPACE", 0x00b21): (135, "ForeignMap"),
-  ("RO_SPACE", 0x00b71): (213, "TransitionArrayMap"),
-  ("RO_SPACE", 0x00bc1): (219, "FeedbackVectorMap"),
+  ("RO_SPACE", 0x00b71): (214, "TransitionArrayMap"),
+  ("RO_SPACE", 0x00bc1): (220, "FeedbackVectorMap"),
   ("RO_SPACE", 0x00c61): (131, "ArgumentsMarkerMap"),
   ("RO_SPACE", 0x00d01): (131, "ExceptionMap"),
   ("RO_SPACE", 0x00da1): (131, "TerminationExceptionMap"),
   ("RO_SPACE", 0x00e49): (131, "OptimizedOutMap"),
   ("RO_SPACE", 0x00ee9): (131, "StaleRegisterMap"),
-  ("RO_SPACE", 0x00f59): (209, "NativeContextMap"),
-  ("RO_SPACE", 0x00fa9): (208, "ModuleContextMap"),
-  ("RO_SPACE", 0x00ff9): (206, "EvalContextMap"),
-  ("RO_SPACE", 0x01049): (210, "ScriptContextMap"),
-  ("RO_SPACE", 0x01099): (202, "AwaitContextMap"),
-  ("RO_SPACE", 0x010e9): (203, "BlockContextMap"),
-  ("RO_SPACE", 0x01139): (204, "CatchContextMap"),
-  ("RO_SPACE", 0x01189): (211, "WithContextMap"),
-  ("RO_SPACE", 0x011d9): (205, "DebugEvaluateContextMap"),
-  ("RO_SPACE", 0x01229): (201, "ScriptContextTableMap"),
+  ("RO_SPACE", 0x00f59): (210, "NativeContextMap"),
+  ("RO_SPACE", 0x00fa9): (209, "ModuleContextMap"),
+  ("RO_SPACE", 0x00ff9): (207, "EvalContextMap"),
+  ("RO_SPACE", 0x01049): (211, "ScriptContextMap"),
+  ("RO_SPACE", 0x01099): (203, "AwaitContextMap"),
+  ("RO_SPACE", 0x010e9): (204, "BlockContextMap"),
+  ("RO_SPACE", 0x01139): (205, "CatchContextMap"),
+  ("RO_SPACE", 0x01189): (212, "WithContextMap"),
+  ("RO_SPACE", 0x011d9): (206, "DebugEvaluateContextMap"),
+  ("RO_SPACE", 0x01229): (202, "ScriptContextTableMap"),
   ("RO_SPACE", 0x01279): (151, "FeedbackMetadataArrayMap"),
-  ("RO_SPACE", 0x012c9): (188, "ArrayListMap"),
+  ("RO_SPACE", 0x012c9): (189, "ArrayListMap"),
   ("RO_SPACE", 0x01319): (130, "BigIntMap"),
-  ("RO_SPACE", 0x01369): (189, "ObjectBoilerplateDescriptionMap"),
+  ("RO_SPACE", 0x01369): (190, "ObjectBoilerplateDescriptionMap"),
   ("RO_SPACE", 0x013b9): (137, "BytecodeArrayMap"),
-  ("RO_SPACE", 0x01409): (216, "CodeDataContainerMap"),
+  ("RO_SPACE", 0x01409): (217, "CodeDataContainerMap"),
   ("RO_SPACE", 0x01459): (150, "FixedDoubleArrayMap"),
-  ("RO_SPACE", 0x014a9): (195, "GlobalDictionaryMap"),
-  ("RO_SPACE", 0x014f9): (218, "ManyClosuresCellMap"),
-  ("RO_SPACE", 0x01549): (188, "ModuleInfoMap"),
+  ("RO_SPACE", 0x014a9): (196, "GlobalDictionaryMap"),
+  ("RO_SPACE", 0x014f9): (219, "ManyClosuresCellMap"),
+  ("RO_SPACE", 0x01549): (189, "ModuleInfoMap"),
   ("RO_SPACE", 0x01599): (134, "MutableHeapNumberMap"),
-  ("RO_SPACE", 0x015e9): (194, "NameDictionaryMap"),
-  ("RO_SPACE", 0x01639): (218, "NoClosuresCellMap"),
-  ("RO_SPACE", 0x01689): (218, "NoFeedbackCellMap"),
-  ("RO_SPACE", 0x016d9): (196, "NumberDictionaryMap"),
-  ("RO_SPACE", 0x01729): (218, "OneClosureCellMap"),
-  ("RO_SPACE", 0x01779): (191, "OrderedHashMapMap"),
-  ("RO_SPACE", 0x017c9): (192, "OrderedHashSetMap"),
-  ("RO_SPACE", 0x01819): (193, "OrderedNameDictionaryMap"),
-  ("RO_SPACE", 0x01869): (221, "PreparseDataMap"),
-  ("RO_SPACE", 0x018b9): (222, "PropertyArrayMap"),
-  ("RO_SPACE", 0x01909): (214, "SideEffectCallHandlerInfoMap"),
-  ("RO_SPACE", 0x01959): (214, "SideEffectFreeCallHandlerInfoMap"),
-  ("RO_SPACE", 0x019a9): (214, "NextCallSideEffectFreeCallHandlerInfoMap"),
-  ("RO_SPACE", 0x019f9): (197, "SimpleNumberDictionaryMap"),
-  ("RO_SPACE", 0x01a49): (188, "SloppyArgumentsElementsMap"),
-  ("RO_SPACE", 0x01a99): (225, "SmallOrderedHashMapMap"),
-  ("RO_SPACE", 0x01ae9): (226, "SmallOrderedHashSetMap"),
-  ("RO_SPACE", 0x01b39): (227, "SmallOrderedNameDictionaryMap"),
-  ("RO_SPACE", 0x01b89): (198, "StringTableMap"),
-  ("RO_SPACE", 0x01bd9): (229, "UncompiledDataWithoutPreparseDataMap"),
-  ("RO_SPACE", 0x01c29): (230, "UncompiledDataWithPreparseDataMap"),
-  ("RO_SPACE", 0x01c79): (231, "WeakArrayListMap"),
-  ("RO_SPACE", 0x01cc9): (199, "EphemeronHashTableMap"),
-  ("RO_SPACE", 0x01d19): (187, "EmbedderDataArrayMap"),
-  ("RO_SPACE", 0x01d69): (232, "WeakCellMap"),
+  ("RO_SPACE", 0x015e9): (195, "NameDictionaryMap"),
+  ("RO_SPACE", 0x01639): (219, "NoClosuresCellMap"),
+  ("RO_SPACE", 0x01689): (219, "NoFeedbackCellMap"),
+  ("RO_SPACE", 0x016d9): (197, "NumberDictionaryMap"),
+  ("RO_SPACE", 0x01729): (219, "OneClosureCellMap"),
+  ("RO_SPACE", 0x01779): (192, "OrderedHashMapMap"),
+  ("RO_SPACE", 0x017c9): (193, "OrderedHashSetMap"),
+  ("RO_SPACE", 0x01819): (194, "OrderedNameDictionaryMap"),
+  ("RO_SPACE", 0x01869): (222, "PreparseDataMap"),
+  ("RO_SPACE", 0x018b9): (223, "PropertyArrayMap"),
+  ("RO_SPACE", 0x01909): (215, "SideEffectCallHandlerInfoMap"),
+  ("RO_SPACE", 0x01959): (215, "SideEffectFreeCallHandlerInfoMap"),
+  ("RO_SPACE", 0x019a9): (215, "NextCallSideEffectFreeCallHandlerInfoMap"),
+  ("RO_SPACE", 0x019f9): (198, "SimpleNumberDictionaryMap"),
+  ("RO_SPACE", 0x01a49): (189, "SloppyArgumentsElementsMap"),
+  ("RO_SPACE", 0x01a99): (226, "SmallOrderedHashMapMap"),
+  ("RO_SPACE", 0x01ae9): (227, "SmallOrderedHashSetMap"),
+  ("RO_SPACE", 0x01b39): (228, "SmallOrderedNameDictionaryMap"),
+  ("RO_SPACE", 0x01b89): (199, "StringTableMap"),
+  ("RO_SPACE", 0x01bd9): (230, "UncompiledDataWithoutPreparseDataMap"),
+  ("RO_SPACE", 0x01c29): (231, "UncompiledDataWithPreparseDataMap"),
+  ("RO_SPACE", 0x01c79): (232, "WeakArrayListMap"),
+  ("RO_SPACE", 0x01cc9): (200, "EphemeronHashTableMap"),
+  ("RO_SPACE", 0x01d19): (188, "EmbedderDataArrayMap"),
+  ("RO_SPACE", 0x01d69): (233, "WeakCellMap"),
   ("RO_SPACE", 0x01db9): (106, "NativeSourceStringMap"),
   ("RO_SPACE", 0x01e09): (64, "StringMap"),
   ("RO_SPACE", 0x01e59): (73, "ConsOneByteStringMap"),
@@ -306,8 +307,8 @@ KNOWN_MAPS = {
   ("RO_SPACE", 0x02719): (149, "FixedBigUint64ArrayMap"),
   ("RO_SPACE", 0x02769): (148, "FixedBigInt64ArrayMap"),
   ("RO_SPACE", 0x027b9): (131, "SelfReferenceMarkerMap"),
-  ("RO_SPACE", 0x02821): (174, "Tuple2Map"),
-  ("RO_SPACE", 0x028c1): (176, "ArrayBoilerplateDescriptionMap"),
+  ("RO_SPACE", 0x02821): (175, "Tuple2Map"),
+  ("RO_SPACE", 0x028c1): (177, "ArrayBoilerplateDescriptionMap"),
   ("RO_SPACE", 0x02c01): (164, "InterceptorInfoMap"),
   ("RO_SPACE", 0x05109): (153, "AccessCheckInfoMap"),
   ("RO_SPACE", 0x05159): (154, "AccessorInfoMap"),
@@ -329,25 +330,26 @@ KNOWN_MAPS = {
   ("RO_SPACE", 0x05659): (171, "PrototypeInfoMap"),
   ("RO_SPACE", 0x056a9): (172, "ScriptMap"),
   ("RO_SPACE", 0x056f9): (173, "StackFrameInfoMap"),
-  ("RO_SPACE", 0x05749): (175, "Tuple3Map"),
-  ("RO_SPACE", 0x05799): (177, "WasmDebugInfoMap"),
-  ("RO_SPACE", 0x057e9): (178, "WasmExceptionTagMap"),
-  ("RO_SPACE", 0x05839): (179, "WasmExportedFunctionDataMap"),
-  ("RO_SPACE", 0x05889): (180, "CallableTaskMap"),
-  ("RO_SPACE", 0x058d9): (181, "CallbackTaskMap"),
-  ("RO_SPACE", 0x05929): (182, "PromiseFulfillReactionJobTaskMap"),
-  ("RO_SPACE", 0x05979): (183, "PromiseRejectReactionJobTaskMap"),
-  ("RO_SPACE", 0x059c9): (184, "PromiseResolveThenableJobTaskMap"),
-  ("RO_SPACE", 0x05a19): (185, "FinalizationGroupCleanupJobTaskMap"),
-  ("RO_SPACE", 0x05a69): (186, "AllocationSiteWithWeakNextMap"),
-  ("RO_SPACE", 0x05ab9): (186, "AllocationSiteWithoutWeakNextMap"),
-  ("RO_SPACE", 0x05b09): (220, "LoadHandler1Map"),
-  ("RO_SPACE", 0x05b59): (220, "LoadHandler2Map"),
-  ("RO_SPACE", 0x05ba9): (220, "LoadHandler3Map"),
-  ("RO_SPACE", 0x05bf9): (228, "StoreHandler0Map"),
-  ("RO_SPACE", 0x05c49): (228, "StoreHandler1Map"),
-  ("RO_SPACE", 0x05c99): (228, "StoreHandler2Map"),
-  ("RO_SPACE", 0x05ce9): (228, "StoreHandler3Map"),
+  ("RO_SPACE", 0x05749): (174, "StackTraceFrameMap"),
+  ("RO_SPACE", 0x05799): (176, "Tuple3Map"),
+  ("RO_SPACE", 0x057e9): (178, "WasmDebugInfoMap"),
+  ("RO_SPACE", 0x05839): (179, "WasmExceptionTagMap"),
+  ("RO_SPACE", 0x05889): (180, "WasmExportedFunctionDataMap"),
+  ("RO_SPACE", 0x058d9): (181, "CallableTaskMap"),
+  ("RO_SPACE", 0x05929): (182, "CallbackTaskMap"),
+  ("RO_SPACE", 0x05979): (183, "PromiseFulfillReactionJobTaskMap"),
+  ("RO_SPACE", 0x059c9): (184, "PromiseRejectReactionJobTaskMap"),
+  ("RO_SPACE", 0x05a19): (185, "PromiseResolveThenableJobTaskMap"),
+  ("RO_SPACE", 0x05a69): (186, "FinalizationGroupCleanupJobTaskMap"),
+  ("RO_SPACE", 0x05ab9): (187, "AllocationSiteWithWeakNextMap"),
+  ("RO_SPACE", 0x05b09): (187, "AllocationSiteWithoutWeakNextMap"),
+  ("RO_SPACE", 0x05b59): (221, "LoadHandler1Map"),
+  ("RO_SPACE", 0x05ba9): (221, "LoadHandler2Map"),
+  ("RO_SPACE", 0x05bf9): (221, "LoadHandler3Map"),
+  ("RO_SPACE", 0x05c49): (229, "StoreHandler0Map"),
+  ("RO_SPACE", 0x05c99): (229, "StoreHandler1Map"),
+  ("RO_SPACE", 0x05ce9): (229, "StoreHandler2Map"),
+  ("RO_SPACE", 0x05d39): (229, "StoreHandler3Map"),
   ("MAP_SPACE", 0x00139): (1057, "ExternalMap"),
   ("MAP_SPACE", 0x00189): (1073, "JSMessageObjectMap"),
 }