#include <ic.h>

Inheritance diagram for v8::internal::IC:

Collaboration diagram for v8::internal::IC:

Public Types
enum	UtilityId { kUtilityCount }

enum	FrameDepth { NO_EXTRA_FRAME = 0 , EXTRA_CALL_FRAME = 1 }

typedef InlineCacheState	State

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

virtual Handle< Code >	CompileHandler (LookupIterator *lookup, Handle< Object > value, CacheHolderFlag cache_holder)

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

virtual Handle< Code >	megamorphic_stub ()

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 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
Code *	raw_target () const

ConstantPoolArray *	constant_pool () const

ConstantPoolArray *	raw_constant_pool () const

void	FindTargetMaps ()

	DISALLOW_IMPLICIT_CONSTRUCTORS (IC)

Private Attributes
Address	fp_

Address *	pc_address_

Isolate *	isolate_

Handle< ConstantPoolArray >	raw_constant_pool_

Handle< Code >	target_

bool	target_set_

State	state_

Code::Kind	kind_

Handle< HeapType >	receiver_type_

MaybeHandle< Code >	maybe_handler_

ExtraICState	extra_ic_state_

MapHandleList	target_maps_

bool	target_maps_set_

Detailed Description

Definition at line 41 of file ic.h.

Member Typedef Documentation

◆ State

typedef InlineCacheState v8::internal::IC::State

Definition at line 55 of file ic.h.

Member Enumeration Documentation

◆ FrameDepth

enum v8::internal::IC::FrameDepth

Enumerator
NO_EXTRA_FRAME
EXTRA_CALL_FRAME

Definition at line 59 of file ic.h.

59 { NO_EXTRA_FRAME = 0, EXTRA_CALL_FRAME = 1 };

v8::internal::IC::NO_EXTRA_FRAME

@ NO_EXTRA_FRAME

Definition: ic.h:59

v8::internal::IC::EXTRA_CALL_FRAME

@ EXTRA_CALL_FRAME

Definition: ic.h:59

◆ UtilityId

enum v8::internal::IC::UtilityId

Enumerator
kUtilityCount

Definition at line 44 of file ic.h.

                  {
 #define CONST_NAME(name) k##name,
     IC_UTIL_LIST(CONST_NAME)
 #undef CONST_NAME
     kUtilityCount
   };

Constructor & Destructor Documentation

◆ IC()

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

Definition at line 141 of file ic.cc.

     : isolate_(isolate), target_set_(false), target_maps_set_(false) {
   // To improve the performance of the (much used) IC code, we unfold a few
   // levels of the stack frame iteration code. This yields a ~35% speedup when
   // running DeltaBlue and a ~25% speedup of gbemu with the '--nouse-ic' flag.
   const Address entry = Isolate::c_entry_fp(isolate->thread_local_top());
   Address constant_pool = NULL;
   if (FLAG_enable_ool_constant_pool) {
     constant_pool =
         Memory::Address_at(entry + ExitFrameConstants::kConstantPoolOffset);
   }
   Address* pc_address =
       reinterpret_cast<Address*>(entry + ExitFrameConstants::kCallerPCOffset);
   Address fp = Memory::Address_at(entry + ExitFrameConstants::kCallerFPOffset);
   // If there's another JavaScript frame on the stack or a
   // StubFailureTrampoline, we need to look one frame further down the stack to
   // find the frame pointer and the return address stack slot.
   if (depth == EXTRA_CALL_FRAME) {
     if (FLAG_enable_ool_constant_pool) {
       constant_pool =
           Memory::Address_at(fp + StandardFrameConstants::kConstantPoolOffset);
     }
     const int kCallerPCOffset = StandardFrameConstants::kCallerPCOffset;
     pc_address = reinterpret_cast<Address*>(fp + kCallerPCOffset);
     fp = Memory::Address_at(fp + StandardFrameConstants::kCallerFPOffset);
   }
 #ifdef DEBUG
   StackFrameIterator it(isolate);
   for (int i = 0; i < depth + 1; i++) it.Advance();
   StackFrame* frame = it.frame();
   DCHECK(fp == frame->fp() && pc_address == frame->pc_address());
 #endif
   fp_ = fp;
   if (FLAG_enable_ool_constant_pool) {
     raw_constant_pool_ = handle(
         ConstantPoolArray::cast(reinterpret_cast<Object*>(constant_pool)),
         isolate);
   }
   pc_address_ = StackFrame::ResolveReturnAddressLocation(pc_address);
   target_ = handle(raw_target(), isolate);
   state_ = target_->ic_state();
   kind_ = target_->kind();
   extra_ic_state_ = target_->extra_ic_state();
 }

References v8::internal::Memory::Address_at(), v8::internal::StackFrameIterator::Advance(), v8::internal::Isolate::c_entry_fp(), constant_pool(), DCHECK, EXTRA_CALL_FRAME, extra_ic_state_, fp(), fp_, v8::internal::StackFrameIterator::frame(), v8::internal::handle(), isolate(), v8::internal::ExitFrameConstants::kCallerFPOffset, v8::internal::StandardFrameConstants::kCallerFPOffset, v8::internal::ExitFrameConstants::kCallerPCOffset, v8::internal::StandardFrameConstants::kCallerPCOffset, v8::internal::ExitFrameConstants::kConstantPoolOffset, v8::internal::StandardFrameConstants::kConstantPoolOffset, kind_, NULL, pc_address_, raw_constant_pool_, raw_target(), state_, target_, and v8::internal::Isolate::thread_local_top().

Here is the call graph for this function:

◆ ~IC()

virtual v8::internal::IC::~IC ( )

inlinevirtual

Definition at line 64 of file ic.h.

64 {}

Member Function Documentation

◆ address()

Address v8::internal::IC::address ( ) const

inline

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

                           {
   // Get the address of the call.
   Address result = Assembler::target_address_from_return_address(pc());
  
   Debug* debug = isolate()->debug();
   // First check if any break points are active if not just return the address
   // of the call.
   if (!debug->has_break_points()) return result;
  
   // At least one break point is active perform additional test to ensure that
   // break point locations are updated correctly.
   if (debug->IsDebugBreak(
           Assembler::target_address_at(result, raw_constant_pool()))) {
     // If the call site is a call to debug break then return the address in
     // the original code instead of the address in the running code. This will
     // cause the original code to be updated and keeps the breakpoint active in
     // the running code.
     Code* code = GetCode();
     Code* original_code = GetOriginalCode();
     intptr_t delta =
         original_code->instruction_start() - code->instruction_start();
     // Return the address in the original code. This is the place where
     // the call which has been overwritten by the DebugBreakXXX resides
     // and the place where the inline cache system should look.
     return result + delta;
   } else {
     // No break point here just return the address of the call.
     return result;
   }
 }

References v8::internal::Isolate::debug(), GetCode(), GetOriginalCode(), v8::internal::Debug::has_break_points(), v8::internal::Code::instruction_start(), v8::internal::Debug::IsDebugBreak(), isolate(), pc(), raw_constant_pool(), v8::internal::Assembler::target_address_at(), and v8::internal::Assembler::target_address_from_return_address().

Referenced by v8::internal::CompareNilIC::Clear(), v8::internal::LoadIC::Clear(), v8::internal::KeyedLoadIC::Clear(), v8::internal::StoreIC::Clear(), v8::internal::KeyedStoreIC::Clear(), v8::internal::CompareIC::Clear(), Clear(), v8::internal::CallIC::DoCustomHandler(), GetTargetAtAddress(), v8::internal::CallIC::HandleMiss(), OnTypeFeedbackChanged(), v8::internal::CallIC::PatchMegamorphic(), PostPatching(), raw_target(), set_target(), SetTargetAtAddress(), v8::internal::BinaryOpIC::Transition(), and v8::internal::CompareIC::UpdateCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddressFromUtilityId()

Address v8::internal::IC::AddressFromUtilityId ( IC::UtilityId id )

static

Definition at line 2687 of file ic.cc.

2687 { return IC_utilities[id]; }

v8::internal::IC_utilities

static const Address IC_utilities[]

Definition: ic.cc:2680

References v8::internal::IC_utilities.

◆ Clear()

void v8::internal::IC::Clear	(	Isolate *	isolate,
		Address	address,
		ConstantPoolArray *	constant_pool
	)

static

Definition at line 478 of file ic.cc.

                                                  {
   Code* target = GetTargetAtAddress(address, constant_pool);
  
   // Don't clear debug break inline cache as it will remove the break point.
   if (target->is_debug_stub()) return;
  
   switch (target->kind()) {
     case Code::LOAD_IC:
       return LoadIC::Clear(isolate, address, target, constant_pool);
     case Code::KEYED_LOAD_IC:
       return KeyedLoadIC::Clear(isolate, address, target, constant_pool);
     case Code::STORE_IC:
       return StoreIC::Clear(isolate, address, target, constant_pool);
     case Code::KEYED_STORE_IC:
       return KeyedStoreIC::Clear(isolate, address, target, constant_pool);
     case Code::CALL_IC:
       return CallIC::Clear(isolate, address, target, constant_pool);
     case Code::COMPARE_IC:
       return CompareIC::Clear(isolate, address, target, constant_pool);
     case Code::COMPARE_NIL_IC:
       return CompareNilIC::Clear(address, target, constant_pool);
     case Code::BINARY_OP_IC:
     case Code::TO_BOOLEAN_IC:
       // Clearing these is tricky and does not
       // make any performance difference.
       return;
     default:
       UNREACHABLE();
   }
 }

References address(), v8::internal::CompareNilIC::Clear(), v8::internal::CallIC::Clear(), v8::internal::LoadIC::Clear(), v8::internal::KeyedLoadIC::Clear(), v8::internal::StoreIC::Clear(), v8::internal::KeyedStoreIC::Clear(), v8::internal::CompareIC::Clear(), constant_pool(), GetTargetAtAddress(), isolate(), target(), and UNREACHABLE.

Referenced by v8::internal::ICUtility::Clear(), and v8::internal::Code::ClearInlineCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CompileHandler()

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

inlineprotectedvirtual

Reimplemented in v8::internal::StoreIC, and v8::internal::LoadIC.

Definition at line 171 of file ic.h.

                                                                     {
     UNREACHABLE();
     return Handle<Code>::null();
   }

References v8::internal::Handle< T >::null(), and UNREACHABLE.

Referenced by ComputeHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeHandler()

Handle< Code > v8::internal::IC::ComputeHandler	(	LookupIterator *	lookup,
		Handle< Object >	value = `Handle<Code>::null()`
	)

protected

Definition at line 897 of file ic.cc.

                                                                             {
   bool receiver_is_holder =
       lookup->GetReceiver().is_identical_to(lookup->GetHolder<JSObject>());
   CacheHolderFlag flag;
   Handle<Map> stub_holder_map = IC::GetHandlerCacheHolder(
       *receiver_type(), receiver_is_holder, isolate(), &flag);
  
   Handle<Code> code = PropertyHandlerCompiler::Find(
       lookup->name(), stub_holder_map, kind(), flag,
       lookup->is_dictionary_holder() ? Code::NORMAL : Code::FAST);
   // Use the cached value if it exists, and if it is different from the
   // handler that just missed.
   if (!code.is_null()) {
     if (!maybe_handler_.is_null() &&
         !maybe_handler_.ToHandleChecked().is_identical_to(code)) {
       return code;
     }
     if (maybe_handler_.is_null()) {
       // maybe_handler_ is only populated for MONOMORPHIC and POLYMORPHIC ICs.
       // In MEGAMORPHIC case, check if the handler in the megamorphic stub
       // cache (which just missed) is different from the cached handler.
       if (state() == MEGAMORPHIC && lookup->GetReceiver()->IsHeapObject()) {
         Map* map = Handle<HeapObject>::cast(lookup->GetReceiver())->map();
         Code* megamorphic_cached_code =
             isolate()->stub_cache()->Get(*lookup->name(), map, code->flags());
         if (megamorphic_cached_code != *code) return code;
       } else {
         return code;
       }
     }
   }
  
   code = CompileHandler(lookup, value, flag);
   DCHECK(code->is_handler());
  
   // TODO(mvstanton): we'd only like to cache code on the map when it's custom
   // code compiled for this map, otherwise it's already cached in the global
   // code
   // cache. We are also guarding against installing code with flags that don't
   // match the desired CacheHolderFlag computed above, which would lead to
   // invalid lookups later.
   if (code->type() != Code::NORMAL &&
       Code::ExtractCacheHolderFromFlags(code->flags()) == flag) {
     Map::UpdateCodeCache(stub_holder_map, lookup->name(), code);
   }
  
   return code;
 }

References v8::internal::Handle< T >::cast(), CompileHandler(), DCHECK, v8::internal::Code::ExtractCacheHolderFromFlags(), v8::internal::Code::FAST, v8::internal::PropertyHandlerCompiler::Find(), v8::internal::flag, v8::internal::StubCache::Get(), GetHandlerCacheHolder(), v8::internal::Handle< T >::is_null(), isolate(), kind(), map, maybe_handler_, v8::internal::MEGAMORPHIC, v8::internal::Code::NORMAL, receiver_type(), state(), v8::internal::Isolate::stub_cache(), and v8::internal::Map::UpdateCodeCache().

Referenced by v8::internal::LoadIC::UpdateCaches(), and v8::internal::StoreIC::UpdateCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ constant_pool()

ConstantPoolArray * v8::internal::IC::constant_pool ( ) const

inlineprivate

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

                                            {
   if (!FLAG_enable_ool_constant_pool) {
     return NULL;
   } else {
     Handle<ConstantPoolArray> result = raw_constant_pool_;
     Debug* debug = isolate()->debug();
     // First check if any break points are active if not just return the
     // original constant pool.
     if (!debug->has_break_points()) return *result;
  
     // At least one break point is active perform additional test to ensure that
     // break point locations are updated correctly.
     Address target = Assembler::target_address_from_return_address(pc());
     if (debug->IsDebugBreak(
             Assembler::target_address_at(target, raw_constant_pool()))) {
       // If the call site is a call to debug break then we want to return the
       // constant pool for the original code instead of the breakpointed code.
       return GetOriginalCode()->constant_pool();
     }
     return *result;
   }
 }

References v8::internal::Code::constant_pool(), v8::internal::Isolate::debug(), GetOriginalCode(), v8::internal::Debug::has_break_points(), v8::internal::Debug::IsDebugBreak(), isolate(), NULL, pc(), raw_constant_pool(), raw_constant_pool_, target(), v8::internal::Assembler::target_address_at(), and v8::internal::Assembler::target_address_from_return_address().

Referenced by v8::internal::CompareNilIC::Clear(), v8::internal::LoadIC::Clear(), v8::internal::KeyedLoadIC::Clear(), v8::internal::StoreIC::Clear(), v8::internal::KeyedStoreIC::Clear(), v8::internal::CompareIC::Clear(), Clear(), GetTargetAtAddress(), IC(), raw_target(), set_target(), and SetTargetAtAddress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyICToMegamorphicCache()

void v8::internal::IC::CopyICToMegamorphicCache ( Handle< Name > name )

protected

Definition at line 761 of file ic.cc.

                                                    {
   TypeHandleList types;
   CodeHandleList handlers;
   TargetTypes(&types);
   if (!target()->FindHandlers(&handlers, types.length())) return;
   for (int i = 0; i < types.length(); i++) {
     UpdateMegamorphicCache(*types.at(i), *name, *handlers.at(i));
   }
 }

References v8::internal::List< T, AllocationPolicy >::at(), name, target(), TargetTypes(), and UpdateMegamorphicCache().

Referenced by PatchCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CurrentTypeOf()

Handle< HeapType > v8::internal::IC::CurrentTypeOf	(	Handle< Object >	object,
		Isolate *	isolate
	)

static

Definition at line 712 of file ic.cc.

                                                                           {
   return object->IsJSGlobalObject()
              ? HeapType::Constant(Handle<JSGlobalObject>::cast(object), isolate)
              : HeapType::NowOf(object, isolate);
 }

References v8::internal::TypeImpl< Config >::Constant(), isolate(), and v8::internal::TypeImpl< Config >::NowOf().

Referenced by v8::internal::PropertyHandlerCompiler::set_type_for_object(), and update_receiver_type().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::internal::IC::DISALLOW_IMPLICIT_CONSTRUCTORS ( IC )

private

◆ extra_ic_state()

ExtraICState v8::internal::IC::extra_ic_state ( ) const

inlineprotected

Definition at line 200 of file ic.h.

200 { return extra_ic_state_; }

References extra_ic_state_.

Referenced by v8::internal::CompareNilIC::CompareNil(), v8::internal::LoadIC::contextual_mode(), v8::internal::StoreIC::generic_stub(), v8::internal::CallIC::HandleMiss(), v8::internal::LoadIC::megamorphic_stub(), v8::internal::StoreIC::megamorphic_stub(), v8::internal::CallIC::PatchMegamorphic(), v8::internal::LoadIC::pre_monomorphic_stub(), v8::internal::LoadIC::set_target(), v8::internal::StoreIC::set_target(), v8::internal::KeyedStoreIC::StoreElementStub(), v8::internal::StoreIC::strict_mode(), v8::internal::ToBooleanIC::ToBoolean(), v8::internal::BinaryOpIC::Transition(), UpdateMonomorphicIC(), and UpdatePolymorphicIC().

Here is the caller graph for this function:

◆ FindTargetMaps()

void v8::internal::IC::FindTargetMaps ( )

inlineprivate

Definition at line 235 of file ic.h.

                         {
     if (target_maps_set_) return;
     target_maps_set_ = true;
     if (state_ == MONOMORPHIC) {
       Map* map = target_->FindFirstMap();
       if (map != NULL) target_maps_.Add(handle(map));
     } else if (state_ != UNINITIALIZED && state_ != PREMONOMORPHIC) {
       target_->FindAllMaps(&target_maps_);
     }
   }

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::handle(), map, v8::internal::MONOMORPHIC, NULL, v8::internal::PREMONOMORPHIC, state_, target_, target_maps_, target_maps_set_, and v8::internal::UNINITIALIZED.

Referenced by FirstTargetMap(), TargetMaps(), and TargetTypes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FirstTargetMap()

Map* v8::internal::IC::FirstTargetMap ( )

inlineprotected

Definition at line 222 of file ic.h.

                         {
     FindTargetMaps();
     return target_maps_.length() > 0 ? *target_maps_.at(0) : NULL;
   }

References v8::internal::List< T, AllocationPolicy >::at(), FindTargetMaps(), NULL, and target_maps_.

Referenced by v8::internal::CompareNilIC::CompareNil(), and TryRemoveInvalidPrototypeDependentStub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fp()

Address v8::internal::IC::fp ( ) const

inlineprotected

Definition at line 134 of file ic.h.

134 { return fp_; }

References fp_.

Referenced by IC().

Here is the caller graph for this function:

◆ GetCode()

Code * v8::internal::IC::GetCode ( ) const

protected

Definition at line 201 of file ic.cc.

                         {
   HandleScope scope(isolate());
   Handle<SharedFunctionInfo> shared(GetSharedFunctionInfo(), isolate());
   Code* code = shared->code();
   return code;
 }

References GetSharedFunctionInfo(), and isolate().

Referenced by address().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetHandlerCacheHolder()

Handle< Map > v8::internal::IC::GetHandlerCacheHolder	(	HeapType *	type,
		bool	receiver_is_holder,
		Isolate *	isolate,
		CacheHolderFlag *	flag
	)

inlinestatic

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

                                                                                {
   Handle<Map> receiver_map = TypeToMap(type, isolate);
   if (receiver_is_holder) {
     *flag = kCacheOnReceiver;
     return receiver_map;
   }
   Context* native_context = *isolate->native_context();
   JSFunction* builtin_ctor = GetRootConstructor(type, native_context);
   if (builtin_ctor != NULL) {
     *flag = kCacheOnPrototypeReceiverIsPrimitive;
     return handle(HeapObject::cast(builtin_ctor->instance_prototype())->map());
   }
   *flag = receiver_map->is_dictionary_map()
               ? kCacheOnPrototypeReceiverIsDictionary
               : kCacheOnPrototype;
   // Callers must ensure that the prototype is non-null.
   return handle(JSObject::cast(receiver_map->prototype())->map());
 }

References v8::internal::flag, GetRootConstructor(), v8::internal::handle(), v8::internal::JSFunction::instance_prototype(), isolate(), v8::internal::kCacheOnPrototype, v8::internal::kCacheOnPrototypeReceiverIsDictionary, v8::internal::kCacheOnPrototypeReceiverIsPrimitive, v8::internal::kCacheOnReceiver, v8::internal::Isolate::native_context(), NULL, and TypeToMap().

Referenced by v8::internal::LoadIC::CompileHandler(), ComputeHandler(), and v8::internal::NamedLoadHandlerCompiler::ComputeLoadNonexistent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetICCacheHolder()

Handle< Map > v8::internal::IC::GetICCacheHolder	(	HeapType *	type,
		Isolate *	isolate,
		CacheHolderFlag *	flag
	)

inlinestatic

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

                                                         {
   Context* native_context = *isolate->native_context();
   JSFunction* builtin_ctor = GetRootConstructor(type, native_context);
   if (builtin_ctor != NULL) {
     *flag = kCacheOnPrototype;
     return handle(builtin_ctor->initial_map());
   }
   *flag = kCacheOnReceiver;
   return TypeToMap(type, isolate);
 }

References v8::internal::flag, GetRootConstructor(), v8::internal::handle(), v8::internal::JSFunction::initial_map(), isolate(), v8::internal::kCacheOnPrototype, v8::internal::kCacheOnReceiver, v8::internal::Isolate::native_context(), NULL, and TypeToMap().

Referenced by v8::internal::PropertyICCompiler::ComputeMonomorphic(), and TryRemoveInvalidPrototypeDependentStub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetOriginalCode()

Code * v8::internal::IC::GetOriginalCode ( ) const

protected

Definition at line 209 of file ic.cc.

                                 {
   HandleScope scope(isolate());
   Handle<SharedFunctionInfo> shared(GetSharedFunctionInfo(), isolate());
   DCHECK(Debug::HasDebugInfo(shared));
   Code* original_code = Debug::GetDebugInfo(shared)->original_code();
   DCHECK(original_code->IsCode());
   return original_code;
 }

References DCHECK, v8::internal::Debug::GetDebugInfo(), GetSharedFunctionInfo(), v8::internal::Debug::HasDebugInfo(), and isolate().

Referenced by address(), and constant_pool().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRootConstructor()

template<class TypeClass >

JSFunction * v8::internal::IC::GetRootConstructor	(	TypeClass *	type,
		Context *	native_context
	)

static

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

                                                                            {
   if (type->Is(TypeClass::Boolean())) {
     return native_context->boolean_function();
   } else if (type->Is(TypeClass::Number())) {
     return native_context->number_function();
   } else if (type->Is(TypeClass::String())) {
     return native_context->string_function();
   } else if (type->Is(TypeClass::Symbol())) {
     return native_context->symbol_function();
   } else {
     return NULL;
   }
 }

References NULL.

Referenced by GetHandlerCacheHolder(), GetICCacheHolder(), and v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::map().

Here is the caller graph for this function:

◆ GetSharedFunctionInfo()

SharedFunctionInfo * v8::internal::IC::GetSharedFunctionInfo ( ) const

protected

Definition at line 187 of file ic.cc.

                                                     {
   // Compute the JavaScript frame for the frame pointer of this IC
   // structure. We need this to be able to find the function
   // corresponding to the frame.
   StackFrameIterator it(isolate());
   while (it.frame()->fp() != this->fp()) it.Advance();
   JavaScriptFrame* frame = JavaScriptFrame::cast(it.frame());
   // Find the function on the stack and both the active code for the
   // function and the original code.
   JSFunction* function = frame->function();
   return function->shared();
 }

References v8::internal::StackFrameIterator::Advance(), v8::internal::JavaScriptFrame::cast(), v8::internal::StackFrameIterator::frame(), v8::internal::JavaScriptFrame::function(), and isolate().

Referenced by GetCode(), and GetOriginalCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTargetAtAddress()

Code * v8::internal::IC::GetTargetAtAddress	(	Address	address,
		ConstantPoolArray *	constant_pool
	)

inlinestaticprotected

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

                                                                {
   // Get the target address of the IC.
   Address target = Assembler::target_address_at(address, constant_pool);
   // Convert target address to the code object. Code::GetCodeFromTargetAddress
   // is safe for use during GC where the map might be marked.
   Code* result = Code::GetCodeFromTargetAddress(target);
   DCHECK(result->is_inline_cache_stub());
   return result;
 }

References address(), constant_pool(), DCHECK, v8::internal::Code::GetCodeFromTargetAddress(), v8::internal::Code::is_inline_cache_stub(), target(), and v8::internal::Assembler::target_address_at().

Referenced by Clear(), raw_target(), and SetTargetAtAddress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handler_kind()

Code::Kind v8::internal::IC::handler_kind ( ) const

inlineprotected

Definition at line 186 of file ic.h.

                                 {
     if (kind_ == Code::KEYED_LOAD_IC) return Code::LOAD_IC;
     DCHECK(kind_ == Code::LOAD_IC || kind_ == Code::STORE_IC ||
            kind_ == Code::KEYED_STORE_IC);
     return kind_;
   }

References DCHECK, and kind_.

◆ InvalidateMaps()

void v8::internal::IC::InvalidateMaps ( Code * stub )

static

Definition at line 460 of file ic.cc.

                                   {
   DCHECK(stub->is_weak_stub());
   stub->mark_as_invalidated_weak_stub();
   Isolate* isolate = stub->GetIsolate();
   Heap* heap = isolate->heap();
   Object* undefined = heap->undefined_value();
   int mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
   for (RelocIterator it(stub, mode_mask); !it.done(); it.next()) {
     RelocInfo::Mode mode = it.rinfo()->rmode();
     if (mode == RelocInfo::EMBEDDED_OBJECT &&
         it.rinfo()->target_object()->IsMap()) {
       it.rinfo()->set_target_object(undefined, SKIP_WRITE_BARRIER);
     }
   }
   CpuFeatures::FlushICache(stub->instruction_start(), stub->instruction_size());
 }

References DCHECK, v8::internal::RelocIterator::done(), v8::internal::RelocInfo::EMBEDDED_OBJECT, v8::internal::CpuFeatures::FlushICache(), v8::internal::HeapObject::GetIsolate(), v8::internal::Isolate::heap(), v8::internal::Code::instruction_size(), v8::internal::Code::instruction_start(), v8::internal::Code::is_weak_stub(), isolate(), v8::internal::Code::mark_as_invalidated_weak_stub(), mode(), v8::internal::RelocInfo::ModeMask(), and v8::internal::SKIP_WRITE_BARRIER.

Referenced by v8::internal::MarkCompactCollector::ClearDependentICList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_target_set()

bool v8::internal::IC::is_target_set ( )

inlineprotected

Definition at line 147 of file ic.h.

147 { return target_set_; }

References target_set_.

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

Here is the caller graph for this function:

◆ IsCleared()

static bool v8::internal::IC::IsCleared ( Code * code )

inlinestatic

Definition at line 112 of file ic.h.

                                     {
     InlineCacheState state = code->ic_state();
     return state == UNINITIALIZED || state == PREMONOMORPHIC;
   }

References v8::internal::Code::ic_state(), v8::internal::PREMONOMORPHIC, state(), and v8::internal::UNINITIALIZED.

Referenced by v8::internal::CompareNilIC::Clear(), v8::internal::LoadIC::Clear(), v8::internal::KeyedLoadIC::Clear(), v8::internal::StoreIC::Clear(), and v8::internal::KeyedStoreIC::Clear().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsNameCompatibleWithPrototypeFailure()

bool v8::internal::IC::IsNameCompatibleWithPrototypeFailure ( Handle< Object > name )

Definition at line 303 of file ic.cc.

                                                                  {
   if (target()->is_keyed_stub()) {
     // Determine whether the failure is due to a name failure.
     if (!name->IsName()) return false;
     Name* stub_name = target()->FindFirstName();
     if (*name != stub_name) return false;
   }
  
   return true;
 }

References name, and target().

Referenced by MarkPrototypeFailure(), and TryRemoveInvalidPrototypeDependentStub().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isolate()

Isolate* v8::internal::IC::isolate ( ) const

inlineprotected

Definition at line 136 of file ic.h.

136 { return isolate_; }

References isolate_.

Here is the caller graph for this function:

◆ IsTransitionOfMonomorphicTarget()

bool v8::internal::IC::IsTransitionOfMonomorphicTarget	(	Map *	source_map,
		Map *	target_map
	)

protected

Definition at line 772 of file ic.cc.

                                                                          {
   if (source_map == NULL) return true;
   if (target_map == NULL) return false;
   ElementsKind target_elements_kind = target_map->elements_kind();
   bool more_general_transition = IsMoreGeneralElementsKindTransition(
       source_map->elements_kind(), target_elements_kind);
   Map* transitioned_map =
       more_general_transition
           ? source_map->LookupElementsTransitionMap(target_elements_kind)
           : NULL;
  
   return transitioned_map == target_map;
 }

References v8::internal::Map::elements_kind(), v8::internal::IsMoreGeneralElementsKindTransition(), v8::internal::Map::LookupElementsTransitionMap(), and NULL.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kind()

Code::Kind v8::internal::IC::kind ( ) const

inlineprotected

Definition at line 185 of file ic.h.

185 { return kind_; }

References kind_.

Referenced by v8::internal::LoadIC::CompileHandler(), ComputeHandler(), v8::internal::StoreIC::generic_stub(), v8::internal::LoadIC::Load(), v8::internal::LoadIC::megamorphic_stub(), v8::internal::StoreIC::megamorphic_stub(), v8::internal::LoadIC::pre_monomorphic_stub(), v8::internal::LoadIC::slow_stub(), v8::internal::StoreIC::slow_stub(), v8::internal::LoadIC::UpdateCaches(), UpdateMegamorphicCache(), UpdateMonomorphicIC(), and UpdatePolymorphicIC().

Here is the caller graph for this function:

◆ MapToType()

template<class T >

template Handle< HeapType > v8::internal::IC::MapToType< HeapType >	(	Handle< Map >	map,
		typename T::Region *	region
	)

static

Definition at line 733 of file ic.cc.

                                                                {
   if (map->instance_type() == HEAP_NUMBER_TYPE) {
     return T::Number(region);
   } else if (map->instance_type() == ODDBALL_TYPE) {
     // The only oddballs that can be recorded in ICs are booleans.
     return T::Boolean(region);
   } else {
     return T::Class(map, region);
   }
 }

References v8::internal::HEAP_NUMBER_TYPE, map, and v8::internal::ODDBALL_TYPE.

◆ MarkPrototypeFailure()

void v8::internal::IC::MarkPrototypeFailure ( Handle< Object > name )

inline

Definition at line 73 of file ic.h.

                                                  {
     DCHECK(IsNameCompatibleWithPrototypeFailure(name));
     state_ = PROTOTYPE_FAILURE;
   }

References DCHECK, IsNameCompatibleWithPrototypeFailure(), name, v8::internal::PROTOTYPE_FAILURE, and state_.

Referenced by UpdateState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ megamorphic_stub()

virtual Handle<Code> v8::internal::IC::megamorphic_stub ( )

inlineprotectedvirtual

Reimplemented in v8::internal::StoreIC, and v8::internal::LoadIC.

Definition at line 192 of file ic.h.

                                           {
     UNREACHABLE();
     return Handle<Code>::null();
   }

References v8::internal::Handle< T >::null(), and UNREACHABLE.

Referenced by PatchCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OnTypeFeedbackChanged()

void v8::internal::IC::OnTypeFeedbackChanged	(	Isolate *	isolate,
		Address	address,
		State	old_state,
		State	new_state,
		bool	target_remains_ic_stub
	)

staticprotected

Definition at line 392 of file ic.cc.

                                                             {
   Code* host =
       isolate->inner_pointer_to_code_cache()->GetCacheEntry(address)->code;
   if (host->kind() != Code::FUNCTION) return;
  
   if (FLAG_type_info_threshold > 0 && target_remains_ic_stub &&
       // Not all Code objects have TypeFeedbackInfo.
       host->type_feedback_info()->IsTypeFeedbackInfo()) {
     int polymorphic_delta = 0;  // "Polymorphic" here includes monomorphic.
     int generic_delta = 0;      // "Generic" here includes megamorphic.
     ComputeTypeInfoCountDelta(old_state, new_state, &polymorphic_delta,
                               &generic_delta);
     TypeFeedbackInfo* info = TypeFeedbackInfo::cast(host->type_feedback_info());
     info->change_ic_with_type_info_count(polymorphic_delta);
     info->change_ic_generic_count(generic_delta);
   }
   if (host->type_feedback_info()->IsTypeFeedbackInfo()) {
     TypeFeedbackInfo* info = TypeFeedbackInfo::cast(host->type_feedback_info());
     info->change_own_type_change_checksum();
   }
   host->set_profiler_ticks(0);
   isolate->runtime_profiler()->NotifyICChanged();
   // TODO(2029): When an optimized function is patched, it would
   // be nice to propagate the corresponding type information to its
   // unoptimized version for the benefit of later inlining.
 }

References address(), v8::internal::TypeFeedbackInfo::change_ic_generic_count(), v8::internal::TypeFeedbackInfo::change_ic_with_type_info_count(), v8::internal::TypeFeedbackInfo::change_own_type_change_checksum(), v8::internal::InnerPointerToCodeCache::InnerPointerToCodeCacheEntry::code, v8::internal::ComputeTypeInfoCountDelta(), v8::internal::InnerPointerToCodeCache::GetCacheEntry(), v8::internal::Isolate::inner_pointer_to_code_cache(), isolate(), v8::internal::Code::kind(), v8::internal::RuntimeProfiler::NotifyICChanged(), v8::internal::Isolate::runtime_profiler(), v8::internal::Code::set_profiler_ticks(), and v8::internal::Code::type_feedback_info().

Referenced by v8::internal::CallIC::DoCustomHandler(), v8::internal::CallIC::HandleMiss(), v8::internal::CallIC::PatchMegamorphic(), and PostPatching().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PatchCache()

void v8::internal::IC::PatchCache	(	Handle< Name >	name,
		Handle< Code >	code
	)

protected

Definition at line 787 of file ic.cc.

                                                         {
   switch (state()) {
     case UNINITIALIZED:
     case PREMONOMORPHIC:
       UpdateMonomorphicIC(code, name);
       break;
     case PROTOTYPE_FAILURE:
     case MONOMORPHIC:
     case POLYMORPHIC:
       if (!target()->is_keyed_stub() || state() == PROTOTYPE_FAILURE) {
         if (UpdatePolymorphicIC(name, code)) break;
         CopyICToMegamorphicCache(name);
       }
       set_target(*megamorphic_stub());
     // Fall through.
     case MEGAMORPHIC:
       UpdateMegamorphicCache(*receiver_type(), *name, *code);
       break;
     case DEBUG_STUB:
       break;
     case DEFAULT:
     case GENERIC:
       UNREACHABLE();
       break;
   }
 }

References CopyICToMegamorphicCache(), v8::internal::DEBUG_STUB, v8::internal::DEFAULT, v8::internal::GENERIC, v8::internal::MEGAMORPHIC, megamorphic_stub(), v8::internal::MONOMORPHIC, name, v8::internal::POLYMORPHIC, v8::internal::PREMONOMORPHIC, v8::internal::PROTOTYPE_FAILURE, receiver_type(), set_target(), state(), target(), v8::internal::UNINITIALIZED, UNREACHABLE, UpdateMegamorphicCache(), UpdateMonomorphicIC(), and UpdatePolymorphicIC().

Referenced by v8::internal::LoadIC::UpdateCaches(), and v8::internal::StoreIC::UpdateCaches().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pc()

Address v8::internal::IC::pc ( ) const

inlineprotected

Definition at line 135 of file ic.h.

135 { return *pc_address_; }

References pc_address_.

Referenced by address(), constant_pool(), and TraceIC().

Here is the caller graph for this function:

◆ PostPatching()

void v8::internal::IC::PostPatching	(	Address	address,
		Code *	target,
		Code *	old_target
	)

staticprotected

Definition at line 422 of file ic.cc.

                                                                      {
   // Type vector based ICs update these statistics at a different time because
   // they don't always patch on state change.
   if (target->kind() == Code::CALL_IC) return;
  
   Isolate* isolate = target->GetHeap()->isolate();
   State old_state = UNINITIALIZED;
   State new_state = UNINITIALIZED;
   bool target_remains_ic_stub = false;
   if (old_target->is_inline_cache_stub() && target->is_inline_cache_stub()) {
     old_state = old_target->ic_state();
     new_state = target->ic_state();
     target_remains_ic_stub = true;
   }
  
   OnTypeFeedbackChanged(isolate, address, old_state, new_state,
                         target_remains_ic_stub);
 }

References address(), v8::internal::Code::ic_state(), v8::internal::Code::is_inline_cache_stub(), isolate(), OnTypeFeedbackChanged(), target(), and v8::internal::UNINITIALIZED.

Referenced by SetTargetAtAddress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ raw_constant_pool()

ConstantPoolArray * v8::internal::IC::raw_constant_pool ( ) const

inlineprivate

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

                                                {
   if (FLAG_enable_ool_constant_pool) {
     return *raw_constant_pool_;
   } else {
     return NULL;
   }
 }

References NULL, and raw_constant_pool_.

Referenced by address(), and constant_pool().

Here is the caller graph for this function:

◆ raw_target()

Code * v8::internal::IC::raw_target ( ) const

inlineprivate

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

                            {
   return GetTargetAtAddress(address(), constant_pool());
 }

References address(), constant_pool(), and GetTargetAtAddress().

Referenced by IC(), TraceIC(), and UpdateTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ receiver_type()

Handle<HeapType> v8::internal::IC::receiver_type ( )

inlineprotected

Definition at line 203 of file ic.h.

203 { return receiver_type_; }

v8::internal::IC::receiver_type_

Handle< HeapType > receiver_type_

Definition: ic.h:266

References receiver_type_.

Referenced by v8::internal::LoadIC::CompileHandler(), v8::internal::StoreIC::CompileHandler(), ComputeHandler(), PatchCache(), TryRemoveInvalidPrototypeDependentStub(), v8::internal::LoadIC::UpdateCaches(), UpdateMonomorphicIC(), and UpdatePolymorphicIC().

Here is the caller graph for this function:

◆ ReferenceError()

MaybeHandle< Object > v8::internal::IC::ReferenceError	(	const char *	type,
		Handle< Name >	name
	)

protected

Definition at line 348 of file ic.cc.

                                                                           {
   HandleScope scope(isolate());
   THROW_NEW_ERROR(isolate(), NewReferenceError(type, HandleVector(&name, 1)),
                   Object);
 }

References v8::internal::HandleVector(), isolate(), name, and THROW_NEW_ERROR.

Referenced by v8::internal::LoadIC::Load().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RegisterWeakMapDependency()

void v8::internal::IC::RegisterWeakMapDependency ( Handle< Code > stub )

static

Definition at line 442 of file ic.cc.

                                                     {
   if (FLAG_collect_maps && FLAG_weak_embedded_maps_in_ic &&
       stub->CanBeWeakStub()) {
     DCHECK(!stub->is_weak_stub());
     MapHandleList maps;
     stub->FindAllMaps(&maps);
     if (maps.length() == 1 && stub->IsWeakObjectInIC(*maps.at(0))) {
       Map::AddDependentIC(maps.at(0), stub);
       stub->mark_as_weak_stub();
       if (FLAG_enable_ool_constant_pool) {
         stub->constant_pool()->set_weak_object_state(
             ConstantPoolArray::WEAK_OBJECTS_IN_IC);
       }
     }
   }
 }

References v8::internal::Map::AddDependentIC(), v8::internal::List< T, AllocationPolicy >::at(), DCHECK, and v8::internal::ConstantPoolArray::WEAK_OBJECTS_IN_IC.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_extra_ic_state()

void v8::internal::IC::set_extra_ic_state ( ExtraICState state )

inlineprotected

Definition at line 201 of file ic.h.

201 { extra_ic_state_ = state; }

References extra_ic_state_, and state().

Here is the call graph for this function:

◆ set_target()

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

inlineprotected

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

                               {
 #ifdef VERIFY_HEAP
   code->VerifyEmbeddedObjectsDependency();
 #endif
   SetTargetAtAddress(address(), code, constant_pool());
   target_set_ = true;
 }

References address(), constant_pool(), SetTargetAtAddress(), and target_set_.

Referenced by v8::internal::CompareNilIC::CompareNil(), v8::internal::CallIC::DoCustomHandler(), PatchCache(), v8::internal::CallIC::PatchMegamorphic(), v8::internal::LoadIC::set_target(), v8::internal::StoreIC::set_target(), v8::internal::KeyedStoreIC::set_target(), v8::internal::ToBooleanIC::ToBoolean(), v8::internal::BinaryOpIC::Transition(), v8::internal::CompareIC::UpdateCaches(), UpdateMonomorphicIC(), and UpdatePolymorphicIC().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetTargetAtAddress()

void v8::internal::IC::SetTargetAtAddress	(	Address	address,
		Code *	target,
		ConstantPoolArray *	constant_pool
	)

inlinestaticprotected

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

                                                               {
   DCHECK(target->is_inline_cache_stub() || target->is_compare_ic_stub());
   Heap* heap = target->GetHeap();
   Code* old_target = GetTargetAtAddress(address, constant_pool);
 #ifdef DEBUG
   // STORE_IC and KEYED_STORE_IC use Code::extra_ic_state() to mark
   // ICs as strict mode. The strict-ness of the IC must be preserved.
   if (old_target->kind() == Code::STORE_IC ||
       old_target->kind() == Code::KEYED_STORE_IC) {
     DCHECK(StoreIC::GetStrictMode(old_target->extra_ic_state()) ==
            StoreIC::GetStrictMode(target->extra_ic_state()));
   }
 #endif
   Assembler::set_target_address_at(address, constant_pool,
                                    target->instruction_start());
   if (heap->gc_state() == Heap::MARK_COMPACT) {
     heap->mark_compact_collector()->RecordCodeTargetPatch(address, target);
   } else {
     heap->incremental_marking()->RecordCodeTargetPatch(address, target);
   }
   PostPatching(address, target, old_target);
 }

References address(), constant_pool(), DCHECK, v8::internal::Code::extra_ic_state(), v8::internal::Heap::gc_state(), v8::internal::StoreIC::GetStrictMode(), GetTargetAtAddress(), v8::internal::Heap::incremental_marking(), v8::internal::Code::kind(), v8::internal::Heap::MARK_COMPACT, v8::internal::Heap::mark_compact_collector(), PostPatching(), v8::internal::MarkCompactCollector::RecordCodeTargetPatch(), v8::internal::IncrementalMarking::RecordCodeTargetPatch(), v8::internal::Assembler::set_target_address_at(), and target().

Referenced by v8::internal::CompareNilIC::Clear(), v8::internal::LoadIC::Clear(), v8::internal::KeyedLoadIC::Clear(), v8::internal::StoreIC::Clear(), v8::internal::KeyedStoreIC::Clear(), v8::internal::CompareIC::Clear(), and set_target().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ state()

State v8::internal::IC::state ( ) const

inline

Definition at line 66 of file ic.h.

66 { return state_; }

References state_.

Referenced by v8::internal::CompareNilIC::Clear(), ComputeHandler(), v8::internal::CallIC::DoCustomHandler(), v8::internal::CallIC::FeedbackToState(), v8::internal::StoreIC::GetStrictMode(), v8::internal::CallIC::HandleMiss(), IsCleared(), v8::internal::KeyedLoadIC::Load(), v8::internal::KeyedLoadIC::LoadElementStub(), PatchCache(), v8::internal::CallIC::PatchMegamorphic(), v8::internal::StoreIC::pre_monomorphic_stub(), set_extra_ic_state(), v8::internal::KeyedStoreIC::StoreElementStub(), TraceIC(), v8::internal::BinaryOpIC::Transition(), TransitionMarkFromState(), TryRemoveInvalidPrototypeDependentStub(), v8::internal::CompareIC::UpdateCaches(), v8::internal::LoadIC::UpdateCaches(), v8::internal::StoreIC::UpdateCaches(), UpdatePolymorphicIC(), and UpdateState().

Here is the caller graph for this function:

◆ target()

Handle<Code> v8::internal::IC::target ( ) const

inlineprotected

Definition at line 132 of file ic.h.

132 { return target_; }

References target_.

Referenced by v8::internal::CompareNilIC::Clear(), v8::internal::LoadIC::Clear(), v8::internal::KeyedLoadIC::Clear(), v8::internal::StoreIC::Clear(), v8::internal::KeyedStoreIC::Clear(), v8::internal::CompareIC::Clear(), Clear(), v8::internal::CompareNilIC::CompareNil(), constant_pool(), CopyICToMegamorphicCache(), GetTargetAtAddress(), v8::internal::CallIC::HandleMiss(), IsNameCompatibleWithPrototypeFailure(), v8::internal::KeyedLoadIC::KeyedLoadIC(), v8::internal::KeyedStoreIC::KeyedStoreIC(), v8::internal::KeyedLoadIC::LoadElementStub(), PatchCache(), v8::internal::CallIC::PatchMegamorphic(), PostPatching(), v8::internal::LoadIC::set_target(), v8::internal::StoreIC::set_target(), SetTargetAtAddress(), v8::internal::KeyedStoreIC::Store(), v8::internal::KeyedStoreIC::StoreElementStub(), v8::internal::ToBooleanIC::ToBoolean(), v8::internal::BinaryOpIC::Transition(), TryRemoveInvalidPrototypeDependentStub(), v8::internal::CompareIC::UpdateCaches(), and UpdatePolymorphicIC().

Here is the caller graph for this function:

◆ TargetMaps()

void v8::internal::IC::TargetMaps ( MapHandleList * list )

inlineprotected

Definition at line 208 of file ic.h.

                                        {
     FindTargetMaps();
     for (int i = 0; i < target_maps_.length(); i++) {
       list->Add(target_maps_.at(i));
     }
   }

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::List< T, AllocationPolicy >::at(), FindTargetMaps(), and target_maps_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TargetTypes()

void v8::internal::IC::TargetTypes ( TypeHandleList * list )

inlineprotected

Definition at line 215 of file ic.h.

                                          {
     FindTargetMaps();
     for (int i = 0; i < target_maps_.length(); i++) {
       list->Add(MapToType<HeapType>(target_maps_.at(i), isolate_));
     }
   }

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::List< T, AllocationPolicy >::at(), FindTargetMaps(), isolate_, and target_maps_.

Referenced by CopyICToMegamorphicCache(), and UpdatePolymorphicIC().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TraceIC() [1/2]

void v8::internal::IC::TraceIC	(	const char *	type,
		Handle< Object >	name
	)

protected

Definition at line 90 of file ic.cc.

                                                       {
   if (FLAG_trace_ic) {
     Code* new_target = raw_target();
     State new_state = new_target->ic_state();
     TraceIC(type, name, state(), new_state);
   }
 }

References v8::internal::Code::ic_state(), name, raw_target(), and state().

Here is the call graph for this function:

◆ TraceIC() [2/2]

void v8::internal::IC::TraceIC	(	const char *	type,
		Handle< Object >	name,
		State	old_state,
		State	new_state
	)

protected

Definition at line 99 of file ic.cc.

                                   {
   if (FLAG_trace_ic) {
     Code* new_target = raw_target();
     PrintF("[%s%s in ", new_target->is_keyed_stub() ? "Keyed" : "", type);
  
     // TODO(jkummerow): Add support for "apply". The logic is roughly:
     // marker = [fp_ + kMarkerOffset];
     // if marker is smi and marker.value == INTERNAL and
     //     the frame's code == builtin(Builtins::kFunctionApply):
     // then print "apply from" and advance one frame
  
     Object* maybe_function =
         Memory::Object_at(fp_ + JavaScriptFrameConstants::kFunctionOffset);
     if (maybe_function->IsJSFunction()) {
       JSFunction* function = JSFunction::cast(maybe_function);
       JavaScriptFrame::PrintFunctionAndOffset(function, function->code(), pc(),
                                               stdout, true);
     }
  
     ExtraICState extra_state = new_target->extra_ic_state();
     const char* modifier = "";
     if (new_target->kind() == Code::KEYED_STORE_IC) {
       modifier = GetTransitionMarkModifier(
           KeyedStoreIC::GetKeyedAccessStoreMode(extra_state));
     }
     PrintF(" (%c->%c%s)", TransitionMarkFromState(old_state),
            TransitionMarkFromState(new_state), modifier);
 #ifdef OBJECT_PRINT
     OFStream os(stdout);
     name->Print(os);
 #else
     name->ShortPrint(stdout);
 #endif
     PrintF("]\n");
   }
 }

References v8::internal::Code::extra_ic_state(), fp_, v8::internal::KeyedStoreIC::GetKeyedAccessStoreMode(), v8::internal::GetTransitionMarkModifier(), v8::internal::Code::is_keyed_stub(), v8::internal::JavaScriptFrameConstants::kFunctionOffset, v8::internal::Code::kind(), name, v8::internal::Memory::Object_at(), pc(), v8::internal::PrintF(), v8::internal::JavaScriptFrame::PrintFunctionAndOffset(), raw_target(), and TransitionMarkFromState().

Here is the call graph for this function:

◆ TransitionMarkFromState()

char v8::internal::IC::TransitionMarkFromState ( IC::State state )

protected

Definition at line 25 of file ic.cc.

                                               {
   switch (state) {
     case UNINITIALIZED:
       return '0';
     case PREMONOMORPHIC:
       return '.';
     case MONOMORPHIC:
       return '1';
     case PROTOTYPE_FAILURE:
       return '^';
     case POLYMORPHIC:
       return 'P';
     case MEGAMORPHIC:
       return 'N';
     case GENERIC:
       return 'G';
  
     // We never see the debugger states here, because the state is
     // computed from the original code - not the patched code. Let
     // these cases fall through to the unreachable code below.
     case DEBUG_STUB:
       break;
     // Type-vector-based ICs resolve state to one of the above.
     case DEFAULT:
       break;
   }
   UNREACHABLE();
   return 0;
 }

References v8::internal::DEBUG_STUB, v8::internal::DEFAULT, v8::internal::GENERIC, v8::internal::MEGAMORPHIC, v8::internal::MONOMORPHIC, v8::internal::POLYMORPHIC, v8::internal::PREMONOMORPHIC, v8::internal::PROTOTYPE_FAILURE, state(), v8::internal::UNINITIALIZED, and UNREACHABLE.

Referenced by TraceIC().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TryRemoveInvalidPrototypeDependentStub()

bool v8::internal::IC::TryRemoveInvalidPrototypeDependentStub	(	Handle< Object >	receiver,
		Handle< String >	name
	)

protected

Definition at line 251 of file ic.cc.

                                                                      {
   if (!IsNameCompatibleWithPrototypeFailure(name)) return false;
   Handle<Map> receiver_map = TypeToMap(*receiver_type(), isolate());
   maybe_handler_ = target()->FindHandlerForMap(*receiver_map);
  
   // The current map wasn't handled yet. There's no reason to stay monomorphic,
   // *unless* we're moving from a deprecated map to its replacement, or
   // to a more general elements kind.
   // TODO(verwaest): Check if the current map is actually what the old map
   // would transition to.
   if (maybe_handler_.is_null()) {
     if (!receiver_map->IsJSObjectMap()) return false;
     Map* first_map = FirstTargetMap();
     if (first_map == NULL) return false;
     Handle<Map> old_map(first_map);
     if (old_map->is_deprecated()) return true;
     if (IsMoreGeneralElementsKindTransition(old_map->elements_kind(),
                                             receiver_map->elements_kind())) {
       return true;
     }
     return false;
   }
  
   CacheHolderFlag flag;
   Handle<Map> ic_holder_map(
       GetICCacheHolder(*receiver_type(), isolate(), &flag));
  
   DCHECK(flag != kCacheOnReceiver || receiver->IsJSObject());
   DCHECK(flag != kCacheOnPrototype || !receiver->IsJSReceiver());
   DCHECK(flag != kCacheOnPrototypeReceiverIsDictionary);
  
   if (state() == MONOMORPHIC) {
     int index = ic_holder_map->IndexInCodeCache(*name, *target());
     if (index >= 0) {
       ic_holder_map->RemoveFromCodeCache(*name, *target(), index);
     }
   }
  
   if (receiver->IsGlobalObject()) {
     Handle<GlobalObject> global = Handle<GlobalObject>::cast(receiver);
     LookupIterator it(global, name, LookupIterator::OWN_SKIP_INTERCEPTOR);
     if (it.state() == LookupIterator::ACCESS_CHECK) return false;
     if (!it.IsFound()) return false;
     Handle<PropertyCell> cell = it.GetPropertyCell();
     return cell->type()->IsConstant();
   }
  
   return true;
 }

References v8::internal::Handle< T >::cast(), DCHECK, FirstTargetMap(), v8::internal::flag, GetICCacheHolder(), v8::internal::IsMoreGeneralElementsKindTransition(), IsNameCompatibleWithPrototypeFailure(), isolate(), v8::internal::kCacheOnPrototype, v8::internal::kCacheOnPrototypeReceiverIsDictionary, v8::internal::kCacheOnReceiver, maybe_handler_, v8::internal::MONOMORPHIC, name, NULL, receiver_type(), state(), target(), and TypeToMap().

Referenced by UpdateState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TypeError()

MaybeHandle< Object > v8::internal::IC::TypeError	(	const char *	type,
		Handle< Object >	object,
		Handle< Object >	key
	)

protected

Definition at line 340 of file ic.cc.

                                                       {
   HandleScope scope(isolate());
   Handle<Object> args[2] = {key, object};
   THROW_NEW_ERROR(isolate(), NewTypeError(type, HandleVector(args, 2)), Object);
 }

References v8::internal::HandleVector(), isolate(), and THROW_NEW_ERROR.

Referenced by v8::internal::LoadIC::Load(), and v8::internal::StoreIC::Store().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TypeToMap()

Handle< Map > v8::internal::IC::TypeToMap	(	HeapType *	type,
		Isolate *	isolate
	)

static

Definition at line 719 of file ic.cc.

                                                           {
   if (type->Is(HeapType::Number()))
     return isolate->factory()->heap_number_map();
   if (type->Is(HeapType::Boolean())) return isolate->factory()->boolean_map();
   if (type->IsConstant()) {
     return handle(
         Handle<JSGlobalObject>::cast(type->AsConstant()->Value())->map());
   }
   DCHECK(type->IsClass());
   return type->AsClass()->Map();
 }

References v8::internal::TypeImpl< Config >::AsClass(), v8::internal::TypeImpl< Config >::AsConstant(), DCHECK, v8::internal::Isolate::factory(), v8::internal::handle(), v8::internal::TypeImpl< Config >::Is(), v8::internal::TypeImpl< Config >::IsClass(), v8::internal::TypeImpl< Config >::IsConstant(), isolate(), v8::internal::TypeImpl< Config >::ClassType::Map(), and v8::internal::TypeImpl< Config >::ConstantType::Value().

Referenced by v8::internal::NamedLoadHandlerCompiler::CompileLoadCallback(), v8::internal::NamedLoadHandlerCompiler::ComputeLoadNonexistent(), GetHandlerCacheHolder(), GetICCacheHolder(), v8::internal::AccessorInfo::IsCompatibleReceiverType(), v8::internal::PropertyHandlerCompiler::NonexistentFrontendHeader(), TryRemoveInvalidPrototypeDependentStub(), and UpdateMegamorphicCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_receiver_type()

void v8::internal::IC::update_receiver_type ( Handle< Object > receiver )

inlineprotected

Definition at line 204 of file ic.h.

                                                      {
     receiver_type_ = CurrentTypeOf(receiver, isolate_);
   }

References CurrentTypeOf(), isolate_, and receiver_type_.

Referenced by v8::internal::StoreIC::LookupForWrite(), and UpdateState().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMegamorphicCache()

void v8::internal::IC::UpdateMegamorphicCache	(	HeapType *	type,
		Name *	name,
		Code *	code
	)

protected

Definition at line 890 of file ic.cc.

                                                                       {
   if (kind() == Code::KEYED_LOAD_IC || kind() == Code::KEYED_STORE_IC) return;
   Map* map = *TypeToMap(type, isolate());
   isolate()->stub_cache()->Set(name, map, code);
 }

References isolate(), kind(), map, name, v8::internal::StubCache::Set(), v8::internal::Isolate::stub_cache(), and TypeToMap().

Referenced by CopyICToMegamorphicCache(), and PatchCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMonomorphicIC()

void v8::internal::IC::UpdateMonomorphicIC	(	Handle< Code >	handler,
		Handle< Name >	name
	)

protected

Definition at line 753 of file ic.cc.

                                                                     {
   DCHECK(handler->is_handler());
   Handle<Code> ic = PropertyICCompiler::ComputeMonomorphic(
       kind(), name, receiver_type(), handler, extra_ic_state());
   set_target(*ic);
 }

References v8::internal::PropertyICCompiler::ComputeMonomorphic(), DCHECK, extra_ic_state(), kind(), name, receiver_type(), and set_target().

Referenced by PatchCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdatePolymorphicIC()

bool v8::internal::IC::UpdatePolymorphicIC	(	Handle< Name >	name,
		Handle< Code >	code
	)

protected

Definition at line 649 of file ic.cc.

                                                                  {
   if (!code->is_handler()) return false;
   if (target()->is_keyed_stub() && state() != PROTOTYPE_FAILURE) return false;
   Handle<HeapType> type = receiver_type();
   TypeHandleList types;
   CodeHandleList handlers;
  
   TargetTypes(&types);
   int number_of_types = types.length();
   int deprecated_types = 0;
   int handler_to_overwrite = -1;
  
   for (int i = 0; i < number_of_types; i++) {
     Handle<HeapType> current_type = types.at(i);
     if (current_type->IsClass() &&
         current_type->AsClass()->Map()->is_deprecated()) {
       // Filter out deprecated maps to ensure their instances get migrated.
       ++deprecated_types;
     } else if (type->NowIs(current_type)) {
       // If the receiver type is already in the polymorphic IC, this indicates
       // there was a prototoype chain failure. In that case, just overwrite the
       // handler.
       handler_to_overwrite = i;
     } else if (handler_to_overwrite == -1 && current_type->IsClass() &&
                type->IsClass() &&
                IsTransitionOfMonomorphicTarget(*current_type->AsClass()->Map(),
                                                *type->AsClass()->Map())) {
       handler_to_overwrite = i;
     }
   }
  
   int number_of_valid_types =
       number_of_types - deprecated_types - (handler_to_overwrite != -1);
  
   if (number_of_valid_types >= 4) return false;
   if (number_of_types == 0) return false;
   if (!target()->FindHandlers(&handlers, types.length())) return false;
  
   number_of_valid_types++;
   if (number_of_valid_types > 1 && target()->is_keyed_stub()) return false;
   Handle<Code> ic;
   if (number_of_valid_types == 1) {
     ic = PropertyICCompiler::ComputeMonomorphic(kind(), name, type, code,
                                                 extra_ic_state());
   } else {
     if (handler_to_overwrite >= 0) {
       handlers.Set(handler_to_overwrite, code);
       if (!type->NowIs(types.at(handler_to_overwrite))) {
         types.Set(handler_to_overwrite, type);
       }
     } else {
       types.Add(type);
       handlers.Add(code);
     }
     ic = PropertyICCompiler::ComputePolymorphic(kind(), &types, &handlers,
                                                 number_of_valid_types, name,
                                                 extra_ic_state());
   }
   set_target(*ic);
   return true;
 }

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::List< T, AllocationPolicy >::at(), v8::internal::PropertyICCompiler::ComputeMonomorphic(), v8::internal::PropertyICCompiler::ComputePolymorphic(), extra_ic_state(), IsTransitionOfMonomorphicTarget(), kind(), name, v8::internal::PROTOTYPE_FAILURE, receiver_type(), v8::internal::List< T, AllocationPolicy >::Set(), set_target(), state(), target(), and TargetTypes().

Referenced by PatchCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateState()

void v8::internal::IC::UpdateState	(	Handle< Object >	receiver,
		Handle< Object >	name
	)

Definition at line 315 of file ic.cc.

                                                                  {
   update_receiver_type(receiver);
   if (!name->IsString()) return;
   if (state() != MONOMORPHIC && state() != POLYMORPHIC) return;
   if (receiver->IsUndefined() || receiver->IsNull()) return;
  
   // Remove the target from the code cache if it became invalid
   // because of changes in the prototype chain to avoid hitting it
   // again.
   if (TryRemoveInvalidPrototypeDependentStub(receiver,
                                              Handle<String>::cast(name))) {
     MarkPrototypeFailure(name);
     return;
   }
  
   // The builtins object is special.  It only changes when JavaScript
   // builtins are loaded lazily.  It is important to keep inline
   // caches for the builtins object monomorphic.  Therefore, if we get
   // an inline cache miss for the builtins object after lazily loading
   // JavaScript builtins, we return uninitialized as the state to
   // force the inline cache back to monomorphic state.
   if (receiver->IsJSBuiltinsObject()) state_ = UNINITIALIZED;
 }

References MarkPrototypeFailure(), v8::internal::MONOMORPHIC, name, v8::internal::POLYMORPHIC, state(), state_, TryRemoveInvalidPrototypeDependentStub(), v8::internal::UNINITIALIZED, and update_receiver_type().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateTarget()

void v8::internal::IC::UpdateTarget ( )

inlineprotected

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

158 { target_ = handle(raw_target(), isolate_); }

References v8::internal::handle(), isolate_, raw_target(), and target_.

Referenced by v8::internal::BinaryOpIC::Transition().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ extra_ic_state_

ExtraICState v8::internal::IC::extra_ic_state_

private

Definition at line 269 of file ic.h.

Referenced by extra_ic_state(), IC(), and set_extra_ic_state().

◆ fp_

Address v8::internal::IC::fp_

private

Definition at line 247 of file ic.h.

Referenced by fp(), IC(), and TraceIC().

◆ isolate_

Isolate* v8::internal::IC::isolate_

private

Definition at line 255 of file ic.h.

Referenced by isolate(), TargetTypes(), update_receiver_type(), and UpdateTarget().

◆ kind_

Code::Kind v8::internal::IC::kind_

private

Definition at line 265 of file ic.h.

Referenced by handler_kind(), IC(), and kind().

◆ maybe_handler_

MaybeHandle<Code> v8::internal::IC::maybe_handler_

private

Definition at line 267 of file ic.h.

Referenced by ComputeHandler(), and TryRemoveInvalidPrototypeDependentStub().

◆ pc_address_

Address* v8::internal::IC::pc_address_

private

Definition at line 253 of file ic.h.

Referenced by IC(), and pc().

◆ raw_constant_pool_

Handle<ConstantPoolArray> v8::internal::IC::raw_constant_pool_

private

Definition at line 259 of file ic.h.

Referenced by constant_pool(), IC(), and raw_constant_pool().

◆ receiver_type_

Handle<HeapType> v8::internal::IC::receiver_type_

private

Definition at line 266 of file ic.h.

Referenced by receiver_type(), and update_receiver_type().

◆ state_

State v8::internal::IC::state_

private

Definition at line 264 of file ic.h.

Referenced by FindTargetMaps(), IC(), MarkPrototypeFailure(), state(), and UpdateState().

◆ target_

Handle<Code> v8::internal::IC::target_

private

Definition at line 262 of file ic.h.

Referenced by FindTargetMaps(), IC(), target(), and UpdateTarget().

◆ target_maps_

MapHandleList v8::internal::IC::target_maps_

private

Definition at line 270 of file ic.h.

Referenced by FindTargetMaps(), FirstTargetMap(), TargetMaps(), and TargetTypes().

◆ target_maps_set_

bool v8::internal::IC::target_maps_set_

private

Definition at line 271 of file ic.h.

Referenced by FindTargetMaps().

◆ target_set_

bool v8::internal::IC::target_set_

private

Definition at line 263 of file ic.h.

Referenced by is_target_set(), and set_target().

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 Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ State

Member Enumeration Documentation

◆ FrameDepth

◆ UtilityId

Constructor & Destructor Documentation

◆ IC()

◆ ~IC()

Member Function Documentation

◆ address()

◆ AddressFromUtilityId()

◆ Clear()

◆ CompileHandler()

◆ ComputeHandler()

◆ constant_pool()

◆ CopyICToMegamorphicCache()

◆ CurrentTypeOf()

◆ DISALLOW_IMPLICIT_CONSTRUCTORS()

◆ extra_ic_state()

◆ FindTargetMaps()

◆ FirstTargetMap()

◆ fp()

◆ GetCode()

◆ GetHandlerCacheHolder()

◆ GetICCacheHolder()

◆ GetOriginalCode()

◆ GetRootConstructor()

◆ GetSharedFunctionInfo()

◆ GetTargetAtAddress()

◆ handler_kind()

◆ InvalidateMaps()

◆ is_target_set()

◆ IsCleared()

◆ IsNameCompatibleWithPrototypeFailure()

◆ isolate()

◆ IsTransitionOfMonomorphicTarget()

◆ kind()

◆ MapToType()

◆ MarkPrototypeFailure()

◆ megamorphic_stub()

◆ OnTypeFeedbackChanged()

◆ PatchCache()

◆ pc()

◆ PostPatching()

◆ raw_constant_pool()

◆ raw_target()

◆ receiver_type()

◆ ReferenceError()

◆ RegisterWeakMapDependency()

◆ set_extra_ic_state()

◆ set_target()

◆ SetTargetAtAddress()

◆ state()

◆ target()

◆ TargetMaps()

◆ TargetTypes()

◆ TraceIC() [1/2]

◆ TraceIC() [2/2]

◆ TransitionMarkFromState()

◆ TryRemoveInvalidPrototypeDependentStub()

◆ TypeError()

◆ TypeToMap()

◆ update_receiver_type()

◆ UpdateMegamorphicCache()

◆ UpdateMonomorphicIC()

◆ UpdatePolymorphicIC()

◆ UpdateState()

◆ UpdateTarget()

Member Data Documentation

◆ extra_ic_state_

◆ fp_

◆ isolate_