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

[dict-proto] C++ implementation of SwissNameDictionary, pt. 1

Browse Source 
This CL is part of a series that adds the C++ implementation of
SwissNameDictionary, a deterministic property backing store based on
Swiss Tables.

This CL contains most of the boilerplate code for introducing a new
instance type.

Bug: v8:11388
Change-Id: Id263b8138a8ce4b465fb28d968223d2e1aaf05a4
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2672030
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Nico Hartmann <nicohartmann@chromium.org>
Reviewed-by: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Marja Hölttä <marja@chromium.org>
Commit-Queue: Frank Emrich <emrich@google.com>
Cr-Commit-Position: refs/heads/master@{#72582}
This commit is contained in:
Frank Emrich 2021-02-05 13:20:38 +01:00 committed by Commit Bot
parent 811d73aa3d
commit 70e49b1722
25 changed files with 475 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
BUILD.gn
View File

@ -1412,6 +1412,7 @@ torque_files = [
"src/objects/stack-frame-info.tq",
"src/objects/string.tq",
"src/objects/struct.tq",
"src/objects/swiss-name-dictionary.tq",
"src/objects/synthetic-module.tq",
"src/objects/template-objects.tq",
"src/objects/templates.tq",
@ -3255,6 +3256,9 @@ v8_source_set("v8_base_without_compiler") {
"src/objects/string.h",
"src/objects/struct-inl.h",
"src/objects/struct.h",
"src/objects/swiss-name-dictionary-inl.h",
"src/objects/swiss-name-dictionary.cc",
"src/objects/swiss-name-dictionary.h",
"src/objects/synthetic-module-inl.h",
"src/objects/synthetic-module.cc",
"src/objects/synthetic-module.h",

2
src/builtins/base.tq
View File

@ -430,6 +430,8 @@ const kNameDictionaryInitialCapacity:
constexpr int32 generates 'NameDictionary::kInitialCapacity';
const kOrderedNameDictionaryInitialCapacity:
constexpr int32 generates 'OrderedNameDictionary::kInitialCapacity';
const kSwissNameDictionaryGroupWidth:
constexpr int32 generates 'SwissNameDictionary::kGroupWidth';
const kWasmArrayHeaderSize:
constexpr int32 generates 'WasmArray::kHeaderSize';

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

@ -21,6 +21,7 @@
#include "src/objects/promise.h"
#include "src/objects/shared-function-info.h"
#include "src/objects/smi.h"
#include "src/objects/swiss-name-dictionary.h"
#include "src/objects/tagged-index.h"
#include "src/roots/roots.h"
#include "torque-generated/exported-macros-assembler.h"

2
src/common/globals.h
View File

@ -1698,6 +1698,8 @@ enum class StubCallMode {
constexpr int kFunctionLiteralIdInvalid = -1;
constexpr int kFunctionLiteralIdTopLevel = 0;
constexpr int kSwissNameDictionaryInitialCapacity = 4;
constexpr int kSmallOrderedHashSetMinCapacity = 4;
constexpr int kSmallOrderedHashMapMinCapacity = 4;

6
src/diagnostics/objects-debug.cc
View File

@ -69,6 +69,7 @@
#include "src/objects/property-descriptor-object-inl.h"
#include "src/objects/stack-frame-info-inl.h"
#include "src/objects/struct-inl.h"
#include "src/objects/swiss-name-dictionary-inl.h"
#include "src/objects/synthetic-module-inl.h"
#include "src/objects/template-objects-inl.h"
#include "src/objects/torque-defined-classes-inl.h"
@ -1255,6 +1256,11 @@ void SmallOrderedNameDictionary::SmallOrderedNameDictionaryVerify(
}
}
void SwissNameDictionary::SwissNameDictionaryVerify(Isolate* isolate) {
// TODO(v8:11388) Here to satisfy compiler, implemented in follow-up CL.
UNREACHABLE();
}
void JSRegExp::JSRegExpVerify(Isolate* isolate) {
TorqueGeneratedClassVerifiers::JSRegExpVerify(*this, isolate);
switch (TypeTag()) {

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

@ -945,6 +945,11 @@ void OrderedNameDictionary::OrderedNameDictionaryPrint(std::ostream& os) {
PrintDictionaryContentsFull(os, *this);
}
void SwissNameDictionary::SwissNameDictionaryPrint(std::ostream& os) {
// Here to satisfy compiler, implemented in follow-up CL.
UNREACHABLE();
}
void PropertyArray::PropertyArrayPrint(std::ostream& os) { // NOLINT
PrintHeader(os, "PropertyArray");
os << "\n - length: " << length();

1
src/handles/handles.h
View File

@ -32,6 +32,7 @@ class RootVisitor;
class SmallOrderedHashMap;
class SmallOrderedHashSet;
class SmallOrderedNameDictionary;
class SwissNameDictionary;
class WasmExportedFunctionData;
// ----------------------------------------------------------------------------

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

@ -47,6 +47,7 @@ namespace internal {
V(SmallOrderedHashSet) \
V(SmallOrderedNameDictionary) \
V(SourceTextModule) \
V(SwissNameDictionary) \
V(Symbol) \
V(SyntheticModule) \
V(TransitionArray) \

1
src/heap/setup-heap-internal.cc
View File

@ -470,6 +470,7 @@ bool Heap::CreateInitialMaps() {
ALLOCATE_VARSIZE_MAP(ORDERED_HASH_SET_TYPE, ordered_hash_set)
ALLOCATE_VARSIZE_MAP(ORDERED_NAME_DICTIONARY_TYPE, ordered_name_dictionary)
ALLOCATE_VARSIZE_MAP(NAME_DICTIONARY_TYPE, name_dictionary)
ALLOCATE_VARSIZE_MAP(SWISS_NAME_DICTIONARY_TYPE, swiss_name_dictionary)
ALLOCATE_VARSIZE_MAP(GLOBAL_DICTIONARY_TYPE, global_dictionary)
ALLOCATE_VARSIZE_MAP(NUMBER_DICTIONARY_TYPE, number_dictionary)
ALLOCATE_VARSIZE_MAP(SIMPLE_NUMBER_DICTIONARY_TYPE,

1
src/objects/all-objects-inl.h
View File

@ -78,6 +78,7 @@
#include "src/objects/string-set-inl.h"
#include "src/objects/string-table-inl.h"
#include "src/objects/struct-inl.h"
#include "src/objects/swiss-name-dictionary-inl.h"
#include "src/objects/synthetic-module-inl.h"
#include "src/objects/tagged-field-inl.h"
#include "src/objects/tagged-impl-inl.h"

69
src/objects/instance-type.h
View File

@ -238,40 +238,41 @@ TYPED_ARRAYS(TYPED_ARRAY_IS_TYPE_FUNCTION_DECL)
// This list must contain only maps that are shared by all objects of their
// instance type.
#define UNIQUE_INSTANCE_TYPE_MAP_LIST_GENERATOR(V, _) \
V(_, AccessorInfoMap, accessor_info_map, AccessorInfo) \
V(_, AccessorPairMap, accessor_pair_map, AccessorPair) \
V(_, AllocationMementoMap, allocation_memento_map, AllocationMemento) \
V(_, ArrayBoilerplateDescriptionMap, array_boilerplate_description_map, \
ArrayBoilerplateDescription) \
V(_, BreakPointMap, break_point_map, BreakPoint) \
V(_, BreakPointInfoMap, break_point_info_map, BreakPointInfo) \
V(_, CachedTemplateObjectMap, cached_template_object_map, \
CachedTemplateObject) \
V(_, CellMap, cell_map, Cell) \
V(_, WeakCellMap, weak_cell_map, WeakCell) \
V(_, CodeMap, code_map, Code) \
V(_, CoverageInfoMap, coverage_info_map, CoverageInfo) \
V(_, DebugInfoMap, debug_info_map, DebugInfo) \
V(_, FeedbackVectorMap, feedback_vector_map, FeedbackVector) \
V(_, FixedDoubleArrayMap, fixed_double_array_map, FixedDoubleArray) \
V(_, FunctionTemplateInfoMap, function_template_info_map, \
FunctionTemplateInfo) \
V(_, HeapNumberMap, heap_number_map, HeapNumber) \
V(_, MetaMap, meta_map, Map) \
V(_, PreparseDataMap, preparse_data_map, PreparseData) \
V(_, PrototypeInfoMap, prototype_info_map, PrototypeInfo) \
V(_, SharedFunctionInfoMap, shared_function_info_map, SharedFunctionInfo) \
V(_, SmallOrderedHashSetMap, small_ordered_hash_set_map, \
SmallOrderedHashSet) \
V(_, SmallOrderedHashMapMap, small_ordered_hash_map_map, \
SmallOrderedHashMap) \
V(_, SmallOrderedNameDictionaryMap, small_ordered_name_dictionary_map, \
SmallOrderedNameDictionary) \
V(_, SymbolMap, symbol_map, Symbol) \
V(_, TransitionArrayMap, transition_array_map, TransitionArray) \
V(_, Tuple2Map, tuple2_map, Tuple2) \
V(_, WeakFixedArrayMap, weak_fixed_array_map, WeakFixedArray) \
#define UNIQUE_INSTANCE_TYPE_MAP_LIST_GENERATOR(V, _) \
V(_, AccessorInfoMap, accessor_info_map, AccessorInfo) \
V(_, AccessorPairMap, accessor_pair_map, AccessorPair) \
V(_, AllocationMementoMap, allocation_memento_map, AllocationMemento) \
V(_, ArrayBoilerplateDescriptionMap, array_boilerplate_description_map, \
ArrayBoilerplateDescription) \
V(_, BreakPointMap, break_point_map, BreakPoint) \
V(_, BreakPointInfoMap, break_point_info_map, BreakPointInfo) \
V(_, CachedTemplateObjectMap, cached_template_object_map, \
CachedTemplateObject) \
V(_, CellMap, cell_map, Cell) \
V(_, WeakCellMap, weak_cell_map, WeakCell) \
V(_, CodeMap, code_map, Code) \
V(_, CoverageInfoMap, coverage_info_map, CoverageInfo) \
V(_, DebugInfoMap, debug_info_map, DebugInfo) \
V(_, FeedbackVectorMap, feedback_vector_map, FeedbackVector) \
V(_, FixedDoubleArrayMap, fixed_double_array_map, FixedDoubleArray) \
V(_, FunctionTemplateInfoMap, function_template_info_map, \
FunctionTemplateInfo) \
V(_, HeapNumberMap, heap_number_map, HeapNumber) \
V(_, MetaMap, meta_map, Map) \
V(_, PreparseDataMap, preparse_data_map, PreparseData) \
V(_, PrototypeInfoMap, prototype_info_map, PrototypeInfo) \
V(_, SharedFunctionInfoMap, shared_function_info_map, SharedFunctionInfo) \
V(_, SmallOrderedHashSetMap, small_ordered_hash_set_map, \
SmallOrderedHashSet) \
V(_, SmallOrderedHashMapMap, small_ordered_hash_map_map, \
SmallOrderedHashMap) \
V(_, SmallOrderedNameDictionaryMap, small_ordered_name_dictionary_map, \
SmallOrderedNameDictionary) \
V(_, SwissNameDictionaryMap, swiss_name_dictionary_map, SwissNameDictionary) \
V(_, SymbolMap, symbol_map, Symbol) \
V(_, TransitionArrayMap, transition_array_map, TransitionArray) \
V(_, Tuple2Map, tuple2_map, Tuple2) \
V(_, WeakFixedArrayMap, weak_fixed_array_map, WeakFixedArray) \
TORQUE_DEFINED_MAP_CSA_LIST_GENERATOR(V, _)
} // namespace internal

3
src/objects/map.cc
View File

@ -242,6 +242,9 @@ VisitorId Map::GetVisitorId(Map map) {
case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
return kVisitSmallOrderedNameDictionary;
case SWISS_NAME_DICTIONARY_TYPE:
return kVisitSwissNameDictionary;
case CODE_DATA_CONTAINER_TYPE:
return kVisitCodeDataContainer;

1
src/objects/map.h
View File

@ -64,6 +64,7 @@ enum InstanceType : uint16_t;
V(SmallOrderedNameDictionary) \
V(SourceTextModule) \
V(Struct) \
V(SwissNameDictionary) \
V(Symbol) \
V(SyntheticModule) \
V(TransitionArray) \

1
src/objects/object-list-macros.h
View File

@ -207,6 +207,7 @@ class ZoneForwardList;
V(StringSet) \
V(StringWrapper) \
V(Struct) \
V(SwissNameDictionary) \
V(Symbol) \
V(SymbolWrapper) \
V(SyntheticModule) \

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

@ -19,6 +19,7 @@
#include "src/objects/oddball.h"
#include "src/objects/ordered-hash-table-inl.h"
#include "src/objects/source-text-module.h"
#include "src/objects/swiss-name-dictionary-inl.h"
#include "src/objects/synthetic-module.h"
#include "src/objects/torque-defined-classes-inl.h"
#include "src/objects/transitions.h"
@ -403,6 +404,38 @@ class V8_EXPORT_PRIVATE SmallOrderedHashTable<Derived>::BodyDescriptor final
}
};
class V8_EXPORT_PRIVATE SwissNameDictionary::BodyDescriptor final
: public BodyDescriptorBase {
public:
static bool IsValidSlot(Map map, HeapObject obj, int offset) {
// Using |unchecked_cast| here and elsewhere in this class because the
// Scavenger may be calling us while the map word contains the forwarding
// address (a Smi) rather than a map.
SwissNameDictionary table = SwissNameDictionary::unchecked_cast(obj);
STATIC_ASSERT(MetaTablePointerOffset() + kTaggedSize ==
DataTableStartOffset());
return offset >= MetaTablePointerOffset() &&
(offset < table.DataTableEndOffset(table.Capacity()));
}
template <typename ObjectVisitor>
static inline void IterateBody(Map map, HeapObject obj, int object_size,
ObjectVisitor* v) {
SwissNameDictionary table = SwissNameDictionary::unchecked_cast(obj);
STATIC_ASSERT(MetaTablePointerOffset() + kTaggedSize ==
DataTableStartOffset());
int start_offset = MetaTablePointerOffset();
int end_offset = table.DataTableEndOffset(table.Capacity());
IteratePointers(obj, start_offset, end_offset, v);
}
static inline int SizeOf(Map map, HeapObject obj) {
SwissNameDictionary table = SwissNameDictionary::unchecked_cast(obj);
return SwissNameDictionary::SizeFor(table.Capacity());
}
};
class ByteArray::BodyDescriptor final : public BodyDescriptorBase {
public:
static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
@ -1050,6 +1083,11 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
return Op::template apply<
SmallOrderedHashTable<SmallOrderedNameDictionary>::BodyDescriptor>(
p1, p2, p3, p4);
case SWISS_NAME_DICTIONARY_TYPE:
return Op::template apply<SwissNameDictionary::BodyDescriptor>(p1, p2, p3,
p4);
case CODE_DATA_CONTAINER_TYPE:
return Op::template apply<CodeDataContainer::BodyDescriptor>(p1, p2, p3,
p4);

4
src/objects/objects.cc
View File

@ -2285,6 +2285,10 @@ int HeapObject::SizeFromMap(Map map) const {
return SmallOrderedNameDictionary::SizeFor(
SmallOrderedNameDictionary::unchecked_cast(*this).Capacity());
}
if (instance_type == SWISS_NAME_DICTIONARY_TYPE) {
return SwissNameDictionary::SizeFor(
SwissNameDictionary::unchecked_cast(*this).Capacity());
}
if (instance_type == PROPERTY_ARRAY_TYPE) {
return PropertyArray::SizeFor(
PropertyArray::cast(*this).synchronized_length());

1
src/objects/objects.h
View File

@ -188,6 +188,7 @@
// - UncompiledData
// - UncompiledDataWithoutPreparseData
// - UncompiledDataWithPreparseData
// - SwissNameDictionary
//
// Formats of Object::ptr_:
// Smi: [31 bit signed int] 0

97
src/objects/swiss-name-dictionary-inl.h Normal file
View File

@ -0,0 +1,97 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_OBJECTS_SWISS_NAME_DICTIONARY_INL_H_
#define V8_OBJECTS_SWISS_NAME_DICTIONARY_INL_H_
#include "src/base/macros.h"
#include "src/execution/isolate-utils-inl.h"
#include "src/heap/heap.h"
#include "src/objects/fixed-array-inl.h"
#include "src/objects/instance-type-inl.h"
#include "src/objects/js-collection-iterator.h"
#include "src/objects/objects-inl.h"
#include "src/objects/smi.h"
#include "src/objects/swiss-name-dictionary.h"
// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"
namespace v8 {
namespace internal {
#include "torque-generated/src/objects/swiss-name-dictionary-tq-inl.inc"
CAST_ACCESSOR(SwissNameDictionary)
OBJECT_CONSTRUCTORS_IMPL(SwissNameDictionary, HeapObject)
int SwissNameDictionary::Capacity() {
return ReadField<int32_t>(CapacityOffset());
}
// static
bool SwissNameDictionary::IsValidCapacity(int capacity) {
return capacity == 0 || (capacity >= kInitialCapacity &&
// Must be power of 2.
((capacity & (capacity - 1)) == 0));
}
// static
constexpr int SwissNameDictionary::DataTableSize(int capacity) {
return capacity * kTaggedSize * kDataTableEntryCount;
}
// static
constexpr int SwissNameDictionary::CtrlTableSize(int capacity) {
// Doing + |kGroupWidth| due to the copy of first group at the end of control
// table.
return (capacity + kGroupWidth) * kOneByteSize;
}
// static
constexpr int SwissNameDictionary::SizeFor(int capacity) {
DCHECK(IsValidCapacity(capacity));
return PropertyDetailsTableStartOffset(capacity) + capacity;
}
// static
constexpr int SwissNameDictionary::PrefixOffset() {
return HeapObject::kHeaderSize;
}
// static
constexpr int SwissNameDictionary::CapacityOffset() {
return PrefixOffset() + sizeof(uint32_t);
}
// static
constexpr int SwissNameDictionary::MetaTablePointerOffset() {
return CapacityOffset() + sizeof(int32_t);
}
// static
constexpr int SwissNameDictionary::DataTableStartOffset() {
return MetaTablePointerOffset() + kTaggedSize;
}
// static
constexpr int SwissNameDictionary::DataTableEndOffset(int capacity) {
return CtrlTableStartOffset(capacity);
}
// static
constexpr int SwissNameDictionary::CtrlTableStartOffset(int capacity) {
return DataTableStartOffset() + DataTableSize(capacity);
}
// static
constexpr int SwissNameDictionary::PropertyDetailsTableStartOffset(
int capacity) {
return CtrlTableStartOffset(capacity) + CtrlTableSize(capacity);
}
} // namespace internal
} // namespace v8
#endif // V8_OBJECTS_SWISS_NAME_DICTIONARY_INL_H_

12
src/objects/swiss-name-dictionary.cc Normal file
View File

@ -0,0 +1,12 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Only including the -inl.h file directly makes the linter complain.
#include "src/objects/swiss-name-dictionary.h"
#include "src/objects/swiss-name-dictionary-inl.h"
namespace v8 {
namespace internal {} // namespace internal
} // namespace v8

117
src/objects/swiss-name-dictionary.h Normal file
View File

@ -0,0 +1,117 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_OBJECTS_SWISS_NAME_DICTIONARY_H_
#define V8_OBJECTS_SWISS_NAME_DICTIONARY_H_
#include "src/base/export-template.h"
#include "src/common/globals.h"
#include "src/objects/fixed-array.h"
#include "src/objects/internal-index.h"
#include "src/objects/js-objects.h"
#include "src/roots/roots.h"
// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"
namespace v8 {
namespace internal {
// A property backing store based on Swiss Tables/Abseil's flat_hash_map. The
// implementation is heavily based on Abseil's raw_hash_set.h.
//
// Memory layout (see below for detailed description of parts):
// Prefix: [table type dependent part, can have 0 size]
// Capacity: 4 bytes, raw int32_t
// Meta table pointer: kTaggedSize bytes
// Data table: 2 * |capacity| * |kTaggedSize| bytes
// Ctrl table: |capacity| + |kGroupWidth| uint8_t entries
// PropertyDetails table: |capacity| uint_8 entries
//
// Note that because of |kInitialCapacity| == 4 there is no need for padding.
//
// Description of parts directly contained in SwissNameDictionary allocation:
// Prefix:
// In case of SwissNameDictionary:
// identity hash: 4 bytes, raw int32_t
// Meta table pointer: kTaggedSize bytes.
// See below for explanation of the meta table.
// For capacity 0, this contains the Smi |kNoMetaTableSentinel| instead.
// Data table:
// For each logical bucket of the hash table, contains the corresponding key
// and value.
// Ctrl table:
// The control table is used to implement a Swiss Table: Each byte is either
// Ctrl::kEmpty, Ctrl::kDeleted, or in case of a bucket denoting a present
// entry in the hash table, the 7 lowest bits of the key's hash. The first
// |capacity| entries are the actual control table. The additional
// |kGroupWidth| bytes contain a copy of the first min(capacity,
// kGroupWidth) bytes of the table.
// PropertyDetails table:
// Each byte contains the PropertyDetails for the corresponding bucket of
// the ctrl table. Entries may contain unitialized data if the corresponding
// bucket hasn't been used before.
//
// Meta table:
// The meta table (not to be confused with the control table used in any
// Swiss Table design!) is a separate ByteArray. Here, the "X" in "uintX_t"
// depends on the capacity of the swiss table. For capacities <= 256 we have X
// = 8, for 256 < |capacity| <= 2^16 we have X = 16, and otherwise X = 32 (see
// MetaTableSizePerEntryFor). It contais the following data:
// Number of Entries: uintX_t.
// Number of Deleted Entries: uintX_t.
// Enumeration table: max_load_factor * Capacity() entries of type uintX_t:
// The i-th entry in the enumeration table
// contains the number of the bucket representing the i-th entry of the
// table in enumeration order. Entries may contain unitialized data if the
// corresponding bucket hasn't been used before.
class SwissNameDictionary : public HeapObject {
public:
inline int Capacity();
inline static bool IsValidCapacity(int capacity);
// Returns total size in bytes required for a table of given capacity.
inline static constexpr int SizeFor(int capacity);
// TODO(v8:11388) This is a temporary placeholder for the actual value, which
// is added here in a follow-up CL.
static const int kGroupWidth = 8;
class BodyDescriptor;
// Note that 0 is also a valid capacity. Changing this value to a smaller one
// may make some padding necessary in the data layout.
static constexpr int kInitialCapacity = kSwissNameDictionaryInitialCapacity;
// Defines how many kTaggedSize sized values are associcated which each entry
// in the data table.
static constexpr int kDataTableEntryCount = 2;
inline static constexpr int DataTableSize(int capacity);
inline static constexpr int CtrlTableSize(int capacity);
// TODO(v8:11388) We would like to use Torque-generated constants here, but
// those are currently incorrect.
// Offset into the overall table, starting at HeapObject standard fields,
// in bytes. This means that the map is stored at offset 0.
using Offset = int;
inline static constexpr Offset PrefixOffset();
inline static constexpr Offset CapacityOffset();
inline static constexpr Offset MetaTablePointerOffset();
inline static constexpr Offset DataTableStartOffset();
inline static constexpr Offset DataTableEndOffset(int capacity);
inline static constexpr Offset CtrlTableStartOffset(int capacity);
inline static constexpr Offset PropertyDetailsTableStartOffset(int capacity);
DECL_VERIFIER(SwissNameDictionary)
DECL_PRINTER(SwissNameDictionary)
DECL_CAST(SwissNameDictionary)
OBJECT_CONSTRUCTORS(SwissNameDictionary, HeapObject);
};
} // namespace internal
} // namespace v8
#endif // V8_OBJECTS_SWISS_NAME_DICTIONARY_H_

15
src/objects/swiss-name-dictionary.tq Normal file
View File

@ -0,0 +1,15 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include 'src/objects/swiss-name-dictionary.h'
@noVerifier
extern class SwissNameDictionary extends HeapObject {
hash: uint32;
const capacity: int32;
meta_table: ByteArray;
data_table[Convert<intptr>(capacity) * 2]: JSAny|TheHole;
ctrl_table[Convert<intptr>(capacity) + kSwissNameDictionaryGroupWidth]: uint8;
property_details_table[Convert<intptr>(capacity)]: uint8;
}

1
src/roots/roots-inl.h
View File

@ -21,6 +21,7 @@
#include "src/objects/scope-info.h"
#include "src/objects/slots.h"
#include "src/objects/string.h"
#include "src/objects/swiss-name-dictionary.h"
#include "src/roots/roots.h"
namespace v8 {

1
src/roots/roots.h
View File

@ -108,6 +108,7 @@ class Symbol;
V(Map, small_ordered_hash_set_map, SmallOrderedHashSetMap) \
V(Map, small_ordered_name_dictionary_map, SmallOrderedNameDictionaryMap) \
V(Map, source_text_module_map, SourceTextModuleMap) \
V(Map, swiss_name_dictionary_map, SwissNameDictionaryMap) \
V(Map, synthetic_module_map, SyntheticModuleMap) \
V(Map, wasm_type_info_map, WasmTypeInfoMap) \
V(Map, weak_fixed_array_map, WeakFixedArrayMap) \

1
src/torque/implementation-visitor.cc
View File

@ -4911,6 +4911,7 @@ void ImplementationVisitor::GenerateExportedMacrosAssembler(
cc_contents << "#include \"src/objects/js-regexp-string-iterator.h\"\n";
cc_contents << "#include \"src/objects/ordered-hash-table.h\"\n";
cc_contents << "#include \"src/objects/property-descriptor-object.h\"\n";
cc_contents << "#include \"src/objects/swiss-name-dictionary.h\"\n";
cc_contents << "#include \"src/objects/synthetic-module.h\"\n";
cc_contents << "#include \"src/objects/template-objects.h\"\n";
{

246
tools/v8heapconst.py
View File

@ -141,16 +141,17 @@ INSTANCE_TYPES = {
177: "SMI_BOX_TYPE",
178: "SMI_PAIR_TYPE",
179: "SORT_STATE_TYPE",
180: "WASM_ARRAY_TYPE",
181: "WASM_CAPI_FUNCTION_DATA_TYPE",
182: "WASM_STRUCT_TYPE",
183: "WEAK_ARRAY_LIST_TYPE",
184: "WEAK_CELL_TYPE",
185: "JS_PROXY_TYPE",
180: "SWISS_NAME_DICTIONARY_TYPE",
181: "WASM_ARRAY_TYPE",
182: "WASM_CAPI_FUNCTION_DATA_TYPE",
183: "WASM_STRUCT_TYPE",
184: "WEAK_ARRAY_LIST_TYPE",
185: "WEAK_CELL_TYPE",
186: "JS_PROXY_TYPE",
1057: "JS_OBJECT_TYPE",
186: "JS_GLOBAL_OBJECT_TYPE",
187: "JS_GLOBAL_PROXY_TYPE",
188: "JS_MODULE_NAMESPACE_TYPE",
187: "JS_GLOBAL_OBJECT_TYPE",
188: "JS_GLOBAL_PROXY_TYPE",
189: "JS_MODULE_NAMESPACE_TYPE",
1040: "JS_SPECIAL_API_OBJECT_TYPE",
1041: "JS_PRIMITIVE_WRAPPER_TYPE",
1042: "JS_ARRAY_ITERATOR_PROTOTYPE_TYPE",
@ -296,94 +297,95 @@ KNOWN_MAPS = {
("read_only_space", 0x02d69): (150, "SmallOrderedHashSetMap"),
("read_only_space", 0x02d91): (151, "SmallOrderedNameDictionaryMap"),
("read_only_space", 0x02db9): (154, "SourceTextModuleMap"),
("read_only_space", 0x02de1): (155, "SyntheticModuleMap"),
("read_only_space", 0x02e09): (71, "WasmTypeInfoMap"),
("read_only_space", 0x02e31): (183, "WeakArrayListMap"),
("read_only_space", 0x02e59): (119, "EphemeronHashTableMap"),
("read_only_space", 0x02e81): (164, "EmbedderDataArrayMap"),
("read_only_space", 0x02ea9): (184, "WeakCellMap"),
("read_only_space", 0x02ed1): (32, "StringMap"),
("read_only_space", 0x02ef9): (41, "ConsOneByteStringMap"),
("read_only_space", 0x02f21): (33, "ConsStringMap"),
("read_only_space", 0x02f49): (37, "ThinStringMap"),
("read_only_space", 0x02f71): (35, "SlicedStringMap"),
("read_only_space", 0x02f99): (43, "SlicedOneByteStringMap"),
("read_only_space", 0x02fc1): (34, "ExternalStringMap"),
("read_only_space", 0x02fe9): (42, "ExternalOneByteStringMap"),
("read_only_space", 0x03011): (50, "UncachedExternalStringMap"),
("read_only_space", 0x03039): (0, "InternalizedStringMap"),
("read_only_space", 0x03061): (2, "ExternalInternalizedStringMap"),
("read_only_space", 0x03089): (10, "ExternalOneByteInternalizedStringMap"),
("read_only_space", 0x030b1): (18, "UncachedExternalInternalizedStringMap"),
("read_only_space", 0x030d9): (26, "UncachedExternalOneByteInternalizedStringMap"),
("read_only_space", 0x03101): (58, "UncachedExternalOneByteStringMap"),
("read_only_space", 0x03129): (67, "SelfReferenceMarkerMap"),
("read_only_space", 0x03151): (67, "BasicBlockCountersMarkerMap"),
("read_only_space", 0x03195): (87, "ArrayBoilerplateDescriptionMap"),
("read_only_space", 0x03269): (99, "InterceptorInfoMap"),
("read_only_space", 0x053e5): (72, "PromiseFulfillReactionJobTaskMap"),
("read_only_space", 0x0540d): (73, "PromiseRejectReactionJobTaskMap"),
("read_only_space", 0x05435): (74, "CallableTaskMap"),
("read_only_space", 0x0545d): (75, "CallbackTaskMap"),
("read_only_space", 0x05485): (76, "PromiseResolveThenableJobTaskMap"),
("read_only_space", 0x054ad): (79, "FunctionTemplateInfoMap"),
("read_only_space", 0x054d5): (80, "ObjectTemplateInfoMap"),
("read_only_space", 0x054fd): (81, "AccessCheckInfoMap"),
("read_only_space", 0x05525): (82, "AccessorInfoMap"),
("read_only_space", 0x0554d): (83, "AccessorPairMap"),
("read_only_space", 0x05575): (84, "AliasedArgumentsEntryMap"),
("read_only_space", 0x0559d): (85, "AllocationMementoMap"),
("read_only_space", 0x055c5): (88, "AsmWasmDataMap"),
("read_only_space", 0x055ed): (89, "AsyncGeneratorRequestMap"),
("read_only_space", 0x05615): (90, "BreakPointMap"),
("read_only_space", 0x0563d): (91, "BreakPointInfoMap"),
("read_only_space", 0x05665): (92, "CachedTemplateObjectMap"),
("read_only_space", 0x0568d): (94, "ClassPositionsMap"),
("read_only_space", 0x056b5): (95, "DebugInfoMap"),
("read_only_space", 0x056dd): (98, "FunctionTemplateRareDataMap"),
("read_only_space", 0x05705): (100, "InterpreterDataMap"),
("read_only_space", 0x0572d): (101, "ModuleRequestMap"),
("read_only_space", 0x05755): (102, "PromiseCapabilityMap"),
("read_only_space", 0x0577d): (103, "PromiseReactionMap"),
("read_only_space", 0x057a5): (104, "PropertyDescriptorObjectMap"),
("read_only_space", 0x057cd): (105, "PrototypeInfoMap"),
("read_only_space", 0x057f5): (106, "RegExpBoilerplateDescriptionMap"),
("read_only_space", 0x0581d): (107, "ScriptMap"),
("read_only_space", 0x05845): (108, "SourceTextModuleInfoEntryMap"),
("read_only_space", 0x0586d): (109, "StackFrameInfoMap"),
("read_only_space", 0x05895): (110, "StackTraceFrameMap"),
("read_only_space", 0x058bd): (111, "TemplateObjectDescriptionMap"),
("read_only_space", 0x058e5): (112, "Tuple2Map"),
("read_only_space", 0x0590d): (113, "WasmExceptionTagMap"),
("read_only_space", 0x05935): (114, "WasmExportedFunctionDataMap"),
("read_only_space", 0x0595d): (115, "WasmIndirectFunctionTableMap"),
("read_only_space", 0x05985): (116, "WasmJSFunctionDataMap"),
("read_only_space", 0x059ad): (135, "SloppyArgumentsElementsMap"),
("read_only_space", 0x059d5): (152, "DescriptorArrayMap"),
("read_only_space", 0x059fd): (157, "UncompiledDataWithoutPreparseDataMap"),
("read_only_space", 0x05a25): (156, "UncompiledDataWithPreparseDataMap"),
("read_only_space", 0x05a4d): (172, "OnHeapBasicBlockProfilerDataMap"),
("read_only_space", 0x05a75): (181, "WasmCapiFunctionDataMap"),
("read_only_space", 0x05a9d): (169, "InternalClassMap"),
("read_only_space", 0x05ac5): (178, "SmiPairMap"),
("read_only_space", 0x05aed): (177, "SmiBoxMap"),
("read_only_space", 0x05b15): (146, "ExportedSubClassBaseMap"),
("read_only_space", 0x05b3d): (147, "ExportedSubClassMap"),
("read_only_space", 0x05b65): (68, "AbstractInternalClassSubclass1Map"),
("read_only_space", 0x05b8d): (69, "AbstractInternalClassSubclass2Map"),
("read_only_space", 0x05bb5): (133, "InternalClassWithSmiElementsMap"),
("read_only_space", 0x05bdd): (170, "InternalClassWithStructElementsMap"),
("read_only_space", 0x05c05): (148, "ExportedSubClass2Map"),
("read_only_space", 0x05c2d): (179, "SortStateMap"),
("read_only_space", 0x05c55): (86, "AllocationSiteWithWeakNextMap"),
("read_only_space", 0x05c7d): (86, "AllocationSiteWithoutWeakNextMap"),
("read_only_space", 0x05ca5): (77, "LoadHandler1Map"),
("read_only_space", 0x05ccd): (77, "LoadHandler2Map"),
("read_only_space", 0x05cf5): (77, "LoadHandler3Map"),
("read_only_space", 0x05d1d): (78, "StoreHandler0Map"),
("read_only_space", 0x05d45): (78, "StoreHandler1Map"),
("read_only_space", 0x05d6d): (78, "StoreHandler2Map"),
("read_only_space", 0x05d95): (78, "StoreHandler3Map"),
("read_only_space", 0x02de1): (180, "SwissNameDictionaryMap"),
("read_only_space", 0x02e09): (155, "SyntheticModuleMap"),
("read_only_space", 0x02e31): (71, "WasmTypeInfoMap"),
("read_only_space", 0x02e59): (184, "WeakArrayListMap"),
("read_only_space", 0x02e81): (119, "EphemeronHashTableMap"),
("read_only_space", 0x02ea9): (164, "EmbedderDataArrayMap"),
("read_only_space", 0x02ed1): (185, "WeakCellMap"),
("read_only_space", 0x02ef9): (32, "StringMap"),
("read_only_space", 0x02f21): (41, "ConsOneByteStringMap"),
("read_only_space", 0x02f49): (33, "ConsStringMap"),
("read_only_space", 0x02f71): (37, "ThinStringMap"),
("read_only_space", 0x02f99): (35, "SlicedStringMap"),
("read_only_space", 0x02fc1): (43, "SlicedOneByteStringMap"),
("read_only_space", 0x02fe9): (34, "ExternalStringMap"),
("read_only_space", 0x03011): (42, "ExternalOneByteStringMap"),
("read_only_space", 0x03039): (50, "UncachedExternalStringMap"),
("read_only_space", 0x03061): (0, "InternalizedStringMap"),
("read_only_space", 0x03089): (2, "ExternalInternalizedStringMap"),
("read_only_space", 0x030b1): (10, "ExternalOneByteInternalizedStringMap"),
("read_only_space", 0x030d9): (18, "UncachedExternalInternalizedStringMap"),
("read_only_space", 0x03101): (26, "UncachedExternalOneByteInternalizedStringMap"),
("read_only_space", 0x03129): (58, "UncachedExternalOneByteStringMap"),
("read_only_space", 0x03151): (67, "SelfReferenceMarkerMap"),
("read_only_space", 0x03179): (67, "BasicBlockCountersMarkerMap"),
("read_only_space", 0x031bd): (87, "ArrayBoilerplateDescriptionMap"),
("read_only_space", 0x03291): (99, "InterceptorInfoMap"),
("read_only_space", 0x0540d): (72, "PromiseFulfillReactionJobTaskMap"),
("read_only_space", 0x05435): (73, "PromiseRejectReactionJobTaskMap"),
("read_only_space", 0x0545d): (74, "CallableTaskMap"),
("read_only_space", 0x05485): (75, "CallbackTaskMap"),
("read_only_space", 0x054ad): (76, "PromiseResolveThenableJobTaskMap"),
("read_only_space", 0x054d5): (79, "FunctionTemplateInfoMap"),
("read_only_space", 0x054fd): (80, "ObjectTemplateInfoMap"),
("read_only_space", 0x05525): (81, "AccessCheckInfoMap"),
("read_only_space", 0x0554d): (82, "AccessorInfoMap"),
("read_only_space", 0x05575): (83, "AccessorPairMap"),
("read_only_space", 0x0559d): (84, "AliasedArgumentsEntryMap"),
("read_only_space", 0x055c5): (85, "AllocationMementoMap"),
("read_only_space", 0x055ed): (88, "AsmWasmDataMap"),
("read_only_space", 0x05615): (89, "AsyncGeneratorRequestMap"),
("read_only_space", 0x0563d): (90, "BreakPointMap"),
("read_only_space", 0x05665): (91, "BreakPointInfoMap"),
("read_only_space", 0x0568d): (92, "CachedTemplateObjectMap"),
("read_only_space", 0x056b5): (94, "ClassPositionsMap"),
("read_only_space", 0x056dd): (95, "DebugInfoMap"),
("read_only_space", 0x05705): (98, "FunctionTemplateRareDataMap"),
("read_only_space", 0x0572d): (100, "InterpreterDataMap"),
("read_only_space", 0x05755): (101, "ModuleRequestMap"),
("read_only_space", 0x0577d): (102, "PromiseCapabilityMap"),
("read_only_space", 0x057a5): (103, "PromiseReactionMap"),
("read_only_space", 0x057cd): (104, "PropertyDescriptorObjectMap"),
("read_only_space", 0x057f5): (105, "PrototypeInfoMap"),
("read_only_space", 0x0581d): (106, "RegExpBoilerplateDescriptionMap"),
("read_only_space", 0x05845): (107, "ScriptMap"),
("read_only_space", 0x0586d): (108, "SourceTextModuleInfoEntryMap"),
("read_only_space", 0x05895): (109, "StackFrameInfoMap"),
("read_only_space", 0x058bd): (110, "StackTraceFrameMap"),
("read_only_space", 0x058e5): (111, "TemplateObjectDescriptionMap"),
("read_only_space", 0x0590d): (112, "Tuple2Map"),
("read_only_space", 0x05935): (113, "WasmExceptionTagMap"),
("read_only_space", 0x0595d): (114, "WasmExportedFunctionDataMap"),
("read_only_space", 0x05985): (115, "WasmIndirectFunctionTableMap"),
("read_only_space", 0x059ad): (116, "WasmJSFunctionDataMap"),
("read_only_space", 0x059d5): (135, "SloppyArgumentsElementsMap"),
("read_only_space", 0x059fd): (152, "DescriptorArrayMap"),
("read_only_space", 0x05a25): (157, "UncompiledDataWithoutPreparseDataMap"),
("read_only_space", 0x05a4d): (156, "UncompiledDataWithPreparseDataMap"),
("read_only_space", 0x05a75): (172, "OnHeapBasicBlockProfilerDataMap"),
("read_only_space", 0x05a9d): (182, "WasmCapiFunctionDataMap"),
("read_only_space", 0x05ac5): (169, "InternalClassMap"),
("read_only_space", 0x05aed): (178, "SmiPairMap"),
("read_only_space", 0x05b15): (177, "SmiBoxMap"),
("read_only_space", 0x05b3d): (146, "ExportedSubClassBaseMap"),
("read_only_space", 0x05b65): (147, "ExportedSubClassMap"),
("read_only_space", 0x05b8d): (68, "AbstractInternalClassSubclass1Map"),
("read_only_space", 0x05bb5): (69, "AbstractInternalClassSubclass2Map"),
("read_only_space", 0x05bdd): (133, "InternalClassWithSmiElementsMap"),
("read_only_space", 0x05c05): (170, "InternalClassWithStructElementsMap"),
("read_only_space", 0x05c2d): (148, "ExportedSubClass2Map"),
("read_only_space", 0x05c55): (179, "SortStateMap"),
("read_only_space", 0x05c7d): (86, "AllocationSiteWithWeakNextMap"),
("read_only_space", 0x05ca5): (86, "AllocationSiteWithoutWeakNextMap"),
("read_only_space", 0x05ccd): (77, "LoadHandler1Map"),
("read_only_space", 0x05cf5): (77, "LoadHandler2Map"),
("read_only_space", 0x05d1d): (77, "LoadHandler3Map"),
("read_only_space", 0x05d45): (78, "StoreHandler0Map"),
("read_only_space", 0x05d6d): (78, "StoreHandler1Map"),
("read_only_space", 0x05d95): (78, "StoreHandler2Map"),
("read_only_space", 0x05dbd): (78, "StoreHandler3Map"),
("map_space", 0x02119): (1057, "ExternalMap"),
("map_space", 0x02141): (1098, "JSMessageObjectMap"),
}
@ -409,31 +411,31 @@ KNOWN_OBJECTS = {
("read_only_space", 0x02831): "TerminationException",
("read_only_space", 0x02899): "OptimizedOut",
("read_only_space", 0x028f9): "StaleRegister",
("read_only_space", 0x03179): "EmptyPropertyArray",
("read_only_space", 0x03181): "EmptyByteArray",
("read_only_space", 0x03189): "EmptyObjectBoilerplateDescription",
("read_only_space", 0x031bd): "EmptyArrayBoilerplateDescription",
("read_only_space", 0x031c9): "EmptyClosureFeedbackCellArray",
("read_only_space", 0x031d1): "EmptySlowElementDictionary",
("read_only_space", 0x031f5): "EmptyOrderedHashMap",
("read_only_space", 0x03209): "EmptyOrderedHashSet",
("read_only_space", 0x0321d): "EmptyFeedbackMetadata",
("read_only_space", 0x03229): "EmptyPropertyDictionary",
("read_only_space", 0x03251): "EmptyOrderedPropertyDictionary",
("read_only_space", 0x03291): "NoOpInterceptorInfo",
("read_only_space", 0x032b9): "EmptyWeakArrayList",
("read_only_space", 0x032c5): "InfinityValue",
("read_only_space", 0x032d1): "MinusZeroValue",
("read_only_space", 0x032dd): "MinusInfinityValue",
("read_only_space", 0x032e9): "SelfReferenceMarker",
("read_only_space", 0x03329): "BasicBlockCountersMarker",
("read_only_space", 0x0336d): "OffHeapTrampolineRelocationInfo",
("read_only_space", 0x03379): "TrampolineTrivialCodeDataContainer",
("read_only_space", 0x03385): "TrampolinePromiseRejectionCodeDataContainer",
("read_only_space", 0x03391): "GlobalThisBindingScopeInfo",
("read_only_space", 0x033c9): "EmptyFunctionScopeInfo",
("read_only_space", 0x033f1): "NativeScopeInfo",
("read_only_space", 0x0340d): "HashSeed",
("read_only_space", 0x031a1): "EmptyPropertyArray",
("read_only_space", 0x031a9): "EmptyByteArray",
("read_only_space", 0x031b1): "EmptyObjectBoilerplateDescription",
("read_only_space", 0x031e5): "EmptyArrayBoilerplateDescription",
("read_only_space", 0x031f1): "EmptyClosureFeedbackCellArray",
("read_only_space", 0x031f9): "EmptySlowElementDictionary",
("read_only_space", 0x0321d): "EmptyOrderedHashMap",
("read_only_space", 0x03231): "EmptyOrderedHashSet",
("read_only_space", 0x03245): "EmptyFeedbackMetadata",
("read_only_space", 0x03251): "EmptyPropertyDictionary",
("read_only_space", 0x03279): "EmptyOrderedPropertyDictionary",
("read_only_space", 0x032b9): "NoOpInterceptorInfo",
("read_only_space", 0x032e1): "EmptyWeakArrayList",
("read_only_space", 0x032ed): "InfinityValue",
("read_only_space", 0x032f9): "MinusZeroValue",
("read_only_space", 0x03305): "MinusInfinityValue",
("read_only_space", 0x03311): "SelfReferenceMarker",
("read_only_space", 0x03351): "BasicBlockCountersMarker",
("read_only_space", 0x03395): "OffHeapTrampolineRelocationInfo",
("read_only_space", 0x033a1): "TrampolineTrivialCodeDataContainer",
("read_only_space", 0x033ad): "TrampolinePromiseRejectionCodeDataContainer",
("read_only_space", 0x033b9): "GlobalThisBindingScopeInfo",
("read_only_space", 0x033f1): "EmptyFunctionScopeInfo",
("read_only_space", 0x03419): "NativeScopeInfo",
("read_only_space", 0x03435): "HashSeed",
("old_space", 0x02119): "ArgumentsIteratorAccessor",
("old_space", 0x0215d): "ArrayLengthAccessor",
("old_space", 0x021a1): "BoundFunctionLengthAccessor",