#include <ic.h>

Inheritance diagram for v8::internal::LoadIC:

Collaboration diagram for v8::internal::LoadIC:

Public Member Functions
ContextualMode	contextual_mode () const

	LoadIC (FrameDepth depth, Isolate *isolate)

bool	IsUndeclaredGlobal (Handle< Object > receiver)

MUST_USE_RESULT MaybeHandle< Object >	Load (Handle< Object > object, Handle< Name > name)

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 (ContextualMode contextual_mode)

static void	GenerateInitialize (MacroAssembler *masm)

static void	GeneratePreMonomorphic (MacroAssembler *masm)

static void	GenerateMiss (MacroAssembler *masm)

static void	GenerateNormal (MacroAssembler *masm)

static void	GenerateRuntimeGetProperty (MacroAssembler *masm)

static Handle< Code >	initialize_stub (Isolate *isolate, ExtraICState extra_state)

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
void	set_target (Code *code)

Handle< Code >	slow_stub () const

virtual Handle< Code >	megamorphic_stub () OVERRIDE

void	UpdateCaches (LookupIterator *lookup)

virtual Handle< Code >	CompileHandler (LookupIterator *lookup, Handle< Object > unused, 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 ()

Private Member Functions
virtual Handle< Code >	pre_monomorphic_stub () const

Handle< Code >	SimpleFieldLoad (FieldIndex index)

Static Private Member Functions
static Handle< Code >	pre_monomorphic_stub (Isolate *isolate, ExtraICState extra_state)

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 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)

Detailed Description

Definition at line 322 of file ic.h.

Constructor & Destructor Documentation

◆ LoadIC()

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

inlineexplicit

Definition at line 332 of file ic.h.

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

References DCHECK.

Member Function Documentation

◆ Clear()

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

staticprivate

Definition at line 527 of file ic.cc.

                                                      {
   if (IsCleared(target)) return;
   Code* code = PropertyICCompiler::FindPreMonomorphic(isolate, Code::LOAD_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::LoadIC::CompileHandler	(	LookupIterator *	lookup,
		Handle< Object >	unused,
		CacheHolderFlag	cache_holder
	)

protectedvirtual

Reimplemented from v8::internal::IC.

Definition at line 947 of file ic.cc.

                                                                   {
   Handle<Object> receiver = lookup->GetReceiver();
   if (receiver->IsString() &&
       Name::Equals(isolate()->factory()->length_string(), lookup->name())) {
     FieldIndex index = FieldIndex::ForInObjectOffset(String::kLengthOffset);
     return SimpleFieldLoad(index);
   }
  
   if (receiver->IsStringWrapper() &&
       Name::Equals(isolate()->factory()->length_string(), lookup->name())) {
     StringLengthStub string_length_stub(isolate());
     return string_length_stub.GetCode();
   }
  
   // Use specialized code for getting prototype of functions.
   if (receiver->IsJSFunction() &&
       Name::Equals(isolate()->factory()->prototype_string(), lookup->name()) &&
       Handle<JSFunction>::cast(receiver)->should_have_prototype() &&
       !Handle<JSFunction>::cast(receiver)
            ->map()
            ->has_non_instance_prototype()) {
     Handle<Code> stub;
     FunctionPrototypeStub function_prototype_stub(isolate());
     return function_prototype_stub.GetCode();
   }
  
   Handle<HeapType> type = receiver_type();
   Handle<JSObject> holder = lookup->GetHolder<JSObject>();
   bool receiver_is_holder = receiver.is_identical_to(holder);
   switch (lookup->state()) {
     case LookupIterator::INTERCEPTOR: {
       DCHECK(!holder->GetNamedInterceptor()->getter()->IsUndefined());
       NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
                                         cache_holder);
       // Perform a lookup behind the interceptor. Copy the LookupIterator since
       // the original iterator will be used to fetch the value.
       LookupIterator it = *lookup;
       it.Next();
       LookupForRead(&it);
       return compiler.CompileLoadInterceptor(&it);
     }
  
     case LookupIterator::ACCESSOR: {
       // Use simple field loads for some well-known callback properties.
       if (receiver_is_holder) {
         DCHECK(receiver->IsJSObject());
         Handle<JSObject> js_receiver = Handle<JSObject>::cast(receiver);
         int object_offset;
         if (Accessors::IsJSObjectFieldAccessor<HeapType>(type, lookup->name(),
                                                          &object_offset)) {
           FieldIndex index =
               FieldIndex::ForInObjectOffset(object_offset, js_receiver->map());
           return SimpleFieldLoad(index);
         }
       }
  
       Handle<Object> accessors = lookup->GetAccessors();
       if (accessors->IsExecutableAccessorInfo()) {
         Handle<ExecutableAccessorInfo> info =
             Handle<ExecutableAccessorInfo>::cast(accessors);
         if (v8::ToCData<Address>(info->getter()) == 0) break;
         if (!ExecutableAccessorInfo::IsCompatibleReceiverType(isolate(), info,
                                                               type)) {
           break;
         }
         if (!holder->HasFastProperties()) break;
         NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
                                           cache_holder);
         return compiler.CompileLoadCallback(lookup->name(), info);
       }
       if (accessors->IsAccessorPair()) {
         Handle<Object> getter(Handle<AccessorPair>::cast(accessors)->getter(),
                               isolate());
         if (!getter->IsJSFunction()) break;
         if (!holder->HasFastProperties()) break;
         Handle<JSFunction> function = Handle<JSFunction>::cast(getter);
         if (!receiver->IsJSObject() && !function->IsBuiltin() &&
             function->shared()->strict_mode() == SLOPPY) {
           // Calling sloppy non-builtins with a value as the receiver
           // requires boxing.
           break;
         }
         CallOptimization call_optimization(function);
         NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
                                           cache_holder);
         if (call_optimization.is_simple_api_call() &&
             call_optimization.IsCompatibleReceiver(receiver, holder)) {
           return compiler.CompileLoadCallback(lookup->name(),
                                               call_optimization);
         }
         return compiler.CompileLoadViaGetter(lookup->name(), function);
       }
       // TODO(dcarney): Handle correctly.
       DCHECK(accessors->IsDeclaredAccessorInfo());
       break;
     }
  
     case LookupIterator::DATA: {
       if (lookup->is_dictionary_holder()) {
         if (kind() != Code::LOAD_IC) break;
         if (holder->IsGlobalObject()) {
           NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
                                             cache_holder);
           Handle<PropertyCell> cell = lookup->GetPropertyCell();
           Handle<Code> code = compiler.CompileLoadGlobal(
               cell, lookup->name(), lookup->IsConfigurable());
           // TODO(verwaest): Move caching of these NORMAL stubs outside as well.
           CacheHolderFlag flag;
           Handle<Map> stub_holder_map = GetHandlerCacheHolder(
               *type, receiver_is_holder, isolate(), &flag);
           Map::UpdateCodeCache(stub_holder_map, lookup->name(), code);
           return code;
         }
         // There is only one shared stub for loading normalized
         // properties. It does not traverse the prototype chain, so the
         // property must be found in the object for the stub to be
         // applicable.
         if (!receiver_is_holder) break;
         return isolate()->builtins()->LoadIC_Normal();
       }
  
       // -------------- Fields --------------
       if (lookup->property_details().type() == FIELD) {
         FieldIndex field = lookup->GetFieldIndex();
         if (receiver_is_holder) {
           return SimpleFieldLoad(field);
         }
         NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
                                           cache_holder);
         return compiler.CompileLoadField(lookup->name(), field);
       }
  
       // -------------- Constant properties --------------
       DCHECK(lookup->property_details().type() == CONSTANT);
       if (receiver_is_holder) {
         LoadConstantStub stub(isolate(), lookup->GetConstantIndex());
         return stub.GetCode();
       }
       NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
                                         cache_holder);
       return compiler.CompileLoadConstant(lookup->name(),
                                           lookup->GetConstantIndex());
     }
  
     case LookupIterator::ACCESS_CHECK:
     case LookupIterator::JSPROXY:
     case LookupIterator::NOT_FOUND:
     case LookupIterator::TRANSITION:
       UNREACHABLE();
   }
  
   return slow_stub();
 }

References v8::internal::ACCESSOR, v8::internal::Isolate::builtins(), v8::internal::Handle< T >::cast(), v8::internal::NamedLoadHandlerCompiler::CompileLoadCallback(), v8::internal::NamedLoadHandlerCompiler::CompileLoadConstant(), v8::internal::NamedLoadHandlerCompiler::CompileLoadField(), v8::internal::NamedLoadHandlerCompiler::CompileLoadGlobal(), v8::internal::NamedLoadHandlerCompiler::CompileLoadInterceptor(), v8::internal::NamedLoadHandlerCompiler::CompileLoadViaGetter(), v8::internal::CONSTANT, DCHECK, v8::internal::Name::Equals(), v8::internal::FIELD, v8::internal::flag, v8::internal::IC::GetHandlerCacheHolder(), v8::internal::AccessorInfo::IsCompatibleReceiverType(), v8::internal::IC::isolate(), v8::internal::IC::kind(), v8::internal::String::kLengthOffset, v8::internal::LookupForRead(), v8::internal::IC::receiver_type(), SimpleFieldLoad(), v8::internal::SLOPPY, slow_stub(), UNREACHABLE, and v8::internal::Map::UpdateCodeCache().

Here is the call graph for this function:

◆ ComputeExtraICState()

static ExtraICState v8::internal::LoadIC::ComputeExtraICState ( ContextualMode contextual_mode )

inlinestatic

Definition at line 324 of file ic.h.

                                                                           {
     return LoadICState(contextual_mode).GetExtraICState();
   }

References contextual_mode().

Here is the call graph for this function:

◆ contextual_mode()

ContextualMode v8::internal::LoadIC::contextual_mode ( ) const

inline

Definition at line 328 of file ic.h.

                                          {
     return LoadICState::GetContextualMode(extra_ic_state());
   }

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

Referenced by ComputeExtraICState(), IsUndeclaredGlobal(), and v8::internal::ThrowReferenceError().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateInitialize()

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

inlinestatic

Definition at line 348 of file ic.h.

348 { GenerateMiss(masm); }

v8::internal::LoadIC::GenerateMiss

static void GenerateMiss(MacroAssembler *masm)

References GenerateMiss().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateMiss()

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

static

Referenced by v8::internal::Generate_LoadIC_Miss(), GenerateInitialize(), v8::internal::KeyedLoadIC::GenerateInitialize(), v8::internal::StoreIC::GenerateInitialize(), v8::internal::KeyedStoreIC::GenerateInitialize(), GeneratePreMonomorphic(), v8::internal::KeyedLoadIC::GeneratePreMonomorphic(), v8::internal::StoreIC::GeneratePreMonomorphic(), and v8::internal::KeyedStoreIC::GeneratePreMonomorphic().

Here is the caller graph for this function:

◆ GenerateNormal()

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

static

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

Here is the caller graph for this function:

◆ GeneratePreMonomorphic()

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

inlinestatic

Definition at line 349 of file ic.h.

                                                            {
     GenerateMiss(masm);
   }

References GenerateMiss().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateRuntimeGetProperty()

static void v8::internal::LoadIC::GenerateRuntimeGetProperty ( MacroAssembler * masm )

static

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

Here is the caller graph for this function:

◆ initialize_stub()

Handle< Code > v8::internal::LoadIC::initialize_stub	(	Isolate *	isolate,
		ExtraICState	extra_state
	)

static

Definition at line 815 of file ic.cc.

                                                                {
   return PropertyICCompiler::ComputeLoad(isolate, UNINITIALIZED, extra_state);
 }

References v8::internal::PropertyICCompiler::ComputeLoad(), v8::internal::IC::isolate(), and v8::internal::UNINITIALIZED.

Here is the call graph for this function:

◆ IsUndeclaredGlobal()

bool v8::internal::LoadIC::IsUndeclaredGlobal ( Handle< Object > receiver )

inline

Definition at line 338 of file ic.h.

                                                    {
     if (receiver->IsGlobalObject()) {
       return contextual_mode() == CONTEXTUAL;
     } else {
       DCHECK(contextual_mode() != CONTEXTUAL);
       return false;
     }
   }

References v8::internal::CONTEXTUAL, contextual_mode(), and DCHECK.

Referenced by Load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Load()

MaybeHandle< Object > v8::internal::LoadIC::Load	(	Handle< Object >	object,
		Handle< Name >	name
	)

Definition at line 586 of file ic.cc.

                                                                          {
   // If the object is undefined or null it's illegal to try to get any
   // of its properties; throw a TypeError in that case.
   if (object->IsUndefined() || object->IsNull()) {
     return TypeError("non_object_property_load", object, name);
   }
  
   // Check if the name is trivially convertible to an index and get
   // the element or char if so.
   uint32_t index;
   if (kind() == Code::KEYED_LOAD_IC && name->AsArrayIndex(&index)) {
     // Rewrite to the generic keyed load stub.
     if (FLAG_use_ic) {
       set_target(*KeyedLoadIC::generic_stub(isolate()));
       TRACE_IC("LoadIC", name);
       TRACE_GENERIC_IC(isolate(), "LoadIC", "name as array index");
     }
     Handle<Object> result;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate(), result,
         Runtime::GetElementOrCharAt(isolate(), object, index), Object);
     return result;
   }
  
   bool use_ic = MigrateDeprecated(object) ? false : FLAG_use_ic;
  
   // Named lookup in the object.
   LookupIterator it(object, name);
   LookupForRead(&it);
  
   if (it.IsFound() || !IsUndeclaredGlobal(object)) {
     // Update inline cache and stub cache.
     if (use_ic) UpdateCaches(&it);
  
     // Get the property.
     Handle<Object> result;
     ASSIGN_RETURN_ON_EXCEPTION(isolate(), result, Object::GetProperty(&it),
                                Object);
     if (it.IsFound()) {
       return result;
     } else if (!IsUndeclaredGlobal(object)) {
       LOG(isolate(), SuspectReadEvent(*name, *object));
       return result;
     }
   }
   return ReferenceError("not_defined", name);
 }

References ASSIGN_RETURN_ON_EXCEPTION, false, v8::internal::KeyedLoadIC::generic_stub(), v8::internal::Runtime::GetElementOrCharAt(), v8::internal::Object::GetProperty(), v8::internal::IC::isolate(), IsUndeclaredGlobal(), v8::internal::IC::kind(), LOG, v8::internal::LookupForRead(), v8::internal::MigrateDeprecated(), name, v8::internal::IC::ReferenceError(), set_target(), TRACE_GENERIC_IC, TRACE_IC, v8::internal::IC::TypeError(), and UpdateCaches().

Referenced by v8::internal::KeyedLoadIC::Load(), and v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ megamorphic_stub()

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

protectedvirtual

Reimplemented from v8::internal::IC.

Definition at line 821 of file ic.cc.

                                       {
   if (kind() == Code::LOAD_IC) {
     MegamorphicLoadStub stub(isolate(), LoadICState(extra_ic_state()));
     return stub.GetCode();
   } else {
     DCHECK_EQ(Code::KEYED_LOAD_IC, kind());
     return KeyedLoadIC::generic_stub(isolate());
   }
 }

References DCHECK_EQ, v8::internal::IC::extra_ic_state(), v8::internal::KeyedLoadIC::generic_stub(), v8::internal::IC::isolate(), and v8::internal::IC::kind().

Here is the call graph for this function:

◆ pre_monomorphic_stub() [1/2]

Handle< Code > v8::internal::LoadIC::pre_monomorphic_stub ( ) const

privatevirtual

Reimplemented in v8::internal::KeyedLoadIC.

Definition at line 843 of file ic.cc.

                                                 {
   if (kind() == Code::LOAD_IC) {
     return LoadIC::pre_monomorphic_stub(isolate(), extra_ic_state());
   } else {
     DCHECK_EQ(Code::KEYED_LOAD_IC, kind());
     return KeyedLoadIC::pre_monomorphic_stub(isolate());
   }
 }

References DCHECK_EQ, v8::internal::IC::extra_ic_state(), v8::internal::IC::isolate(), v8::internal::IC::kind(), and v8::internal::KeyedLoadIC::pre_monomorphic_stub().

Referenced by v8::internal::KeyedLoadIC::pre_monomorphic_stub(), v8::internal::StoreIC::pre_monomorphic_stub(), v8::internal::KeyedStoreIC::pre_monomorphic_stub(), and 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::LoadIC::pre_monomorphic_stub	(	Isolate *	isolate,
		ExtraICState	extra_state
	)

staticprivate

Definition at line 832 of file ic.cc.

                                                                     {
   return PropertyICCompiler::ComputeLoad(isolate, PREMONOMORPHIC, extra_state);
 }

References v8::internal::PropertyICCompiler::ComputeLoad(), v8::internal::IC::isolate(), and v8::internal::PREMONOMORPHIC.

Here is the call graph for this function:

◆ set_target()

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

inlineprotected

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

                                   {
   // The contextual mode must be preserved across IC patching.
   DCHECK(LoadICState::GetContextualMode(code->extra_ic_state()) ==
          LoadICState::GetContextualMode(target()->extra_ic_state()));
  
   IC::set_target(code);
 }

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

Referenced by Load(), v8::internal::KeyedLoadIC::Load(), and UpdateCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SimpleFieldLoad()

Handle< Code > v8::internal::LoadIC::SimpleFieldLoad ( FieldIndex index )

private

Definition at line 853 of file ic.cc.

                                                      {
   LoadFieldStub stub(isolate(), index);
   return stub.GetCode();
 }

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

Referenced by CompileHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slow_stub()

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

inlineprotected

Definition at line 365 of file ic.h.

                                  {
     if (kind() == Code::LOAD_IC) {
       return isolate()->builtins()->LoadIC_Slow();
     } else {
       DCHECK_EQ(Code::KEYED_LOAD_IC, kind());
       return isolate()->builtins()->KeyedLoadIC_Slow();
     }
   }

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

Referenced by CompileHandler(), and UpdateCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateCaches()

void v8::internal::LoadIC::UpdateCaches ( LookupIterator * lookup )

protected

Definition at line 859 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("LoadIC", lookup->name());
     return;
   }
  
   Handle<Code> code;
   if (lookup->state() == LookupIterator::JSPROXY ||
       lookup->state() == LookupIterator::ACCESS_CHECK) {
     code = slow_stub();
   } else if (!lookup->IsFound()) {
     if (kind() == Code::LOAD_IC) {
       code = NamedLoadHandlerCompiler::ComputeLoadNonexistent(lookup->name(),
                                                               receiver_type());
       // TODO(jkummerow/verwaest): Introduce a builtin that handles this case.
       if (code.is_null()) code = slow_stub();
     } else {
       code = slow_stub();
     }
   } else {
     code = ComputeHandler(lookup);
   }
  
   PatchCache(lookup->name(), code);
   TRACE_IC("LoadIC", lookup->name());
 }

References v8::internal::IC::ComputeHandler(), v8::internal::NamedLoadHandlerCompiler::ComputeLoadNonexistent(), v8::internal::Handle< T >::is_null(), v8::internal::IC::kind(), v8::internal::IC::PatchCache(), pre_monomorphic_stub(), v8::internal::IC::receiver_type(), set_target(), slow_stub(), v8::internal::IC::state(), TRACE_IC, and v8::internal::UNINITIALIZED.

Referenced by Load().

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 394 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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Static Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LoadIC()

Member Function Documentation

◆ Clear()

◆ CompileHandler()

◆ ComputeExtraICState()

◆ contextual_mode()

◆ GenerateInitialize()

◆ GenerateMiss()

◆ GenerateNormal()

◆ GeneratePreMonomorphic()

◆ GenerateRuntimeGetProperty()

◆ initialize_stub()

◆ IsUndeclaredGlobal()

◆ Load()

◆ megamorphic_stub()

◆ pre_monomorphic_stub() [1/2]

◆ pre_monomorphic_stub() [2/2]

◆ set_target()

◆ SimpleFieldLoad()

◆ slow_stub()

◆ UpdateCaches()

Friends And Related Function Documentation

◆ IC