v8::internal::KeyedLoadIC Class Reference

#include <ic.h>

Inheritance diagram for v8::internal::KeyedLoadIC:

Collaboration diagram for v8::internal::KeyedLoadIC:

Public Member Functions
	KeyedLoadIC (FrameDepth depth, Isolate *isolate)
MUST_USE_RESULT MaybeHandle< Object >	Load (Handle< Object > object, Handle< Object > key)
Public Member Functions inherited from v8::internal::LoadIC
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 void	GenerateMiss (MacroAssembler *masm)
static void	GenerateRuntimeGetProperty (MacroAssembler *masm)
static void	GenerateInitialize (MacroAssembler *masm)
static void	GeneratePreMonomorphic (MacroAssembler *masm)
static void	GenerateGeneric (MacroAssembler *masm)
static void	GenerateString (MacroAssembler *masm)
static Handle< Code >	generic_stub (Isolate *isolate)
static Handle< Code >	pre_monomorphic_stub (Isolate *isolate)
Static Public Member Functions inherited from v8::internal::LoadIC
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)

Static Public Attributes
static const int	kSlowCaseBitFieldMask

Protected Member Functions
Handle< Code >	LoadElementStub (Handle< JSObject > receiver)
virtual Handle< Code >	pre_monomorphic_stub () const
Protected Member Functions inherited from v8::internal::LoadIC
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
Handle< Code >	generic_stub () const
Handle< Code >	string_stub ()

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

Constructor & Destructor Documentation

KeyedLoadIC()

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

inlineexplicit

Definition at line 400 of file ic.h.

      : LoadIC(depth, isolate) {
    DCHECK(target()->is_keyed_load_stub());
  }

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

Here is the call graph for this function:

Member Function Documentation

Clear()

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

staticprivate

Definition at line 511 of file ic.cc.

                                                          {
  if (IsCleared(target)) return;
  // Make sure to also clear the map used in inline fast cases.  If we
  // do not clear these maps, cached code can keep objects alive
  // through the embedded maps.
  SetTargetAtAddress(address, *pre_monomorphic_stub(isolate), constant_pool);
}

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

GenerateGeneric()

static void v8::internal::KeyedLoadIC::GenerateGeneric ( MacroAssembler *  masm )

static

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

Here is the caller graph for this function:

GenerateInitialize()

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

inlinestatic

Definition at line 411 of file ic.h.

{ GenerateMiss(masm); }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateMiss()

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

static

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

Here is the caller graph for this function:

GeneratePreMonomorphic()

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

inlinestatic

Definition at line 412 of file ic.h.

                                                           {
    GenerateMiss(masm);
  }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateRuntimeGetProperty()

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

static

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

Here is the caller graph for this function:

GenerateString()

static void v8::internal::KeyedLoadIC::GenerateString ( MacroAssembler *  masm )

static

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

Here is the caller graph for this function:

generic_stub() [1/2]

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

inlineprivate

Definition at line 435 of file ic.h.

{ return generic_stub(isolate()); }

References generic_stub(), and v8::internal::IC::isolate().

Referenced by generic_stub(), v8::internal::LoadIC::Load(), Load(), LoadElementStub(), and v8::internal::LoadIC::megamorphic_stub().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_stub() [2/2]

Handle< Code > v8::internal::KeyedLoadIC::generic_stub ( Isolate *  isolate )

static

Definition at line 568 of file ic.cc.

                                                       {
  if (FLAG_compiled_keyed_generic_loads) {
    return KeyedLoadGenericStub(isolate).GetCode();
  } else {
    return isolate->builtins()->KeyedLoadIC_Generic();
  }
}

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

Here is the call graph for this function:

Load()

MaybeHandle< Object > v8::internal::KeyedLoadIC::Load	(	Handle< Object >	object,
		Handle< Object >	key
	)

Definition at line 1171 of file ic.cc.

                                                          {
  if (MigrateDeprecated(object)) {
    Handle<Object> result;
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate(), result, Runtime::GetObjectProperty(isolate(), object, key),
        Object);
    return result;
  }
 
  Handle<Object> load_handle;
  Handle<Code> stub = generic_stub();
 
  // Check for non-string values that can be converted into an
  // internalized string directly or is representable as a smi.
  key = TryConvertKey(key, isolate());
 
  if (key->IsInternalizedString() || key->IsSymbol()) {
    ASSIGN_RETURN_ON_EXCEPTION(isolate(), load_handle,
                               LoadIC::Load(object, Handle<Name>::cast(key)),
                               Object);
  } else if (FLAG_use_ic && !object->IsAccessCheckNeeded()) {
    if (object->IsString() && key->IsNumber()) {
      if (state() == UNINITIALIZED) stub = string_stub();
    } else if (object->IsJSObject()) {
      Handle<JSObject> receiver = Handle<JSObject>::cast(object);
      if (!Object::ToSmi(isolate(), key).is_null()) {
        stub = LoadElementStub(receiver);
      }
    }
  }
 
  if (!is_target_set()) {
    Code* generic = *generic_stub();
    if (*stub == generic) {
      TRACE_GENERIC_IC(isolate(), "KeyedLoadIC", "set generic");
    }
    set_target(*stub);
    TRACE_IC("LoadIC", key);
  }
 
  if (!load_handle.is_null()) return load_handle;
  Handle<Object> result;
  ASSIGN_RETURN_ON_EXCEPTION(isolate(), result,
                             Runtime::GetObjectProperty(isolate(), object, key),
                             Object);
  return result;
}

References ASSIGN_RETURN_ON_EXCEPTION, v8::internal::Handle< T >::cast(), generic_stub(), v8::internal::Runtime::GetObjectProperty(), v8::internal::Handle< T >::is_null(), v8::internal::IC::is_target_set(), v8::internal::IC::isolate(), v8::internal::LoadIC::Load(), LoadElementStub(), v8::internal::MigrateDeprecated(), v8::internal::LoadIC::set_target(), v8::internal::IC::state(), string_stub(), v8::internal::Object::ToSmi(), TRACE_GENERIC_IC, TRACE_IC, v8::internal::TryConvertKey(), and v8::internal::UNINITIALIZED.

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

Here is the call graph for this function:

Here is the caller graph for this function:

LoadElementStub()

Handle< Code > v8::internal::KeyedLoadIC::LoadElementStub ( Handle< JSObject >  receiver )

protected

Definition at line 1124 of file ic.cc.

                                                                   {
  Handle<Map> receiver_map(receiver->map(), isolate());
  MapHandleList target_receiver_maps;
  if (target().is_identical_to(string_stub())) {
    target_receiver_maps.Add(isolate()->factory()->string_map());
  } else {
    TargetMaps(&target_receiver_maps);
  }
  if (target_receiver_maps.length() == 0) {
    return PropertyICCompiler::ComputeKeyedLoadMonomorphic(receiver_map);
  }
 
  // The first time a receiver is seen that is a transitioned version of the
  // previous monomorphic receiver type, assume the new ElementsKind is the
  // monomorphic type. This benefits global arrays that only transition
  // once, and all call sites accessing them are faster if they remain
  // monomorphic. If this optimistic assumption is not true, the IC will
  // miss again and it will become polymorphic and support both the
  // untransitioned and transitioned maps.
  if (state() == MONOMORPHIC && IsMoreGeneralElementsKindTransition(
                                    target_receiver_maps.at(0)->elements_kind(),
                                    receiver->GetElementsKind())) {
    return PropertyICCompiler::ComputeKeyedLoadMonomorphic(receiver_map);
  }
 
  DCHECK(state() != GENERIC);
 
  // Determine the list of receiver maps that this call site has seen,
  // adding the map that was just encountered.
  if (!AddOneReceiverMapIfMissing(&target_receiver_maps, receiver_map)) {
    // If the miss wasn't due to an unseen map, a polymorphic stub
    // won't help, use the generic stub.
    TRACE_GENERIC_IC(isolate(), "KeyedLoadIC", "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(), "KeyedLoadIC", "max polymorph exceeded");
    return generic_stub();
  }
 
  return PropertyICCompiler::ComputeKeyedLoadPolymorphic(&target_receiver_maps);
}

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::AddOneReceiverMapIfMissing(), v8::internal::List< T, AllocationPolicy >::at(), v8::internal::PropertyICCompiler::ComputeKeyedLoadMonomorphic(), v8::internal::PropertyICCompiler::ComputeKeyedLoadPolymorphic(), DCHECK, v8::internal::GENERIC, generic_stub(), v8::internal::IsMoreGeneralElementsKindTransition(), v8::internal::IC::isolate(), v8::internal::kMaxKeyedPolymorphism, v8::internal::MONOMORPHIC, v8::internal::IC::state(), string_stub(), v8::internal::IC::target(), v8::internal::IC::TargetMaps(), and TRACE_GENERIC_IC.

Referenced by Load().

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::KeyedLoadIC::pre_monomorphic_stub ( ) const

inlineprotectedvirtual

Reimplemented from v8::internal::LoadIC.

Definition at line 430 of file ic.h.

                                                    {
    return pre_monomorphic_stub(isolate());
  }

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

Referenced by Clear(), and v8::internal::LoadIC::pre_monomorphic_stub().

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::KeyedLoadIC::pre_monomorphic_stub ( Isolate *  isolate )

static

Definition at line 838 of file ic.cc.

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

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

Here is the call graph for this function:

string_stub()

Handle<Code> v8::internal::KeyedLoadIC::string_stub ( )

inlineprivate

Definition at line 436 of file ic.h.

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

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

Referenced by Load(), and LoadElementStub().

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

Member Data Documentation

kSlowCaseBitFieldMask

const int v8::internal::KeyedLoadIC::kSlowCaseBitFieldMask

static

Initial value:

=
      (1 << Map::kIsAccessCheckNeeded) | (1 << Map::kHasIndexedInterceptor)

Definition at line 422 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.cc