| // Copyright 2017 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_FIXED_ARRAY_H_ |
| #define V8_OBJECTS_FIXED_ARRAY_H_ |
| |
| #include "src/maybe-handles.h" |
| #include "src/objects.h" |
| |
| // Has to be the last include (doesn't have include guards): |
| #include "src/objects/object-macros.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| class WeakArrayBodyDescriptor; |
| |
| #define FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(V) \ |
| V(BYTECODE_ARRAY_CONSTANT_POOL_SUB_TYPE) \ |
| V(BYTECODE_ARRAY_HANDLER_TABLE_SUB_TYPE) \ |
| V(CODE_STUBS_TABLE_SUB_TYPE) \ |
| V(COMPILATION_CACHE_TABLE_SUB_TYPE) \ |
| V(CONTEXT_SUB_TYPE) \ |
| V(COPY_ON_WRITE_SUB_TYPE) \ |
| V(DEOPTIMIZATION_DATA_SUB_TYPE) \ |
| V(DESCRIPTOR_ARRAY_SUB_TYPE) \ |
| V(EMBEDDED_OBJECT_SUB_TYPE) \ |
| V(ENUM_CACHE_SUB_TYPE) \ |
| V(ENUM_INDICES_CACHE_SUB_TYPE) \ |
| V(DEPENDENT_CODE_SUB_TYPE) \ |
| V(DICTIONARY_ELEMENTS_SUB_TYPE) \ |
| V(DICTIONARY_PROPERTIES_SUB_TYPE) \ |
| V(EMPTY_PROPERTIES_DICTIONARY_SUB_TYPE) \ |
| V(PACKED_ELEMENTS_SUB_TYPE) \ |
| V(FAST_PROPERTIES_SUB_TYPE) \ |
| V(FAST_TEMPLATE_INSTANTIATIONS_CACHE_SUB_TYPE) \ |
| V(HANDLER_TABLE_SUB_TYPE) \ |
| V(JS_COLLECTION_SUB_TYPE) \ |
| V(JS_WEAK_COLLECTION_SUB_TYPE) \ |
| V(NOSCRIPT_SHARED_FUNCTION_INFOS_SUB_TYPE) \ |
| V(NUMBER_STRING_CACHE_SUB_TYPE) \ |
| V(OBJECT_TO_CODE_SUB_TYPE) \ |
| V(OPTIMIZED_CODE_LITERALS_SUB_TYPE) \ |
| V(OPTIMIZED_CODE_MAP_SUB_TYPE) \ |
| V(PROTOTYPE_USERS_SUB_TYPE) \ |
| V(REGEXP_MULTIPLE_CACHE_SUB_TYPE) \ |
| V(RETAINED_MAPS_SUB_TYPE) \ |
| V(SCOPE_INFO_SUB_TYPE) \ |
| V(SCRIPT_LIST_SUB_TYPE) \ |
| V(SERIALIZED_OBJECTS_SUB_TYPE) \ |
| V(SHARED_FUNCTION_INFOS_SUB_TYPE) \ |
| V(SINGLE_CHARACTER_STRING_CACHE_SUB_TYPE) \ |
| V(SLOW_TEMPLATE_INSTANTIATIONS_CACHE_SUB_TYPE) \ |
| V(STRING_SPLIT_CACHE_SUB_TYPE) \ |
| V(STRING_TABLE_SUB_TYPE) \ |
| V(TEMPLATE_INFO_SUB_TYPE) \ |
| V(FEEDBACK_METADATA_SUB_TYPE) \ |
| V(WEAK_NEW_SPACE_OBJECT_TO_CODE_SUB_TYPE) |
| |
| enum FixedArraySubInstanceType { |
| #define DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE(name) name, |
| FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE) |
| #undef DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE |
| LAST_FIXED_ARRAY_SUB_TYPE = WEAK_NEW_SPACE_OBJECT_TO_CODE_SUB_TYPE |
| }; |
| |
| // Common superclass for FixedArrays that allow implementations to share |
| // common accessors and some code paths. |
| class FixedArrayBase : public HeapObject { |
| public: |
| // [length]: length of the array. |
| inline int length() const; |
| inline void set_length(int value); |
| |
| // Get and set the length using acquire loads and release stores. |
| inline int synchronized_length() const; |
| inline void synchronized_set_length(int value); |
| |
| inline Object* unchecked_synchronized_length() const; |
| |
| DECL_CAST(FixedArrayBase) |
| |
| static int GetMaxLengthForNewSpaceAllocation(ElementsKind kind); |
| |
| bool IsCowArray() const; |
| |
| // Maximal allowed size, in bytes, of a single FixedArrayBase. |
| // Prevents overflowing size computations, as well as extreme memory |
| // consumption. |
| #ifdef V8_HOST_ARCH_32_BIT |
| static const int kMaxSize = 512 * MB; |
| #else |
| static const int kMaxSize = 1024 * MB; |
| #endif // V8_HOST_ARCH_32_BIT |
| |
| // Layout description. |
| // Length is smi tagged when it is stored. |
| static const int kLengthOffset = HeapObject::kHeaderSize; |
| static const int kHeaderSize = kLengthOffset + kPointerSize; |
| }; |
| |
| // FixedArray describes fixed-sized arrays with element type Object*. |
| class FixedArray : public FixedArrayBase { |
| public: |
| // Setter and getter for elements. |
| inline Object* get(int index) const; |
| static inline Handle<Object> get(FixedArray* array, int index, |
| Isolate* isolate); |
| template <class T> |
| MaybeHandle<T> GetValue(Isolate* isolate, int index) const; |
| |
| template <class T> |
| Handle<T> GetValueChecked(Isolate* isolate, int index) const; |
| |
| // Return a grown copy if the index is bigger than the array's length. |
| static Handle<FixedArray> SetAndGrow(Isolate* isolate, |
| Handle<FixedArray> array, int index, |
| Handle<Object> value, |
| PretenureFlag pretenure = NOT_TENURED); |
| |
| // Setter that uses write barrier. |
| inline void set(int index, Object* value); |
| inline bool is_the_hole(Isolate* isolate, int index); |
| |
| // Setter that doesn't need write barrier. |
| inline void set(int index, Smi* value); |
| // Setter with explicit barrier mode. |
| inline void set(int index, Object* value, WriteBarrierMode mode); |
| |
| // Setters for frequently used oddballs located in old space. |
| inline void set_undefined(int index); |
| inline void set_undefined(Isolate* isolate, int index); |
| inline void set_null(int index); |
| inline void set_null(Isolate* isolate, int index); |
| inline void set_the_hole(int index); |
| inline void set_the_hole(Isolate* isolate, int index); |
| |
| inline Object** GetFirstElementAddress(); |
| inline bool ContainsOnlySmisOrHoles(); |
| // Returns true iff the elements are Numbers and sorted ascending. |
| bool ContainsSortedNumbers(); |
| |
| // Gives access to raw memory which stores the array's data. |
| inline Object** data_start(); |
| |
| inline void FillWithHoles(int from, int to); |
| |
| // Shrink the array and insert filler objects. {new_length} must be > 0. |
| void Shrink(Isolate* isolate, int new_length); |
| // If {new_length} is 0, return the canonical empty FixedArray. Otherwise |
| // like above. |
| static Handle<FixedArray> ShrinkOrEmpty(Isolate* isolate, |
| Handle<FixedArray> array, |
| int new_length); |
| |
| // Copy a sub array from the receiver to dest. |
| void CopyTo(int pos, FixedArray* dest, int dest_pos, int len) const; |
| |
| // Garbage collection support. |
| static constexpr int SizeFor(int length) { |
| return kHeaderSize + length * kPointerSize; |
| } |
| |
| // Code Generation support. |
| static constexpr int OffsetOfElementAt(int index) { return SizeFor(index); } |
| |
| // Garbage collection support. |
| inline Object** RawFieldOfElementAt(int index); |
| |
| DECL_CAST(FixedArray) |
| // Maximally allowed length of a FixedArray. |
| static const int kMaxLength = (kMaxSize - kHeaderSize) / kPointerSize; |
| static_assert(Internals::IsValidSmi(kMaxLength), |
| "FixedArray maxLength not a Smi"); |
| |
| // Maximally allowed length for regular (non large object space) object. |
| STATIC_ASSERT(kMaxRegularHeapObjectSize < kMaxSize); |
| static const int kMaxRegularLength = |
| (kMaxRegularHeapObjectSize - kHeaderSize) / kPointerSize; |
| |
| // Dispatched behavior. |
| DECL_PRINTER(FixedArray) |
| DECL_VERIFIER(FixedArray) |
| #ifdef DEBUG |
| // Checks if two FixedArrays have identical contents. |
| bool IsEqualTo(FixedArray* other); |
| #endif |
| |
| typedef FlexibleBodyDescriptor<kHeaderSize> BodyDescriptor; |
| // No weak fields. |
| typedef BodyDescriptor BodyDescriptorWeak; |
| |
| protected: |
| // Set operation on FixedArray without using write barriers. Can |
| // only be used for storing old space objects or smis. |
| static inline void NoWriteBarrierSet(FixedArray* array, int index, |
| Object* value); |
| |
| private: |
| STATIC_ASSERT(kHeaderSize == Internals::kFixedArrayHeaderSize); |
| |
| inline void set_undefined(ReadOnlyRoots ro_roots, int index); |
| inline void set_null(ReadOnlyRoots ro_roots, int index); |
| inline void set_the_hole(ReadOnlyRoots ro_roots, int index); |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(FixedArray); |
| }; |
| |
| // FixedArray alias added only because of IsFixedArrayExact() predicate, which |
| // checks for the exact instance type FIXED_ARRAY_TYPE instead of a range |
| // check: [FIRST_FIXED_ARRAY_TYPE, LAST_FIXED_ARRAY_TYPE]. |
| class FixedArrayExact final : public FixedArray { |
| public: |
| DECL_CAST(FixedArrayExact) |
| }; |
| |
| // FixedDoubleArray describes fixed-sized arrays with element type double. |
| class FixedDoubleArray : public FixedArrayBase { |
| public: |
| // Setter and getter for elements. |
| inline double get_scalar(int index); |
| inline uint64_t get_representation(int index); |
| static inline Handle<Object> get(FixedDoubleArray* array, int index, |
| Isolate* isolate); |
| inline void set(int index, double value); |
| inline void set_the_hole(Isolate* isolate, int index); |
| inline void set_the_hole(int index); |
| |
| // Checking for the hole. |
| inline bool is_the_hole(Isolate* isolate, int index); |
| inline bool is_the_hole(int index); |
| |
| // Garbage collection support. |
| inline static int SizeFor(int length) { |
| return kHeaderSize + length * kDoubleSize; |
| } |
| |
| // Gives access to raw memory which stores the array's data. |
| inline double* data_start(); |
| |
| inline void FillWithHoles(int from, int to); |
| |
| // Code Generation support. |
| static int OffsetOfElementAt(int index) { return SizeFor(index); } |
| |
| DECL_CAST(FixedDoubleArray) |
| |
| // Maximally allowed length of a FixedArray. |
| static const int kMaxLength = (kMaxSize - kHeaderSize) / kDoubleSize; |
| static_assert(Internals::IsValidSmi(kMaxLength), |
| "FixedDoubleArray maxLength not a Smi"); |
| |
| // Dispatched behavior. |
| DECL_PRINTER(FixedDoubleArray) |
| DECL_VERIFIER(FixedDoubleArray) |
| |
| class BodyDescriptor; |
| // No weak fields. |
| typedef BodyDescriptor BodyDescriptorWeak; |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(FixedDoubleArray); |
| }; |
| |
| // WeakFixedArray describes fixed-sized arrays with element type |
| // MaybeObject*. |
| class WeakFixedArray : public HeapObject { |
| public: |
| DECL_CAST(WeakFixedArray) |
| |
| inline MaybeObject* Get(int index) const; |
| |
| // Setter that uses write barrier. |
| inline void Set(int index, MaybeObject* value); |
| |
| // Setter with explicit barrier mode. |
| inline void Set(int index, MaybeObject* value, WriteBarrierMode mode); |
| |
| static constexpr int SizeFor(int length) { |
| return kHeaderSize + length * kPointerSize; |
| } |
| |
| DECL_INT_ACCESSORS(length) |
| |
| // Get and set the length using acquire loads and release stores. |
| inline int synchronized_length() const; |
| inline void synchronized_set_length(int value); |
| |
| // Gives access to raw memory which stores the array's data. |
| inline MaybeObject** data_start(); |
| |
| inline MaybeObject** RawFieldOfElementAt(int index); |
| |
| inline MaybeObject** GetFirstElementAddress(); |
| |
| DECL_PRINTER(WeakFixedArray) |
| DECL_VERIFIER(WeakFixedArray) |
| |
| typedef WeakArrayBodyDescriptor BodyDescriptor; |
| typedef BodyDescriptor BodyDescriptorWeak; |
| |
| static const int kLengthOffset = HeapObject::kHeaderSize; |
| static const int kHeaderSize = kLengthOffset + kPointerSize; |
| |
| static const int kMaxLength = |
| (FixedArray::kMaxSize - kHeaderSize) / kPointerSize; |
| static_assert(Internals::IsValidSmi(kMaxLength), |
| "WeakFixedArray maxLength not a Smi"); |
| |
| protected: |
| static int OffsetOfElementAt(int index) { |
| return kHeaderSize + index * kPointerSize; |
| } |
| |
| private: |
| friend class Heap; |
| |
| static const int kFirstIndex = 1; |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(WeakFixedArray); |
| }; |
| |
| // WeakArrayList is like a WeakFixedArray with static convenience methods for |
| // adding more elements. length() returns the number of elements in the list and |
| // capacity() returns the allocated size. The number of elements is stored at |
| // kLengthOffset and is updated with every insertion. The array grows |
| // dynamically with O(1) amortized insertion. |
| class WeakArrayList : public HeapObject { |
| public: |
| DECL_CAST(WeakArrayList) |
| DECL_VERIFIER(WeakArrayList) |
| DECL_PRINTER(WeakArrayList) |
| |
| static Handle<WeakArrayList> AddToEnd(Isolate* isolate, |
| Handle<WeakArrayList> array, |
| MaybeObjectHandle value); |
| |
| inline MaybeObject* Get(int index) const; |
| |
| // Set the element at index to obj. The underlying array must be large enough. |
| // If you need to grow the WeakArrayList, use the static AddToEnd() method |
| // instead. |
| inline void Set(int index, MaybeObject* value, |
| WriteBarrierMode mode = UPDATE_WRITE_BARRIER); |
| |
| static constexpr int SizeForCapacity(int capacity) { |
| return kHeaderSize + capacity * kPointerSize; |
| } |
| |
| // Gives access to raw memory which stores the array's data. |
| inline MaybeObject** data_start(); |
| |
| bool IsFull(); |
| |
| DECL_INT_ACCESSORS(capacity) |
| DECL_INT_ACCESSORS(length) |
| |
| // Get and set the capacity using acquire loads and release stores. |
| inline int synchronized_capacity() const; |
| inline void synchronized_set_capacity(int value); |
| |
| typedef WeakArrayBodyDescriptor BodyDescriptor; |
| typedef BodyDescriptor BodyDescriptorWeak; |
| |
| static const int kCapacityOffset = HeapObject::kHeaderSize; |
| static const int kLengthOffset = kCapacityOffset + kPointerSize; |
| static const int kHeaderSize = kLengthOffset + kPointerSize; |
| |
| static const int kMaxCapacity = |
| (FixedArray::kMaxSize - kHeaderSize) / kPointerSize; |
| |
| static Handle<WeakArrayList> EnsureSpace( |
| Isolate* isolate, Handle<WeakArrayList> array, int length, |
| PretenureFlag pretenure = NOT_TENURED); |
| |
| // Returns the number of non-cleaned weak references in the array. |
| int CountLiveWeakReferences() const; |
| |
| // Returns whether an entry was found and removed. Will move the elements |
| // around in the array - this method can only be used in cases where the user |
| // doesn't care about the indices! Users should make sure there are no |
| // duplicates. |
| bool RemoveOne(MaybeObjectHandle value); |
| |
| class Iterator { |
| public: |
| explicit Iterator(WeakArrayList* array) : index_(0), array_(array) {} |
| |
| inline HeapObject* Next(); |
| |
| private: |
| int index_; |
| WeakArrayList* array_; |
| #ifdef DEBUG |
| DisallowHeapAllocation no_gc_; |
| #endif // DEBUG |
| DISALLOW_COPY_AND_ASSIGN(Iterator); |
| }; |
| |
| private: |
| static int OffsetOfElementAt(int index) { |
| return kHeaderSize + index * kPointerSize; |
| } |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(WeakArrayList); |
| }; |
| |
| // Generic array grows dynamically with O(1) amortized insertion. |
| // |
| // ArrayList is a FixedArray with static convenience methods for adding more |
| // elements. The Length() method returns the number of elements in the list, not |
| // the allocated size. The number of elements is stored at kLengthIndex and is |
| // updated with every insertion. The elements of the ArrayList are stored in the |
| // underlying FixedArray starting at kFirstIndex. |
| class ArrayList : public FixedArray { |
| public: |
| static Handle<ArrayList> Add(Isolate* isolate, Handle<ArrayList> array, |
| Handle<Object> obj); |
| static Handle<ArrayList> Add(Isolate* isolate, Handle<ArrayList> array, |
| Handle<Object> obj1, Handle<Object> obj2); |
| static Handle<ArrayList> New(Isolate* isolate, int size); |
| |
| // Returns the number of elements in the list, not the allocated size, which |
| // is length(). Lower and upper case length() return different results! |
| inline int Length() const; |
| |
| // Sets the Length() as used by Elements(). Does not change the underlying |
| // storage capacity, i.e., length(). |
| inline void SetLength(int length); |
| inline Object* Get(int index) const; |
| inline Object** Slot(int index); |
| |
| // Set the element at index to obj. The underlying array must be large enough. |
| // If you need to grow the ArrayList, use the static Add() methods instead. |
| inline void Set(int index, Object* obj, |
| WriteBarrierMode mode = UPDATE_WRITE_BARRIER); |
| |
| // Set the element at index to undefined. This does not change the Length(). |
| inline void Clear(int index, Object* undefined); |
| |
| // Return a copy of the list of size Length() without the first entry. The |
| // number returned by Length() is stored in the first entry. |
| static Handle<FixedArray> Elements(Isolate* isolate, Handle<ArrayList> array); |
| bool IsFull(); |
| DECL_CAST(ArrayList) |
| |
| private: |
| static Handle<ArrayList> EnsureSpace(Isolate* isolate, |
| Handle<ArrayList> array, int length); |
| static const int kLengthIndex = 0; |
| static const int kFirstIndex = 1; |
| DISALLOW_IMPLICIT_CONSTRUCTORS(ArrayList); |
| }; |
| |
| enum SearchMode { ALL_ENTRIES, VALID_ENTRIES }; |
| |
| template <SearchMode search_mode, typename T> |
| inline int Search(T* array, Name* name, int valid_entries = 0, |
| int* out_insertion_index = nullptr); |
| |
| // ByteArray represents fixed sized byte arrays. Used for the relocation info |
| // that is attached to code objects. |
| class ByteArray : public FixedArrayBase { |
| public: |
| inline int Size(); |
| |
| // Setter and getter. |
| inline byte get(int index) const; |
| inline void set(int index, byte value); |
| |
| // Copy in / copy out whole byte slices. |
| inline void copy_out(int index, byte* buffer, int length); |
| inline void copy_in(int index, const byte* buffer, int length); |
| |
| // Treat contents as an int array. |
| inline int get_int(int index) const; |
| inline void set_int(int index, int value); |
| |
| inline uint32_t get_uint32(int index) const; |
| inline void set_uint32(int index, uint32_t value); |
| |
| // Clear uninitialized padding space. This ensures that the snapshot content |
| // is deterministic. |
| inline void clear_padding(); |
| |
| static int SizeFor(int length) { |
| return OBJECT_POINTER_ALIGN(kHeaderSize + length); |
| } |
| // We use byte arrays for free blocks in the heap. Given a desired size in |
| // bytes that is a multiple of the word size and big enough to hold a byte |
| // array, this function returns the number of elements a byte array should |
| // have. |
| static int LengthFor(int size_in_bytes) { |
| DCHECK(IsAligned(size_in_bytes, kPointerSize)); |
| DCHECK_GE(size_in_bytes, kHeaderSize); |
| return size_in_bytes - kHeaderSize; |
| } |
| |
| // Returns data start address. |
| inline byte* GetDataStartAddress(); |
| |
| inline int DataSize() const; |
| |
| // Returns a pointer to the ByteArray object for a given data start address. |
| static inline ByteArray* FromDataStartAddress(Address address); |
| |
| DECL_CAST(ByteArray) |
| |
| // Dispatched behavior. |
| inline int ByteArraySize(); |
| DECL_PRINTER(ByteArray) |
| DECL_VERIFIER(ByteArray) |
| |
| // Layout description. |
| static const int kAlignedSize = OBJECT_POINTER_ALIGN(kHeaderSize); |
| |
| // Maximal length of a single ByteArray. |
| static const int kMaxLength = kMaxSize - kHeaderSize; |
| static_assert(Internals::IsValidSmi(kMaxLength), |
| "ByteArray maxLength not a Smi"); |
| |
| class BodyDescriptor; |
| // No weak fields. |
| typedef BodyDescriptor BodyDescriptorWeak; |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(ByteArray); |
| }; |
| |
| // Wrapper class for ByteArray which can store arbitrary C++ classes, as long |
| // as they can be copied with memcpy. |
| template <class T> |
| class PodArray : public ByteArray { |
| public: |
| static Handle<PodArray<T>> New(Isolate* isolate, int length, |
| PretenureFlag pretenure = NOT_TENURED); |
| void copy_out(int index, T* result) { |
| ByteArray::copy_out(index * sizeof(T), reinterpret_cast<byte*>(result), |
| sizeof(T)); |
| } |
| T get(int index) { |
| T result; |
| copy_out(index, &result); |
| return result; |
| } |
| void set(int index, const T& value) { |
| copy_in(index * sizeof(T), reinterpret_cast<const byte*>(&value), |
| sizeof(T)); |
| } |
| inline int length(); |
| DECL_CAST(PodArray<T>) |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(PodArray<T>); |
| }; |
| |
| class FixedTypedArrayBase : public FixedArrayBase { |
| public: |
| // [base_pointer]: Either points to the FixedTypedArrayBase itself or nullptr. |
| DECL_ACCESSORS(base_pointer, Object) |
| |
| // [external_pointer]: Contains the offset between base_pointer and the start |
| // of the data. If the base_pointer is a nullptr, the external_pointer |
| // therefore points to the actual backing store. |
| DECL_ACCESSORS(external_pointer, void) |
| |
| // Dispatched behavior. |
| DECL_CAST(FixedTypedArrayBase) |
| |
| static const int kBasePointerOffset = FixedArrayBase::kHeaderSize; |
| static const int kExternalPointerOffset = kBasePointerOffset + kPointerSize; |
| static const int kHeaderSize = |
| DOUBLE_POINTER_ALIGN(kExternalPointerOffset + kPointerSize); |
| |
| static const int kDataOffset = kHeaderSize; |
| |
| static const int kMaxElementSize = 8; |
| |
| #ifdef V8_HOST_ARCH_32_BIT |
| static const size_t kMaxByteLength = std::numeric_limits<size_t>::max(); |
| #else |
| static const size_t kMaxByteLength = |
| static_cast<size_t>(Smi::kMaxValue) * kMaxElementSize; |
| #endif // V8_HOST_ARCH_32_BIT |
| |
| static const size_t kMaxLength = Smi::kMaxValue; |
| |
| class BodyDescriptor; |
| // No weak fields. |
| typedef BodyDescriptor BodyDescriptorWeak; |
| |
| inline int size() const; |
| |
| static inline int TypedArraySize(InstanceType type, int length); |
| inline int TypedArraySize(InstanceType type) const; |
| |
| // Use with care: returns raw pointer into heap. |
| inline void* DataPtr(); |
| |
| inline int DataSize() const; |
| |
| inline size_t ByteLength() const; |
| |
| private: |
| static inline int ElementSize(InstanceType type); |
| |
| inline int DataSize(InstanceType type) const; |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArrayBase); |
| }; |
| |
| template <class Traits> |
| class FixedTypedArray : public FixedTypedArrayBase { |
| public: |
| typedef typename Traits::ElementType ElementType; |
| static const InstanceType kInstanceType = Traits::kInstanceType; |
| |
| DECL_CAST(FixedTypedArray<Traits>) |
| |
| static inline ElementType get_scalar_from_data_ptr(void* data_ptr, int index); |
| inline ElementType get_scalar(int index); |
| static inline Handle<Object> get(Isolate* isolate, FixedTypedArray* array, |
| int index); |
| inline void set(int index, ElementType value); |
| |
| static inline ElementType from(int value); |
| static inline ElementType from(uint32_t value); |
| static inline ElementType from(double value); |
| static inline ElementType from(int64_t value); |
| static inline ElementType from(uint64_t value); |
| |
| static inline ElementType FromHandle(Handle<Object> value, |
| bool* lossless = nullptr); |
| |
| // This accessor applies the correct conversion from Smi, HeapNumber |
| // and undefined. |
| inline void SetValue(uint32_t index, Object* value); |
| |
| DECL_PRINTER(FixedTypedArray) |
| DECL_VERIFIER(FixedTypedArray) |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArray); |
| }; |
| |
| #define FIXED_TYPED_ARRAY_TRAITS(Type, type, TYPE, elementType) \ |
| STATIC_ASSERT(sizeof(elementType) <= FixedTypedArrayBase::kMaxElementSize); \ |
| class Type##ArrayTraits { \ |
| public: /* NOLINT */ \ |
| typedef elementType ElementType; \ |
| static const InstanceType kInstanceType = FIXED_##TYPE##_ARRAY_TYPE; \ |
| static const char* Designator() { return #type " array"; } \ |
| static inline Handle<Object> ToHandle(Isolate* isolate, \ |
| elementType scalar); \ |
| static inline elementType defaultValue(); \ |
| }; \ |
| \ |
| typedef FixedTypedArray<Type##ArrayTraits> Fixed##Type##Array; |
| |
| TYPED_ARRAYS(FIXED_TYPED_ARRAY_TRAITS) |
| |
| #undef FIXED_TYPED_ARRAY_TRAITS |
| |
| class TemplateList : public FixedArray { |
| public: |
| static Handle<TemplateList> New(Isolate* isolate, int size); |
| inline int length() const; |
| inline Object* get(int index) const; |
| inline void set(int index, Object* value); |
| static Handle<TemplateList> Add(Isolate* isolate, Handle<TemplateList> list, |
| Handle<Object> value); |
| DECL_CAST(TemplateList) |
| private: |
| static const int kLengthIndex = 0; |
| static const int kFirstElementIndex = kLengthIndex + 1; |
| DISALLOW_IMPLICIT_CONSTRUCTORS(TemplateList); |
| }; |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #include "src/objects/object-macros-undef.h" |
| |
| #endif // V8_OBJECTS_FIXED_ARRAY_H_ |