#include <ic.h>

Inheritance diagram for v8::internal::StoreIC:

Collaboration diagram for v8::internal::StoreIC:

Classes
class	StrictModeState

Public Member Functions
	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)

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)

Static Public Attributes
static const ExtraICState	kStrictModeState = 1 << StrictModeState::kShift

Protected Member Functions
virtual Handle< Code >	megamorphic_stub () OVERRIDE

Handle< Code >	generic_stub () const

Handle< Code >	slow_stub () const

virtual Handle< Code >	pre_monomorphic_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::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)

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

Detailed Description

Definition at line 447 of file ic.h.

Constructor & Destructor Documentation

◆ StoreIC()

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

inline

Definition at line 461 of file ic.h.

                                               : IC(depth, isolate) {
     DCHECK(IsStoreStub());
   }

References DCHECK.

Member Function Documentation

◆ Clear()

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

staticprivate

Definition at line 536 of file ic.cc.

                                                       {
   if (IsCleared(target)) return;
   Code* code = PropertyICCompiler::FindPreMonomorphic(isolate, Code::STORE_IC,
                                                       target->extra_ic_state());
   SetTargetAtAddress(address, code, constant_pool);
 }

References v8::internal::IC::address(), v8::internal::IC::constant_pool(), v8::internal::PropertyICCompiler::FindPreMonomorphic(), v8::internal::IC::IsCleared(), v8::internal::IC::isolate(), 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:

◆ CompileHandler()

Handle< Code > v8::internal::StoreIC::CompileHandler	(	LookupIterator *	lookup,
		Handle< Object >	value,
		CacheHolderFlag	cache_holder
	)

protectedvirtual

Reimplemented from v8::internal::IC.

Definition at line 1423 of file ic.cc.

                                                                    {
   DCHECK_NE(LookupIterator::JSPROXY, lookup->state());
  
   // This is currently guaranteed by checks in StoreIC::Store.
   Handle<JSObject> receiver = Handle<JSObject>::cast(lookup->GetReceiver());
   Handle<JSObject> holder = lookup->GetHolder<JSObject>();
   DCHECK(!receiver->IsAccessCheckNeeded());
  
   switch (lookup->state()) {
     case LookupIterator::TRANSITION: {
       Handle<Map> transition = lookup->transition_map();
       // Currently not handled by CompileStoreTransition.
       if (!holder->HasFastProperties()) {
         TRACE_GENERIC_IC(isolate(), "StoreIC", "transition from slow");
         break;
       }
  
       DCHECK(lookup->IsCacheableTransition());
       NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
       return compiler.CompileStoreTransition(transition, lookup->name());
     }
  
     case LookupIterator::INTERCEPTOR: {
       DCHECK(!holder->GetNamedInterceptor()->setter()->IsUndefined());
       NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
       return compiler.CompileStoreInterceptor(lookup->name());
     }
  
     case LookupIterator::ACCESSOR: {
       if (!holder->HasFastProperties()) {
         TRACE_GENERIC_IC(isolate(), "StoreIC", "accessor on slow map");
         break;
       }
       Handle<Object> accessors = lookup->GetAccessors();
       if (accessors->IsExecutableAccessorInfo()) {
         Handle<ExecutableAccessorInfo> info =
             Handle<ExecutableAccessorInfo>::cast(accessors);
         if (v8::ToCData<Address>(info->setter()) == 0) {
           TRACE_GENERIC_IC(isolate(), "StoreIC", "setter == 0");
           break;
         }
         if (!ExecutableAccessorInfo::IsCompatibleReceiverType(
                 isolate(), info, receiver_type())) {
           TRACE_GENERIC_IC(isolate(), "StoreIC", "incompatible receiver type");
           break;
         }
         NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
         return compiler.CompileStoreCallback(receiver, lookup->name(), info);
       } else if (accessors->IsAccessorPair()) {
         Handle<Object> setter(Handle<AccessorPair>::cast(accessors)->setter(),
                               isolate());
         if (!setter->IsJSFunction()) {
           TRACE_GENERIC_IC(isolate(), "StoreIC", "setter not a function");
           break;
         }
         Handle<JSFunction> function = Handle<JSFunction>::cast(setter);
         CallOptimization call_optimization(function);
         NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
         if (call_optimization.is_simple_api_call() &&
             call_optimization.IsCompatibleReceiver(receiver, holder)) {
           return compiler.CompileStoreCallback(receiver, lookup->name(),
                                                call_optimization);
         }
         return compiler.CompileStoreViaSetter(receiver, lookup->name(),
                                               Handle<JSFunction>::cast(setter));
       }
       // TODO(dcarney): Handle correctly.
       DCHECK(accessors->IsDeclaredAccessorInfo());
       TRACE_GENERIC_IC(isolate(), "StoreIC", "declared accessor info");
       break;
     }
  
     case LookupIterator::DATA: {
       if (lookup->is_dictionary_holder()) {
         if (holder->IsGlobalObject()) {
           Handle<PropertyCell> cell = lookup->GetPropertyCell();
           Handle<HeapType> union_type = PropertyCell::UpdatedType(cell, value);
           StoreGlobalStub stub(isolate(), union_type->IsConstant(),
                                receiver->IsJSGlobalProxy());
           Handle<Code> code = stub.GetCodeCopyFromTemplate(
               Handle<GlobalObject>::cast(holder), cell);
           // TODO(verwaest): Move caching of these NORMAL stubs outside as well.
           HeapObject::UpdateMapCodeCache(receiver, lookup->name(), code);
           return code;
         }
         DCHECK(holder.is_identical_to(receiver));
         return isolate()->builtins()->StoreIC_Normal();
       }
  
       // -------------- Fields --------------
       if (lookup->property_details().type() == FIELD) {
         bool use_stub = true;
         if (lookup->representation().IsHeapObject()) {
           // Only use a generic stub if no types need to be tracked.
           Handle<HeapType> field_type = lookup->GetFieldType();
           HeapType::Iterator<Map> it = field_type->Classes();
           use_stub = it.Done();
         }
         if (use_stub) {
           StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
                               lookup->representation());
           return stub.GetCode();
         }
         NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
         return compiler.CompileStoreField(lookup);
       }
  
       // -------------- Constant properties --------------
       DCHECK(lookup->property_details().type() == CONSTANT);
       TRACE_GENERIC_IC(isolate(), "StoreIC", "constant property");
       break;
     }
  
     case LookupIterator::ACCESS_CHECK:
     case LookupIterator::JSPROXY:
     case LookupIterator::NOT_FOUND:
       UNREACHABLE();
   }
   return slow_stub();
 }

References v8::internal::ACCESSOR, v8::internal::Isolate::builtins(), v8::internal::Handle< T >::cast(), v8::internal::NamedStoreHandlerCompiler::CompileStoreCallback(), v8::internal::NamedStoreHandlerCompiler::CompileStoreField(), v8::internal::NamedStoreHandlerCompiler::CompileStoreInterceptor(), v8::internal::NamedStoreHandlerCompiler::CompileStoreTransition(), v8::internal::NamedStoreHandlerCompiler::CompileStoreViaSetter(), v8::internal::CONSTANT, DCHECK, DCHECK_NE, v8::internal::TypeImpl< Config >::Iterator< T >::Done(), v8::internal::FIELD, v8::internal::StoreGlobalStub::GetCodeCopyFromTemplate(), v8::internal::AccessorInfo::IsCompatibleReceiverType(), v8::internal::IC::isolate(), v8::internal::IC::receiver_type(), slow_stub(), TRACE_GENERIC_IC, UNREACHABLE, v8::internal::PropertyCell::UpdatedType(), and v8::internal::HeapObject::UpdateMapCodeCache().

Here is the call graph for this function:

◆ ComputeExtraICState()

static ExtraICState v8::internal::StoreIC::ComputeExtraICState ( StrictMode flag )

inlinestatic

Definition at line 450 of file ic.h.

                                                            {
     return StrictModeState::encode(flag);
   }

References v8::internal::flag.

Referenced by initialize_stub(), and pre_monomorphic_stub().

Here is the caller graph for this function:

◆ GenerateInitialize()

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

inlinestatic

Definition at line 471 of file ic.h.

471 { GenerateMiss(masm); }

v8::internal::StoreIC::GenerateMiss

static void GenerateMiss(MacroAssembler *masm)

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

Referenced by v8::internal::PropertyICCompiler::CompileStoreInitialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateMegamorphic()

static void v8::internal::StoreIC::GenerateMegamorphic ( MacroAssembler * masm )

static

Referenced by v8::internal::PropertyICCompiler::CompileStoreMegamorphic().

Here is the caller graph for this function:

◆ GenerateMiss()

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

static

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

Here is the caller graph for this function:

◆ GenerateNormal()

static void v8::internal::StoreIC::GenerateNormal ( MacroAssembler * masm )

static

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

Here is the caller graph for this function:

◆ GeneratePreMonomorphic()

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

inlinestatic

Definition at line 472 of file ic.h.

                                                            {
     GenerateMiss(masm);
   }

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

Referenced by v8::internal::PropertyICCompiler::CompileStorePreMonomorphic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateRuntimeSetProperty()

static void v8::internal::StoreIC::GenerateRuntimeSetProperty	(	MacroAssembler *	masm,
		StrictMode	strict_mode
	)

static

◆ GenerateSlow()

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

static

◆ generic_stub()

Handle< Code > v8::internal::StoreIC::generic_stub ( ) const

protected

Definition at line 1370 of file ic.cc.

                                          {
   if (kind() == Code::STORE_IC) {
     return PropertyICCompiler::ComputeStore(isolate(), GENERIC,
                                             extra_ic_state());
   } else {
     DCHECK(kind() == Code::KEYED_STORE_IC);
     if (strict_mode() == STRICT) {
       return isolate()->builtins()->KeyedStoreIC_Generic_Strict();
     } else {
       return isolate()->builtins()->KeyedStoreIC_Generic();
     }
   }
 }

References v8::internal::Isolate::builtins(), v8::internal::PropertyICCompiler::ComputeStore(), DCHECK, v8::internal::IC::extra_ic_state(), v8::internal::GENERIC, v8::internal::IC::isolate(), v8::internal::IC::kind(), v8::internal::STRICT, and strict_mode().

Referenced by v8::internal::KeyedStoreIC::Store(), and v8::internal::KeyedStoreIC::StoreElementStub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStrictMode()

static StrictMode v8::internal::StoreIC::GetStrictMode ( ExtraICState state )

inlinestatic

Definition at line 453 of file ic.h.

                                                       {
     return StrictModeState::decode(state);
   }

References v8::internal::IC::state().

Referenced by v8::internal::KeyedStoreIC::Clear(), v8::internal::PropertyICCompiler::CompileStoreGeneric(), set_target(), v8::internal::KeyedStoreIC::set_target(), and v8::internal::IC::SetTargetAtAddress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize_stub()

Handle< Code > v8::internal::StoreIC::initialize_stub	(	Isolate *	isolate,
		StrictMode	strict_mode
	)

static

Definition at line 1346 of file ic.cc.

                                                               {
   ExtraICState extra_state = ComputeExtraICState(strict_mode);
   Handle<Code> ic =
       PropertyICCompiler::ComputeStore(isolate, UNINITIALIZED, extra_state);
   return ic;
 }

References ComputeExtraICState(), v8::internal::PropertyICCompiler::ComputeStore(), v8::internal::IC::isolate(), strict_mode(), and v8::internal::UNINITIALIZED.

Here is the call graph for this function:

◆ LookupForWrite()

bool v8::internal::StoreIC::LookupForWrite	(	LookupIterator *	it,
		Handle< Object >	value,
		JSReceiver::StoreFromKeyed	store_mode
	)

Definition at line 1221 of file ic.cc.

                                                                   {
   // Disable ICs for non-JSObjects for now.
   Handle<Object> receiver = it->GetReceiver();
   if (!receiver->IsJSObject()) return false;
   DCHECK(!Handle<JSObject>::cast(receiver)->map()->is_deprecated());
  
   for (; it->IsFound(); it->Next()) {
     switch (it->state()) {
       case LookupIterator::NOT_FOUND:
       case LookupIterator::TRANSITION:
         UNREACHABLE();
       case LookupIterator::JSPROXY:
         return false;
       case LookupIterator::INTERCEPTOR: {
         Handle<JSObject> holder = it->GetHolder<JSObject>();
         InterceptorInfo* info = holder->GetNamedInterceptor();
         if (it->HolderIsReceiverOrHiddenPrototype()) {
           if (!info->setter()->IsUndefined()) return true;
         } else if (!info->getter()->IsUndefined() ||
                    !info->query()->IsUndefined()) {
           return false;
         }
         break;
       }
       case LookupIterator::ACCESS_CHECK:
         if (it->GetHolder<JSObject>()->IsAccessCheckNeeded()) return false;
         break;
       case LookupIterator::ACCESSOR:
         return !it->IsReadOnly();
       case LookupIterator::DATA: {
         if (it->IsReadOnly()) return false;
         Handle<JSObject> holder = it->GetHolder<JSObject>();
         if (receiver.is_identical_to(holder)) {
           it->PrepareForDataProperty(value);
           // The previous receiver map might just have been deprecated,
           // so reload it.
           update_receiver_type(receiver);
           return true;
         }
  
         // Receiver != holder.
         PrototypeIterator iter(it->isolate(), receiver);
         if (receiver->IsJSGlobalProxy()) {
           return it->GetHolder<Object>().is_identical_to(
               PrototypeIterator::GetCurrent(iter));
         }
  
         it->PrepareTransitionToDataProperty(value, NONE, store_mode);
         return it->IsCacheableTransition();
       }
     }
   }
  
   it->PrepareTransitionToDataProperty(value, NONE, store_mode);
   return it->IsCacheableTransition();
 }

References v8::internal::ACCESSOR, DCHECK, v8::internal::PrototypeIterator::GetCurrent(), map, NONE, UNREACHABLE, and v8::internal::IC::update_receiver_type().

Referenced by UpdateCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ megamorphic_stub()

Handle< Code > v8::internal::StoreIC::megamorphic_stub ( )

protectedvirtual

Reimplemented from v8::internal::IC.

Definition at line 1355 of file ic.cc.

                                        {
   if (kind() == Code::STORE_IC) {
     return PropertyICCompiler::ComputeStore(isolate(), MEGAMORPHIC,
                                             extra_ic_state());
   } else {
     DCHECK(kind() == Code::KEYED_STORE_IC);
     if (strict_mode() == STRICT) {
       return isolate()->builtins()->KeyedStoreIC_Generic_Strict();
     } else {
       return isolate()->builtins()->KeyedStoreIC_Generic();
     }
   }
 }

References v8::internal::Isolate::builtins(), v8::internal::PropertyICCompiler::ComputeStore(), DCHECK, v8::internal::IC::extra_ic_state(), v8::internal::IC::isolate(), v8::internal::IC::kind(), v8::internal::MEGAMORPHIC, v8::internal::STRICT, and strict_mode().

Here is the call graph for this function:

◆ pre_monomorphic_stub() [1/2]

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

inlineprotectedvirtual

Reimplemented in v8::internal::KeyedStoreIC.

Definition at line 499 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 UpdateCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pre_monomorphic_stub() [2/2]

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

staticprotected

Definition at line 1395 of file ic.cc.

                                                                    {
   ExtraICState state = ComputeExtraICState(strict_mode);
   return PropertyICCompiler::ComputeStore(isolate, PREMONOMORPHIC, state);
 }

References ComputeExtraICState(), v8::internal::PropertyICCompiler::ComputeStore(), v8::internal::IC::isolate(), v8::internal::PREMONOMORPHIC, v8::internal::IC::state(), and strict_mode().

Here is the call graph for this function:

◆ set_target()

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

inlineprivate

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

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

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

Referenced by UpdateCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slow_stub()

Handle< Code > v8::internal::StoreIC::slow_stub ( ) const

protected

Definition at line 1385 of file ic.cc.

                                       {
   if (kind() == Code::STORE_IC) {
     return isolate()->builtins()->StoreIC_Slow();
   } else {
     DCHECK(kind() == Code::KEYED_STORE_IC);
     return isolate()->builtins()->KeyedStoreIC_Slow();
   }
 }

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

Referenced by CompileHandler(), v8::internal::KeyedStoreIC::Store(), and UpdateCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Store()

MaybeHandle< Object > v8::internal::StoreIC::Store	(	Handle< Object >	object,
		Handle< Name >	name,
		Handle< Object >	value,
		JSReceiver::StoreFromKeyed	store_mode = `JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED`
	)

Definition at line 1280 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) || object->IsJSProxy()) {
     Handle<Object> result;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate(), result,
         Object::SetProperty(object, name, value, strict_mode()), Object);
     return result;
   }
  
   // If the object is undefined or null it's illegal to try to set any
   // properties on it; throw a TypeError in that case.
   if (object->IsUndefined() || object->IsNull()) {
     return TypeError("non_object_property_store", object, name);
   }
  
   // Check if the given name is an array index.
   uint32_t index;
   if (name->AsArrayIndex(&index)) {
     // Ignore other stores where the receiver is not a JSObject.
     // TODO(1475): Must check prototype chains of object wrappers.
     if (!object->IsJSObject()) return value;
     Handle<JSObject> receiver = Handle<JSObject>::cast(object);
  
     Handle<Object> result;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate(), result,
         JSObject::SetElement(receiver, index, value, NONE, strict_mode()),
         Object);
     return value;
   }
  
   // Observed objects are always modified through the runtime.
   if (object->IsHeapObject() &&
       Handle<HeapObject>::cast(object)->map()->is_observed()) {
     Handle<Object> result;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate(), result,
         Object::SetProperty(object, name, value, strict_mode(), store_mode),
         Object);
     return result;
   }
  
   LookupIterator it(object, name);
   if (FLAG_use_ic) UpdateCaches(&it, value, store_mode);
  
   // Set the property.
   Handle<Object> result;
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate(), result,
       Object::SetProperty(&it, value, strict_mode(), store_mode), Object);
   return result;
 }

References ASSIGN_RETURN_ON_EXCEPTION, v8::internal::Handle< T >::cast(), v8::internal::IC::isolate(), v8::internal::MigrateDeprecated(), name, NONE, v8::internal::JSObject::SetElement(), v8::internal::Object::SetProperty(), strict_mode(), v8::internal::IC::TypeError(), and UpdateCaches().

Referenced by v8::internal::RUNTIME_FUNCTION(), and v8::internal::KeyedStoreIC::Store().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ strict_mode()

StrictMode v8::internal::StoreIC::strict_mode ( ) const

inline

Definition at line 465 of file ic.h.

                                  {
     return StrictModeState::decode(extra_ic_state());
   }

References v8::internal::IC::extra_ic_state().

Referenced by generic_stub(), initialize_stub(), megamorphic_stub(), pre_monomorphic_stub(), v8::internal::RUNTIME_FUNCTION(), v8::internal::KeyedStoreIC::set_target(), Store(), v8::internal::KeyedStoreIC::Store(), and v8::internal::KeyedStoreIC::StoreElementStub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateCaches()

void v8::internal::StoreIC::UpdateCaches	(	LookupIterator *	lookup,
		Handle< Object >	value,
		JSReceiver::StoreFromKeyed	store_mode
	)

protected

Definition at line 1402 of file ic.cc.

                                                                 {
   if (state() == UNINITIALIZED) {
     // This is the first time we execute this inline cache. Set the target to
     // the pre monomorphic stub to delay setting the monomorphic state.
     set_target(*pre_monomorphic_stub());
     TRACE_IC("StoreIC", lookup->name());
     return;
   }
  
   bool use_ic = LookupForWrite(lookup, value, store_mode);
   if (!use_ic) {
     TRACE_GENERIC_IC(isolate(), "StoreIC", "LookupForWrite said 'false'");
   }
   Handle<Code> code = use_ic ? ComputeHandler(lookup, value) : slow_stub();
  
   PatchCache(lookup->name(), code);
   TRACE_IC("StoreIC", lookup->name());
 }

References v8::internal::IC::ComputeHandler(), v8::internal::IC::isolate(), LookupForWrite(), v8::internal::IC::PatchCache(), pre_monomorphic_stub(), set_target(), slow_stub(), v8::internal::IC::state(), TRACE_GENERIC_IC, TRACE_IC, and v8::internal::UNINITIALIZED.

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 520 of file ic.h.

Member Data Documentation

◆ kStrictModeState

const ExtraICState v8::internal::StoreIC::kStrictModeState = 1 << StrictModeState::kShift

static

Definition at line 459 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

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Private Member Functions

Static Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ StoreIC()

Member Function Documentation

◆ Clear()

◆ CompileHandler()

◆ ComputeExtraICState()

◆ GenerateInitialize()

◆ GenerateMegamorphic()

◆ GenerateMiss()

◆ GenerateNormal()

◆ GeneratePreMonomorphic()

◆ GenerateRuntimeSetProperty()

◆ GenerateSlow()

◆ generic_stub()

◆ GetStrictMode()

◆ initialize_stub()

◆ LookupForWrite()

◆ megamorphic_stub()

◆ pre_monomorphic_stub() [1/2]

◆ pre_monomorphic_stub() [2/2]

◆ set_target()

◆ slow_stub()

◆ Store()

◆ strict_mode()

◆ UpdateCaches()

Friends And Related Function Documentation

◆ IC

Member Data Documentation

◆ kStrictModeState