[runtime] Inline Foreign fields into CallHandlerInfo

... to avoid additional indirection on every access.

Bug: v8:12949
Change-Id: I16840ac0517e86f1f70252153112ca3475527416
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3693707
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Reviewed-by: Dominik Inführ <dinfuehr@chromium.org>
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/main@{#81083}

include/v8-internal.h

@@ -316,6 +316,8 @@ enum ExternalPointerTag : uint64_t {
   kEmbedderDataSlotPayloadTag =     MAKE_TAG(0b1000001111101111),
   kCodeEntryPointTag =              MAKE_TAG(0b1000001111110111),
   kExternalObjectValueTag =         MAKE_TAG(0b1000001111111011),
+  kCallHandlerInfoCallbackTag =     MAKE_TAG(0b1000001111111101),
+  kCallHandlerInfoJsCallbackTag =   MAKE_TAG(0b1000001111111110),
 };
 // clang-format on
 #undef MAKE_TAG

src/api/api-arguments-inl.h

@@ -134,7 +134,7 @@ Handle<Object> FunctionCallbackArguments::Call(CallHandlerInfo handler) {
   Isolate* isolate = this->isolate();
   RCS_SCOPE(isolate, RuntimeCallCounterId::kFunctionCallback);
   v8::FunctionCallback f =
-      v8::ToCData<v8::FunctionCallback>(handler.callback());
+      reinterpret_cast<v8::FunctionCallback>(handler.callback());
   Handle<Object> receiver_check_unsupported;
   if (isolate->debug_execution_mode() == DebugInfo::kSideEffects &&
       !isolate->debug()->PerformSideEffectCheckForCallback(

src/api/api.cc

@@ -1459,9 +1459,8 @@ void FunctionTemplate::SetCallHandler(
   i::HandleScope scope(i_isolate);
   i::Handle<i::CallHandlerInfo> obj = i_isolate->factory()->NewCallHandlerInfo(
       side_effect_type == SideEffectType::kHasNoSideEffect);
-  SET_FIELD_WRAPPED(i_isolate, obj, set_callback, callback);
+  obj->set_callback(i_isolate, reinterpret_cast<i::Address>(callback));
-  SET_FIELD_WRAPPED(i_isolate, obj, set_js_callback,
+  obj->set_js_callback(i_isolate, obj->redirected_callback());
-                    obj->redirected_callback());
   if (data.IsEmpty()) {
     data = v8::Undefined(reinterpret_cast<v8::Isolate*>(i_isolate));
   }
@@ -1916,9 +1915,8 @@ void ObjectTemplate::SetCallAsFunctionHandler(FunctionCallback callback,
   EnsureNotPublished(cons, "v8::ObjectTemplate::SetCallAsFunctionHandler");
   i::Handle<i::CallHandlerInfo> obj =
       i_isolate->factory()->NewCallHandlerInfo();
-  SET_FIELD_WRAPPED(i_isolate, obj, set_callback, callback);
+  obj->set_callback(i_isolate, reinterpret_cast<i::Address>(callback));
-  SET_FIELD_WRAPPED(i_isolate, obj, set_js_callback,
+  obj->set_js_callback(i_isolate, obj->redirected_callback());
-                    obj->redirected_callback());
   if (data.IsEmpty()) {
     data = v8::Undefined(reinterpret_cast<v8::Isolate*>(i_isolate));
   }

src/builtins/builtins-call-gen.cc

@@ -733,9 +733,7 @@ void CallOrConstructBuiltinsAssembler::CallFunctionTemplate(
   // Perform the actual API callback invocation via CallApiCallback.
   TNode<CallHandlerInfo> call_handler_info = LoadObjectField<CallHandlerInfo>(
       function_template_info, FunctionTemplateInfo::kCallCodeOffset);
-  TNode<Foreign> foreign = LoadObjectField<Foreign>(
+  TNode<RawPtrT> callback = LoadCallHandlerInfoJsCallbackPtr(call_handler_info);
-      call_handler_info, CallHandlerInfo::kJsCallbackOffset);
-  TNode<RawPtrT> callback = LoadForeignForeignAddressPtr(foreign);
   TNode<Object> call_data =
       LoadObjectField<Object>(call_handler_info, CallHandlerInfo::kDataOffset);
   TailCallStub(CodeFactory::CallApiCallback(isolate()), context, callback,

src/codegen/code-stub-assembler.h

@@ -14,6 +14,7 @@
 #include "src/common/message-template.h"
 #include "src/compiler/code-assembler.h"
 #include "src/numbers/integer-literal.h"
+#include "src/objects/api-callbacks.h"
 #include "src/objects/arguments.h"
 #include "src/objects/bigint.h"
 #include "src/objects/cell.h"
@@ -1148,6 +1149,13 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
                                          kForeignForeignAddressTag);
   }
 
+  TNode<RawPtrT> LoadCallHandlerInfoJsCallbackPtr(
+      TNode<CallHandlerInfo> object) {
+    return LoadExternalPointerFromObject(object,
+                                         CallHandlerInfo::kJsCallbackOffset,
+                                         kCallHandlerInfoJsCallbackTag);
+  }
+
   TNode<RawPtrT> LoadExternalStringResourcePtr(TNode<ExternalString> object) {
     return LoadExternalPointerFromObject(
         object, ExternalString::kResourceOffset, kExternalStringResourceTag);

src/compiler/heap-refs.cc

@@ -1678,9 +1678,7 @@ bool StringRef::IsExternalString() const {
   return object()->IsExternalString();
 }
 
-Address CallHandlerInfoRef::callback() const {
+Address CallHandlerInfoRef::callback() const { return object()->callback(); }
-  return v8::ToCData<Address>(object()->callback());
-}
 
 ZoneVector<Address> FunctionTemplateInfoRef::c_functions() const {
   return GetCFunctions(FixedArray::cast(object()->GetCFunctionOverloads()),

src/diagnostics/objects-printer.cc

@@ -2161,8 +2161,8 @@ void StoreHandler::StoreHandlerPrint(std::ostream& os) {
 
 void CallHandlerInfo::CallHandlerInfoPrint(std::ostream& os) {
   PrintHeader(os, "CallHandlerInfo");
-  os << "\n - callback: " << Brief(callback());
+  os << "\n - callback: " << reinterpret_cast<void*>(callback());
-  os << "\n - js_callback: " << Brief(js_callback());
+  os << "\n - js_callback: " << reinterpret_cast<void*>(js_callback());
   os << "\n - data: " << Brief(data());
   os << "\n - side_effect_free: "
      << (IsSideEffectFreeCallHandlerInfo() ? "true" : "false");

src/heap/factory.cc

@@ -3963,8 +3963,8 @@ Handle<CallHandlerInfo> Factory::NewCallHandlerInfo(bool has_no_side_effect) {
   CallHandlerInfo info = CallHandlerInfo::cast(New(map, AllocationType::kOld));
   DisallowGarbageCollection no_gc;
   Object undefined_value = read_only_roots().undefined_value();
-  info.set_callback(undefined_value, SKIP_WRITE_BARRIER);
+  // Initializes both callback and js_callback fields.
-  info.set_js_callback(undefined_value, SKIP_WRITE_BARRIER);
+  info.AllocateExternalPointerEntries(isolate());
   info.set_data(undefined_value, SKIP_WRITE_BARRIER);
   return handle(info, isolate());
 }

src/heap/objects-visiting.h

@@ -18,6 +18,7 @@ namespace internal {
   V(BigInt)                             \
   V(ByteArray)                          \
   V(BytecodeArray)                      \
+  V(CallHandlerInfo)                    \
   V(Cell)                               \
   V(Code)                               \
   V(CodeDataContainer)                  \

src/ic/accessor-assembler.cc

@@ -264,9 +264,7 @@ void AccessorAssembler::HandleLoadAccessor(
   CSA_CHECK(this, IsNotCleared(maybe_context));
   TNode<HeapObject> context = GetHeapObjectAssumeWeak(maybe_context);
 
-  TNode<Foreign> foreign = LoadObjectField<Foreign>(
+  TNode<RawPtrT> callback = LoadCallHandlerInfoJsCallbackPtr(call_handler_info);
-      call_handler_info, CallHandlerInfo::kJsCallbackOffset);
-  TNode<RawPtrT> callback = LoadForeignForeignAddressPtr(foreign);
   TNode<Object> data =
       LoadObjectField(call_handler_info, CallHandlerInfo::kDataOffset);
 
@@ -1944,9 +1942,8 @@ void AccessorAssembler::HandleStoreICProtoHandler(
           IsCleared(maybe_context), [=] { return SmiConstant(0); },
           [=] { return GetHeapObjectAssumeWeak(maybe_context); });
 
-      TNode<Foreign> foreign = LoadObjectField<Foreign>(
+      TNode<RawPtrT> callback =
-          call_handler_info, CallHandlerInfo::kJsCallbackOffset);
+          LoadCallHandlerInfoJsCallbackPtr(call_handler_info);
-      TNode<RawPtrT> callback = LoadForeignForeignAddressPtr(foreign);
       TNode<Object> data =
           LoadObjectField(call_handler_info, CallHandlerInfo::kDataOffset);
 

src/logging/log.cc

@@ -2344,8 +2344,7 @@ void ExistingCodeLogger::LogExistingFunction(
     Object raw_call_data = fun_data->call_code(kAcquireLoad);
     if (!raw_call_data.IsUndefined(isolate_)) {
       CallHandlerInfo call_data = CallHandlerInfo::cast(raw_call_data);
-      Object callback_obj = call_data.callback();
+      Address entry_point = call_data.callback();
-      Address entry_point = v8::ToCData<Address>(callback_obj);
 #if USES_FUNCTION_DESCRIPTORS
       entry_point = *FUNCTION_ENTRYPOINT_ADDRESS(entry_point);
 #endif

src/objects/api-callbacks-inl.h

@@ -115,6 +115,19 @@ bool CallHandlerInfo::NextCallHasNoSideEffect() {
   return false;
 }
 
+void CallHandlerInfo::AllocateExternalPointerEntries(Isolate* isolate) {
+  InitExternalPointerField(kCallbackOffset, isolate,
+                           kCallHandlerInfoCallbackTag);
+  InitExternalPointerField(kJsCallbackOffset, isolate,
+                           kCallHandlerInfoJsCallbackTag);
+}
+
+EXTERNAL_POINTER_ACCESSORS(CallHandlerInfo, callback, Address, kCallbackOffset,
+                           kCallHandlerInfoCallbackTag)
+
+EXTERNAL_POINTER_ACCESSORS(CallHandlerInfo, js_callback, Address,
+                           kJsCallbackOffset, kCallHandlerInfoJsCallbackTag)
+
 }  // namespace internal
 }  // namespace v8
 

src/objects/api-callbacks.h

@@ -104,7 +104,7 @@ class InterceptorInfo
 };
 
 class CallHandlerInfo
-    : public TorqueGeneratedCallHandlerInfo<CallHandlerInfo, Struct> {
+    : public TorqueGeneratedCallHandlerInfo<CallHandlerInfo, HeapObject> {
  public:
   inline bool IsSideEffectFreeCallHandlerInfo() const;
   inline bool IsSideEffectCallHandlerInfo() const;
@@ -117,9 +117,24 @@ class CallHandlerInfo
   DECL_PRINTER(CallHandlerInfo)
   DECL_VERIFIER(CallHandlerInfo)
 
+  // [callback]: the address of the callback function.
+  DECL_EXTERNAL_POINTER_ACCESSORS(callback, Address)
+
+  // [js_callback]: either the address of the callback function as above,
+  // or a trampoline in case we are running with the simulator.
+  // Use this entry from generated code.
+  DECL_EXTERNAL_POINTER_ACCESSORS(js_callback, Address)
+
   Address redirected_callback() const;
 
-  using BodyDescriptor = StructBodyDescriptor;
+  class BodyDescriptor;
+
+ private:
+  friend class Factory;
+  friend class SerializerDeserializer;
+  friend class StartupSerializer;
+
+  inline void AllocateExternalPointerEntries(Isolate* isolate);
 
   TQ_OBJECT_CONSTRUCTORS(CallHandlerInfo)
 };

src/objects/api-callbacks.tq

@@ -2,10 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-extern class CallHandlerInfo extends Struct {
+extern class CallHandlerInfo extends HeapObject {
-  callback: NonNullForeign|Undefined|Zero;
-  js_callback: NonNullForeign|Undefined|Zero;
   data: Object;
+  callback: ExternalPointer;
+  // This either points at the same as above, or a trampoline in case we are
+  // running with the simulator. Use this entry from generated code.
+  js_callback: ExternalPointer;
 }
 
 bitfield struct InterceptorInfoFlags extends uint31 {
@@ -54,7 +56,7 @@ extern class AccessorInfo extends Struct {
   setter: NonNullForeign|Zero;
   getter: NonNullForeign|Zero;
   // This either points at the same as above, or a trampoline in case we are
-  // running with the simulator. Use these entries from generated code.
+  // running with the simulator. Use this entry from generated code.
   js_getter: NonNullForeign|Zero;
   data: Object;
 }

src/objects/map.cc

@@ -195,7 +195,7 @@ VisitorId Map::GetVisitorId(Map map) {
       return kVisitJSWeakCollection;
 
     case CALL_HANDLER_INFO_TYPE:
-      return kVisitStruct;
+      return kVisitCallHandlerInfo;
 
     case JS_PROXY_TYPE:
       return kVisitStruct;

src/objects/map.h

@@ -35,6 +35,7 @@ enum InstanceType : uint16_t;
 #define POINTER_VISITOR_ID_LIST(V)      \
   V(AllocationSite)                     \
   V(BytecodeArray)                      \
+  V(CallHandlerInfo)                    \
   V(Cell)                               \
   V(Code)                               \
   V(CodeDataContainer)                  \

src/objects/object-macros-undef.h

@@ -27,6 +27,8 @@
 #undef DEF_GETTER
 #undef DEF_RELAXED_GETTER
 #undef DEF_ACQUIRE_GETTER
+#undef TQ_FIELD_TYPE
+#undef DECL_FIELD_OFFSET_TQ
 #undef DECL_SETTER
 #undef DECL_ACCESSORS
 #undef DECL_ACCESSORS_LOAD_TAG
@@ -77,14 +79,18 @@
 #undef BOOL_ACCESSORS
 #undef DECL_RELAXED_BOOL_ACCESSORS
 #undef RELAXED_BOOL_ACCESSORS
+#undef DECL_EXTERNAL_POINTER_ACCESSORS
+#undef EXTERNAL_POINTER_ACCESSORS
 #undef BIT_FIELD_ACCESSORS2
 #undef BIT_FIELD_ACCESSORS
 #undef RELAXED_INT16_ACCESSORS
 #undef FIELD_ADDR
+#undef SEQ_CST_READ_FIELD
 #undef ACQUIRE_READ_FIELD
 #undef RELAXED_READ_FIELD
 #undef RELAXED_READ_WEAK_FIELD
 #undef WRITE_FIELD
+#undef SEQ_CST_WRITE_FIELD
 #undef RELEASE_WRITE_FIELD
 #undef RELAXED_WRITE_FIELD
 #undef RELAXED_WRITE_WEAK_FIELD
@@ -125,3 +131,4 @@
 #undef DEFINE_DEOPT_ENTRY_ACCESSORS
 #undef TQ_OBJECT_CONSTRUCTORS
 #undef TQ_OBJECT_CONSTRUCTORS_IMPL
+#undef TQ_CPP_OBJECT_DEFINITION_ASSERTS

src/objects/object-macros.h

@@ -398,6 +398,33 @@
                 kRelaxedStore);                                      \
   }
 
+#define DECL_EXTERNAL_POINTER_ACCESSORS(name, type)        \
+  inline type name() const;                                \
+  inline type name(i::Isolate* isolate_for_sandbox) const; \
+  inline void set_##name(i::Isolate* isolate, type value);
+
+#define EXTERNAL_POINTER_ACCESSORS(holder, name, type, offset, tag)         \
+  type holder::name() const {                                               \
+    i::Isolate* isolate_for_sandbox = GetIsolateForSandbox(*this);          \
+    return holder::name(isolate_for_sandbox);                               \
+  }                                                                         \
+  type holder::name(i::Isolate* isolate_for_sandbox) const {                \
+    /* This is a workaround for MSVC error C2440 not allowing  */           \
+    /* reinterpret casts to the same type. */                               \
+    struct C2440 {};                                                        \
+    Address result =                                                        \
+        Object::ReadExternalPointerField(offset, isolate_for_sandbox, tag); \
+    return reinterpret_cast<type>(reinterpret_cast<C2440*>(result));        \
+  }                                                                         \
+  void holder::set_##name(i::Isolate* isolate, type value) {                \
+    /* This is a workaround for MSVC error C2440 not allowing  */           \
+    /* reinterpret casts to the same type. */                               \
+    struct C2440 {};                                                        \
+    Address the_value =                                                     \
+        reinterpret_cast<Address>(reinterpret_cast<C2440*>(value));         \
+    Object::WriteExternalPointerField(offset, isolate, the_value, tag);     \
+  }
+
 #define BIT_FIELD_ACCESSORS2(holder, get_field, set_field, name, BitField) \
   typename BitField::FieldType holder::name() const {                      \
     return BitField::decode(get_field());                                  \

src/objects/objects-body-descriptors-inl.h

@@ -1009,14 +1009,14 @@ class NativeContext::BodyDescriptor final : public BodyDescriptorBase {
 class CodeDataContainer::BodyDescriptor final : public BodyDescriptorBase {
  public:
   static bool IsValidSlot(Map map, HeapObject obj, int offset) {
-    return offset >= CodeDataContainer::kHeaderSize &&
+    return offset >= HeapObject::kHeaderSize &&
            offset <= CodeDataContainer::kPointerFieldsWeakEndOffset;
   }
 
   template <typename ObjectVisitor>
   static inline void IterateBody(Map map, HeapObject obj, int object_size,
                                  ObjectVisitor* v) {
-    IteratePointers(obj, CodeDataContainer::kHeaderSize,
+    IteratePointers(obj, HeapObject::kHeaderSize,
                     CodeDataContainer::kPointerFieldsStrongEndOffset, v);
     IterateCustomWeakPointers(
         obj, CodeDataContainer::kPointerFieldsStrongEndOffset,
@@ -1421,6 +1421,33 @@ class EphemeronHashTable::BodyDescriptor final : public BodyDescriptorBase {
   }
 };
 
+class CallHandlerInfo::BodyDescriptor final : public BodyDescriptorBase {
+ public:
+  static_assert(CallHandlerInfo::kEndOfStrongFieldsOffset ==
+                CallHandlerInfo::kCallbackOffset);
+  static_assert(CallHandlerInfo::kCallbackOffset <
+                CallHandlerInfo::kJsCallbackOffset);
+
+  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
+    return offset < CallHandlerInfo::kEndOfStrongFieldsOffset;
+  }
+
+  template <typename ObjectVisitor>
+  static inline void IterateBody(Map map, HeapObject obj, int object_size,
+                                 ObjectVisitor* v) {
+    IteratePointers(obj, HeapObject::kHeaderSize,
+                    CallHandlerInfo::kEndOfStrongFieldsOffset, v);
+    v->VisitExternalPointer(
+        obj, obj.RawExternalPointerField(CallHandlerInfo::kCallbackOffset),
+        kCallHandlerInfoCallbackTag);
+    v->VisitExternalPointer(
+        obj, obj.RawExternalPointerField(CallHandlerInfo::kJsCallbackOffset),
+        kCallHandlerInfoJsCallbackTag);
+  }
+
+  static inline int SizeOf(Map map, HeapObject object) { return kSize; }
+};
+
 #include "torque-generated/objects-body-descriptors-inl.inc"
 
 }  // namespace internal

src/objects/objects.cc

@@ -1485,7 +1485,7 @@ Address AccessorInfo::redirected_getter() const {
 }
 
 Address CallHandlerInfo::redirected_callback() const {
-  Address address = v8::ToCData<Address>(callback());
+  Address address = callback();
   ApiFunction fun(address);
   ExternalReference::Type type = ExternalReference::DIRECT_API_CALL;
   return ExternalReference::Create(&fun, type).address();
@@ -2119,8 +2119,8 @@ void HeapObject::HeapObjectShortPrint(std::ostream& os) {
     case CALL_HANDLER_INFO_TYPE: {
       CallHandlerInfo info = CallHandlerInfo::cast(*this);
       os << "<CallHandlerInfo ";
-      os << "callback= " << Brief(info.callback());
+      os << "callback= " << reinterpret_cast<void*>(info.callback());
-      os << ", js_callback= " << Brief(info.js_callback());
+      os << ", js_callback= " << reinterpret_cast<void*>(info.js_callback());
       os << ", data= " << Brief(info.data());
       if (info.IsSideEffectFreeCallHandlerInfo()) {
         os << ", side_effect_free= true>";

src/snapshot/serializer-deserializer.cc

@@ -68,8 +68,8 @@ void SerializerDeserializer::RestoreExternalReferenceRedirector(
 void SerializerDeserializer::RestoreExternalReferenceRedirector(
     Isolate* isolate, CallHandlerInfo call_handler_info) {
   DisallowGarbageCollection no_gc;
-  Foreign::cast(call_handler_info.js_callback())
+  call_handler_info.set_js_callback(isolate,
-      .set_foreign_address(isolate, call_handler_info.redirected_callback());
+                                    call_handler_info.redirected_callback());
 }
 
 }  // namespace internal

src/snapshot/serializer.cc

@@ -1079,7 +1079,8 @@ void Serializer::ObjectSerializer::VisitExternalPointer(
   PtrComprCageBase cage_base(isolate());
   InstanceType instance_type = object_->map(cage_base).instance_type();
   if (InstanceTypeChecker::IsForeign(instance_type) ||
-      InstanceTypeChecker::IsJSExternalObject(instance_type)) {
+      InstanceTypeChecker::IsJSExternalObject(instance_type) ||
+      InstanceTypeChecker::IsCallHandlerInfo(instance_type)) {
     Address value = slot.load(isolate(), tag);
     OutputExternalReference(value, kSystemPointerSize, true, tag);
     bytes_processed_so_far_ += kExternalPointerSize;

src/snapshot/startup-serializer.cc

@@ -169,10 +169,8 @@ void StartupSerializer::SerializeObjectImpl(Handle<HeapObject> obj) {
     accessor_infos_.Push(*info);
   } else if (use_simulator && obj->IsCallHandlerInfo(cage_base)) {
     Handle<CallHandlerInfo> info = Handle<CallHandlerInfo>::cast(obj);
-    Address original_address =
+    Address original_address = info->callback();
-        Foreign::cast(info->callback()).foreign_address(isolate());
+    info->set_js_callback(isolate(), original_address);
-    Foreign::cast(info->js_callback())
-        .set_foreign_address(isolate(), original_address);
     call_handler_infos_.Push(*info);
   } else if (obj->IsScript(cage_base) &&
              Handle<Script>::cast(obj)->IsUserJavaScript()) {

tools/v8heapconst.py

@@ -57,57 +57,57 @@ INSTANCE_TYPES = {
   150: "BREAK_POINT_TYPE",
   151: "BREAK_POINT_INFO_TYPE",
   152: "CACHED_TEMPLATE_OBJECT_TYPE",
-  153: "CALL_HANDLER_INFO_TYPE",
+  153: "CALL_SITE_INFO_TYPE",
-  154: "CALL_SITE_INFO_TYPE",
+  154: "CLASS_POSITIONS_TYPE",
-  155: "CLASS_POSITIONS_TYPE",
+  155: "DEBUG_INFO_TYPE",
-  156: "DEBUG_INFO_TYPE",
+  156: "ENUM_CACHE_TYPE",
-  157: "ENUM_CACHE_TYPE",
+  157: "ERROR_STACK_DATA_TYPE",
-  158: "ERROR_STACK_DATA_TYPE",
+  158: "FEEDBACK_CELL_TYPE",
-  159: "FEEDBACK_CELL_TYPE",
+  159: "FUNCTION_TEMPLATE_RARE_DATA_TYPE",
-  160: "FUNCTION_TEMPLATE_RARE_DATA_TYPE",
+  160: "INTERCEPTOR_INFO_TYPE",
-  161: "INTERCEPTOR_INFO_TYPE",
+  161: "INTERPRETER_DATA_TYPE",
-  162: "INTERPRETER_DATA_TYPE",
+  162: "MODULE_REQUEST_TYPE",
-  163: "MODULE_REQUEST_TYPE",
+  163: "PROMISE_CAPABILITY_TYPE",
-  164: "PROMISE_CAPABILITY_TYPE",
+  164: "PROMISE_ON_STACK_TYPE",
-  165: "PROMISE_ON_STACK_TYPE",
+  165: "PROMISE_REACTION_TYPE",
-  166: "PROMISE_REACTION_TYPE",
+  166: "PROPERTY_DESCRIPTOR_OBJECT_TYPE",
-  167: "PROPERTY_DESCRIPTOR_OBJECT_TYPE",
+  167: "PROTOTYPE_INFO_TYPE",
-  168: "PROTOTYPE_INFO_TYPE",
+  168: "REG_EXP_BOILERPLATE_DESCRIPTION_TYPE",
-  169: "REG_EXP_BOILERPLATE_DESCRIPTION_TYPE",
+  169: "SCRIPT_TYPE",
-  170: "SCRIPT_TYPE",
+  170: "SCRIPT_OR_MODULE_TYPE",
-  171: "SCRIPT_OR_MODULE_TYPE",
+  171: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE",
-  172: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE",
+  172: "STACK_FRAME_INFO_TYPE",
-  173: "STACK_FRAME_INFO_TYPE",
+  173: "TEMPLATE_OBJECT_DESCRIPTION_TYPE",
-  174: "TEMPLATE_OBJECT_DESCRIPTION_TYPE",
+  174: "TUPLE2_TYPE",
-  175: "TUPLE2_TYPE",
+  175: "WASM_CONTINUATION_OBJECT_TYPE",
-  176: "WASM_CONTINUATION_OBJECT_TYPE",
+  176: "WASM_EXCEPTION_TAG_TYPE",
-  177: "WASM_EXCEPTION_TAG_TYPE",
+  177: "WASM_INDIRECT_FUNCTION_TABLE_TYPE",
-  178: "WASM_INDIRECT_FUNCTION_TABLE_TYPE",
+  178: "FIXED_ARRAY_TYPE",
-  179: "FIXED_ARRAY_TYPE",
+  179: "HASH_TABLE_TYPE",
-  180: "HASH_TABLE_TYPE",
+  180: "EPHEMERON_HASH_TABLE_TYPE",
-  181: "EPHEMERON_HASH_TABLE_TYPE",
+  181: "GLOBAL_DICTIONARY_TYPE",
-  182: "GLOBAL_DICTIONARY_TYPE",
+  182: "NAME_DICTIONARY_TYPE",
-  183: "NAME_DICTIONARY_TYPE",
+  183: "NAME_TO_INDEX_HASH_TABLE_TYPE",
-  184: "NAME_TO_INDEX_HASH_TABLE_TYPE",
+  184: "NUMBER_DICTIONARY_TYPE",
-  185: "NUMBER_DICTIONARY_TYPE",
+  185: "ORDERED_HASH_MAP_TYPE",
-  186: "ORDERED_HASH_MAP_TYPE",
+  186: "ORDERED_HASH_SET_TYPE",
-  187: "ORDERED_HASH_SET_TYPE",
+  187: "ORDERED_NAME_DICTIONARY_TYPE",
-  188: "ORDERED_NAME_DICTIONARY_TYPE",
+  188: "REGISTERED_SYMBOL_TABLE_TYPE",
-  189: "REGISTERED_SYMBOL_TABLE_TYPE",
+  189: "SIMPLE_NUMBER_DICTIONARY_TYPE",
-  190: "SIMPLE_NUMBER_DICTIONARY_TYPE",
+  190: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
-  191: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
+  191: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
-  192: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
+  192: "SCRIPT_CONTEXT_TABLE_TYPE",
-  193: "SCRIPT_CONTEXT_TABLE_TYPE",
+  193: "BYTE_ARRAY_TYPE",
-  194: "BYTE_ARRAY_TYPE",
+  194: "BYTECODE_ARRAY_TYPE",
-  195: "BYTECODE_ARRAY_TYPE",
+  195: "FIXED_DOUBLE_ARRAY_TYPE",
-  196: "FIXED_DOUBLE_ARRAY_TYPE",
+  196: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
-  197: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
+  197: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
-  198: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
+  198: "TURBOFAN_BITSET_TYPE_TYPE",
-  199: "TURBOFAN_BITSET_TYPE_TYPE",
+  199: "TURBOFAN_HEAP_CONSTANT_TYPE_TYPE",
-  200: "TURBOFAN_HEAP_CONSTANT_TYPE_TYPE",
+  200: "TURBOFAN_OTHER_NUMBER_CONSTANT_TYPE_TYPE",
-  201: "TURBOFAN_OTHER_NUMBER_CONSTANT_TYPE_TYPE",
+  201: "TURBOFAN_RANGE_TYPE_TYPE",
-  202: "TURBOFAN_RANGE_TYPE_TYPE",
+  202: "TURBOFAN_UNION_TYPE_TYPE",
-  203: "TURBOFAN_UNION_TYPE_TYPE",
+  203: "CALL_HANDLER_INFO_TYPE",
   204: "FOREIGN_TYPE",
   205: "WASM_INTERNAL_FUNCTION_TYPE",
   206: "WASM_TYPE_INFO_TYPE",
@@ -281,8 +281,8 @@ KNOWN_MAPS = {
     ("read_only_space", 0x02171): (131, "NullMap"),
     ("read_only_space", 0x02199): (234, "StrongDescriptorArrayMap"),
     ("read_only_space", 0x021c1): (264, "WeakArrayListMap"),
-    ("read_only_space", 0x02205): (157, "EnumCacheMap"),
+    ("read_only_space", 0x02205): (156, "EnumCacheMap"),
-    ("read_only_space", 0x02239): (179, "FixedArrayMap"),
+    ("read_only_space", 0x02239): (178, "FixedArrayMap"),
     ("read_only_space", 0x02285): (8, "OneByteInternalizedStringMap"),
     ("read_only_space", 0x022d1): (247, "FreeSpaceMap"),
     ("read_only_space", 0x022f9): (246, "OnePointerFillerMap"),
@@ -292,9 +292,9 @@ KNOWN_MAPS = {
     ("read_only_space", 0x02405): (130, "HeapNumberMap"),
     ("read_only_space", 0x02439): (131, "TheHoleMap"),
     ("read_only_space", 0x02499): (131, "BooleanMap"),
-    ("read_only_space", 0x0253d): (194, "ByteArrayMap"),
+    ("read_only_space", 0x0253d): (193, "ByteArrayMap"),
-    ("read_only_space", 0x02565): (179, "FixedCOWArrayMap"),
+    ("read_only_space", 0x02565): (178, "FixedCOWArrayMap"),
-    ("read_only_space", 0x0258d): (180, "HashTableMap"),
+    ("read_only_space", 0x0258d): (179, "HashTableMap"),
     ("read_only_space", 0x025b5): (128, "SymbolMap"),
     ("read_only_space", 0x025dd): (40, "OneByteStringMap"),
     ("read_only_space", 0x02605): (256, "ScopeInfoMap"),
@@ -311,35 +311,35 @@ KNOWN_MAPS = {
     ("read_only_space", 0x02839): (131, "TerminationExceptionMap"),
     ("read_only_space", 0x028a1): (131, "OptimizedOutMap"),
     ("read_only_space", 0x02901): (131, "StaleRegisterMap"),
-    ("read_only_space", 0x02961): (193, "ScriptContextTableMap"),
+    ("read_only_space", 0x02961): (192, "ScriptContextTableMap"),
-    ("read_only_space", 0x02989): (191, "ClosureFeedbackCellArrayMap"),
+    ("read_only_space", 0x02989): (190, "ClosureFeedbackCellArrayMap"),
     ("read_only_space", 0x029b1): (244, "FeedbackMetadataArrayMap"),
-    ("read_only_space", 0x029d9): (179, "ArrayListMap"),
+    ("read_only_space", 0x029d9): (178, "ArrayListMap"),
     ("read_only_space", 0x02a01): (129, "BigIntMap"),
-    ("read_only_space", 0x02a29): (192, "ObjectBoilerplateDescriptionMap"),
+    ("read_only_space", 0x02a29): (191, "ObjectBoilerplateDescriptionMap"),
-    ("read_only_space", 0x02a51): (195, "BytecodeArrayMap"),
+    ("read_only_space", 0x02a51): (194, "BytecodeArrayMap"),
     ("read_only_space", 0x02a79): (241, "CodeDataContainerMap"),
     ("read_only_space", 0x02aa1): (242, "CoverageInfoMap"),
-    ("read_only_space", 0x02ac9): (196, "FixedDoubleArrayMap"),
+    ("read_only_space", 0x02ac9): (195, "FixedDoubleArrayMap"),
-    ("read_only_space", 0x02af1): (182, "GlobalDictionaryMap"),
+    ("read_only_space", 0x02af1): (181, "GlobalDictionaryMap"),
-    ("read_only_space", 0x02b19): (159, "ManyClosuresCellMap"),
+    ("read_only_space", 0x02b19): (158, "ManyClosuresCellMap"),
     ("read_only_space", 0x02b41): (251, "MegaDomHandlerMap"),
-    ("read_only_space", 0x02b69): (179, "ModuleInfoMap"),
+    ("read_only_space", 0x02b69): (178, "ModuleInfoMap"),
-    ("read_only_space", 0x02b91): (183, "NameDictionaryMap"),
+    ("read_only_space", 0x02b91): (182, "NameDictionaryMap"),
-    ("read_only_space", 0x02bb9): (159, "NoClosuresCellMap"),
+    ("read_only_space", 0x02bb9): (158, "NoClosuresCellMap"),
-    ("read_only_space", 0x02be1): (185, "NumberDictionaryMap"),
+    ("read_only_space", 0x02be1): (184, "NumberDictionaryMap"),
-    ("read_only_space", 0x02c09): (159, "OneClosureCellMap"),
+    ("read_only_space", 0x02c09): (158, "OneClosureCellMap"),
-    ("read_only_space", 0x02c31): (186, "OrderedHashMapMap"),
+    ("read_only_space", 0x02c31): (185, "OrderedHashMapMap"),
-    ("read_only_space", 0x02c59): (187, "OrderedHashSetMap"),
+    ("read_only_space", 0x02c59): (186, "OrderedHashSetMap"),
-    ("read_only_space", 0x02c81): (184, "NameToIndexHashTableMap"),
+    ("read_only_space", 0x02c81): (183, "NameToIndexHashTableMap"),
-    ("read_only_space", 0x02ca9): (189, "RegisteredSymbolTableMap"),
+    ("read_only_space", 0x02ca9): (188, "RegisteredSymbolTableMap"),
-    ("read_only_space", 0x02cd1): (188, "OrderedNameDictionaryMap"),
+    ("read_only_space", 0x02cd1): (187, "OrderedNameDictionaryMap"),
     ("read_only_space", 0x02cf9): (253, "PreparseDataMap"),
     ("read_only_space", 0x02d21): (254, "PropertyArrayMap"),
-    ("read_only_space", 0x02d49): (153, "SideEffectCallHandlerInfoMap"),
+    ("read_only_space", 0x02d49): (203, "SideEffectCallHandlerInfoMap"),
-    ("read_only_space", 0x02d71): (153, "SideEffectFreeCallHandlerInfoMap"),
+    ("read_only_space", 0x02d71): (203, "SideEffectFreeCallHandlerInfoMap"),
-    ("read_only_space", 0x02d99): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
+    ("read_only_space", 0x02d99): (203, "NextCallSideEffectFreeCallHandlerInfoMap"),
-    ("read_only_space", 0x02dc1): (190, "SimpleNumberDictionaryMap"),
+    ("read_only_space", 0x02dc1): (189, "SimpleNumberDictionaryMap"),
     ("read_only_space", 0x02de9): (228, "SmallOrderedHashMapMap"),
     ("read_only_space", 0x02e11): (229, "SmallOrderedHashSetMap"),
     ("read_only_space", 0x02e39): (230, "SmallOrderedNameDictionaryMap"),
@@ -354,7 +354,7 @@ KNOWN_MAPS = {
     ("read_only_space", 0x02fa1): (263, "WasmOnFulfilledDataMap"),
     ("read_only_space", 0x02fc9): (206, "WasmTypeInfoMap"),
     ("read_only_space", 0x02ff1): (237, "WeakFixedArrayMap"),
-    ("read_only_space", 0x03019): (181, "EphemeronHashTableMap"),
+    ("read_only_space", 0x03019): (180, "EphemeronHashTableMap"),
     ("read_only_space", 0x03041): (243, "EmbedderDataArrayMap"),
     ("read_only_space", 0x03069): (265, "WeakCellMap"),
     ("read_only_space", 0x03091): (32, "StringMap"),
@@ -379,7 +379,7 @@ KNOWN_MAPS = {
     ("read_only_space", 0x03389): (131, "SelfReferenceMarkerMap"),
     ("read_only_space", 0x033b1): (131, "BasicBlockCountersMarkerMap"),
     ("read_only_space", 0x033f5): (147, "ArrayBoilerplateDescriptionMap"),
-    ("read_only_space", 0x034f5): (161, "InterceptorInfoMap"),
+    ("read_only_space", 0x034f5): (160, "InterceptorInfoMap"),
     ("read_only_space", 0x05fc5): (132, "PromiseFulfillReactionJobTaskMap"),
     ("read_only_space", 0x05fed): (133, "PromiseRejectReactionJobTaskMap"),
     ("read_only_space", 0x06015): (134, "CallableTaskMap"),
@@ -397,40 +397,40 @@ KNOWN_MAPS = {
     ("read_only_space", 0x061f5): (150, "BreakPointMap"),
     ("read_only_space", 0x0621d): (151, "BreakPointInfoMap"),
     ("read_only_space", 0x06245): (152, "CachedTemplateObjectMap"),
-    ("read_only_space", 0x0626d): (154, "CallSiteInfoMap"),
+    ("read_only_space", 0x0626d): (153, "CallSiteInfoMap"),
-    ("read_only_space", 0x06295): (155, "ClassPositionsMap"),
+    ("read_only_space", 0x06295): (154, "ClassPositionsMap"),
-    ("read_only_space", 0x062bd): (156, "DebugInfoMap"),
+    ("read_only_space", 0x062bd): (155, "DebugInfoMap"),
-    ("read_only_space", 0x062e5): (158, "ErrorStackDataMap"),
+    ("read_only_space", 0x062e5): (157, "ErrorStackDataMap"),
-    ("read_only_space", 0x0630d): (160, "FunctionTemplateRareDataMap"),
+    ("read_only_space", 0x0630d): (159, "FunctionTemplateRareDataMap"),
-    ("read_only_space", 0x06335): (162, "InterpreterDataMap"),
+    ("read_only_space", 0x06335): (161, "InterpreterDataMap"),
-    ("read_only_space", 0x0635d): (163, "ModuleRequestMap"),
+    ("read_only_space", 0x0635d): (162, "ModuleRequestMap"),
-    ("read_only_space", 0x06385): (164, "PromiseCapabilityMap"),
+    ("read_only_space", 0x06385): (163, "PromiseCapabilityMap"),
-    ("read_only_space", 0x063ad): (165, "PromiseOnStackMap"),
+    ("read_only_space", 0x063ad): (164, "PromiseOnStackMap"),
-    ("read_only_space", 0x063d5): (166, "PromiseReactionMap"),
+    ("read_only_space", 0x063d5): (165, "PromiseReactionMap"),
-    ("read_only_space", 0x063fd): (167, "PropertyDescriptorObjectMap"),
+    ("read_only_space", 0x063fd): (166, "PropertyDescriptorObjectMap"),
-    ("read_only_space", 0x06425): (168, "PrototypeInfoMap"),
+    ("read_only_space", 0x06425): (167, "PrototypeInfoMap"),
-    ("read_only_space", 0x0644d): (169, "RegExpBoilerplateDescriptionMap"),
+    ("read_only_space", 0x0644d): (168, "RegExpBoilerplateDescriptionMap"),
-    ("read_only_space", 0x06475): (170, "ScriptMap"),
+    ("read_only_space", 0x06475): (169, "ScriptMap"),
-    ("read_only_space", 0x0649d): (171, "ScriptOrModuleMap"),
+    ("read_only_space", 0x0649d): (170, "ScriptOrModuleMap"),
-    ("read_only_space", 0x064c5): (172, "SourceTextModuleInfoEntryMap"),
+    ("read_only_space", 0x064c5): (171, "SourceTextModuleInfoEntryMap"),
-    ("read_only_space", 0x064ed): (173, "StackFrameInfoMap"),
+    ("read_only_space", 0x064ed): (172, "StackFrameInfoMap"),
-    ("read_only_space", 0x06515): (174, "TemplateObjectDescriptionMap"),
+    ("read_only_space", 0x06515): (173, "TemplateObjectDescriptionMap"),
-    ("read_only_space", 0x0653d): (175, "Tuple2Map"),
+    ("read_only_space", 0x0653d): (174, "Tuple2Map"),
-    ("read_only_space", 0x06565): (176, "WasmContinuationObjectMap"),
+    ("read_only_space", 0x06565): (175, "WasmContinuationObjectMap"),
-    ("read_only_space", 0x0658d): (177, "WasmExceptionTagMap"),
+    ("read_only_space", 0x0658d): (176, "WasmExceptionTagMap"),
-    ("read_only_space", 0x065b5): (178, "WasmIndirectFunctionTableMap"),
+    ("read_only_space", 0x065b5): (177, "WasmIndirectFunctionTableMap"),
-    ("read_only_space", 0x065dd): (198, "SloppyArgumentsElementsMap"),
+    ("read_only_space", 0x065dd): (197, "SloppyArgumentsElementsMap"),
     ("read_only_space", 0x06605): (233, "DescriptorArrayMap"),
     ("read_only_space", 0x0662d): (219, "UncompiledDataWithoutPreparseDataMap"),
     ("read_only_space", 0x06655): (217, "UncompiledDataWithPreparseDataMap"),
     ("read_only_space", 0x0667d): (220, "UncompiledDataWithoutPreparseDataWithJobMap"),
     ("read_only_space", 0x066a5): (218, "UncompiledDataWithPreparseDataAndJobMap"),
     ("read_only_space", 0x066cd): (252, "OnHeapBasicBlockProfilerDataMap"),
-    ("read_only_space", 0x066f5): (199, "TurbofanBitsetTypeMap"),
+    ("read_only_space", 0x066f5): (198, "TurbofanBitsetTypeMap"),
-    ("read_only_space", 0x0671d): (203, "TurbofanUnionTypeMap"),
+    ("read_only_space", 0x0671d): (202, "TurbofanUnionTypeMap"),
-    ("read_only_space", 0x06745): (202, "TurbofanRangeTypeMap"),
+    ("read_only_space", 0x06745): (201, "TurbofanRangeTypeMap"),
-    ("read_only_space", 0x0676d): (200, "TurbofanHeapConstantTypeMap"),
+    ("read_only_space", 0x0676d): (199, "TurbofanHeapConstantTypeMap"),
-    ("read_only_space", 0x06795): (201, "TurbofanOtherNumberConstantTypeMap"),
+    ("read_only_space", 0x06795): (200, "TurbofanOtherNumberConstantTypeMap"),
     ("read_only_space", 0x067bd): (248, "InternalClassMap"),
     ("read_only_space", 0x067e5): (259, "SmiPairMap"),
     ("read_only_space", 0x0680d): (258, "SmiBoxMap"),
@@ -438,7 +438,7 @@ KNOWN_MAPS = {
     ("read_only_space", 0x0685d): (226, "ExportedSubClassMap"),
     ("read_only_space", 0x06885): (231, "AbstractInternalClassSubclass1Map"),
     ("read_only_space", 0x068ad): (232, "AbstractInternalClassSubclass2Map"),
-    ("read_only_space", 0x068d5): (197, "InternalClassWithSmiElementsMap"),
+    ("read_only_space", 0x068d5): (196, "InternalClassWithSmiElementsMap"),
     ("read_only_space", 0x068fd): (249, "InternalClassWithStructElementsMap"),
     ("read_only_space", 0x06925): (227, "ExportedSubClass2Map"),
     ("read_only_space", 0x0694d): (260, "SortStateMap"),