Revert "[static-roots] Allow creating isolates from existing r/o snapshot"
This reverts commit 331c577e1d.
Reason for revert: https://ci.chromium.org/ui/p/v8/builders/ci/V8%20Linux64%20-%20debug%20-%20single%20generation%20-%20builder/9912/overview
Original change's description:
> [static-roots] Allow creating isolates from existing r/o snapshot
>
> This adds the ability to create an isolate from scratch, except the
> read only roots, which are initialized from a read_only_data snapshot.
> To do this we split the heap setup in a read/only part and the rest.
> The goal of these changes is to later support writing serializer tests,
> even if the read only roots are static and have to be loaded from a
> fixed snapshot.
>
> Bug: v8:13466
> Change-Id: I078695b95710e5281da013ca0c08af0e153b4725
> Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/4037271
> Reviewed-by: Igor Sheludko <ishell@chromium.org>
> Reviewed-by: Dominik Inführ <dinfuehr@chromium.org>
> Commit-Queue: Olivier Flückiger <olivf@chromium.org>
> Cr-Commit-Position: refs/heads/main@{#84750}
Bug: v8:13466
Change-Id: I91512140abb98993578d27e65e6080e1d3f317e6
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/4089967
Auto-Submit: Nico Hartmann <nicohartmann@chromium.org>
Commit-Queue: Nico Hartmann <nicohartmann@chromium.org>
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Owners-Override: Nico Hartmann <nicohartmann@chromium.org>
Cr-Commit-Position: refs/heads/main@{#84751}
This commit is contained in:
Nico Hartmann
V8 LUCI CQ
parent
331c577e1d
commit
1d733b97a2
@ -4026,13 +4026,6 @@ bool Isolate::InitWithoutSnapshot() {
|
||||
return Init(nullptr, nullptr, nullptr, false);
|
||||
}
|
||||
|
||||
bool Isolate::InitWithReadOnlySnapshot(SnapshotData* read_only_snapshot_data) {
|
||||
DCHECK_NOT_NULL(read_only_snapshot_data);
|
||||
// Without external code space builtin code objects are alocated in ro space
|
||||
DCHECK(V8_EXTERNAL_CODE_SPACE_BOOL);
|
||||
return Init(nullptr, read_only_snapshot_data, nullptr, false);
|
||||
}
|
||||
|
||||
bool Isolate::InitWithSnapshot(SnapshotData* startup_snapshot_data,
|
||||
SnapshotData* read_only_snapshot_data,
|
||||
SnapshotData* shared_heap_snapshot_data,
|
||||
@ -4145,13 +4138,10 @@ bool Isolate::Init(SnapshotData* startup_snapshot_data,
|
||||
CHECK_EQ(V8HeapCompressionScheme::base(), cage_base());
|
||||
#endif // V8_COMPRESS_POINTERS_IN_SHARED_CAGE
|
||||
|
||||
const bool create_heap_objects = (shared_heap_snapshot_data == nullptr);
|
||||
const bool setup_up_existing_read_only_roots =
|
||||
create_heap_objects && (read_only_snapshot_data != nullptr);
|
||||
// We either have both or none.
|
||||
const bool create_heap_objects = (read_only_snapshot_data == nullptr);
|
||||
// We either have all or none.
|
||||
DCHECK_EQ(create_heap_objects, startup_snapshot_data == nullptr);
|
||||
DCHECK_IMPLIES(setup_up_existing_read_only_roots,
|
||||
startup_snapshot_data == nullptr);
|
||||
DCHECK_EQ(create_heap_objects, shared_heap_snapshot_data == nullptr);
|
||||
|
||||
// Code space setup requires the permissions to be set to default state.
|
||||
RwxMemoryWriteScope::SetDefaultPermissionsForNewThread();
|
||||
@ -4304,28 +4294,6 @@ bool Isolate::Init(SnapshotData* startup_snapshot_data,
|
||||
string_forwarding_table_ = shared_heap_isolate()->string_forwarding_table_;
|
||||
}
|
||||
|
||||
// If we create an isolate from scratch, but based on existing read only
|
||||
// roots, then we need to populate the string cache with its strings.
|
||||
if (setup_up_existing_read_only_roots) {
|
||||
HandleScope scope(this);
|
||||
ReadOnlyHeapObjectIterator iterator(read_only_heap());
|
||||
for (HeapObject object = iterator.Next(); !object.is_null();
|
||||
object = iterator.Next()) {
|
||||
if (object.IsInternalizedString()) {
|
||||
auto s = String::cast(object);
|
||||
Handle<String> str(s, this);
|
||||
StringTableInsertionKey key(
|
||||
this, str, DeserializingUserCodeOption::kNotDeserializingUserCode);
|
||||
auto result = string_table()->LookupKey(this, &key);
|
||||
// Since this is startup, there should be no duplicate entries in the
|
||||
// string table, and the lookup should unconditionally add the given
|
||||
// string.
|
||||
DCHECK_EQ(*result, *str);
|
||||
USE(result);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (V8_SHORT_BUILTIN_CALLS_BOOL && v8_flags.short_builtin_calls) {
|
||||
#if defined(V8_OS_ANDROID)
|
||||
// On Android, the check is not operative to detect memory, and re-embedded
|
||||
@ -4470,9 +4438,7 @@ bool Isolate::Init(SnapshotData* startup_snapshot_data,
|
||||
CodePageCollectionMemoryModificationScope modification_scope(heap());
|
||||
|
||||
if (create_heap_objects) {
|
||||
if (!setup_up_existing_read_only_roots) {
|
||||
read_only_heap_->OnCreateHeapObjectsComplete(this);
|
||||
}
|
||||
read_only_heap_->OnCreateHeapObjectsComplete(this);
|
||||
} else {
|
||||
SharedHeapDeserializer shared_heap_deserializer(
|
||||
this, shared_heap_snapshot_data, can_rehash);
|
||||
|
||||
@ -661,7 +661,6 @@ class V8_EXPORT_PRIVATE Isolate final : private HiddenFactory {
|
||||
bool InitializeCounters(); // Returns false if already initialized.
|
||||
|
||||
bool InitWithoutSnapshot();
|
||||
bool InitWithReadOnlySnapshot(SnapshotData* read_only_snapshot_data);
|
||||
bool InitWithSnapshot(SnapshotData* startup_snapshot_data,
|
||||
SnapshotData* read_only_snapshot_data,
|
||||
SnapshotData* shared_heap_snapshot_data,
|
||||
|
||||
@ -2382,13 +2382,9 @@ Handle<FixedDoubleArray> Factory::CopyFixedDoubleArray(
|
||||
}
|
||||
|
||||
Handle<HeapNumber> Factory::NewHeapNumberForCodeAssembler(double value) {
|
||||
ReadOnlyRoots roots(isolate());
|
||||
auto num = roots.FindHeapNumber(value);
|
||||
if (!num.is_null()) return num;
|
||||
// Add known HeapNumber constants to the read only roots. This ensures
|
||||
// r/o snapshots to be deterministic.
|
||||
DCHECK(!CanAllocateInReadOnlySpace());
|
||||
return NewHeapNumber<AllocationType::kOld>(value);
|
||||
return CanAllocateInReadOnlySpace()
|
||||
? NewHeapNumber<AllocationType::kReadOnly>(value)
|
||||
: NewHeapNumber<AllocationType::kOld>(value);
|
||||
}
|
||||
|
||||
Handle<JSObject> Factory::NewError(Handle<JSFunction> constructor,
|
||||
|
||||
@ -667,8 +667,7 @@ class Heap {
|
||||
// Support for the API.
|
||||
//
|
||||
|
||||
void CreateReadOnlyApiObjects();
|
||||
void CreateMutableApiObjects();
|
||||
void CreateApiObjects();
|
||||
|
||||
// Implements the corresponding V8 API function.
|
||||
bool IdleNotification(double deadline_in_seconds);
|
||||
@ -811,8 +810,7 @@ class Heap {
|
||||
|
||||
// Bootstraps the object heap with the core set of objects required to run.
|
||||
// Returns whether it succeeded.
|
||||
bool CreateReadOnlyHeapObjects();
|
||||
bool CreateMutableHeapObjects();
|
||||
bool CreateHeapObjects();
|
||||
|
||||
// Create ObjectStats if live_object_stats_ or dead_object_stats_ are nullptr.
|
||||
void CreateObjectStats();
|
||||
@ -1812,10 +1810,9 @@ class Heap {
|
||||
|
||||
inline void UpdateOldSpaceLimits();
|
||||
|
||||
bool CreateInitialReadOnlyMaps();
|
||||
bool CreateInitialMaps();
|
||||
void CreateInternalAccessorInfoObjects();
|
||||
void CreateInitialMutableObjects();
|
||||
void CreateInitialReadOnlyObjects();
|
||||
void CreateInitialObjects();
|
||||
|
||||
// Zaps the memory of a code object.
|
||||
V8_EXPORT_PRIVATE void ZapCodeObject(Address start_address,
|
||||
@ -2049,8 +2046,7 @@ class Heap {
|
||||
|
||||
// Allocates a JS Map in the heap.
|
||||
V8_WARN_UNUSED_RESULT AllocationResult
|
||||
AllocateMap(AllocationType allocation_type, InstanceType instance_type,
|
||||
int instance_size,
|
||||
AllocateMap(InstanceType instance_type, int instance_size,
|
||||
ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND,
|
||||
int inobject_properties = 0);
|
||||
|
||||
|
||||
@ -145,8 +145,7 @@ ReadOnlyHeap* ReadOnlyHeap::CreateInitalHeapForBootstrapping(
|
||||
} else {
|
||||
std::unique_ptr<SoleReadOnlyHeap> sole_ro_heap(
|
||||
new SoleReadOnlyHeap(ro_space));
|
||||
// The global shared ReadOnlyHeap is used with shared cage and if pointer
|
||||
// compression is disabled.
|
||||
// The global shared ReadOnlyHeap is only used without pointer compression.
|
||||
SoleReadOnlyHeap::shared_ro_heap_ = sole_ro_heap.get();
|
||||
ro_heap = std::move(sole_ro_heap);
|
||||
}
|
||||
|
||||
@ -87,7 +87,7 @@ class ReadOnlyHeap {
|
||||
|
||||
// Returns whether the ReadOnlySpace will actually be shared taking into
|
||||
// account whether shared memory is available with pointer compression.
|
||||
static constexpr bool IsReadOnlySpaceShared() {
|
||||
static bool IsReadOnlySpaceShared() {
|
||||
return V8_SHARED_RO_HEAP_BOOL &&
|
||||
(!COMPRESS_POINTERS_BOOL || COMPRESS_POINTERS_IN_SHARED_CAGE_BOOL);
|
||||
}
|
||||
@ -96,8 +96,6 @@ class ReadOnlyHeap {
|
||||
virtual void InitializeFromIsolateRoots(Isolate* isolate) {}
|
||||
virtual bool IsOwnedByIsolate() { return true; }
|
||||
|
||||
bool init_complete() { return init_complete_; }
|
||||
|
||||
protected:
|
||||
friend class ReadOnlyArtifacts;
|
||||
friend class PointerCompressedReadOnlyArtifacts;
|
||||
|
||||
@ -66,93 +66,33 @@ Handle<SharedFunctionInfo> CreateSharedFunctionInfo(
|
||||
return shared;
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
bool IsMutableMap(InstanceType instance_type, ElementsKind elements_kind) {
|
||||
bool is_js_object = InstanceTypeChecker::IsJSObject(instance_type);
|
||||
bool is_wasm_object = false;
|
||||
#if V8_ENABLE_WEBASSEMBLY
|
||||
is_wasm_object =
|
||||
instance_type == WASM_STRUCT_TYPE || instance_type == WASM_ARRAY_TYPE;
|
||||
#endif // V8_ENABLE_WEBASSEMBLY
|
||||
DCHECK_IMPLIES(is_js_object &&
|
||||
!Map::CanHaveFastTransitionableElementsKind(instance_type),
|
||||
IsDictionaryElementsKind(elements_kind) ||
|
||||
IsTerminalElementsKind(elements_kind));
|
||||
// JSObjects have maps with a mutable prototype_validity_cell, so they cannot
|
||||
// go in RO_SPACE. Maps for managed Wasm objects have mutable subtype lists.
|
||||
return is_js_object || is_wasm_object;
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
|
||||
bool SetupIsolateDelegate::SetupHeapInternal(Isolate* isolate) {
|
||||
auto heap = isolate->heap();
|
||||
if (!isolate->read_only_heap()->init_complete()) {
|
||||
if (!heap->CreateReadOnlyHeapObjects()) return false;
|
||||
}
|
||||
#ifdef DEBUG
|
||||
auto ro_size = heap->read_only_space()->Size();
|
||||
#endif
|
||||
DCHECK_EQ(heap->old_space()->Size(), 0);
|
||||
DCHECK_EQ(heap->new_space()->Size(), 0);
|
||||
auto res = heap->CreateMutableHeapObjects();
|
||||
DCHECK_EQ(heap->read_only_space()->Size(), ro_size);
|
||||
return res;
|
||||
return isolate->heap()->CreateHeapObjects();
|
||||
}
|
||||
|
||||
bool Heap::CreateReadOnlyHeapObjects() {
|
||||
bool Heap::CreateHeapObjects() {
|
||||
// Create initial maps.
|
||||
if (!CreateInitialReadOnlyMaps()) return false;
|
||||
|
||||
CreateReadOnlyApiObjects();
|
||||
CreateInitialReadOnlyObjects();
|
||||
|
||||
#ifdef DEBUG
|
||||
ReadOnlyRoots roots(isolate());
|
||||
for (auto pos = RootIndex::kFirstReadOnlyRoot;
|
||||
pos <= RootIndex::kLastReadOnlyRoot; ++pos) {
|
||||
DCHECK(roots.at(pos));
|
||||
}
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Heap::CreateMutableHeapObjects() {
|
||||
ReadOnlyRoots roots(this);
|
||||
|
||||
#define ALLOCATE_MAP(instance_type, size, field_name) \
|
||||
{ \
|
||||
Map map; \
|
||||
if (!AllocateMap(AllocationType::kMap, (instance_type), size).To(&map)) \
|
||||
return false; \
|
||||
set_##field_name##_map(map); \
|
||||
}
|
||||
|
||||
{ // Map allocation
|
||||
ALLOCATE_MAP(JS_MESSAGE_OBJECT_TYPE, JSMessageObject::kHeaderSize,
|
||||
message_object)
|
||||
ALLOCATE_MAP(JS_EXTERNAL_OBJECT_TYPE, JSExternalObject::kHeaderSize,
|
||||
external)
|
||||
external_map().set_is_extensible(false);
|
||||
}
|
||||
#undef ALLOCATE_MAP
|
||||
if (!CreateInitialMaps()) return false;
|
||||
|
||||
// Ensure that all young generation pages are iterable. It must be after heap
|
||||
// setup, so that the maps have been created.
|
||||
if (new_space()) new_space()->MakeIterable();
|
||||
|
||||
CreateMutableApiObjects();
|
||||
CreateApiObjects();
|
||||
|
||||
// Create initial objects
|
||||
CreateInitialMutableObjects();
|
||||
CreateInitialObjects();
|
||||
CreateInternalAccessorInfoObjects();
|
||||
CHECK_EQ(0u, gc_count_);
|
||||
|
||||
set_native_contexts_list(roots.undefined_value());
|
||||
set_allocation_sites_list(roots.undefined_value());
|
||||
set_dirty_js_finalization_registries_list(roots.undefined_value());
|
||||
set_dirty_js_finalization_registries_list_tail(roots.undefined_value());
|
||||
set_native_contexts_list(ReadOnlyRoots(this).undefined_value());
|
||||
set_allocation_sites_list(ReadOnlyRoots(this).undefined_value());
|
||||
set_dirty_js_finalization_registries_list(
|
||||
ReadOnlyRoots(this).undefined_value());
|
||||
set_dirty_js_finalization_registries_list_tail(
|
||||
ReadOnlyRoots(this).undefined_value());
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -189,17 +129,28 @@ const Heap::StructTable Heap::struct_table[] = {
|
||||
#undef DATA_HANDLER_ELEMENT
|
||||
};
|
||||
|
||||
AllocationResult Heap::AllocateMap(AllocationType allocation_type,
|
||||
InstanceType instance_type,
|
||||
AllocationResult Heap::AllocateMap(InstanceType instance_type,
|
||||
int instance_size,
|
||||
ElementsKind elements_kind,
|
||||
int inobject_properties) {
|
||||
static_assert(LAST_JS_OBJECT_TYPE == LAST_TYPE);
|
||||
bool is_js_object = InstanceTypeChecker::IsJSObject(instance_type);
|
||||
bool is_wasm_object = false;
|
||||
#if V8_ENABLE_WEBASSEMBLY
|
||||
is_wasm_object =
|
||||
instance_type == WASM_STRUCT_TYPE || instance_type == WASM_ARRAY_TYPE;
|
||||
#endif // V8_ENABLE_WEBASSEMBLY
|
||||
DCHECK_IMPLIES(is_js_object &&
|
||||
!Map::CanHaveFastTransitionableElementsKind(instance_type),
|
||||
IsDictionaryElementsKind(elements_kind) ||
|
||||
IsTerminalElementsKind(elements_kind));
|
||||
HeapObject result;
|
||||
DCHECK_EQ(allocation_type, IsMutableMap(instance_type, elements_kind)
|
||||
? AllocationType::kMap
|
||||
: AllocationType::kReadOnly);
|
||||
AllocationResult allocation = AllocateRaw(Map::kSize, allocation_type);
|
||||
// JSObjects have maps with a mutable prototype_validity_cell, so they cannot
|
||||
// go in RO_SPACE. Maps for managed Wasm objects have mutable subtype lists.
|
||||
bool is_mutable = is_js_object || is_wasm_object;
|
||||
AllocationResult allocation =
|
||||
AllocateRaw(Map::kSize, is_mutable ? AllocationType::kMap
|
||||
: AllocationType::kReadOnly);
|
||||
if (!allocation.To(&result)) return allocation;
|
||||
|
||||
result.set_map_after_allocation(ReadOnlyRoots(this).meta_map(),
|
||||
@ -267,8 +218,7 @@ AllocationResult Heap::Allocate(Handle<Map> map,
|
||||
return AllocationResult::FromObject(result);
|
||||
}
|
||||
|
||||
bool Heap::CreateInitialReadOnlyMaps() {
|
||||
ReadOnlyRoots roots(this);
|
||||
bool Heap::CreateInitialMaps() {
|
||||
HeapObject obj;
|
||||
{
|
||||
AllocationResult allocation = AllocatePartialMap(MAP_TYPE, Map::kSize);
|
||||
@ -279,6 +229,8 @@ bool Heap::CreateInitialReadOnlyMaps() {
|
||||
set_meta_map(new_meta_map);
|
||||
new_meta_map.set_map_after_allocation(new_meta_map);
|
||||
|
||||
ReadOnlyRoots roots(this);
|
||||
{ // Partial map allocation
|
||||
#define ALLOCATE_PARTIAL_MAP(instance_type, size, field_name) \
|
||||
{ \
|
||||
Map map; \
|
||||
@ -286,7 +238,6 @@ bool Heap::CreateInitialReadOnlyMaps() {
|
||||
set_##field_name##_map(map); \
|
||||
}
|
||||
|
||||
{ // Partial map allocation
|
||||
ALLOCATE_PARTIAL_MAP(FIXED_ARRAY_TYPE, kVariableSizeSentinel, fixed_array);
|
||||
ALLOCATE_PARTIAL_MAP(WEAK_FIXED_ARRAY_TYPE, kVariableSizeSentinel,
|
||||
weak_fixed_array);
|
||||
@ -409,14 +360,12 @@ bool Heap::CreateInitialReadOnlyMaps() {
|
||||
FinalizePartialMap(Map::cast(Object(roots_table()[entry.index])));
|
||||
}
|
||||
|
||||
#define ALLOCATE_MAP(instance_type, size, field_name) \
|
||||
{ \
|
||||
Map map; \
|
||||
if (!AllocateMap(AllocationType::kReadOnly, (instance_type), size) \
|
||||
.To(&map)) { \
|
||||
return false; \
|
||||
} \
|
||||
set_##field_name##_map(map); \
|
||||
{ // Map allocation
|
||||
#define ALLOCATE_MAP(instance_type, size, field_name) \
|
||||
{ \
|
||||
Map map; \
|
||||
if (!AllocateMap((instance_type), size).To(&map)) return false; \
|
||||
set_##field_name##_map(map); \
|
||||
}
|
||||
|
||||
#define ALLOCATE_VARSIZE_MAP(instance_type, field_name) \
|
||||
@ -430,7 +379,6 @@ bool Heap::CreateInitialReadOnlyMaps() {
|
||||
(constructor_function_index)); \
|
||||
}
|
||||
|
||||
{ // Map allocation
|
||||
ALLOCATE_VARSIZE_MAP(SCOPE_INFO_TYPE, scope_info)
|
||||
ALLOCATE_VARSIZE_MAP(FIXED_ARRAY_TYPE, module_info)
|
||||
ALLOCATE_VARSIZE_MAP(CLOSURE_FEEDBACK_CELL_ARRAY_TYPE,
|
||||
@ -458,10 +406,7 @@ bool Heap::CreateInitialReadOnlyMaps() {
|
||||
for (unsigned i = 0; i < arraysize(string_type_table); i++) {
|
||||
const StringTypeTable& entry = string_type_table[i];
|
||||
Map map;
|
||||
if (!AllocateMap(AllocationType::kReadOnly, entry.type, entry.size)
|
||||
.To(&map)) {
|
||||
return false;
|
||||
}
|
||||
if (!AllocateMap(entry.type, entry.size).To(&map)) return false;
|
||||
map.SetConstructorFunctionIndex(Context::STRING_FUNCTION_INDEX);
|
||||
// Mark cons string maps as unstable, because their objects can change
|
||||
// maps during GC.
|
||||
@ -588,11 +533,16 @@ bool Heap::CreateInitialReadOnlyMaps() {
|
||||
WasmContinuationObject::kSize, wasm_continuation_object)
|
||||
|
||||
ALLOCATE_MAP(WEAK_CELL_TYPE, WeakCell::kSize, weak_cell)
|
||||
}
|
||||
|
||||
ALLOCATE_MAP(JS_MESSAGE_OBJECT_TYPE, JSMessageObject::kHeaderSize,
|
||||
message_object)
|
||||
ALLOCATE_MAP(JS_EXTERNAL_OBJECT_TYPE, JSExternalObject::kHeaderSize,
|
||||
external)
|
||||
external_map().set_is_extensible(false);
|
||||
#undef ALLOCATE_PRIMITIVE_MAP
|
||||
#undef ALLOCATE_VARSIZE_MAP
|
||||
#undef ALLOCATE_MAP
|
||||
|
||||
}
|
||||
{
|
||||
AllocationResult alloc = AllocateRaw(
|
||||
ArrayList::SizeFor(ArrayList::kFirstIndex), AllocationType::kReadOnly);
|
||||
@ -706,23 +656,20 @@ bool Heap::CreateInitialReadOnlyMaps() {
|
||||
return true;
|
||||
}
|
||||
|
||||
void Heap::CreateMutableApiObjects() {
|
||||
void Heap::CreateApiObjects() {
|
||||
Isolate* isolate = this->isolate();
|
||||
HandleScope scope(isolate);
|
||||
|
||||
set_message_listeners(*TemplateList::New(isolate, 2));
|
||||
}
|
||||
|
||||
void Heap::CreateReadOnlyApiObjects() {
|
||||
HandleScope scope(isolate());
|
||||
Handle<InterceptorInfo> info =
|
||||
Handle<InterceptorInfo>::cast(isolate()->factory()->NewStruct(
|
||||
Handle<InterceptorInfo>::cast(isolate->factory()->NewStruct(
|
||||
INTERCEPTOR_INFO_TYPE, AllocationType::kReadOnly));
|
||||
info->set_flags(0);
|
||||
set_noop_interceptor_info(*info);
|
||||
}
|
||||
|
||||
void Heap::CreateInitialReadOnlyObjects() {
|
||||
void Heap::CreateInitialObjects() {
|
||||
HandleScope initial_objects_handle_scope(isolate());
|
||||
Factory* factory = isolate()->factory();
|
||||
ReadOnlyRoots roots(this);
|
||||
@ -740,18 +687,15 @@ void Heap::CreateInitialReadOnlyObjects() {
|
||||
*factory->NewHeapNumber<AllocationType::kReadOnly>(V8_INFINITY));
|
||||
set_minus_infinity_value(
|
||||
*factory->NewHeapNumber<AllocationType::kReadOnly>(-V8_INFINITY));
|
||||
set_max_safe_integer(
|
||||
*factory->NewHeapNumber<AllocationType::kReadOnly>(kMaxSafeInteger));
|
||||
set_max_uint_32(
|
||||
*factory->NewHeapNumber<AllocationType::kReadOnly>(kMaxUInt32));
|
||||
set_smi_min_value(
|
||||
*factory->NewHeapNumber<AllocationType::kReadOnly>(kSmiMinValue));
|
||||
set_smi_max_value_plus_one(
|
||||
*factory->NewHeapNumber<AllocationType::kReadOnly>(0.0 - kSmiMinValue));
|
||||
|
||||
set_hash_seed(*factory->NewByteArray(kInt64Size, AllocationType::kReadOnly));
|
||||
InitializeHashSeed();
|
||||
|
||||
// There's no "current microtask" in the beginning.
|
||||
set_current_microtask(roots.undefined_value());
|
||||
|
||||
set_weak_refs_keep_during_job(roots.undefined_value());
|
||||
|
||||
// Allocate and initialize table for single character one byte strings.
|
||||
int table_size = String::kMaxOneByteCharCode + 1;
|
||||
set_single_character_string_table(
|
||||
@ -909,13 +853,54 @@ void Heap::CreateInitialReadOnlyObjects() {
|
||||
Handle<RegisteredSymbolTable> empty_symbol_table = RegisteredSymbolTable::New(
|
||||
isolate(), 1, AllocationType::kReadOnly, USE_CUSTOM_MINIMUM_CAPACITY);
|
||||
DCHECK(!empty_symbol_table->HasSufficientCapacityToAdd(1));
|
||||
set_empty_symbol_table(*empty_symbol_table);
|
||||
set_public_symbol_table(*empty_symbol_table);
|
||||
set_api_symbol_table(*empty_symbol_table);
|
||||
set_api_private_symbol_table(*empty_symbol_table);
|
||||
|
||||
set_number_string_cache(*factory->NewFixedArray(
|
||||
kInitialNumberStringCacheSize * 2, AllocationType::kOld));
|
||||
|
||||
set_basic_block_profiling_data(roots.empty_array_list());
|
||||
|
||||
// Allocate cache for string split and regexp-multiple.
|
||||
set_string_split_cache(*factory->NewFixedArray(
|
||||
RegExpResultsCache::kRegExpResultsCacheSize, AllocationType::kOld));
|
||||
set_regexp_multiple_cache(*factory->NewFixedArray(
|
||||
RegExpResultsCache::kRegExpResultsCacheSize, AllocationType::kOld));
|
||||
|
||||
// Allocate FeedbackCell for builtins.
|
||||
Handle<FeedbackCell> many_closures_cell =
|
||||
factory->NewManyClosuresCell(factory->undefined_value());
|
||||
set_many_closures_cell(*many_closures_cell);
|
||||
|
||||
set_detached_contexts(roots.empty_weak_array_list());
|
||||
set_retaining_path_targets(roots.empty_weak_array_list());
|
||||
|
||||
set_feedback_vectors_for_profiling_tools(roots.undefined_value());
|
||||
set_functions_marked_for_manual_optimization(roots.undefined_value());
|
||||
set_shared_wasm_memories(roots.empty_weak_array_list());
|
||||
set_locals_block_list_cache(roots.undefined_value());
|
||||
#ifdef V8_ENABLE_WEBASSEMBLY
|
||||
set_active_continuation(roots.undefined_value());
|
||||
set_active_suspender(roots.undefined_value());
|
||||
set_js_to_wasm_wrappers(roots.empty_weak_array_list());
|
||||
set_wasm_canonical_rtts(roots.empty_weak_array_list());
|
||||
#endif // V8_ENABLE_WEBASSEMBLY
|
||||
|
||||
set_script_list(roots.empty_weak_array_list());
|
||||
|
||||
Handle<NumberDictionary> slow_element_dictionary = NumberDictionary::New(
|
||||
isolate(), 1, AllocationType::kReadOnly, USE_CUSTOM_MINIMUM_CAPACITY);
|
||||
DCHECK(!slow_element_dictionary->HasSufficientCapacityToAdd(1));
|
||||
set_empty_slow_element_dictionary(*slow_element_dictionary);
|
||||
|
||||
set_materialized_objects(*factory->NewFixedArray(0, AllocationType::kOld));
|
||||
|
||||
// Handling of script id generation is in Heap::NextScriptId().
|
||||
set_last_script_id(Smi::FromInt(v8::UnboundScript::kNoScriptId));
|
||||
set_last_debugging_id(Smi::FromInt(DebugInfo::kNoDebuggingId));
|
||||
set_next_template_serial_number(Smi::zero());
|
||||
|
||||
// Allocate the empty OrderedHashMap.
|
||||
Handle<OrderedHashMap> empty_ordered_hash_map =
|
||||
OrderedHashMap::AllocateEmpty(isolate(), AllocationType::kReadOnly)
|
||||
@ -957,81 +942,6 @@ void Heap::CreateInitialReadOnlyObjects() {
|
||||
ScopeInfo::CreateForNativeContext(isolate());
|
||||
set_native_scope_info(*native_scope_info);
|
||||
|
||||
// Canonical off-heap trampoline data
|
||||
set_off_heap_trampoline_relocation_info(
|
||||
*Builtins::GenerateOffHeapTrampolineRelocInfo(isolate_));
|
||||
|
||||
if (V8_EXTERNAL_CODE_SPACE_BOOL) {
|
||||
// These roots will not be used.
|
||||
HeapObject no_container = *isolate()->factory()->undefined_value();
|
||||
set_trampoline_trivial_code_data_container(no_container);
|
||||
set_trampoline_promise_rejection_code_data_container(no_container);
|
||||
|
||||
} else {
|
||||
set_trampoline_trivial_code_data_container(
|
||||
*isolate()->factory()->NewCodeDataContainer(0,
|
||||
AllocationType::kReadOnly));
|
||||
|
||||
set_trampoline_promise_rejection_code_data_container(
|
||||
*isolate()->factory()->NewCodeDataContainer(
|
||||
Code::IsPromiseRejectionField::encode(true),
|
||||
AllocationType::kReadOnly));
|
||||
}
|
||||
}
|
||||
|
||||
void Heap::CreateInitialMutableObjects() {
|
||||
HandleScope initial_objects_handle_scope(isolate());
|
||||
Factory* factory = isolate()->factory();
|
||||
ReadOnlyRoots roots(this);
|
||||
|
||||
// There's no "current microtask" in the beginning.
|
||||
set_current_microtask(roots.undefined_value());
|
||||
|
||||
set_weak_refs_keep_during_job(roots.undefined_value());
|
||||
|
||||
set_public_symbol_table(roots.empty_symbol_table());
|
||||
set_api_symbol_table(roots.empty_symbol_table());
|
||||
set_api_private_symbol_table(roots.empty_symbol_table());
|
||||
|
||||
set_number_string_cache(*factory->NewFixedArray(
|
||||
kInitialNumberStringCacheSize * 2, AllocationType::kOld));
|
||||
|
||||
set_basic_block_profiling_data(roots.empty_array_list());
|
||||
|
||||
// Allocate cache for string split and regexp-multiple.
|
||||
set_string_split_cache(*factory->NewFixedArray(
|
||||
RegExpResultsCache::kRegExpResultsCacheSize, AllocationType::kOld));
|
||||
set_regexp_multiple_cache(*factory->NewFixedArray(
|
||||
RegExpResultsCache::kRegExpResultsCacheSize, AllocationType::kOld));
|
||||
|
||||
// Allocate FeedbackCell for builtins.
|
||||
Handle<FeedbackCell> many_closures_cell =
|
||||
factory->NewManyClosuresCell(factory->undefined_value());
|
||||
set_many_closures_cell(*many_closures_cell);
|
||||
|
||||
set_detached_contexts(roots.empty_weak_array_list());
|
||||
set_retaining_path_targets(roots.empty_weak_array_list());
|
||||
|
||||
set_feedback_vectors_for_profiling_tools(roots.undefined_value());
|
||||
set_functions_marked_for_manual_optimization(roots.undefined_value());
|
||||
set_shared_wasm_memories(roots.empty_weak_array_list());
|
||||
set_locals_block_list_cache(roots.undefined_value());
|
||||
#ifdef V8_ENABLE_WEBASSEMBLY
|
||||
set_active_continuation(roots.undefined_value());
|
||||
set_active_suspender(roots.undefined_value());
|
||||
set_js_to_wasm_wrappers(roots.empty_weak_array_list());
|
||||
set_wasm_canonical_rtts(roots.empty_weak_array_list());
|
||||
#endif // V8_ENABLE_WEBASSEMBLY
|
||||
|
||||
set_script_list(roots.empty_weak_array_list());
|
||||
|
||||
set_materialized_objects(*factory->NewFixedArray(0, AllocationType::kOld));
|
||||
|
||||
// Handling of script id generation is in Heap::NextScriptId().
|
||||
set_last_script_id(Smi::FromInt(v8::UnboundScript::kNoScriptId));
|
||||
set_last_debugging_id(Smi::FromInt(DebugInfo::kNoDebuggingId));
|
||||
set_next_template_serial_number(Smi::zero());
|
||||
|
||||
// Allocate the empty script.
|
||||
Handle<Script> script = factory->NewScript(factory->empty_string());
|
||||
script->set_type(Script::TYPE_NATIVE);
|
||||
@ -1062,6 +972,27 @@ void Heap::CreateInitialMutableObjects() {
|
||||
set_serialized_objects(roots.empty_fixed_array());
|
||||
set_serialized_global_proxy_sizes(roots.empty_fixed_array());
|
||||
|
||||
/* Canonical off-heap trampoline data */
|
||||
set_off_heap_trampoline_relocation_info(
|
||||
*Builtins::GenerateOffHeapTrampolineRelocInfo(isolate_));
|
||||
|
||||
if (V8_EXTERNAL_CODE_SPACE_BOOL) {
|
||||
// These roots will not be used.
|
||||
HeapObject no_container = *isolate()->factory()->undefined_value();
|
||||
set_trampoline_trivial_code_data_container(no_container);
|
||||
set_trampoline_promise_rejection_code_data_container(no_container);
|
||||
|
||||
} else {
|
||||
set_trampoline_trivial_code_data_container(
|
||||
*isolate()->factory()->NewCodeDataContainer(0,
|
||||
AllocationType::kReadOnly));
|
||||
|
||||
set_trampoline_promise_rejection_code_data_container(
|
||||
*isolate()->factory()->NewCodeDataContainer(
|
||||
Code::IsPromiseRejectionField::encode(true),
|
||||
AllocationType::kReadOnly));
|
||||
}
|
||||
|
||||
// Evaluate the hash values which will then be cached in the strings.
|
||||
isolate()->factory()->zero_string()->EnsureHash();
|
||||
isolate()->factory()->one_string()->EnsureHash();
|
||||
|
||||
@ -56,17 +56,5 @@ READ_ONLY_ROOT_LIST(ROOT_TYPE_CHECK)
|
||||
#undef ROOT_TYPE_CHECK
|
||||
#endif
|
||||
|
||||
Handle<HeapNumber> ReadOnlyRoots::FindHeapNumber(double value) {
|
||||
auto bits = base::bit_cast<uint64_t>(value);
|
||||
for (auto pos = RootIndex::kFirstHeapNumberRoot;
|
||||
pos <= RootIndex::kLastHeapNumberRoot; ++pos) {
|
||||
auto root = HeapNumber::cast(Object(at(pos)));
|
||||
if (base::bit_cast<uint64_t>(root.value()) == bits) {
|
||||
return Handle<HeapNumber>(GetLocation(pos));
|
||||
}
|
||||
}
|
||||
return Handle<HeapNumber>();
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
} // namespace v8
|
||||
|
||||
@ -34,18 +34,6 @@ class RootVisitor;
|
||||
class String;
|
||||
class Symbol;
|
||||
|
||||
#define STRONG_READ_ONLY_HEAP_NUMBER_ROOT_LIST(V) \
|
||||
/* Special numbers */ \
|
||||
V(HeapNumber, nan_value, NanValue) \
|
||||
V(HeapNumber, hole_nan_value, HoleNanValue) \
|
||||
V(HeapNumber, infinity_value, InfinityValue) \
|
||||
V(HeapNumber, minus_zero_value, MinusZeroValue) \
|
||||
V(HeapNumber, minus_infinity_value, MinusInfinityValue) \
|
||||
V(HeapNumber, max_safe_integer, MaxSafeInteger) \
|
||||
V(HeapNumber, max_uint_32, MaxUInt32) \
|
||||
V(HeapNumber, smi_min_value, SmiMinValue) \
|
||||
V(HeapNumber, smi_max_value_plus_one, SmiMaxValuePlusOne)
|
||||
|
||||
// Defines all the read-only roots in Heap.
|
||||
#define STRONG_READ_ONLY_ROOT_LIST(V) \
|
||||
/* Cluster the most popular ones in a few cache lines here at the top. */ \
|
||||
@ -211,7 +199,12 @@ class Symbol;
|
||||
V(WeakFixedArray, empty_weak_fixed_array, EmptyWeakFixedArray) \
|
||||
V(WeakArrayList, empty_weak_array_list, EmptyWeakArrayList) \
|
||||
V(Cell, invalid_prototype_validity_cell, InvalidPrototypeValidityCell) \
|
||||
STRONG_READ_ONLY_HEAP_NUMBER_ROOT_LIST(V) \
|
||||
/* Special numbers */ \
|
||||
V(HeapNumber, nan_value, NanValue) \
|
||||
V(HeapNumber, hole_nan_value, HoleNanValue) \
|
||||
V(HeapNumber, infinity_value, InfinityValue) \
|
||||
V(HeapNumber, minus_zero_value, MinusZeroValue) \
|
||||
V(HeapNumber, minus_infinity_value, MinusInfinityValue) \
|
||||
/* Table of strings of one-byte single characters */ \
|
||||
V(FixedArray, single_character_string_table, SingleCharacterStringTable) \
|
||||
/* Marker for self-references during code-generation */ \
|
||||
@ -229,7 +222,6 @@ class Symbol;
|
||||
V(ScopeInfo, global_this_binding_scope_info, GlobalThisBindingScopeInfo) \
|
||||
V(ScopeInfo, empty_function_scope_info, EmptyFunctionScopeInfo) \
|
||||
V(ScopeInfo, native_scope_info, NativeScopeInfo) \
|
||||
V(RegisteredSymbolTable, empty_symbol_table, EmptySymbolTable) \
|
||||
/* Hash seed */ \
|
||||
V(ByteArray, hash_seed, HashSeed)
|
||||
|
||||
@ -439,9 +431,6 @@ enum class RootIndex : uint16_t {
|
||||
kFirstReadOnlyRoot = kFirstRoot,
|
||||
kLastReadOnlyRoot = kFirstReadOnlyRoot + kReadOnlyRootsCount - 1,
|
||||
|
||||
kFirstHeapNumberRoot = kNanValue,
|
||||
kLastHeapNumberRoot = kSmiMaxValuePlusOne,
|
||||
|
||||
// Use for fast protector update checks
|
||||
kFirstNameForProtector = kconstructor_string,
|
||||
kNameForProtectorCount = 0 NAME_FOR_PROTECTOR_ROOT_LIST(COUNT_ROOT),
|
||||
@ -527,12 +516,6 @@ class RootsTable {
|
||||
static_cast<unsigned>(RootIndex::kLastImmortalImmovableRoot);
|
||||
}
|
||||
|
||||
static constexpr bool IsReadOnly(RootIndex root_index) {
|
||||
static_assert(static_cast<int>(RootIndex::kFirstReadOnlyRoot) == 0);
|
||||
return static_cast<unsigned>(root_index) <=
|
||||
static_cast<unsigned>(RootIndex::kLastReadOnlyRoot);
|
||||
}
|
||||
|
||||
private:
|
||||
FullObjectSlot begin() {
|
||||
return FullObjectSlot(&roots_[static_cast<size_t>(RootIndex::kFirstRoot)]);
|
||||
@ -631,10 +614,6 @@ class ReadOnlyRoots {
|
||||
void VerifyNameForProtectors();
|
||||
#endif
|
||||
|
||||
// Returns heap number with identical value if it already exists or the empty
|
||||
// handle otherwise.
|
||||
Handle<HeapNumber> FindHeapNumber(double value);
|
||||
|
||||
// Get the address of a given read-only root index, without type checks.
|
||||
V8_INLINE Address at(RootIndex root_index) const;
|
||||
|
||||
|
||||
@ -125,17 +125,6 @@ class TestSerializer {
|
||||
return v8_isolate;
|
||||
}
|
||||
|
||||
static v8::Isolate* NewIsolateFromReadOnlySnapshot(
|
||||
SnapshotData* read_only_snapshot) {
|
||||
const bool kEnableSerializer = false;
|
||||
const bool kIsShared = false;
|
||||
v8::Isolate* v8_isolate = NewIsolate(kEnableSerializer, kIsShared);
|
||||
v8::Isolate::Scope isolate_scope(v8_isolate);
|
||||
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
|
||||
isolate->InitWithReadOnlySnapshot(read_only_snapshot);
|
||||
return v8_isolate;
|
||||
}
|
||||
|
||||
static void InitializeProcessWideSharedIsolateFromBlob(
|
||||
const StartupBlobs& blobs) {
|
||||
base::MutexGuard guard(
|
||||
@ -5307,52 +5296,5 @@ UNINITIALIZED_TEST(BreakPointAccessorContextSnapshot) {
|
||||
FreeCurrentEmbeddedBlob();
|
||||
}
|
||||
|
||||
#if V8_EXTERNAL_CODE_SPACE_BOOL
|
||||
UNINITIALIZED_TEST(CreateIsolateFromReadOnlySnapshot) {
|
||||
auto working_builtins = [](v8::Isolate* isolate) {
|
||||
v8::Isolate::Scope i_scope(isolate);
|
||||
v8::HandleScope h_scope(isolate);
|
||||
v8::Local<v8::Context> context = v8::Context::New(isolate);
|
||||
v8::Context::Scope c_scope(context);
|
||||
v8::Maybe<int32_t> result = CompileRun("(function(x){return +x+40})(\"2\")")
|
||||
->Int32Value(isolate->GetCurrentContext());
|
||||
CHECK_EQ(42, result.FromJust());
|
||||
};
|
||||
|
||||
v8::Isolate* isolate1 = TestSerializer::NewIsolateInitialized();
|
||||
StartupBlobs blobs1 = Serialize(isolate1);
|
||||
auto ro1 = SnapshotData(blobs1.read_only);
|
||||
isolate1->Dispose();
|
||||
|
||||
v8::Isolate* isolate2 = TestSerializer::NewIsolateFromReadOnlySnapshot(&ro1);
|
||||
auto blobs2 = Serialize(isolate2);
|
||||
auto ro2 = SnapshotData(blobs2.read_only);
|
||||
isolate2->Dispose();
|
||||
|
||||
v8::Isolate* isolate3 = TestSerializer::NewIsolateFromReadOnlySnapshot(&ro2);
|
||||
auto blobs3 = Serialize(isolate3);
|
||||
auto ro3 = SnapshotData(blobs3.read_only);
|
||||
isolate3->Dispose();
|
||||
|
||||
v8::Isolate* isolate4 = TestSerializer::NewIsolateFromBlob(blobs2);
|
||||
working_builtins(isolate4);
|
||||
isolate4->Dispose();
|
||||
v8::Isolate* isolate5 = TestSerializer::NewIsolateFromBlob(blobs3);
|
||||
working_builtins(isolate5);
|
||||
isolate5->Dispose();
|
||||
|
||||
// The first snapshot is not stable since the serializer does not preserve the
|
||||
// order of objects in the read only heap.
|
||||
CHECK_EQ(blobs2.startup, blobs3.startup);
|
||||
CHECK_EQ(blobs2.shared_space, blobs3.shared_space);
|
||||
CHECK_EQ(blobs2.read_only, blobs3.read_only);
|
||||
|
||||
blobs1.Dispose();
|
||||
blobs2.Dispose();
|
||||
blobs3.Dispose();
|
||||
FreeCurrentEmbeddedBlob();
|
||||
}
|
||||
#endif // V8_EXTERNAL_CODE_SPACE_BOOL
|
||||
|
||||
} // namespace internal
|
||||
} // namespace v8
|
||||
|
||||
@ -93,17 +93,6 @@ TEST_F(RootsTest, TestHeapRootsNotReadOnly) {
|
||||
MUTABLE_ROOT_LIST(CHECK_NOT_IN_RO_SPACE)
|
||||
}
|
||||
|
||||
TEST_F(RootsTest, TestHeapNumberList) {
|
||||
ReadOnlyRoots roots(isolate());
|
||||
for (auto pos = RootIndex::kFirstReadOnlyRoot;
|
||||
pos <= RootIndex::kLastReadOnlyRoot; ++pos) {
|
||||
auto obj = Object(roots.at(pos));
|
||||
bool in_nr_range = pos >= RootIndex::kFirstHeapNumberRoot &&
|
||||
pos <= RootIndex::kLastHeapNumberRoot;
|
||||
CHECK_EQ(obj.IsHeapNumber(), in_nr_range);
|
||||
}
|
||||
}
|
||||
|
||||
#undef CHECK_NOT_IN_RO_SPACE
|
||||
|
||||
} // namespace internal
|
||||
|
||||
@ -4,7 +4,7 @@ tools/gcmole/gcmole-test.cc:30:10: warning: Possibly stale variable due to GCs.
|
||||
tools/gcmole/gcmole-test.cc:28:20: note: Call might cause unexpected GC.
|
||||
isolate->heap()->CollectGarbage(OLD_SPACE, GarbageCollectionReason::kTesting);
|
||||
^
|
||||
./src/heap/heap.h:983:21: note: GC call here.
|
||||
./src/heap/heap.h:981:21: note: GC call here.
|
||||
V8_EXPORT_PRIVATE bool CollectGarbage(
|
||||
^
|
||||
tools/gcmole/gcmole-test.cc:48:3: warning: Possible problem with evaluation order with interleaved GCs.
|
||||
|
||||
@ -394,75 +394,75 @@ KNOWN_MAPS = {
|
||||
("read_only_space", 0x03499): (131, "BasicBlockCountersMarkerMap"),
|
||||
("read_only_space", 0x034dd): (146, "ArrayBoilerplateDescriptionMap"),
|
||||
("read_only_space", 0x035dd): (158, "InterceptorInfoMap"),
|
||||
("read_only_space", 0x0763d): (132, "PromiseFulfillReactionJobTaskMap"),
|
||||
("read_only_space", 0x07665): (133, "PromiseRejectReactionJobTaskMap"),
|
||||
("read_only_space", 0x0768d): (134, "CallableTaskMap"),
|
||||
("read_only_space", 0x076b5): (135, "CallbackTaskMap"),
|
||||
("read_only_space", 0x076dd): (136, "PromiseResolveThenableJobTaskMap"),
|
||||
("read_only_space", 0x07705): (139, "FunctionTemplateInfoMap"),
|
||||
("read_only_space", 0x0772d): (140, "ObjectTemplateInfoMap"),
|
||||
("read_only_space", 0x07755): (141, "AccessCheckInfoMap"),
|
||||
("read_only_space", 0x0777d): (142, "AccessorPairMap"),
|
||||
("read_only_space", 0x077a5): (143, "AliasedArgumentsEntryMap"),
|
||||
("read_only_space", 0x077cd): (144, "AllocationMementoMap"),
|
||||
("read_only_space", 0x077f5): (147, "AsmWasmDataMap"),
|
||||
("read_only_space", 0x0781d): (148, "AsyncGeneratorRequestMap"),
|
||||
("read_only_space", 0x07845): (149, "BreakPointMap"),
|
||||
("read_only_space", 0x0786d): (150, "BreakPointInfoMap"),
|
||||
("read_only_space", 0x07895): (151, "CallSiteInfoMap"),
|
||||
("read_only_space", 0x078bd): (152, "ClassPositionsMap"),
|
||||
("read_only_space", 0x078e5): (153, "DebugInfoMap"),
|
||||
("read_only_space", 0x0790d): (155, "ErrorStackDataMap"),
|
||||
("read_only_space", 0x07935): (157, "FunctionTemplateRareDataMap"),
|
||||
("read_only_space", 0x0795d): (159, "InterpreterDataMap"),
|
||||
("read_only_space", 0x07985): (160, "ModuleRequestMap"),
|
||||
("read_only_space", 0x079ad): (161, "PromiseCapabilityMap"),
|
||||
("read_only_space", 0x079d5): (162, "PromiseOnStackMap"),
|
||||
("read_only_space", 0x079fd): (163, "PromiseReactionMap"),
|
||||
("read_only_space", 0x07a25): (164, "PropertyDescriptorObjectMap"),
|
||||
("read_only_space", 0x07a4d): (165, "PrototypeInfoMap"),
|
||||
("read_only_space", 0x07a75): (166, "RegExpBoilerplateDescriptionMap"),
|
||||
("read_only_space", 0x07a9d): (167, "ScriptMap"),
|
||||
("read_only_space", 0x07ac5): (168, "ScriptOrModuleMap"),
|
||||
("read_only_space", 0x07aed): (169, "SourceTextModuleInfoEntryMap"),
|
||||
("read_only_space", 0x07b15): (170, "StackFrameInfoMap"),
|
||||
("read_only_space", 0x07b3d): (171, "TemplateObjectDescriptionMap"),
|
||||
("read_only_space", 0x07b65): (172, "Tuple2Map"),
|
||||
("read_only_space", 0x07b8d): (173, "WasmExceptionTagMap"),
|
||||
("read_only_space", 0x07bb5): (174, "WasmIndirectFunctionTableMap"),
|
||||
("read_only_space", 0x07bdd): (194, "SloppyArgumentsElementsMap"),
|
||||
("read_only_space", 0x07c05): (227, "DescriptorArrayMap"),
|
||||
("read_only_space", 0x07c2d): (202, "UncompiledDataWithoutPreparseDataMap"),
|
||||
("read_only_space", 0x07c55): (200, "UncompiledDataWithPreparseDataMap"),
|
||||
("read_only_space", 0x07c7d): (203, "UncompiledDataWithoutPreparseDataWithJobMap"),
|
||||
("read_only_space", 0x07ca5): (201, "UncompiledDataWithPreparseDataAndJobMap"),
|
||||
("read_only_space", 0x07ccd): (248, "OnHeapBasicBlockProfilerDataMap"),
|
||||
("read_only_space", 0x07cf5): (195, "TurbofanBitsetTypeMap"),
|
||||
("read_only_space", 0x07d1d): (199, "TurbofanUnionTypeMap"),
|
||||
("read_only_space", 0x07d45): (198, "TurbofanRangeTypeMap"),
|
||||
("read_only_space", 0x07d6d): (196, "TurbofanHeapConstantTypeMap"),
|
||||
("read_only_space", 0x07d95): (197, "TurbofanOtherNumberConstantTypeMap"),
|
||||
("read_only_space", 0x07dbd): (244, "InternalClassMap"),
|
||||
("read_only_space", 0x07de5): (255, "SmiPairMap"),
|
||||
("read_only_space", 0x07e0d): (254, "SmiBoxMap"),
|
||||
("read_only_space", 0x07e35): (219, "ExportedSubClassBaseMap"),
|
||||
("read_only_space", 0x07e5d): (220, "ExportedSubClassMap"),
|
||||
("read_only_space", 0x07e85): (225, "AbstractInternalClassSubclass1Map"),
|
||||
("read_only_space", 0x07ead): (226, "AbstractInternalClassSubclass2Map"),
|
||||
("read_only_space", 0x07ed5): (193, "InternalClassWithSmiElementsMap"),
|
||||
("read_only_space", 0x07efd): (245, "InternalClassWithStructElementsMap"),
|
||||
("read_only_space", 0x07f25): (221, "ExportedSubClass2Map"),
|
||||
("read_only_space", 0x07f4d): (256, "SortStateMap"),
|
||||
("read_only_space", 0x07f75): (262, "WasmStringViewIterMap"),
|
||||
("read_only_space", 0x07f9d): (145, "AllocationSiteWithWeakNextMap"),
|
||||
("read_only_space", 0x07fc5): (145, "AllocationSiteWithoutWeakNextMap"),
|
||||
("read_only_space", 0x08091): (137, "LoadHandler1Map"),
|
||||
("read_only_space", 0x080b9): (137, "LoadHandler2Map"),
|
||||
("read_only_space", 0x080e1): (137, "LoadHandler3Map"),
|
||||
("read_only_space", 0x08109): (138, "StoreHandler0Map"),
|
||||
("read_only_space", 0x08131): (138, "StoreHandler1Map"),
|
||||
("read_only_space", 0x08159): (138, "StoreHandler2Map"),
|
||||
("read_only_space", 0x08181): (138, "StoreHandler3Map"),
|
||||
("read_only_space", 0x075f1): (132, "PromiseFulfillReactionJobTaskMap"),
|
||||
("read_only_space", 0x07619): (133, "PromiseRejectReactionJobTaskMap"),
|
||||
("read_only_space", 0x07641): (134, "CallableTaskMap"),
|
||||
("read_only_space", 0x07669): (135, "CallbackTaskMap"),
|
||||
("read_only_space", 0x07691): (136, "PromiseResolveThenableJobTaskMap"),
|
||||
("read_only_space", 0x076b9): (139, "FunctionTemplateInfoMap"),
|
||||
("read_only_space", 0x076e1): (140, "ObjectTemplateInfoMap"),
|
||||
("read_only_space", 0x07709): (141, "AccessCheckInfoMap"),
|
||||
("read_only_space", 0x07731): (142, "AccessorPairMap"),
|
||||
("read_only_space", 0x07759): (143, "AliasedArgumentsEntryMap"),
|
||||
("read_only_space", 0x07781): (144, "AllocationMementoMap"),
|
||||
("read_only_space", 0x077a9): (147, "AsmWasmDataMap"),
|
||||
("read_only_space", 0x077d1): (148, "AsyncGeneratorRequestMap"),
|
||||
("read_only_space", 0x077f9): (149, "BreakPointMap"),
|
||||
("read_only_space", 0x07821): (150, "BreakPointInfoMap"),
|
||||
("read_only_space", 0x07849): (151, "CallSiteInfoMap"),
|
||||
("read_only_space", 0x07871): (152, "ClassPositionsMap"),
|
||||
("read_only_space", 0x07899): (153, "DebugInfoMap"),
|
||||
("read_only_space", 0x078c1): (155, "ErrorStackDataMap"),
|
||||
("read_only_space", 0x078e9): (157, "FunctionTemplateRareDataMap"),
|
||||
("read_only_space", 0x07911): (159, "InterpreterDataMap"),
|
||||
("read_only_space", 0x07939): (160, "ModuleRequestMap"),
|
||||
("read_only_space", 0x07961): (161, "PromiseCapabilityMap"),
|
||||
("read_only_space", 0x07989): (162, "PromiseOnStackMap"),
|
||||
("read_only_space", 0x079b1): (163, "PromiseReactionMap"),
|
||||
("read_only_space", 0x079d9): (164, "PropertyDescriptorObjectMap"),
|
||||
("read_only_space", 0x07a01): (165, "PrototypeInfoMap"),
|
||||
("read_only_space", 0x07a29): (166, "RegExpBoilerplateDescriptionMap"),
|
||||
("read_only_space", 0x07a51): (167, "ScriptMap"),
|
||||
("read_only_space", 0x07a79): (168, "ScriptOrModuleMap"),
|
||||
("read_only_space", 0x07aa1): (169, "SourceTextModuleInfoEntryMap"),
|
||||
("read_only_space", 0x07ac9): (170, "StackFrameInfoMap"),
|
||||
("read_only_space", 0x07af1): (171, "TemplateObjectDescriptionMap"),
|
||||
("read_only_space", 0x07b19): (172, "Tuple2Map"),
|
||||
("read_only_space", 0x07b41): (173, "WasmExceptionTagMap"),
|
||||
("read_only_space", 0x07b69): (174, "WasmIndirectFunctionTableMap"),
|
||||
("read_only_space", 0x07b91): (194, "SloppyArgumentsElementsMap"),
|
||||
("read_only_space", 0x07bb9): (227, "DescriptorArrayMap"),
|
||||
("read_only_space", 0x07be1): (202, "UncompiledDataWithoutPreparseDataMap"),
|
||||
("read_only_space", 0x07c09): (200, "UncompiledDataWithPreparseDataMap"),
|
||||
("read_only_space", 0x07c31): (203, "UncompiledDataWithoutPreparseDataWithJobMap"),
|
||||
("read_only_space", 0x07c59): (201, "UncompiledDataWithPreparseDataAndJobMap"),
|
||||
("read_only_space", 0x07c81): (248, "OnHeapBasicBlockProfilerDataMap"),
|
||||
("read_only_space", 0x07ca9): (195, "TurbofanBitsetTypeMap"),
|
||||
("read_only_space", 0x07cd1): (199, "TurbofanUnionTypeMap"),
|
||||
("read_only_space", 0x07cf9): (198, "TurbofanRangeTypeMap"),
|
||||
("read_only_space", 0x07d21): (196, "TurbofanHeapConstantTypeMap"),
|
||||
("read_only_space", 0x07d49): (197, "TurbofanOtherNumberConstantTypeMap"),
|
||||
("read_only_space", 0x07d71): (244, "InternalClassMap"),
|
||||
("read_only_space", 0x07d99): (255, "SmiPairMap"),
|
||||
("read_only_space", 0x07dc1): (254, "SmiBoxMap"),
|
||||
("read_only_space", 0x07de9): (219, "ExportedSubClassBaseMap"),
|
||||
("read_only_space", 0x07e11): (220, "ExportedSubClassMap"),
|
||||
("read_only_space", 0x07e39): (225, "AbstractInternalClassSubclass1Map"),
|
||||
("read_only_space", 0x07e61): (226, "AbstractInternalClassSubclass2Map"),
|
||||
("read_only_space", 0x07e89): (193, "InternalClassWithSmiElementsMap"),
|
||||
("read_only_space", 0x07eb1): (245, "InternalClassWithStructElementsMap"),
|
||||
("read_only_space", 0x07ed9): (221, "ExportedSubClass2Map"),
|
||||
("read_only_space", 0x07f01): (256, "SortStateMap"),
|
||||
("read_only_space", 0x07f29): (262, "WasmStringViewIterMap"),
|
||||
("read_only_space", 0x07f51): (145, "AllocationSiteWithWeakNextMap"),
|
||||
("read_only_space", 0x07f79): (145, "AllocationSiteWithoutWeakNextMap"),
|
||||
("read_only_space", 0x08045): (137, "LoadHandler1Map"),
|
||||
("read_only_space", 0x0806d): (137, "LoadHandler2Map"),
|
||||
("read_only_space", 0x08095): (137, "LoadHandler3Map"),
|
||||
("read_only_space", 0x080bd): (138, "StoreHandler0Map"),
|
||||
("read_only_space", 0x080e5): (138, "StoreHandler1Map"),
|
||||
("read_only_space", 0x0810d): (138, "StoreHandler2Map"),
|
||||
("read_only_space", 0x08135): (138, "StoreHandler3Map"),
|
||||
("old_space", 0x0438d): (2116, "ExternalMap"),
|
||||
("old_space", 0x043b5): (2120, "JSMessageObjectMap"),
|
||||
}
|
||||
@ -507,19 +507,14 @@ KNOWN_OBJECTS = {
|
||||
("read_only_space", 0x03649): "InfinityValue",
|
||||
("read_only_space", 0x03655): "MinusZeroValue",
|
||||
("read_only_space", 0x03661): "MinusInfinityValue",
|
||||
("read_only_space", 0x0366d): "MaxSafeInteger",
|
||||
("read_only_space", 0x03679): "MaxUInt32",
|
||||
("read_only_space", 0x03685): "SmiMinValue",
|
||||
("read_only_space", 0x03691): "SmiMaxValuePlusOne",
|
||||
("read_only_space", 0x0369d): "SingleCharacterStringTable",
|
||||
("read_only_space", 0x04aa5): "SelfReferenceMarker",
|
||||
("read_only_space", 0x04ae5): "BasicBlockCountersMarker",
|
||||
("read_only_space", 0x04b29): "OffHeapTrampolineRelocationInfo",
|
||||
("read_only_space", 0x04b35): "GlobalThisBindingScopeInfo",
|
||||
("read_only_space", 0x04b65): "EmptyFunctionScopeInfo",
|
||||
("read_only_space", 0x04b89): "NativeScopeInfo",
|
||||
("read_only_space", 0x04ba1): "EmptySymbolTable",
|
||||
("read_only_space", 0x04bbd): "HashSeed",
|
||||
("read_only_space", 0x0366d): "SingleCharacterStringTable",
|
||||
("read_only_space", 0x04a75): "SelfReferenceMarker",
|
||||
("read_only_space", 0x04ab5): "BasicBlockCountersMarker",
|
||||
("read_only_space", 0x04af9): "OffHeapTrampolineRelocationInfo",
|
||||
("read_only_space", 0x04b05): "GlobalThisBindingScopeInfo",
|
||||
("read_only_space", 0x04b35): "EmptyFunctionScopeInfo",
|
||||
("read_only_space", 0x04b59): "NativeScopeInfo",
|
||||
("read_only_space", 0x04b71): "HashSeed",
|
||||
("old_space", 0x0423d): "ArgumentsIteratorAccessor",
|
||||
("old_space", 0x04255): "ArrayLengthAccessor",
|
||||
("old_space", 0x0426d): "BoundFunctionLengthAccessor",
|
||||
@ -558,30 +553,30 @@ KNOWN_OBJECTS = {
|
||||
("old_space", 0x04581): "StringSplitCache",
|
||||
("old_space", 0x04989): "RegExpMultipleCache",
|
||||
("old_space", 0x04d91): "BuiltinsConstantsTable",
|
||||
("old_space", 0x051b9): "AsyncFunctionAwaitRejectSharedFun",
|
||||
("old_space", 0x051dd): "AsyncFunctionAwaitResolveSharedFun",
|
||||
("old_space", 0x05201): "AsyncGeneratorAwaitRejectSharedFun",
|
||||
("old_space", 0x05225): "AsyncGeneratorAwaitResolveSharedFun",
|
||||
("old_space", 0x05249): "AsyncGeneratorYieldWithAwaitResolveSharedFun",
|
||||
("old_space", 0x0526d): "AsyncGeneratorReturnResolveSharedFun",
|
||||
("old_space", 0x05291): "AsyncGeneratorReturnClosedRejectSharedFun",
|
||||
("old_space", 0x052b5): "AsyncGeneratorReturnClosedResolveSharedFun",
|
||||
("old_space", 0x052d9): "AsyncIteratorValueUnwrapSharedFun",
|
||||
("old_space", 0x052fd): "PromiseAllResolveElementSharedFun",
|
||||
("old_space", 0x05321): "PromiseAllSettledResolveElementSharedFun",
|
||||
("old_space", 0x05345): "PromiseAllSettledRejectElementSharedFun",
|
||||
("old_space", 0x05369): "PromiseAnyRejectElementSharedFun",
|
||||
("old_space", 0x0538d): "PromiseCapabilityDefaultRejectSharedFun",
|
||||
("old_space", 0x053b1): "PromiseCapabilityDefaultResolveSharedFun",
|
||||
("old_space", 0x053d5): "PromiseCatchFinallySharedFun",
|
||||
("old_space", 0x053f9): "PromiseGetCapabilitiesExecutorSharedFun",
|
||||
("old_space", 0x0541d): "PromiseThenFinallySharedFun",
|
||||
("old_space", 0x05441): "PromiseThrowerFinallySharedFun",
|
||||
("old_space", 0x05465): "PromiseValueThunkFinallySharedFun",
|
||||
("old_space", 0x05489): "ProxyRevokeSharedFun",
|
||||
("old_space", 0x054ad): "ShadowRealmImportValueFulfilledSFI",
|
||||
("old_space", 0x054d1): "SourceTextModuleExecuteAsyncModuleFulfilledSFI",
|
||||
("old_space", 0x054f5): "SourceTextModuleExecuteAsyncModuleRejectedSFI",
|
||||
("old_space", 0x051f9): "AsyncFunctionAwaitRejectSharedFun",
|
||||
("old_space", 0x0521d): "AsyncFunctionAwaitResolveSharedFun",
|
||||
("old_space", 0x05241): "AsyncGeneratorAwaitRejectSharedFun",
|
||||
("old_space", 0x05265): "AsyncGeneratorAwaitResolveSharedFun",
|
||||
("old_space", 0x05289): "AsyncGeneratorYieldWithAwaitResolveSharedFun",
|
||||
("old_space", 0x052ad): "AsyncGeneratorReturnResolveSharedFun",
|
||||
("old_space", 0x052d1): "AsyncGeneratorReturnClosedRejectSharedFun",
|
||||
("old_space", 0x052f5): "AsyncGeneratorReturnClosedResolveSharedFun",
|
||||
("old_space", 0x05319): "AsyncIteratorValueUnwrapSharedFun",
|
||||
("old_space", 0x0533d): "PromiseAllResolveElementSharedFun",
|
||||
("old_space", 0x05361): "PromiseAllSettledResolveElementSharedFun",
|
||||
("old_space", 0x05385): "PromiseAllSettledRejectElementSharedFun",
|
||||
("old_space", 0x053a9): "PromiseAnyRejectElementSharedFun",
|
||||
("old_space", 0x053cd): "PromiseCapabilityDefaultRejectSharedFun",
|
||||
("old_space", 0x053f1): "PromiseCapabilityDefaultResolveSharedFun",
|
||||
("old_space", 0x05415): "PromiseCatchFinallySharedFun",
|
||||
("old_space", 0x05439): "PromiseGetCapabilitiesExecutorSharedFun",
|
||||
("old_space", 0x0545d): "PromiseThenFinallySharedFun",
|
||||
("old_space", 0x05481): "PromiseThrowerFinallySharedFun",
|
||||
("old_space", 0x054a5): "PromiseValueThunkFinallySharedFun",
|
||||
("old_space", 0x054c9): "ProxyRevokeSharedFun",
|
||||
("old_space", 0x054ed): "ShadowRealmImportValueFulfilledSFI",
|
||||
("old_space", 0x05511): "SourceTextModuleExecuteAsyncModuleFulfilledSFI",
|
||||
("old_space", 0x05535): "SourceTextModuleExecuteAsyncModuleRejectedSFI",
|
||||
}
|
||||
|
||||
# Lower 32 bits of first page addresses for various heap spaces.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user