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

[runtime] Inline Foreign fields into CallHandlerInfo

Browse Source 
... 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}
This commit is contained in:
Igor Sheludko 2022-06-10 18:37:17 +02:00 committed by V8 LUCI CQ
parent ea6bedaeb1
commit 7445a4fd2a
24 changed files with 245 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/v8-internal.h
View File

@ -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

2
src/api/api-arguments-inl.h
View File

@ -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(

10
src/api/api.cc
View File

@ -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);
SET_FIELD_WRAPPED(i_isolate, obj, set_js_callback,
obj->redirected_callback());
obj->set_callback(i_isolate, reinterpret_cast<i::Address>(callback));
obj->set_js_callback(i_isolate, 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);
SET_FIELD_WRAPPED(i_isolate, obj, set_js_callback,
obj->redirected_callback());
obj->set_callback(i_isolate, reinterpret_cast<i::Address>(callback));
obj->set_js_callback(i_isolate, obj->redirected_callback());
if (data.IsEmpty()) {
data = v8::Undefined(reinterpret_cast<v8::Isolate*>(i_isolate));
}

4
src/builtins/builtins-call-gen.cc
View File

@ -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>(
call_handler_info, CallHandlerInfo::kJsCallbackOffset);
TNode<RawPtrT> callback = LoadForeignForeignAddressPtr(foreign);
TNode<RawPtrT> callback = LoadCallHandlerInfoJsCallbackPtr(call_handler_info);
TNode<Object> call_data =
LoadObjectField<Object>(call_handler_info, CallHandlerInfo::kDataOffset);
TailCallStub(CodeFactory::CallApiCallback(isolate()), context, callback,

8
src/codegen/code-stub-assembler.h
View File

@ -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);

4
src/compiler/heap-refs.cc
View File

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

4
src/diagnostics/objects-printer.cc
View File

@ -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 - js_callback: " << Brief(js_callback());
os << "\n - callback: " << reinterpret_cast<void*>(callback());
os << "\n - js_callback: " << reinterpret_cast<void*>(js_callback());
os << "\n - data: " << Brief(data());
os << "\n - side_effect_free: "
<< (IsSideEffectFreeCallHandlerInfo() ? "true" : "false");

4
src/heap/factory.cc
View File

@ -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);
info.set_js_callback(undefined_value, SKIP_WRITE_BARRIER);
// Initializes both callback and js_callback fields.
info.AllocateExternalPointerEntries(isolate());
info.set_data(undefined_value, SKIP_WRITE_BARRIER);
return handle(info, isolate());
}

1
src/heap/objects-visiting.h
View File

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

9
src/ic/accessor-assembler.cc
View File

@ -264,9 +264,7 @@ void AccessorAssembler::HandleLoadAccessor(
CSA_CHECK(this, IsNotCleared(maybe_context));
TNode<HeapObject> context = GetHeapObjectAssumeWeak(maybe_context);
TNode<Foreign> foreign = LoadObjectField<Foreign>(
call_handler_info, CallHandlerInfo::kJsCallbackOffset);
TNode<RawPtrT> callback = LoadForeignForeignAddressPtr(foreign);
TNode<RawPtrT> callback = LoadCallHandlerInfoJsCallbackPtr(call_handler_info);
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>(
call_handler_info, CallHandlerInfo::kJsCallbackOffset);
TNode<RawPtrT> callback = LoadForeignForeignAddressPtr(foreign);
TNode<RawPtrT> callback =
LoadCallHandlerInfoJsCallbackPtr(call_handler_info);
TNode<Object> data =
LoadObjectField(call_handler_info, CallHandlerInfo::kDataOffset);

3
src/logging/log.cc
View File

@ -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 = v8::ToCData<Address>(callback_obj);
Address entry_point = call_data.callback();
#if USES_FUNCTION_DESCRIPTORS
entry_point = *FUNCTION_ENTRYPOINT_ADDRESS(entry_point);
#endif

13
src/objects/api-callbacks-inl.h
View File

@ -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

19
src/objects/api-callbacks.h
View File

@ -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)
};

10
src/objects/api-callbacks.tq
View File

@ -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 {
callback: NonNullForeign|Undefined|Zero;
js_callback: NonNullForeign|Undefined|Zero;
extern class CallHandlerInfo extends HeapObject {
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;
}

2
src/objects/map.cc
View File

@ -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;

1
src/objects/map.h
View File

@ -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) \

7
src/objects/object-macros-undef.h
View File

@ -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

27
src/objects/object-macros.h
View File

@ -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()); \

31
src/objects/objects-body-descriptors-inl.h
View File

@ -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

6
src/objects/objects.cc
View File

@ -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 << ", js_callback= " << Brief(info.js_callback());
os << "callback= " << reinterpret_cast<void*>(info.callback());
os << ", js_callback= " << reinterpret_cast<void*>(info.js_callback());
os << ", data= " << Brief(info.data());
if (info.IsSideEffectFreeCallHandlerInfo()) {
os << ", side_effect_free= true>";

4
src/snapshot/serializer-deserializer.cc
View File

@ -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())
.set_foreign_address(isolate, call_handler_info.redirected_callback());
call_handler_info.set_js_callback(isolate,
call_handler_info.redirected_callback());
}
} // namespace internal

3
src/snapshot/serializer.cc
View File

@ -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;

6
src/snapshot/startup-serializer.cc
View File

@ -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 =
Foreign::cast(info->callback()).foreign_address(isolate());
Foreign::cast(info->js_callback())
.set_foreign_address(isolate(), original_address);
Address original_address = info->callback();
info->set_js_callback(isolate(), original_address);
call_handler_infos_.Push(*info);
} else if (obj->IsScript(cage_base) &&
Handle<Script>::cast(obj)->IsUserJavaScript()) {

218
tools/v8heapconst.py
View File

@ -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",
154: "CALL_SITE_INFO_TYPE",
155: "CLASS_POSITIONS_TYPE",
156: "DEBUG_INFO_TYPE",
157: "ENUM_CACHE_TYPE",
158: "ERROR_STACK_DATA_TYPE",
159: "FEEDBACK_CELL_TYPE",
160: "FUNCTION_TEMPLATE_RARE_DATA_TYPE",
161: "INTERCEPTOR_INFO_TYPE",
162: "INTERPRETER_DATA_TYPE",
163: "MODULE_REQUEST_TYPE",
164: "PROMISE_CAPABILITY_TYPE",
165: "PROMISE_ON_STACK_TYPE",
166: "PROMISE_REACTION_TYPE",
167: "PROPERTY_DESCRIPTOR_OBJECT_TYPE",
168: "PROTOTYPE_INFO_TYPE",
169: "REG_EXP_BOILERPLATE_DESCRIPTION_TYPE",
170: "SCRIPT_TYPE",
171: "SCRIPT_OR_MODULE_TYPE",
172: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE",
173: "STACK_FRAME_INFO_TYPE",
174: "TEMPLATE_OBJECT_DESCRIPTION_TYPE",
175: "TUPLE2_TYPE",
176: "WASM_CONTINUATION_OBJECT_TYPE",
177: "WASM_EXCEPTION_TAG_TYPE",
178: "WASM_INDIRECT_FUNCTION_TABLE_TYPE",
179: "FIXED_ARRAY_TYPE",
180: "HASH_TABLE_TYPE",
181: "EPHEMERON_HASH_TABLE_TYPE",
182: "GLOBAL_DICTIONARY_TYPE",
183: "NAME_DICTIONARY_TYPE",
184: "NAME_TO_INDEX_HASH_TABLE_TYPE",
185: "NUMBER_DICTIONARY_TYPE",
186: "ORDERED_HASH_MAP_TYPE",
187: "ORDERED_HASH_SET_TYPE",
188: "ORDERED_NAME_DICTIONARY_TYPE",
189: "REGISTERED_SYMBOL_TABLE_TYPE",
190: "SIMPLE_NUMBER_DICTIONARY_TYPE",
191: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
192: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
193: "SCRIPT_CONTEXT_TABLE_TYPE",
194: "BYTE_ARRAY_TYPE",
195: "BYTECODE_ARRAY_TYPE",
196: "FIXED_DOUBLE_ARRAY_TYPE",
197: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
198: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
199: "TURBOFAN_BITSET_TYPE_TYPE",
200: "TURBOFAN_HEAP_CONSTANT_TYPE_TYPE",
201: "TURBOFAN_OTHER_NUMBER_CONSTANT_TYPE_TYPE",
202: "TURBOFAN_RANGE_TYPE_TYPE",
203: "TURBOFAN_UNION_TYPE_TYPE",
153: "CALL_SITE_INFO_TYPE",
154: "CLASS_POSITIONS_TYPE",
155: "DEBUG_INFO_TYPE",
156: "ENUM_CACHE_TYPE",
157: "ERROR_STACK_DATA_TYPE",
158: "FEEDBACK_CELL_TYPE",
159: "FUNCTION_TEMPLATE_RARE_DATA_TYPE",
160: "INTERCEPTOR_INFO_TYPE",
161: "INTERPRETER_DATA_TYPE",
162: "MODULE_REQUEST_TYPE",
163: "PROMISE_CAPABILITY_TYPE",
164: "PROMISE_ON_STACK_TYPE",
165: "PROMISE_REACTION_TYPE",
166: "PROPERTY_DESCRIPTOR_OBJECT_TYPE",
167: "PROTOTYPE_INFO_TYPE",
168: "REG_EXP_BOILERPLATE_DESCRIPTION_TYPE",
169: "SCRIPT_TYPE",
170: "SCRIPT_OR_MODULE_TYPE",
171: "SOURCE_TEXT_MODULE_INFO_ENTRY_TYPE",
172: "STACK_FRAME_INFO_TYPE",
173: "TEMPLATE_OBJECT_DESCRIPTION_TYPE",
174: "TUPLE2_TYPE",
175: "WASM_CONTINUATION_OBJECT_TYPE",
176: "WASM_EXCEPTION_TAG_TYPE",
177: "WASM_INDIRECT_FUNCTION_TABLE_TYPE",
178: "FIXED_ARRAY_TYPE",
179: "HASH_TABLE_TYPE",
180: "EPHEMERON_HASH_TABLE_TYPE",
181: "GLOBAL_DICTIONARY_TYPE",
182: "NAME_DICTIONARY_TYPE",
183: "NAME_TO_INDEX_HASH_TABLE_TYPE",
184: "NUMBER_DICTIONARY_TYPE",
185: "ORDERED_HASH_MAP_TYPE",
186: "ORDERED_HASH_SET_TYPE",
187: "ORDERED_NAME_DICTIONARY_TYPE",
188: "REGISTERED_SYMBOL_TABLE_TYPE",
189: "SIMPLE_NUMBER_DICTIONARY_TYPE",
190: "CLOSURE_FEEDBACK_CELL_ARRAY_TYPE",
191: "OBJECT_BOILERPLATE_DESCRIPTION_TYPE",
192: "SCRIPT_CONTEXT_TABLE_TYPE",
193: "BYTE_ARRAY_TYPE",
194: "BYTECODE_ARRAY_TYPE",
195: "FIXED_DOUBLE_ARRAY_TYPE",
196: "INTERNAL_CLASS_WITH_SMI_ELEMENTS_TYPE",
197: "SLOPPY_ARGUMENTS_ELEMENTS_TYPE",
198: "TURBOFAN_BITSET_TYPE_TYPE",
199: "TURBOFAN_HEAP_CONSTANT_TYPE_TYPE",
200: "TURBOFAN_OTHER_NUMBER_CONSTANT_TYPE_TYPE",
201: "TURBOFAN_RANGE_TYPE_TYPE",
202: "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", 0x02239): (179, "FixedArrayMap"),
("read_only_space", 0x02205): (156, "EnumCacheMap"),
("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", 0x02565): (179, "FixedCOWArrayMap"),
("read_only_space", 0x0258d): (180, "HashTableMap"),
("read_only_space", 0x0253d): (193, "ByteArrayMap"),
("read_only_space", 0x02565): (178, "FixedCOWArrayMap"),
("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", 0x02989): (191, "ClosureFeedbackCellArrayMap"),
("read_only_space", 0x02961): (192, "ScriptContextTableMap"),
("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", 0x02a51): (195, "BytecodeArrayMap"),
("read_only_space", 0x02a29): (191, "ObjectBoilerplateDescriptionMap"),
("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", 0x02af1): (182, "GlobalDictionaryMap"),
("read_only_space", 0x02b19): (159, "ManyClosuresCellMap"),
("read_only_space", 0x02ac9): (195, "FixedDoubleArrayMap"),
("read_only_space", 0x02af1): (181, "GlobalDictionaryMap"),
("read_only_space", 0x02b19): (158, "ManyClosuresCellMap"),
("read_only_space", 0x02b41): (251, "MegaDomHandlerMap"),
("read_only_space", 0x02b69): (179, "ModuleInfoMap"),
("read_only_space", 0x02b91): (183, "NameDictionaryMap"),
("read_only_space", 0x02bb9): (159, "NoClosuresCellMap"),
("read_only_space", 0x02be1): (185, "NumberDictionaryMap"),
("read_only_space", 0x02c09): (159, "OneClosureCellMap"),
("read_only_space", 0x02c31): (186, "OrderedHashMapMap"),
("read_only_space", 0x02c59): (187, "OrderedHashSetMap"),
("read_only_space", 0x02c81): (184, "NameToIndexHashTableMap"),
("read_only_space", 0x02ca9): (189, "RegisteredSymbolTableMap"),
("read_only_space", 0x02cd1): (188, "OrderedNameDictionaryMap"),
("read_only_space", 0x02b69): (178, "ModuleInfoMap"),
("read_only_space", 0x02b91): (182, "NameDictionaryMap"),
("read_only_space", 0x02bb9): (158, "NoClosuresCellMap"),
("read_only_space", 0x02be1): (184, "NumberDictionaryMap"),
("read_only_space", 0x02c09): (158, "OneClosureCellMap"),
("read_only_space", 0x02c31): (185, "OrderedHashMapMap"),
("read_only_space", 0x02c59): (186, "OrderedHashSetMap"),
("read_only_space", 0x02c81): (183, "NameToIndexHashTableMap"),
("read_only_space", 0x02ca9): (188, "RegisteredSymbolTableMap"),
("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", 0x02d71): (153, "SideEffectFreeCallHandlerInfoMap"),
("read_only_space", 0x02d99): (153, "NextCallSideEffectFreeCallHandlerInfoMap"),
("read_only_space", 0x02dc1): (190, "SimpleNumberDictionaryMap"),
("read_only_space", 0x02d49): (203, "SideEffectCallHandlerInfoMap"),
("read_only_space", 0x02d71): (203, "SideEffectFreeCallHandlerInfoMap"),
("read_only_space", 0x02d99): (203, "NextCallSideEffectFreeCallHandlerInfoMap"),
("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", 0x06295): (155, "ClassPositionsMap"),
("read_only_space", 0x062bd): (156, "DebugInfoMap"),
("read_only_space", 0x062e5): (158, "ErrorStackDataMap"),
("read_only_space", 0x0630d): (160, "FunctionTemplateRareDataMap"),
("read_only_space", 0x06335): (162, "InterpreterDataMap"),
("read_only_space", 0x0635d): (163, "ModuleRequestMap"),
("read_only_space", 0x06385): (164, "PromiseCapabilityMap"),
("read_only_space", 0x063ad): (165, "PromiseOnStackMap"),
("read_only_space", 0x063d5): (166, "PromiseReactionMap"),
("read_only_space", 0x063fd): (167, "PropertyDescriptorObjectMap"),
("read_only_space", 0x06425): (168, "PrototypeInfoMap"),
("read_only_space", 0x0644d): (169, "RegExpBoilerplateDescriptionMap"),
("read_only_space", 0x06475): (170, "ScriptMap"),
("read_only_space", 0x0649d): (171, "ScriptOrModuleMap"),
("read_only_space", 0x064c5): (172, "SourceTextModuleInfoEntryMap"),
("read_only_space", 0x064ed): (173, "StackFrameInfoMap"),
("read_only_space", 0x06515): (174, "TemplateObjectDescriptionMap"),
("read_only_space", 0x0653d): (175, "Tuple2Map"),
("read_only_space", 0x06565): (176, "WasmContinuationObjectMap"),
("read_only_space", 0x0658d): (177, "WasmExceptionTagMap"),
("read_only_space", 0x065b5): (178, "WasmIndirectFunctionTableMap"),
("read_only_space", 0x065dd): (198, "SloppyArgumentsElementsMap"),
("read_only_space", 0x0626d): (153, "CallSiteInfoMap"),
("read_only_space", 0x06295): (154, "ClassPositionsMap"),
("read_only_space", 0x062bd): (155, "DebugInfoMap"),
("read_only_space", 0x062e5): (157, "ErrorStackDataMap"),
("read_only_space", 0x0630d): (159, "FunctionTemplateRareDataMap"),
("read_only_space", 0x06335): (161, "InterpreterDataMap"),
("read_only_space", 0x0635d): (162, "ModuleRequestMap"),
("read_only_space", 0x06385): (163, "PromiseCapabilityMap"),
("read_only_space", 0x063ad): (164, "PromiseOnStackMap"),
("read_only_space", 0x063d5): (165, "PromiseReactionMap"),
("read_only_space", 0x063fd): (166, "PropertyDescriptorObjectMap"),
("read_only_space", 0x06425): (167, "PrototypeInfoMap"),
("read_only_space", 0x0644d): (168, "RegExpBoilerplateDescriptionMap"),
("read_only_space", 0x06475): (169, "ScriptMap"),
("read_only_space", 0x0649d): (170, "ScriptOrModuleMap"),
("read_only_space", 0x064c5): (171, "SourceTextModuleInfoEntryMap"),
("read_only_space", 0x064ed): (172, "StackFrameInfoMap"),
("read_only_space", 0x06515): (173, "TemplateObjectDescriptionMap"),
("read_only_space", 0x0653d): (174, "Tuple2Map"),
("read_only_space", 0x06565): (175, "WasmContinuationObjectMap"),
("read_only_space", 0x0658d): (176, "WasmExceptionTagMap"),
("read_only_space", 0x065b5): (177, "WasmIndirectFunctionTableMap"),
("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", 0x0671d): (203, "TurbofanUnionTypeMap"),
("read_only_space", 0x06745): (202, "TurbofanRangeTypeMap"),
("read_only_space", 0x0676d): (200, "TurbofanHeapConstantTypeMap"),
("read_only_space", 0x06795): (201, "TurbofanOtherNumberConstantTypeMap"),
("read_only_space", 0x066f5): (198, "TurbofanBitsetTypeMap"),
("read_only_space", 0x0671d): (202, "TurbofanUnionTypeMap"),
("read_only_space", 0x06745): (201, "TurbofanRangeTypeMap"),
("read_only_space", 0x0676d): (199, "TurbofanHeapConstantTypeMap"),
("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"),