v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits > Class Template Reference

Inheritance diagram for v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >:

Collaboration diagram for v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >:

Public Member Functions
	FastElementsAccessor (const char *name)
Public Member Functions inherited from v8::internal::ElementsAccessor
	ElementsAccessor (const char *name)
virtual	~ElementsAccessor ()
const char *	name () const
bool	HasElement (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key)
MUST_USE_RESULT MaybeHandle< Object >	Get (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key)
MUST_USE_RESULT PropertyAttributes	GetAttributes (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key)
MUST_USE_RESULT MaybeHandle< AccessorPair >	GetAccessorPair (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key)
void	CopyElements (Handle< JSObject > from_holder, Handle< FixedArrayBase > to, ElementsKind from_kind)
MUST_USE_RESULT MaybeHandle< FixedArray >	AddElementsToFixedArray (Handle< Object > receiver, Handle< JSObject > holder, Handle< FixedArray > to)

Protected Types
typedef KindTraits::BackingStore	BackingStore
Protected Types inherited from v8::internal::ElementsAccessorBase< FastElementsAccessorSubclass, KindTraits >
typedef KindTraits	ElementsTraits
typedef ElementsTraitsParam::BackingStore	BackingStore

Protected Member Functions
virtual MaybeHandle< Object >	Delete (Handle< JSObject > obj, uint32_t key, JSReceiver::DeleteMode mode) FINAL OVERRIDE
Protected Member Functions inherited from v8::internal::ElementsAccessorBase< FastElementsAccessorSubclass, KindTraits >
	ElementsAccessorBase (const char *name)
virtual ElementsKind	kind () const FINAL OVERRIDE
virtual void	Validate (Handle< JSObject > holder) FINAL OVERRIDE
virtual bool	HasElement (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key, Handle< FixedArrayBase > backing_store) FINAL OVERRIDE
virtual MUST_USE_RESULT MaybeHandle< Object >	Get (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key, Handle< FixedArrayBase > backing_store) FINAL OVERRIDE
virtual MUST_USE_RESULT PropertyAttributes	GetAttributes (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key, Handle< FixedArrayBase > backing_store) FINAL OVERRIDE
virtual MUST_USE_RESULT MaybeHandle< AccessorPair >	GetAccessorPair (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key, Handle< FixedArrayBase > backing_store) FINAL OVERRIDE
virtual MUST_USE_RESULT MaybeHandle< Object >	SetLength (Handle< JSArray > array, Handle< Object > length) FINAL OVERRIDE
virtual void	SetCapacityAndLength (Handle< JSArray > array, int capacity, int length) FINAL OVERRIDE
virtual void	CopyElements (Handle< FixedArrayBase > from, uint32_t from_start, ElementsKind from_kind, Handle< FixedArrayBase > to, uint32_t to_start, int copy_size) FINAL OVERRIDE
virtual void	CopyElements (JSObject *from_holder, uint32_t from_start, ElementsKind from_kind, Handle< FixedArrayBase > to, uint32_t to_start, int copy_size) FINAL OVERRIDE
virtual MaybeHandle< FixedArray >	AddElementsToFixedArray (Handle< Object > receiver, Handle< JSObject > holder, Handle< FixedArray > to, Handle< FixedArrayBase > from) FINAL OVERRIDE
virtual uint32_t	GetCapacity (Handle< FixedArrayBase > backing_store) FINAL OVERRIDE
virtual uint32_t	GetKeyForIndex (Handle< FixedArrayBase > backing_store, uint32_t index) FINAL OVERRIDE

Static Protected Member Functions
static Handle< Object >	SetLengthWithoutNormalize (Handle< FixedArrayBase > backing_store, Handle< JSArray > array, Handle< Object > length_object, uint32_t length)
static Handle< Object >	DeleteCommon (Handle< JSObject > obj, uint32_t key, JSReceiver::DeleteMode mode)
static bool	HasElementImpl (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key, Handle< FixedArrayBase > backing_store)
static void	ValidateContents (Handle< JSObject > holder, int length)
Static Protected Member Functions inherited from v8::internal::ElementsAccessorBase< FastElementsAccessorSubclass, KindTraits >
static void	ValidateContents (Handle< JSObject > holder, int length)
static void	ValidateImpl (Handle< JSObject > holder)
static bool	HasElementImpl (Handle< Object > receiver, Handle< JSObject > holder, uint32_t key, Handle< FixedArrayBase > backing_store)
static MUST_USE_RESULT MaybeHandle< Object >	GetImpl (Handle< Object > receiver, Handle< JSObject > obj, uint32_t key, Handle< FixedArrayBase > backing_store)
static MUST_USE_RESULT PropertyAttributes	GetAttributesImpl (Handle< Object > receiver, Handle< JSObject > obj, uint32_t key, Handle< FixedArrayBase > backing_store)
static MUST_USE_RESULT MaybeHandle< AccessorPair >	GetAccessorPairImpl (Handle< Object > receiver, Handle< JSObject > obj, uint32_t key, Handle< FixedArrayBase > backing_store)
static MUST_USE_RESULT MaybeHandle< Object >	SetLengthImpl (Handle< JSObject > obj, Handle< Object > length, Handle< FixedArrayBase > backing_store)
static void	SetFastElementsCapacityAndLength (Handle< JSObject > obj, int capacity, int length)
static void	CopyElementsImpl (FixedArrayBase *from, uint32_t from_start, FixedArrayBase *to, ElementsKind from_kind, uint32_t to_start, int packed_size, int copy_size)
static uint32_t	GetCapacityImpl (Handle< FixedArrayBase > backing_store)
static uint32_t	GetKeyForIndexImpl (Handle< FixedArrayBase > backing_store, uint32_t index)

Friends
class	ElementsAccessorBase< FastElementsAccessorSubclass, KindTraits >
class	SloppyArgumentsElementsAccessor

Additional Inherited Members
Static Public Member Functions inherited from v8::internal::ElementsAccessor
static ElementsAccessor *	ForKind (ElementsKind elements_kind)
static ElementsAccessor *	ForArray (Handle< FixedArrayBase > array)
static void	InitializeOncePerProcess ()
static void	TearDown ()
Static Public Attributes inherited from v8::internal::ElementsAccessor
static const int	kCopyToEnd = -1
static const int	kCopyToEndAndInitializeToHole = -2

Detailed Description

template<typename FastElementsAccessorSubclass, typename KindTraits>
class v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >

Definition at line 873 of file elements.cc.

Member Typedef Documentation

BackingStore

template<typename FastElementsAccessorSubclass , typename KindTraits >

typedef KindTraits::BackingStore v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >::BackingStore

protected

Definition at line 883 of file elements.cc.

Constructor & Destructor Documentation

FastElementsAccessor()

template<typename FastElementsAccessorSubclass , typename KindTraits >

v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >::FastElementsAccessor ( const char *  name )

inlineexplicit

Definition at line 876 of file elements.cc.

      : ElementsAccessorBase<FastElementsAccessorSubclass,
                             KindTraits>(name) {}

Member Function Documentation

Delete()

template<typename FastElementsAccessorSubclass , typename KindTraits >

virtual MaybeHandle<Object> v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >::Delete ( Handle< JSObject >  obj, uint32_t  key, JSReceiver::DeleteMode  mode  )

inlineprotectedvirtual

Implements v8::internal::ElementsAccessorBase< FastElementsAccessorSubclass, KindTraits >.

Definition at line 995 of file elements.cc.

                                                {
    return DeleteCommon(obj, key, mode);
  }

References v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >::DeleteCommon(), and mode().

Here is the call graph for this function:

DeleteCommon()

template<typename FastElementsAccessorSubclass , typename KindTraits >

static Handle<Object> v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >::DeleteCommon ( Handle< JSObject >  obj, uint32_t  key, JSReceiver::DeleteMode  mode  )

inlinestaticprotected

Definition at line 936 of file elements.cc.

                                                                {
    DCHECK(obj->HasFastSmiOrObjectElements() ||
           obj->HasFastDoubleElements() ||
           obj->HasFastArgumentsElements());
    Isolate* isolate = obj->GetIsolate();
    Heap* heap = obj->GetHeap();
    Handle<FixedArrayBase> elements(obj->elements());
    if (*elements == heap->empty_fixed_array()) {
      return isolate->factory()->true_value();
    }
    Handle<BackingStore> backing_store = Handle<BackingStore>::cast(elements);
    bool is_sloppy_arguments_elements_map =
        backing_store->map() == heap->sloppy_arguments_elements_map();
    if (is_sloppy_arguments_elements_map) {
      backing_store = handle(
          BackingStore::cast(Handle<FixedArray>::cast(backing_store)->get(1)),
          isolate);
    }
    uint32_t length = static_cast<uint32_t>(
        obj->IsJSArray()
        ? Smi::cast(Handle<JSArray>::cast(obj)->length())->value()
        : backing_store->length());
    if (key < length) {
      if (!is_sloppy_arguments_elements_map) {
        ElementsKind kind = KindTraits::Kind;
        if (IsFastPackedElementsKind(kind)) {
          JSObject::TransitionElementsKind(obj, GetHoleyElementsKind(kind));
        }
        if (IsFastSmiOrObjectElementsKind(KindTraits::Kind)) {
          Handle<Object> writable = JSObject::EnsureWritableFastElements(obj);
          backing_store = Handle<BackingStore>::cast(writable);
        }
      }
      backing_store->set_the_hole(key);
      // If an old space backing store is larger than a certain size and
      // has too few used values, normalize it.
      // To avoid doing the check on every delete we require at least
      // one adjacent hole to the value being deleted.
      const int kMinLengthForSparsenessCheck = 64;
      if (backing_store->length() >= kMinLengthForSparsenessCheck &&
          !heap->InNewSpace(*backing_store) &&
          ((key > 0 && backing_store->is_the_hole(key - 1)) ||
           (key + 1 < length && backing_store->is_the_hole(key + 1)))) {
        int num_used = 0;
        for (int i = 0; i < backing_store->length(); ++i) {
          if (!backing_store->is_the_hole(i)) ++num_used;
          // Bail out early if more than 1/4 is used.
          if (4 * num_used > backing_store->length()) break;
        }
        if (4 * num_used <= backing_store->length()) {
          JSObject::NormalizeElements(obj);
        }
      }
    }
    return isolate->factory()->true_value();
  }

References v8::internal::Handle< T >::cast(), DCHECK, v8::internal::JSObject::EnsureWritableFastElements(), v8::internal::Isolate::factory(), v8::internal::GetHoleyElementsKind(), v8::internal::handle(), v8::internal::Heap::InNewSpace(), v8::internal::IsFastPackedElementsKind(), v8::internal::IsFastSmiOrObjectElementsKind(), v8::internal::ElementsAccessorBase< FastElementsAccessorSubclass, KindTraits >::kind(), v8::internal::JSObject::NormalizeElements(), and v8::internal::JSObject::TransitionElementsKind().

Referenced by v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >::Delete(), and v8::internal::SloppyArgumentsElementsAccessor::Delete().

Here is the call graph for this function:

Here is the caller graph for this function:

HasElementImpl()

template<typename FastElementsAccessorSubclass , typename KindTraits >

static bool v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >::HasElementImpl ( Handle< Object >  receiver, Handle< JSObject >  holder, uint32_t  key, Handle< FixedArrayBase >  backing_store  )

inlinestaticprotected

Definition at line 1002 of file elements.cc.

                                            {
    if (key >= static_cast<uint32_t>(backing_store->length())) {
      return false;
    }
    return !Handle<BackingStore>::cast(backing_store)->is_the_hole(key);
  }

References v8::internal::Handle< T >::cast().

Here is the call graph for this function:

SetLengthWithoutNormalize()

template<typename FastElementsAccessorSubclass , typename KindTraits >

static Handle<Object> v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >::SetLengthWithoutNormalize ( Handle< FixedArrayBase >  backing_store, Handle< JSArray >  array, Handle< Object >  length_object, uint32_t  length  )

inlinestaticprotected

Definition at line 886 of file elements.cc.

                       {
    Isolate* isolate = array->GetIsolate();
    uint32_t old_capacity = backing_store->length();
    Handle<Object> old_length(array->length(), isolate);
    bool same_or_smaller_size = old_length->IsSmi() &&
        static_cast<uint32_t>(Handle<Smi>::cast(old_length)->value()) >= length;
    ElementsKind kind = array->GetElementsKind();
 
    if (!same_or_smaller_size && IsFastElementsKind(kind) &&
        !IsFastHoleyElementsKind(kind)) {
      kind = GetHoleyElementsKind(kind);
      JSObject::TransitionElementsKind(array, kind);
    }
 
    // Check whether the backing store should be shrunk.
    if (length <= old_capacity) {
      if (array->HasFastSmiOrObjectElements()) {
        backing_store = JSObject::EnsureWritableFastElements(array);
      }
      if (2 * length <= old_capacity) {
        // If more than half the elements won't be used, trim the array.
        if (length == 0) {
          array->initialize_elements();
        } else {
          isolate->heap()->RightTrimFixedArray<Heap::FROM_MUTATOR>(
              *backing_store, old_capacity - length);
        }
      } else {
        // Otherwise, fill the unused tail with holes.
        int old_length = FastD2IChecked(array->length()->Number());
        for (int i = length; i < old_length; i++) {
          Handle<BackingStore>::cast(backing_store)->set_the_hole(i);
        }
      }
      return length_object;
    }
 
    // Check whether the backing store should be expanded.
    uint32_t min = JSObject::NewElementsCapacity(old_capacity);
    uint32_t new_capacity = length > min ? length : min;
    FastElementsAccessorSubclass::SetFastElementsCapacityAndLength(
        array, new_capacity, length);
    JSObject::ValidateElements(array);
    return length_object;
  }

References v8::internal::Handle< T >::cast(), v8::internal::JSObject::EnsureWritableFastElements(), v8::internal::FastD2IChecked(), v8::internal::Heap::FROM_MUTATOR, v8::internal::GetHoleyElementsKind(), v8::internal::Isolate::heap(), v8::internal::IsFastElementsKind(), v8::internal::IsFastHoleyElementsKind(), v8::internal::ElementsAccessorBase< FastElementsAccessorSubclass, KindTraits >::kind(), v8::internal::min(), v8::internal::JSObject::NewElementsCapacity(), v8::internal::Heap::RightTrimFixedArray(), v8::internal::JSObject::TransitionElementsKind(), and v8::internal::JSObject::ValidateElements().

Here is the call graph for this function:

ValidateContents()

template<typename FastElementsAccessorSubclass , typename KindTraits >

static void v8::internal::FastElementsAccessor< FastElementsAccessorSubclass, KindTraits >::ValidateContents ( Handle< JSObject >  holder, int  length  )

inlinestaticprotected

Definition at line 1013 of file elements.cc.

                                                                    {
#if DEBUG
    Isolate* isolate = holder->GetIsolate();
    HandleScope scope(isolate);
    Handle<FixedArrayBase> elements(holder->elements(), isolate);
    Map* map = elements->map();
    DCHECK((IsFastSmiOrObjectElementsKind(KindTraits::Kind) &&
            (map == isolate->heap()->fixed_array_map() ||
             map == isolate->heap()->fixed_cow_array_map())) ||
           (IsFastDoubleElementsKind(KindTraits::Kind) ==
            ((map == isolate->heap()->fixed_array_map() && length == 0) ||
             map == isolate->heap()->fixed_double_array_map())));
    DisallowHeapAllocation no_gc;
    for (int i = 0; i < length; i++) {
      HandleScope scope(isolate);
      Handle<BackingStore> backing_store = Handle<BackingStore>::cast(elements);
      DCHECK((!IsFastSmiElementsKind(KindTraits::Kind) ||
              BackingStore::get(backing_store, i)->IsSmi()) ||
             (IsFastHoleyElementsKind(KindTraits::Kind) ==
              backing_store->is_the_hole(i)));
    }
#endif
  }

References v8::internal::Handle< T >::cast(), DCHECK, v8::internal::Isolate::heap(), v8::internal::IsFastDoubleElementsKind(), v8::internal::IsFastHoleyElementsKind(), v8::internal::IsFastSmiElementsKind(), v8::internal::IsFastSmiOrObjectElementsKind(), and map.

Here is the call graph for this function:

Friends And Related Function Documentation

ElementsAccessorBase< FastElementsAccessorSubclass, KindTraits >

template<typename FastElementsAccessorSubclass , typename KindTraits >

friend class ElementsAccessorBase< FastElementsAccessorSubclass, KindTraits >

friend

Definition at line 876 of file elements.cc.

SloppyArgumentsElementsAccessor

template<typename FastElementsAccessorSubclass , typename KindTraits >

friend class SloppyArgumentsElementsAccessor

friend

Definition at line 881 of file elements.cc.

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/elements.cc