Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2026-04-19 18:30:27 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibJS/Runtime/Object.h
Andreas Kling 614713ed08 LibJS: Replace IndexedProperties with inline Packed/Holey/Dictionary 
Replace the OwnPtr<IndexedPropertyStorage> indirection with inline
indexed element storage directly on Object. This eliminates virtual
dispatch and reduces indirection for indexed property access.

The new system uses three storage kinds tracked by IndexedStorageKind:

- Packed: Dense array, no holes. Elements stored in a malloced Value*
  array with capacity header (same layout as named properties).
- Holey: Dense array with possible holes marked by empty sentinel.
  Same physical layout as Packed.
- Dictionary: Sparse storage using GenericIndexedPropertyStorage,
  type-punned into the m_indexed_elements pointer.

Transitions: None->Packed->Holey->Dictionary (mostly monotonic).
Dictionary mode triggers on non-default attributes or sparse arrays.

Object keeps the same 48-byte size since m_indexed_elements (8 bytes)
replaces IndexedProperties (8 bytes), and the storage kind + array
size fit in existing padding alongside m_flags.

The asm interpreter benefits from one fewer indirection: it now reads
the element pointer and array size directly from Object fields instead
of chasing through OwnPtr -> IndexedPropertyStorage -> Vector.

Removes: IndexedProperties, SimpleIndexedPropertyStorage,
IndexedPropertyStorage, IndexedPropertyIterator.
Keeps: GenericIndexedPropertyStorage (for Dictionary mode).
2026-03-17 22:28:35 -05:00

412 lines
19 KiB
C++
Raw Blame History

/*
* Copyright (c) 2020-2024, Andreas Kling <andreas@ladybird.org>
* Copyright (c) 2020-2023, Linus Groh <linusg@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Badge.h>
#include <AK/StringView.h>
#include <LibGC/CellAllocator.h>
#include <LibGC/RootVector.h>
#include <LibJS/Export.h>
#include <LibJS/Forward.h>
#include <LibJS/Heap/Cell.h>
#include <LibJS/Runtime/Completion.h>
#include <LibJS/Runtime/IndexedProperties.h>
#include <LibJS/Runtime/PrimitiveString.h>
#include <LibJS/Runtime/PrivateEnvironment.h>
#include <LibJS/Runtime/PropertyDescriptor.h>
#include <LibJS/Runtime/PropertyKey.h>
#include <LibJS/Runtime/Shape.h>
#include <LibJS/Runtime/Value.h>
namespace JS {
#define JS_OBJECT(class_, base_class) GC_CELL(class_, base_class)
struct PrivateElement {
enum class Kind {
Field,
Method,
Accessor
};
PrivateName key;
Kind kind { Kind::Field };
Value value;
void visit_edges(Cell::Visitor& visitor)
{
visitor.visit(value);
}
};
// Non-standard: This is information optionally returned by object property access functions.
// It can be used to implement inline caches for property lookup.
struct CacheableGetPropertyMetadata {
enum class Type {
NotCacheable,
GetOwnProperty,
GetPropertyInPrototypeChain,
};
Type type { Type::NotCacheable };
Optional<u32> property_offset;
GC::Ptr<Object const> prototype;
};
struct CacheableSetPropertyMetadata {
enum class Type {
NotCacheable,
AddOwnProperty,
ChangeOwnProperty,
ChangePropertyInPrototypeChain,
};
Type type { Type::NotCacheable };
Optional<u32> property_offset;
GC::Ptr<Object const> prototype;
};
enum class IndexedStorageKind : u8 {
None = 0,
Packed = 1,
Holey = 2,
Dictionary = 3,
};
class JS_API Object : public Cell {
GC_CELL(Object, Cell);
GC_DECLARE_ALLOCATOR(Object);
public:
static GC::Ref<Object> create_prototype(Realm&, Object* prototype);
static GC::Ref<Object> create(Realm&, Object* prototype);
static GC::Ref<Object> create_with_premade_shape(Shape&);
virtual void initialize(Realm&) override;
GC_ALLOW_CELL_DESTRUCTOR virtual ~Object();
enum class PropertyKind {
Key,
Value,
KeyAndValue,
};
enum class IntegrityLevel {
Sealed,
Frozen,
};
enum class ShouldThrowExceptions {
No,
Yes,
};
enum class MayInterfereWithIndexedPropertyAccess {
No,
Yes,
};
// Please DO NOT make up your own non-standard methods unless you
// have a very good reason to do so. If any object abstract
// operation from the spec is missing, add it instead.
// Functionality for implementation details like shapes and
// property storage are obviously exempt from this rule :^)
//
// Methods named [[Foo]]() in the spec are named internal_foo()
// here, as they are "The [[Foo]] internal method of a ... object".
// They must be virtual and may be overridden. All other methods
// follow the regular PascalCase name converted to camel_case
// naming convention and must not be virtual.
// 7.1 Type Conversion, https://tc39.es/ecma262/#sec-type-conversion
ThrowCompletionOr<Value> ordinary_to_primitive(Value::PreferredType preferred_type) const;
// 7.2 Testing and Comparison Operations, https://tc39.es/ecma262/#sec-testing-and-comparison-operations
ThrowCompletionOr<bool> is_extensible() const;
// 7.3 Operations on Objects, https://tc39.es/ecma262/#sec-operations-on-objects
ThrowCompletionOr<Value> get(PropertyKey const&) const;
ThrowCompletionOr<Value> get(PropertyKey const&, Bytecode::PropertyLookupCache&) const;
ThrowCompletionOr<void> set(PropertyKey const&, Value, ShouldThrowExceptions);
ThrowCompletionOr<void> set(PropertyKey const&, Value, Bytecode::PropertyLookupCache&);
ThrowCompletionOr<bool> create_data_property(PropertyKey const&, Value, Optional<u32>* new_property_offset = nullptr);
void create_method_property(PropertyKey const&, Value);
ThrowCompletionOr<bool> create_data_property_or_throw(PropertyKey const&, Value);
void create_non_enumerable_data_property_or_throw(PropertyKey const&, Value);
ThrowCompletionOr<void> define_property_or_throw(PropertyKey const&, PropertyDescriptor&);
ThrowCompletionOr<void> delete_property_or_throw(PropertyKey const&);
ThrowCompletionOr<bool> has_property(PropertyKey const&) const;
ThrowCompletionOr<bool> has_own_property(PropertyKey const&) const;
ThrowCompletionOr<bool> set_integrity_level(IntegrityLevel);
ThrowCompletionOr<bool> test_integrity_level(IntegrityLevel) const;
ThrowCompletionOr<GC::RootVector<Value>> enumerable_own_property_names(PropertyKind kind) const;
ThrowCompletionOr<void> copy_data_properties(VM&, Value source, HashTable<PropertyKey> const& excluded_keys, HashTable<JS::Value> const& excluded_values = {});
ThrowCompletionOr<GC::Ref<Object>> snapshot_own_properties(VM&, GC::Ptr<Object> prototype, HashTable<PropertyKey> const& excluded_keys = {}, HashTable<Value> const& excluded_values = {});
PrivateElement* private_element_find(PrivateName const& name);
ThrowCompletionOr<void> private_field_add(PrivateName const& name, Value value);
ThrowCompletionOr<void> private_method_or_accessor_add(PrivateElement element);
ThrowCompletionOr<Value> private_get(PrivateName const& name);
ThrowCompletionOr<void> private_set(PrivateName const& name, Value value);
ThrowCompletionOr<void> define_field(ClassFieldDefinition const&);
ThrowCompletionOr<void> initialize_instance_elements(ECMAScriptFunctionObject& constructor);
// 10.1 Ordinary Object Internal Methods and Internal Slots, https://tc39.es/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots
virtual ThrowCompletionOr<Object*> internal_get_prototype_of() const;
virtual ThrowCompletionOr<bool> internal_set_prototype_of(Object* prototype);
virtual ThrowCompletionOr<bool> internal_is_extensible() const;
virtual ThrowCompletionOr<bool> internal_prevent_extensions();
virtual ThrowCompletionOr<Optional<PropertyDescriptor>> internal_get_own_property(PropertyKey const&) const;
virtual ThrowCompletionOr<bool> internal_define_own_property(PropertyKey const&, PropertyDescriptor&, Optional<PropertyDescriptor>* precomputed_get_own_property = nullptr);
virtual ThrowCompletionOr<bool> internal_has_property(PropertyKey const&) const;
enum class PropertyLookupPhase {
OwnProperty,
PrototypeChain,
};
virtual ThrowCompletionOr<Value> internal_get(PropertyKey const&, Value receiver, CacheableGetPropertyMetadata* = nullptr, PropertyLookupPhase = PropertyLookupPhase::OwnProperty) const;
virtual ThrowCompletionOr<bool> internal_set(PropertyKey const&, Value value, Value receiver, CacheableSetPropertyMetadata* = nullptr, PropertyLookupPhase = PropertyLookupPhase::OwnProperty);
virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&);
virtual ThrowCompletionOr<GC::RootVector<Value>> internal_own_property_keys() const;
// NOTE: Any subclass of Object that overrides property access slots ([[Get]], [[Set]] etc)
// to customize access to indexed properties (properties where the name is a positive integer)
// must return true for this, to opt out of optimizations that rely on assumptions that
// might not hold when property access behaves differently.
[[nodiscard]] bool extensible() const { return m_flags & Flag::IsExtensible; }
void set_extensible(bool value)
{
if (value)
m_flags |= Flag::IsExtensible;
else
m_flags &= ~Flag::IsExtensible;
}
[[nodiscard]] bool may_interfere_with_indexed_property_access() const { return m_flags & Flag::MayInterfereWithIndexedPropertyAccess; }
void set_may_interfere_with_indexed_property_access() { m_flags |= Flag::MayInterfereWithIndexedPropertyAccess; }
ThrowCompletionOr<bool> ordinary_set_with_own_descriptor(PropertyKey const&, Value, Value, Optional<PropertyDescriptor>, CacheableSetPropertyMetadata* = nullptr, PropertyLookupPhase = PropertyLookupPhase::OwnProperty);
// 10.4.7 Immutable Prototype Exotic Objects, https://tc39.es/ecma262/#sec-immutable-prototype-exotic-objects
ThrowCompletionOr<bool> set_immutable_prototype(Object* prototype);
// 20.1 Object Objects, https://tc39.es/ecma262/#sec-object-objects
ThrowCompletionOr<Object*> define_properties(Value properties);
// 14.7.5 The for-in, for-of, and for-await-of Statements
Optional<Completion> enumerate_object_properties(Function<Optional<Completion>(Value)>) const;
// Implementation-specific storage abstractions
Optional<ValueAndAttributes> storage_get(PropertyKey const&) const;
bool storage_has(PropertyKey const&) const;
Optional<u32> storage_set(PropertyKey const&, ValueAndAttributes const&);
void storage_delete(PropertyKey const&);
// Non-standard methods
ThrowCompletionOr<void> for_each_own_property_with_enumerability(Function<ThrowCompletionOr<void>(PropertyKey const&, bool)>&&) const;
size_t own_properties_count() const;
Value get_without_side_effects(PropertyKey const&) const;
void define_direct_property(PropertyKey const& property_key, Value value, PropertyAttributes attributes) { (void)storage_set(property_key, { value, attributes }); }
void define_direct_accessor(PropertyKey const&, FunctionObject* getter, FunctionObject* setter, PropertyAttributes attributes);
using IntrinsicAccessor = Value (*)(Realm&);
void define_intrinsic_accessor(PropertyKey const&, PropertyAttributes attributes, IntrinsicAccessor accessor);
void define_native_function(Realm&, PropertyKey const&, ESCAPING Function<ThrowCompletionOr<Value>(VM&)>, i32 length, PropertyAttributes attributes, Optional<Bytecode::Builtin> builtin = {});
void define_native_accessor(Realm&, PropertyKey const&, ESCAPING Function<ThrowCompletionOr<Value>(VM&)> getter, ESCAPING Function<ThrowCompletionOr<Value>(VM&)> setter, PropertyAttributes attributes);
void define_native_javascript_backed_function(PropertyKey const&, GC::Ref<NativeJavaScriptBackedFunction> function, i32 length, PropertyAttributes attributes);
virtual bool is_dom_node() const { return false; }
virtual bool is_dom_document() const { return false; }
virtual bool is_dom_element() const { return false; }
virtual bool is_dom_event_target() const { return false; }
virtual bool is_dom_event() const { return false; }
virtual bool is_html_window() const { return false; }
virtual bool is_html_window_proxy() const { return false; }
virtual bool is_html_location() const { return false; }
virtual bool is_canvas_rendering_context_2d() const { return false; }
[[nodiscard]] bool is_function() const { return m_flags & Flag::IsFunction; }
virtual bool is_bound_function() const { return false; }
virtual bool is_promise() const { return false; }
virtual bool is_error_object() const { return false; }
virtual bool is_date() const { return false; }
virtual bool is_number_object() const { return false; }
virtual bool is_boolean_object() const { return false; }
virtual bool is_regexp_object() const { return false; }
virtual bool is_bigint_object() const { return false; }
virtual bool is_string_object() const { return false; }
virtual bool is_array_buffer() const { return false; }
virtual bool is_array_exotic_object() const { return false; }
virtual bool is_global_object() const { return false; }
virtual bool is_proxy_object() const { return false; }
virtual bool is_native_function() const { return false; }
[[nodiscard]] bool is_ecmascript_function_object() const { return m_flags & Flag::IsECMAScriptFunctionObject; }
void set_is_ecmascript_function_object() { m_flags |= Flag::IsECMAScriptFunctionObject; }
void set_is_function() { m_flags |= Flag::IsFunction; }
void clear_is_function() { m_flags &= ~Flag::IsFunction; }
virtual bool is_array_iterator() const { return false; }
virtual bool is_raw_json_object() const { return false; }
virtual bool is_set_object() const { return false; }
virtual bool is_map_object() const { return false; }
virtual bool is_weak_map() const { return false; }
virtual bool is_typed_array_base() const { return false; }
#define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, Type) \
virtual bool is_##snake_name() const { return false; }
JS_ENUMERATE_TYPED_ARRAYS
#undef __JS_ENUMERATE
virtual bool eligible_for_own_property_enumeration_fast_path() const { return true; }
virtual BuiltinIterator* as_builtin_iterator_if_next_is_not_redefined([[maybe_unused]] Value next_method) { return nullptr; }
virtual bool is_array_iterator_prototype() const { return false; }
virtual bool is_map_iterator_prototype() const { return false; }
virtual bool is_set_iterator_prototype() const { return false; }
virtual bool is_string_iterator_prototype() const { return false; }
// B.3.7 The [[IsHTMLDDA]] Internal Slot, https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
virtual bool is_htmldda() const { return false; }
bool has_parameter_map() const { return m_flags & Flag::HasParameterMap; }
void set_has_parameter_map() { m_flags |= Flag::HasParameterMap; }
virtual void visit_edges(Cell::Visitor&) override;
Value get_direct(size_t index) const { return m_named_properties[index]; }
void put_direct(size_t index, Value value) { m_named_properties[index] = value; }
// Indexed property storage
Optional<ValueAndAttributes> indexed_get(u32 index) const;
void indexed_put(u32 index, Value, PropertyAttributes attributes = default_attributes);
bool indexed_has(u32 index) const;
void indexed_delete(u32 index);
u32 indexed_array_like_size() const { return m_indexed_array_like_size; }
bool set_indexed_array_like_size(size_t new_size);
void indexed_append(Value value, PropertyAttributes attributes = default_attributes);
ValueAndAttributes indexed_take_first();
ValueAndAttributes indexed_take_last();
size_t indexed_real_size() const;
Vector<u32> indexed_indices() const;
void set_indexed_property_elements(Vector<Value>&& values);
IndexedStorageKind indexed_storage_kind() const { return m_indexed_storage_kind; }
template<typename Callback>
void indexed_for_each_value(Callback callback)
{
switch (m_indexed_storage_kind) {
case IndexedStorageKind::None:
break;
case IndexedStorageKind::Packed:
for (u32 i = 0; i < m_indexed_array_like_size; ++i)
callback(m_indexed_elements[i]);
break;
case IndexedStorageKind::Holey:
for (u32 i = 0; i < m_indexed_array_like_size; ++i) {
if (!m_indexed_elements[i].is_special_empty_value())
callback(m_indexed_elements[i]);
}
break;
case IndexedStorageKind::Dictionary:
for (auto& element : indexed_dictionary()->sparse_elements())
callback(element.value.value);
break;
}
}
// For FunctionPrototype.apply fast path
ReadonlySpan<Value> indexed_packed_elements_span() const;
Shape& shape() { return *m_shape; }
Shape const& shape() const { return *m_shape; }
void unsafe_set_shape(Shape&);
void convert_to_prototype_if_needed();
template<typename T>
bool fast_is() const = delete;
void set_prototype(Object*);
[[nodiscard]] bool has_magical_length_property() const { return m_flags & Flag::HasMagicalLengthProperty; }
void set_has_magical_length_property() { m_flags |= Flag::HasMagicalLengthProperty; }
[[nodiscard]] bool is_typed_array() const { return m_flags & Flag::IsTypedArray; }
void set_is_typed_array() { m_flags |= Flag::IsTypedArray; }
[[nodiscard]] bool has_intrinsic_accessors() const { return m_flags & Flag::HasIntrinsicAccessors; }
void set_has_intrinsic_accessors() { m_flags |= Flag::HasIntrinsicAccessors; }
Object const* prototype() const { return shape().prototype(); }
protected:
enum class GlobalObjectTag { Tag };
enum class ConstructWithoutPrototypeTag { Tag };
enum class ConstructWithPrototypeTag { Tag };
Object(GlobalObjectTag, Realm&, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
Object(ConstructWithoutPrototypeTag, Realm&, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
Object(Realm&, Object* prototype, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
Object(ConstructWithPrototypeTag, Object& prototype, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
explicit Object(Shape&, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
private:
struct Flag {
static constexpr u8 IsExtensible = 1 << 0;
static constexpr u8 HasParameterMap = 1 << 1;
static constexpr u8 HasMagicalLengthProperty = 1 << 2;
static constexpr u8 IsTypedArray = 1 << 3;
static constexpr u8 MayInterfereWithIndexedPropertyAccess = 1 << 4;
static constexpr u8 HasIntrinsicAccessors = 1 << 5;
static constexpr u8 IsECMAScriptFunctionObject = 1 << 6;
static constexpr u8 IsFunction = 1 << 7;
};
u8 m_flags { Flag::IsExtensible };
IndexedStorageKind m_indexed_storage_kind { IndexedStorageKind::None };
// 2 bytes padding
u32 m_indexed_array_like_size { 0 };
void set_shape(Shape& shape) { m_shape = &shape; }
Object* prototype() { return shape().prototype(); }
// Indexed storage helpers
GenericIndexedPropertyStorage* indexed_dictionary() const;
u32 indexed_elements_capacity() const;
void ensure_indexed_elements(u32 needed_capacity);
void grow_indexed_elements(u32 needed_capacity);
void transition_to_dictionary();
void free_indexed_elements();
void ensure_named_storage_capacity(u32 needed);
bool named_storage_is_inline() const { return m_named_properties == const_cast<Object*>(this)->m_inline_named_storage; }
public:
static constexpr u32 INLINE_NAMED_PROPERTY_CAPACITY = 2;
private:
GC::Ptr<Shape> m_shape;
Value* m_named_properties { m_inline_named_storage };
Value* m_indexed_elements { nullptr };
OwnPtr<Vector<PrivateElement>> m_private_elements; // [[PrivateElements]]
Value m_inline_named_storage[INLINE_NAMED_PROPERTY_CAPACITY] {};
};
#if !defined(AK_OS_WINDOWS)
static_assert(sizeof(Object) <= 64, "Keep the size of JS::Object down!");
#endif
}
Reference in a new issue View git blame Copy permalink