v8::internal::KeyedStoreIC Class Reference

#include <ic.h>

Inheritance diagram for v8::internal::KeyedStoreIC:

Collaboration diagram for v8::internal::KeyedStoreIC:

Classes
class	ExtraICStateKeyedAccessStoreMode

Public Member Functions
	KeyedStoreIC (FrameDepth depth, Isolate *isolate)
MUST_USE_RESULT MaybeHandle< Object >	Store (Handle< Object > object, Handle< Object > name, Handle< Object > value)
Public Member Functions inherited from v8::internal::StoreIC
	StoreIC (FrameDepth depth, Isolate *isolate)
StrictMode	strict_mode () const
MUST_USE_RESULT MaybeHandle< Object >	Store (Handle< Object > object, Handle< Name > name, Handle< Object > value, JSReceiver::StoreFromKeyed store_mode=JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED)
bool	LookupForWrite (LookupIterator *it, Handle< Object > value, JSReceiver::StoreFromKeyed store_mode)
Public Member Functions inherited from v8::internal::IC
	IC (FrameDepth depth, Isolate *isolate)
virtual	~IC ()
State	state () const
Address	address () const
void	UpdateState (Handle< Object > receiver, Handle< Object > name)
bool	IsNameCompatibleWithPrototypeFailure (Handle< Object > name)
void	MarkPrototypeFailure (Handle< Object > name)

Static Public Member Functions
static ExtraICState	ComputeExtraICState (StrictMode flag, KeyedAccessStoreMode mode)
static KeyedAccessStoreMode	GetKeyedAccessStoreMode (ExtraICState extra_state)
static void	GenerateInitialize (MacroAssembler *masm)
static void	GeneratePreMonomorphic (MacroAssembler *masm)
static void	GenerateMiss (MacroAssembler *masm)
static void	GenerateSlow (MacroAssembler *masm)
static void	GenerateGeneric (MacroAssembler *masm, StrictMode strict_mode)
static void	GenerateSloppyArguments (MacroAssembler *masm)
Static Public Member Functions inherited from v8::internal::StoreIC
static ExtraICState	ComputeExtraICState (StrictMode flag)
static StrictMode	GetStrictMode (ExtraICState state)
static void	GenerateSlow (MacroAssembler *masm)
static void	GenerateInitialize (MacroAssembler *masm)
static void	GeneratePreMonomorphic (MacroAssembler *masm)
static void	GenerateMiss (MacroAssembler *masm)
static void	GenerateMegamorphic (MacroAssembler *masm)
static void	GenerateNormal (MacroAssembler *masm)
static void	GenerateRuntimeSetProperty (MacroAssembler *masm, StrictMode strict_mode)
static Handle< Code >	initialize_stub (Isolate *isolate, StrictMode strict_mode)
Static Public Member Functions inherited from v8::internal::IC
static Address	AddressFromUtilityId (UtilityId id)
static void	RegisterWeakMapDependency (Handle< Code > stub)
static void	InvalidateMaps (Code *stub)
static void	Clear (Isolate *isolate, Address address, ConstantPoolArray *constant_pool)
template<class TypeClass >
static JSFunction *	GetRootConstructor (TypeClass *type, Context *native_context)
static Handle< Map >	GetHandlerCacheHolder (HeapType *type, bool receiver_is_holder, Isolate *isolate, CacheHolderFlag *flag)
static Handle< Map >	GetICCacheHolder (HeapType *type, Isolate *isolate, CacheHolderFlag *flag)
static bool	IsCleared (Code *code)
static Handle< Map >	TypeToMap (HeapType *type, Isolate *isolate)
template<class T >
static T::TypeHandle	MapToType (Handle< Map > map, typename T::Region *region)
static Handle< HeapType >	CurrentTypeOf (Handle< Object > object, Isolate *isolate)

Protected Member Functions
virtual Handle< Code >	pre_monomorphic_stub () const
Handle< Code >	StoreElementStub (Handle< JSObject > receiver, KeyedAccessStoreMode store_mode)
Protected Member Functions inherited from v8::internal::StoreIC
virtual Handle< Code >	megamorphic_stub () OVERRIDE
Handle< Code >	generic_stub () const
Handle< Code >	slow_stub () const
void	UpdateCaches (LookupIterator *lookup, Handle< Object > value, JSReceiver::StoreFromKeyed store_mode)
virtual Handle< Code >	CompileHandler (LookupIterator *lookup, Handle< Object > value, CacheHolderFlag cache_holder)
Protected Member Functions inherited from v8::internal::IC
Handle< Code >	target () const
Address	fp () const
Address	pc () const
Isolate *	isolate () const
SharedFunctionInfo *	GetSharedFunctionInfo () const
Code *	GetCode () const
Code *	GetOriginalCode () const
void	set_target (Code *code)
bool	is_target_set ()
char	TransitionMarkFromState (IC::State state)
void	TraceIC (const char *type, Handle< Object > name)
void	TraceIC (const char *type, Handle< Object > name, State old_state, State new_state)
MaybeHandle< Object >	TypeError (const char *type, Handle< Object > object, Handle< Object > key)
MaybeHandle< Object >	ReferenceError (const char *type, Handle< Name > name)
Handle< Code >	ComputeHandler (LookupIterator *lookup, Handle< Object > value=Handle< Code >::null())
void	UpdateMonomorphicIC (Handle< Code > handler, Handle< Name > name)
bool	UpdatePolymorphicIC (Handle< Name > name, Handle< Code > code)
void	UpdateMegamorphicCache (HeapType *type, Name *name, Code *code)
void	CopyICToMegamorphicCache (Handle< Name > name)
bool	IsTransitionOfMonomorphicTarget (Map *source_map, Map *target_map)
void	PatchCache (Handle< Name > name, Handle< Code > code)
Code::Kind	kind () const
Code::Kind	handler_kind () const
bool	TryRemoveInvalidPrototypeDependentStub (Handle< Object > receiver, Handle< String > name)
ExtraICState	extra_ic_state () const
void	set_extra_ic_state (ExtraICState state)
Handle< HeapType >	receiver_type ()
void	update_receiver_type (Handle< Object > receiver)
void	TargetMaps (MapHandleList *list)
void	TargetTypes (TypeHandleList *list)
Map *	FirstTargetMap ()
void	UpdateTarget ()

Static Protected Member Functions
static Handle< Code >	pre_monomorphic_stub (Isolate *isolate, StrictMode strict_mode)
Static Protected Member Functions inherited from v8::internal::StoreIC
static Handle< Code >	pre_monomorphic_stub (Isolate *isolate, StrictMode strict_mode)
Static Protected Member Functions inherited from v8::internal::IC
static Code *	GetTargetAtAddress (Address address, ConstantPoolArray *constant_pool)
static void	SetTargetAtAddress (Address address, Code *target, ConstantPoolArray *constant_pool)
static void	OnTypeFeedbackChanged (Isolate *isolate, Address address, State old_state, State new_state, bool target_remains_ic_stub)
static void	PostPatching (Address address, Code *target, Code *old_target)

Private Member Functions
void	set_target (Code *code)
Handle< Code >	sloppy_arguments_stub ()
KeyedAccessStoreMode	GetStoreMode (Handle< JSObject > receiver, Handle< Object > key, Handle< Object > value)
Handle< Map >	ComputeTransitionedMap (Handle< Map > map, KeyedAccessStoreMode store_mode)

Static Private Member Functions
static void	Clear (Isolate *isolate, Address address, Code *target, ConstantPoolArray *constant_pool)

Friends
class	IC

Additional Inherited Members
Public Types inherited from v8::internal::IC
enum	UtilityId { kUtilityCount }
enum	FrameDepth { NO_EXTRA_FRAME = 0 , EXTRA_CALL_FRAME = 1 }
typedef InlineCacheState	State
Static Public Attributes inherited from v8::internal::StoreIC
static const ExtraICState	kStrictModeState = 1 << StrictModeState::kShift

Detailed Description

Definition at line 530 of file ic.h.

Constructor & Destructor Documentation

KeyedStoreIC()

v8::internal::KeyedStoreIC::KeyedStoreIC ( FrameDepth  depth, Isolate *  isolate  )

inline

Definition at line 548 of file ic.h.

                                                   : StoreIC(depth, isolate) {
    DCHECK(target()->is_keyed_store_stub());
  }

References DCHECK, and v8::internal::IC::target().

Here is the call graph for this function:

Member Function Documentation

Clear()

void v8::internal::KeyedStoreIC::Clear ( Isolate *  isolate, Address  address, Code *  target, ConstantPoolArray *  constant_pool  )

staticprivate

Definition at line 545 of file ic.cc.

                                                           {
  if (IsCleared(target)) return;
  SetTargetAtAddress(
      address, *pre_monomorphic_stub(
                   isolate, StoreIC::GetStrictMode(target->extra_ic_state())),
      constant_pool);
}

References v8::internal::IC::address(), v8::internal::IC::constant_pool(), v8::internal::StoreIC::GetStrictMode(), v8::internal::IC::IsCleared(), v8::internal::IC::isolate(), pre_monomorphic_stub(), v8::internal::IC::SetTargetAtAddress(), and v8::internal::IC::target().

Referenced by v8::internal::IC::Clear().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeExtraICState()

static ExtraICState v8::internal::KeyedStoreIC::ComputeExtraICState ( StrictMode  flag, KeyedAccessStoreMode  mode  )

inlinestatic

Definition at line 537 of file ic.h.

                                                                     {
    return StrictModeState::encode(flag) |
           ExtraICStateKeyedAccessStoreMode::encode(mode);
  }

References v8::internal::flag, and mode().

Referenced by v8::internal::PropertyICCompiler::ComputeKeyedStoreMonomorphic(), and v8::internal::PropertyICCompiler::ComputeKeyedStorePolymorphic().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeTransitionedMap()

Handle< Map > v8::internal::KeyedStoreIC::ComputeTransitionedMap ( Handle< Map >  map, KeyedAccessStoreMode  store_mode  )

private

Definition at line 1666 of file ic.cc.

                                                      {
  switch (store_mode) {
    case STORE_TRANSITION_SMI_TO_OBJECT:
    case STORE_TRANSITION_DOUBLE_TO_OBJECT:
    case STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT:
    case STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT:
      return Map::TransitionElementsTo(map, FAST_ELEMENTS);
    case STORE_TRANSITION_SMI_TO_DOUBLE:
    case STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE:
      return Map::TransitionElementsTo(map, FAST_DOUBLE_ELEMENTS);
    case STORE_TRANSITION_HOLEY_SMI_TO_OBJECT:
    case STORE_TRANSITION_HOLEY_DOUBLE_TO_OBJECT:
    case STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_OBJECT:
    case STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT:
      return Map::TransitionElementsTo(map, FAST_HOLEY_ELEMENTS);
    case STORE_TRANSITION_HOLEY_SMI_TO_DOUBLE:
    case STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_DOUBLE:
      return Map::TransitionElementsTo(map, FAST_HOLEY_DOUBLE_ELEMENTS);
    case STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS:
      DCHECK(map->has_external_array_elements());
    // Fall through
    case STORE_NO_TRANSITION_HANDLE_COW:
    case STANDARD_STORE:
    case STORE_AND_GROW_NO_TRANSITION:
      return map;
  }
  UNREACHABLE();
  return MaybeHandle<Map>().ToHandleChecked();
}

References DCHECK, v8::internal::FAST_DOUBLE_ELEMENTS, v8::internal::FAST_ELEMENTS, v8::internal::FAST_HOLEY_DOUBLE_ELEMENTS, v8::internal::FAST_HOLEY_ELEMENTS, map, v8::internal::STANDARD_STORE, v8::internal::STORE_AND_GROW_NO_TRANSITION, v8::internal::STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT, v8::internal::STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT, v8::internal::STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_DOUBLE, v8::internal::STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_OBJECT, v8::internal::STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE, v8::internal::STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT, v8::internal::STORE_NO_TRANSITION_HANDLE_COW, v8::internal::STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS, v8::internal::STORE_TRANSITION_DOUBLE_TO_OBJECT, v8::internal::STORE_TRANSITION_HOLEY_DOUBLE_TO_OBJECT, v8::internal::STORE_TRANSITION_HOLEY_SMI_TO_DOUBLE, v8::internal::STORE_TRANSITION_HOLEY_SMI_TO_OBJECT, v8::internal::STORE_TRANSITION_SMI_TO_DOUBLE, v8::internal::STORE_TRANSITION_SMI_TO_OBJECT, v8::internal::Map::TransitionElementsTo(), and UNREACHABLE.

Referenced by StoreElementStub().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateGeneric()

static void v8::internal::KeyedStoreIC::GenerateGeneric ( MacroAssembler *  masm, StrictMode  strict_mode  )

static

Referenced by v8::internal::Generate_KeyedStoreIC_Generic(), and v8::internal::Generate_KeyedStoreIC_Generic_Strict().

Here is the caller graph for this function:

GenerateInitialize()

static void v8::internal::KeyedStoreIC::GenerateInitialize ( MacroAssembler *  masm )

inlinestatic

Definition at line 557 of file ic.h.

{ GenerateMiss(masm); }

References v8::internal::LoadIC::GenerateMiss().

Referenced by v8::internal::Generate_KeyedStoreIC_Initialize(), and v8::internal::Generate_KeyedStoreIC_Initialize_Strict().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateMiss()

static void v8::internal::KeyedStoreIC::GenerateMiss ( MacroAssembler *  masm )

static

Referenced by v8::internal::Generate_KeyedStoreIC_Miss().

Here is the caller graph for this function:

GeneratePreMonomorphic()

static void v8::internal::KeyedStoreIC::GeneratePreMonomorphic ( MacroAssembler *  masm )

inlinestatic

Definition at line 558 of file ic.h.

                                                           {
    GenerateMiss(masm);
  }

References v8::internal::LoadIC::GenerateMiss().

Referenced by v8::internal::Generate_KeyedStoreIC_PreMonomorphic(), and v8::internal::Generate_KeyedStoreIC_PreMonomorphic_Strict().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateSloppyArguments()

static void v8::internal::KeyedStoreIC::GenerateSloppyArguments ( MacroAssembler *  masm )

static

Referenced by v8::internal::Generate_KeyedStoreIC_SloppyArguments().

Here is the caller graph for this function:

GenerateSlow()

static void v8::internal::KeyedStoreIC::GenerateSlow ( MacroAssembler *  masm )

static

GetKeyedAccessStoreMode()

static KeyedAccessStoreMode v8::internal::KeyedStoreIC::GetKeyedAccessStoreMode ( ExtraICState  extra_state )

inlinestatic

Definition at line 543 of file ic.h.

                                {
    return ExtraICStateKeyedAccessStoreMode::decode(extra_state);
  }

Referenced by v8::internal::PropertyICCompiler::ComputeKeyedStoreMonomorphic(), v8::internal::PropertyICCompiler::ComputeMonomorphic(), v8::internal::TypeFeedbackOracle::GetStoreMode(), StoreElementStub(), and v8::internal::IC::TraceIC().

Here is the caller graph for this function:

GetStoreMode()

KeyedAccessStoreMode v8::internal::KeyedStoreIC::GetStoreMode ( Handle< JSObject >  receiver, Handle< Object >  key, Handle< Object >  value  )

private

Definition at line 1707 of file ic.cc.

                                                                      {
  Handle<Smi> smi_key = Object::ToSmi(isolate(), key).ToHandleChecked();
  int index = smi_key->value();
  bool oob_access = IsOutOfBoundsAccess(receiver, index);
  // Don't consider this a growing store if the store would send the receiver to
  // dictionary mode.
  bool allow_growth = receiver->IsJSArray() && oob_access &&
                      !receiver->WouldConvertToSlowElements(key);
  if (allow_growth) {
    // Handle growing array in stub if necessary.
    if (receiver->HasFastSmiElements()) {
      if (value->IsHeapNumber()) {
        if (receiver->HasFastHoleyElements()) {
          return STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_DOUBLE;
        } else {
          return STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE;
        }
      }
      if (value->IsHeapObject()) {
        if (receiver->HasFastHoleyElements()) {
          return STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_OBJECT;
        } else {
          return STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT;
        }
      }
    } else if (receiver->HasFastDoubleElements()) {
      if (!value->IsSmi() && !value->IsHeapNumber()) {
        if (receiver->HasFastHoleyElements()) {
          return STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT;
        } else {
          return STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT;
        }
      }
    }
    return STORE_AND_GROW_NO_TRANSITION;
  } else {
    // Handle only in-bounds elements accesses.
    if (receiver->HasFastSmiElements()) {
      if (value->IsHeapNumber()) {
        if (receiver->HasFastHoleyElements()) {
          return STORE_TRANSITION_HOLEY_SMI_TO_DOUBLE;
        } else {
          return STORE_TRANSITION_SMI_TO_DOUBLE;
        }
      } else if (value->IsHeapObject()) {
        if (receiver->HasFastHoleyElements()) {
          return STORE_TRANSITION_HOLEY_SMI_TO_OBJECT;
        } else {
          return STORE_TRANSITION_SMI_TO_OBJECT;
        }
      }
    } else if (receiver->HasFastDoubleElements()) {
      if (!value->IsSmi() && !value->IsHeapNumber()) {
        if (receiver->HasFastHoleyElements()) {
          return STORE_TRANSITION_HOLEY_DOUBLE_TO_OBJECT;
        } else {
          return STORE_TRANSITION_DOUBLE_TO_OBJECT;
        }
      }
    }
    if (!FLAG_trace_external_array_abuse &&
        receiver->map()->has_external_array_elements() && oob_access) {
      return STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS;
    }
    Heap* heap = receiver->GetHeap();
    if (receiver->elements()->map() == heap->fixed_cow_array_map()) {
      return STORE_NO_TRANSITION_HANDLE_COW;
    } else {
      return STANDARD_STORE;
    }
  }
}

References v8::internal::IC::isolate(), v8::internal::IsOutOfBoundsAccess(), v8::internal::STANDARD_STORE, v8::internal::STORE_AND_GROW_NO_TRANSITION, v8::internal::STORE_AND_GROW_TRANSITION_DOUBLE_TO_OBJECT, v8::internal::STORE_AND_GROW_TRANSITION_HOLEY_DOUBLE_TO_OBJECT, v8::internal::STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_DOUBLE, v8::internal::STORE_AND_GROW_TRANSITION_HOLEY_SMI_TO_OBJECT, v8::internal::STORE_AND_GROW_TRANSITION_SMI_TO_DOUBLE, v8::internal::STORE_AND_GROW_TRANSITION_SMI_TO_OBJECT, v8::internal::STORE_NO_TRANSITION_HANDLE_COW, v8::internal::STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS, v8::internal::STORE_TRANSITION_DOUBLE_TO_OBJECT, v8::internal::STORE_TRANSITION_HOLEY_DOUBLE_TO_OBJECT, v8::internal::STORE_TRANSITION_HOLEY_SMI_TO_DOUBLE, v8::internal::STORE_TRANSITION_HOLEY_SMI_TO_OBJECT, v8::internal::STORE_TRANSITION_SMI_TO_DOUBLE, v8::internal::STORE_TRANSITION_SMI_TO_OBJECT, and v8::internal::Object::ToSmi().

Referenced by Store().

Here is the call graph for this function:

Here is the caller graph for this function:

pre_monomorphic_stub() [1/2]

virtual Handle<Code> v8::internal::KeyedStoreIC::pre_monomorphic_stub ( ) const

inlineprotectedvirtual

Reimplemented from v8::internal::StoreIC.

Definition at line 567 of file ic.h.

                                                    {
    return pre_monomorphic_stub(isolate(), strict_mode());
  }

References v8::internal::IC::isolate(), and v8::internal::LoadIC::pre_monomorphic_stub().

Referenced by Clear().

Here is the call graph for this function:

Here is the caller graph for this function:

pre_monomorphic_stub() [2/2]

static Handle<Code> v8::internal::KeyedStoreIC::pre_monomorphic_stub ( Isolate *  isolate, StrictMode  strict_mode  )

inlinestaticprotected

Definition at line 570 of file ic.h.

                                                                   {
    if (strict_mode == STRICT) {
      return isolate->builtins()->KeyedStoreIC_PreMonomorphic_Strict();
    } else {
      return isolate->builtins()->KeyedStoreIC_PreMonomorphic();
    }
  }

References v8::internal::Isolate::builtins(), v8::internal::IC::isolate(), and v8::internal::STRICT.

Here is the call graph for this function:

set_target()

void v8::internal::KeyedStoreIC::set_target ( Code *  code )

inlineprivate

Definition at line 147 of file ic-inl.h.

                                        {
  // Strict mode must be preserved across IC patching.
  DCHECK(GetStrictMode(code->extra_ic_state()) == strict_mode());
  IC::set_target(code);
}

References DCHECK, v8::internal::Code::extra_ic_state(), v8::internal::StoreIC::GetStrictMode(), v8::internal::IC::set_target(), and v8::internal::StoreIC::strict_mode().

Referenced by Store().

Here is the call graph for this function:

Here is the caller graph for this function:

sloppy_arguments_stub()

Handle<Code> v8::internal::KeyedStoreIC::sloppy_arguments_stub ( )

inlineprivate

Definition at line 586 of file ic.h.

                                       {
    return isolate()->builtins()->KeyedStoreIC_SloppyArguments();
  }

References v8::internal::Isolate::builtins(), and v8::internal::IC::isolate().

Referenced by Store().

Here is the call graph for this function:

Here is the caller graph for this function:

Store()

MaybeHandle< Object > v8::internal::KeyedStoreIC::Store	(	Handle< Object >	object,
		Handle< Object >	name,
		Handle< Object >	value
	)

Definition at line 1783 of file ic.cc.

                                                              {
  // TODO(verwaest): Let SetProperty do the migration, since storing a property
  // might deprecate the current map again, if value does not fit.
  if (MigrateDeprecated(object)) {
    Handle<Object> result;
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate(), result, Runtime::SetObjectProperty(isolate(), object, key,
                                                      value, strict_mode()),
        Object);
    return result;
  }
 
  // Check for non-string values that can be converted into an
  // internalized string directly or is representable as a smi.
  key = TryConvertKey(key, isolate());
 
  Handle<Object> store_handle;
  Handle<Code> stub = generic_stub();
 
  if (key->IsInternalizedString()) {
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate(), store_handle,
        StoreIC::Store(object, Handle<String>::cast(key), value,
                       JSReceiver::MAY_BE_STORE_FROM_KEYED),
        Object);
    // TODO(jkummerow): Ideally we'd wrap this in "if (!is_target_set())",
    // but doing so causes Hydrogen crashes. Needs investigation.
    TRACE_GENERIC_IC(isolate(), "KeyedStoreIC",
                     "unhandled internalized string key");
    TRACE_IC("StoreIC", key);
    set_target(*stub);
    return store_handle;
  }
 
  bool use_ic =
      FLAG_use_ic && !object->IsStringWrapper() &&
      !object->IsAccessCheckNeeded() && !object->IsJSGlobalProxy() &&
      !(object->IsJSObject() && JSObject::cast(*object)->map()->is_observed());
  if (use_ic && !object->IsSmi()) {
    // Don't use ICs for maps of the objects in Array's prototype chain. We
    // expect to be able to trap element sets to objects with those maps in
    // the runtime to enable optimization of element hole access.
    Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object);
    if (heap_object->map()->IsMapInArrayPrototypeChain()) {
      TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "map in array prototype");
      use_ic = false;
    }
  }
 
  if (use_ic) {
    DCHECK(!object->IsAccessCheckNeeded());
 
    if (object->IsJSObject()) {
      Handle<JSObject> receiver = Handle<JSObject>::cast(object);
      bool key_is_smi_like = !Object::ToSmi(isolate(), key).is_null();
      if (receiver->elements()->map() ==
          isolate()->heap()->sloppy_arguments_elements_map()) {
        if (strict_mode() == SLOPPY) {
          stub = sloppy_arguments_stub();
        } else {
          TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "arguments receiver");
        }
      } else if (key_is_smi_like &&
                 !(target().is_identical_to(sloppy_arguments_stub()))) {
        // We should go generic if receiver isn't a dictionary, but our
        // prototype chain does have dictionary elements. This ensures that
        // other non-dictionary receivers in the polymorphic case benefit
        // from fast path keyed stores.
        if (!(receiver->map()->DictionaryElementsInPrototypeChainOnly())) {
          KeyedAccessStoreMode store_mode = GetStoreMode(receiver, key, value);
          stub = StoreElementStub(receiver, store_mode);
        } else {
          TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "dictionary prototype");
        }
      } else {
        TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "non-smi-like key");
      }
    } else {
      TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "non-JSObject receiver");
    }
  }
 
  if (store_handle.is_null()) {
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate(), store_handle,
        Runtime::SetObjectProperty(isolate(), object, key, value,
                                   strict_mode()),
        Object);
  }
 
  DCHECK(!is_target_set());
  Code* generic = *generic_stub();
  if (*stub == generic) {
    TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "set generic");
  }
  if (*stub == *slow_stub()) {
    TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "slow stub");
  }
  DCHECK(!stub.is_null());
  set_target(*stub);
  TRACE_IC("StoreIC", key);
 
  return store_handle;
}

References ASSIGN_RETURN_ON_EXCEPTION, v8::internal::Handle< T >::cast(), DCHECK, v8::internal::StoreIC::generic_stub(), GetStoreMode(), v8::internal::Handle< T >::is_null(), v8::internal::IC::is_target_set(), v8::internal::IC::isolate(), v8::internal::Object::MAY_BE_STORE_FROM_KEYED, v8::internal::MigrateDeprecated(), set_target(), v8::internal::Runtime::SetObjectProperty(), v8::internal::SLOPPY, sloppy_arguments_stub(), v8::internal::StoreIC::slow_stub(), v8::internal::StoreIC::Store(), StoreElementStub(), v8::internal::StoreIC::strict_mode(), v8::internal::IC::target(), v8::internal::Object::ToSmi(), TRACE_GENERIC_IC, TRACE_IC, and v8::internal::TryConvertKey().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

StoreElementStub()

Handle< Code > v8::internal::KeyedStoreIC::StoreElementStub ( Handle< JSObject >  receiver, KeyedAccessStoreMode  store_mode  )

protected

Definition at line 1547 of file ic.cc.

                                                                             {
  // Don't handle megamorphic property accesses for INTERCEPTORS or CALLBACKS
  // via megamorphic stubs, since they don't have a map in their relocation info
  // and so the stubs can't be harvested for the object needed for a map check.
  if (target()->type() != Code::NORMAL) {
    TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "non-NORMAL target type");
    return generic_stub();
  }
 
  Handle<Map> receiver_map(receiver->map(), isolate());
  MapHandleList target_receiver_maps;
  TargetMaps(&target_receiver_maps);
  if (target_receiver_maps.length() == 0) {
    Handle<Map> monomorphic_map =
        ComputeTransitionedMap(receiver_map, store_mode);
    store_mode = GetNonTransitioningStoreMode(store_mode);
    return PropertyICCompiler::ComputeKeyedStoreMonomorphic(
        monomorphic_map, strict_mode(), store_mode);
  }
 
  // There are several special cases where an IC that is MONOMORPHIC can still
  // transition to a different GetNonTransitioningStoreMode IC that handles a
  // superset of the original IC. Handle those here if the receiver map hasn't
  // changed or it has transitioned to a more general kind.
  KeyedAccessStoreMode old_store_mode =
      KeyedStoreIC::GetKeyedAccessStoreMode(target()->extra_ic_state());
  Handle<Map> previous_receiver_map = target_receiver_maps.at(0);
  if (state() == MONOMORPHIC) {
    Handle<Map> transitioned_receiver_map = receiver_map;
    if (IsTransitionStoreMode(store_mode)) {
      transitioned_receiver_map =
          ComputeTransitionedMap(receiver_map, store_mode);
    }
    if ((receiver_map.is_identical_to(previous_receiver_map) &&
         IsTransitionStoreMode(store_mode)) ||
        IsTransitionOfMonomorphicTarget(*previous_receiver_map,
                                        *transitioned_receiver_map)) {
      // If the "old" and "new" maps are in the same elements map family, or
      // if they at least come from the same origin for a transitioning store,
      // stay MONOMORPHIC and use the map for the most generic ElementsKind.
      store_mode = GetNonTransitioningStoreMode(store_mode);
      return PropertyICCompiler::ComputeKeyedStoreMonomorphic(
          transitioned_receiver_map, strict_mode(), store_mode);
    } else if (*previous_receiver_map == receiver->map() &&
               old_store_mode == STANDARD_STORE &&
               (store_mode == STORE_AND_GROW_NO_TRANSITION ||
                store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS ||
                store_mode == STORE_NO_TRANSITION_HANDLE_COW)) {
      // A "normal" IC that handles stores can switch to a version that can
      // grow at the end of the array, handle OOB accesses or copy COW arrays
      // and still stay MONOMORPHIC.
      return PropertyICCompiler::ComputeKeyedStoreMonomorphic(
          receiver_map, strict_mode(), store_mode);
    }
  }
 
  DCHECK(state() != GENERIC);
 
  bool map_added =
      AddOneReceiverMapIfMissing(&target_receiver_maps, receiver_map);
 
  if (IsTransitionStoreMode(store_mode)) {
    Handle<Map> transitioned_receiver_map =
        ComputeTransitionedMap(receiver_map, store_mode);
    map_added |= AddOneReceiverMapIfMissing(&target_receiver_maps,
                                            transitioned_receiver_map);
  }
 
  if (!map_added) {
    // If the miss wasn't due to an unseen map, a polymorphic stub
    // won't help, use the generic stub.
    TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "same map added twice");
    return generic_stub();
  }
 
  // If the maximum number of receiver maps has been exceeded, use the generic
  // version of the IC.
  if (target_receiver_maps.length() > kMaxKeyedPolymorphism) {
    TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "max polymorph exceeded");
    return generic_stub();
  }
 
  // Make sure all polymorphic handlers have the same store mode, otherwise the
  // generic stub must be used.
  store_mode = GetNonTransitioningStoreMode(store_mode);
  if (old_store_mode != STANDARD_STORE) {
    if (store_mode == STANDARD_STORE) {
      store_mode = old_store_mode;
    } else if (store_mode != old_store_mode) {
      TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "store mode mismatch");
      return generic_stub();
    }
  }
 
  // If the store mode isn't the standard mode, make sure that all polymorphic
  // receivers are either external arrays, or all "normal" arrays. Otherwise,
  // use the generic stub.
  if (store_mode != STANDARD_STORE) {
    int external_arrays = 0;
    for (int i = 0; i < target_receiver_maps.length(); ++i) {
      if (target_receiver_maps[i]->has_external_array_elements() ||
          target_receiver_maps[i]->has_fixed_typed_array_elements()) {
        external_arrays++;
      }
    }
    if (external_arrays != 0 &&
        external_arrays != target_receiver_maps.length()) {
      TRACE_GENERIC_IC(isolate(), "KeyedStoreIC",
                       "unsupported combination of external and normal arrays");
      return generic_stub();
    }
  }
 
  return PropertyICCompiler::ComputeKeyedStorePolymorphic(
      &target_receiver_maps, store_mode, strict_mode());
}

References v8::internal::AddOneReceiverMapIfMissing(), v8::internal::List< T, AllocationPolicy >::at(), v8::internal::PropertyICCompiler::ComputeKeyedStoreMonomorphic(), v8::internal::PropertyICCompiler::ComputeKeyedStorePolymorphic(), ComputeTransitionedMap(), DCHECK, v8::internal::IC::extra_ic_state(), v8::internal::GENERIC, v8::internal::StoreIC::generic_stub(), GetKeyedAccessStoreMode(), v8::internal::GetNonTransitioningStoreMode(), v8::internal::IC::isolate(), v8::internal::IC::IsTransitionOfMonomorphicTarget(), v8::internal::IsTransitionStoreMode(), v8::internal::kMaxKeyedPolymorphism, v8::internal::MONOMORPHIC, v8::internal::Code::NORMAL, v8::internal::STANDARD_STORE, v8::internal::IC::state(), v8::internal::STORE_AND_GROW_NO_TRANSITION, v8::internal::STORE_NO_TRANSITION_HANDLE_COW, v8::internal::STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS, v8::internal::StoreIC::strict_mode(), v8::internal::IC::target(), v8::internal::IC::TargetMaps(), and TRACE_GENERIC_IC.

Referenced by Store().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

IC

friend class IC

friend

Definition at line 599 of file ic.h.

---

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

• /mnt/V8SourceCode/src/ic/ic.h
• /mnt/V8SourceCode/src/ic/ic-inl.h
• /mnt/V8SourceCode/src/ic/ic.cc