diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /js/src/vm/PropertyInfo.h | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'js/src/vm/PropertyInfo.h')
-rw-r--r-- | js/src/vm/PropertyInfo.h | 221 |
1 files changed, 221 insertions, 0 deletions
diff --git a/js/src/vm/PropertyInfo.h b/js/src/vm/PropertyInfo.h new file mode 100644 index 0000000000..497c2a242a --- /dev/null +++ b/js/src/vm/PropertyInfo.h @@ -0,0 +1,221 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef vm_PropertyInfo_h +#define vm_PropertyInfo_h + +#include "mozilla/Assertions.h" + +#include <limits> +#include <stdint.h> + +#include "jstypes.h" +#include "NamespaceImports.h" + +#include "js/GCVector.h" +#include "js/PropertyDescriptor.h" +#include "util/EnumFlags.h" + +namespace js { + +/* Limit on the number of slotful properties in an object. */ +static constexpr uint32_t SHAPE_INVALID_SLOT = Bit(24) - 1; +static constexpr uint32_t SHAPE_MAXIMUM_SLOT = Bit(24) - 2; + +// Flags associated with each property stored in the shape tree. +enum class PropertyFlag : uint8_t { + // Property attributes. See also JS::PropertyAttribute. + Configurable = 1 << 0, + Enumerable = 1 << 1, + Writable = 1 << 2, + + // Whether this is an accessor property. Accessor properties have a slot that + // stores a GetterSetter instance. + AccessorProperty = 1 << 3, + + // If set, this is a custom data property. The property is exposed as a data + // property to JS code and PropertyDescriptor, but instead of an object slot + // it uses custom get/set logic. + // + // This is used to implement the special array.length and ArgumentsObject + // properties. + // + // This flag is deprecated (we don't want to add more uses). + CustomDataProperty = 1 << 4, +}; + +class PropertyFlags : public EnumFlags<PropertyFlag> { + using Base = EnumFlags<PropertyFlag>; + using Base::Base; + + public: + static const PropertyFlags defaultDataPropFlags; + + static PropertyFlags fromRaw(uint8_t flags) { return PropertyFlags(flags); } + + bool configurable() const { return hasFlag(PropertyFlag::Configurable); } + bool enumerable() const { return hasFlag(PropertyFlag::Enumerable); } + bool writable() const { + MOZ_ASSERT(isDataDescriptor()); + return hasFlag(PropertyFlag::Writable); + } + + // Note: this returns true only for plain data properties with a slot. Returns + // false for custom data properties. See CustomDataProperty flag. + bool isDataProperty() const { + return !isAccessorProperty() && !isCustomDataProperty(); + } + bool isAccessorProperty() const { + return hasFlag(PropertyFlag::AccessorProperty); + } + bool isCustomDataProperty() const { + return hasFlag(PropertyFlag::CustomDataProperty); + } + + // Note: unlike isDataProperty, this returns true also for custom data + // properties. + bool isDataDescriptor() const { return !isAccessorProperty(); } +}; + +constexpr PropertyFlags PropertyFlags::defaultDataPropFlags = { + PropertyFlag::Configurable, PropertyFlag::Enumerable, + PropertyFlag::Writable}; + +// PropertyInfo contains information (PropertyFlags, slot number) for a +// property stored in the Shape tree. Property lookups on NativeObjects return a +// PropertyInfo. +// +// There's also a CompactPropertyInfo type that's used by CompactPropMap to +// store small slot numbers (CompactPropertyInfo is two bytes instead of four). +template <typename T> +class PropertyInfoBase { + static_assert(std::is_same_v<T, uint32_t> || std::is_same_v<T, uint16_t>); + + static constexpr uint32_t FlagsMask = 0xff; + static constexpr uint32_t SlotShift = 8; + + T slotAndFlags_ = 0; + + static_assert(SHAPE_INVALID_SLOT <= (UINT32_MAX >> SlotShift), + "SHAPE_INVALID_SLOT must fit in slotAndFlags_"); + static_assert(SHAPE_MAXIMUM_SLOT <= (UINT32_MAX >> SlotShift), + "SHAPE_MAXIMUM_SLOT must fit in slotAndFlags_"); + + // Constructor is private, code should prefer Maybe<PropertyInfo>. This + // constructor is only used for the propInfos array in property maps + // (CompactPropMap and LinkedPropMap are friend classes for this reason). + PropertyInfoBase() = default; + + template <typename U> + friend class PropertyInfoBase; + friend class CompactPropMap; + friend class LinkedPropMap; + + public: + static constexpr size_t MaxSlotNumber = + std::numeric_limits<T>::max() >> SlotShift; + + PropertyInfoBase(PropertyFlags flags, uint32_t slot) + : slotAndFlags_((slot << SlotShift) | flags.toRaw()) { + MOZ_ASSERT(maybeSlot() == slot); + MOZ_ASSERT(this->flags() == flags); + } + + template <typename U> + explicit PropertyInfoBase(PropertyInfoBase<U> other) + : slotAndFlags_(other.slotAndFlags_) { + // Assert assigning PropertyInfo to CompactPropertyInfo doesn't lose + // information. + MOZ_ASSERT(slotAndFlags_ == other.slotAndFlags_); + } + + bool isDataProperty() const { return flags().isDataProperty(); } + bool isCustomDataProperty() const { return flags().isCustomDataProperty(); } + bool isAccessorProperty() const { return flags().isAccessorProperty(); } + bool isDataDescriptor() const { return flags().isDataDescriptor(); } + + bool hasSlot() const { return !isCustomDataProperty(); } + + uint32_t slot() const { + MOZ_ASSERT(hasSlot()); + MOZ_ASSERT(maybeSlot() < SHAPE_INVALID_SLOT); + return maybeSlot(); + } + + uint32_t maybeSlot() const { return slotAndFlags_ >> SlotShift; } + + PropertyFlags flags() const { + return PropertyFlags::fromRaw(slotAndFlags_ & FlagsMask); + } + bool writable() const { return flags().writable(); } + bool configurable() const { return flags().configurable(); } + bool enumerable() const { return flags().enumerable(); } + + JS::PropertyAttributes propAttributes() const { + JS::PropertyAttributes attrs{}; + if (configurable()) { + attrs += JS::PropertyAttribute::Configurable; + } + if (enumerable()) { + attrs += JS::PropertyAttribute::Enumerable; + } + if (isDataDescriptor() && writable()) { + attrs += JS::PropertyAttribute::Writable; + } + return attrs; + } + + T toRaw() const { return slotAndFlags_; } + + bool operator==(const PropertyInfoBase<T>& other) const { + return slotAndFlags_ == other.slotAndFlags_; + } + bool operator!=(const PropertyInfoBase<T>& other) const { + return !operator==(other); + } +}; + +using PropertyInfo = PropertyInfoBase<uint32_t>; +using CompactPropertyInfo = PropertyInfoBase<uint16_t>; + +static_assert(sizeof(PropertyInfo) == sizeof(uint32_t)); +static_assert(sizeof(CompactPropertyInfo) == sizeof(uint16_t)); + +class PropertyInfoWithKey : public PropertyInfo { + PropertyKey key_; + + public: + PropertyInfoWithKey(PropertyFlags flags, uint32_t slot, PropertyKey key) + : PropertyInfo(flags, slot), key_(key) {} + + PropertyInfoWithKey(PropertyInfo prop, PropertyKey key) + : PropertyInfo(prop), key_(key) {} + + PropertyKey key() const { return key_; } + + void trace(JSTracer* trc) { + TraceRoot(trc, &key_, "PropertyInfoWithKey-key"); + } +}; + +template <class Wrapper> +class WrappedPtrOperations<PropertyInfoWithKey, Wrapper> { + const PropertyInfoWithKey& value() const { + return static_cast<const Wrapper*>(this)->get(); + } + + public: + bool isDataProperty() const { return value().isDataProperty(); } + uint32_t slot() const { return value().slot(); } + PropertyKey key() const { return value().key(); } + PropertyFlags flags() const { return value().flags(); } +}; + +using PropertyInfoWithKeyVector = GCVector<PropertyInfoWithKey, 16>; + +} // namespace js + +#endif /* vm_PropertyInfo_h */ |