v8::internal::ElementHandlerCompiler Class Reference

#include <handler-compiler.h>

Inheritance diagram for v8::internal::ElementHandlerCompiler:

Collaboration diagram for v8::internal::ElementHandlerCompiler:

Public Member Functions
	ElementHandlerCompiler (Isolate *isolate)
virtual	~ElementHandlerCompiler ()
void	CompileElementHandlers (MapHandleList *receiver_maps, CodeHandleList *handlers)

Static Public Member Functions
static void	GenerateStoreSlow (MacroAssembler *masm)
Static Public Member Functions inherited from v8::internal::PropertyHandlerCompiler
static Handle< Code >	Find (Handle< Name > name, Handle< Map > map, Code::Kind kind, CacheHolderFlag cache_holder, Code::StubType type)

Additional Inherited Members
Protected Member Functions inherited from v8::internal::PropertyHandlerCompiler
	PropertyHandlerCompiler (Isolate *isolate, Code::Kind kind, Handle< HeapType > type, Handle< JSObject > holder, CacheHolderFlag cache_holder)
virtual	~PropertyHandlerCompiler ()
virtual Register	FrontendHeader (Register object_reg, Handle< Name > name, Label *miss)
virtual void	FrontendFooter (Handle< Name > name, Label *miss)
Register	Frontend (Register object_reg, Handle< Name > name)
void	NonexistentFrontendHeader (Handle< Name > name, Label *miss, Register scratch1, Register scratch2)
Register	CheckPrototypes (Register object_reg, Register holder_reg, Register scratch1, Register scratch2, Handle< Name > name, Label *miss, PrototypeCheckType check=CHECK_ALL_MAPS)
Handle< Code >	GetCode (Code::Kind kind, Code::StubType type, Handle< Name > name)
void	set_type_for_object (Handle< Object > object)
void	set_holder (Handle< JSObject > holder)
Handle< HeapType >	type () const
Handle< JSObject >	holder () const
Static Protected Member Functions inherited from v8::internal::PropertyHandlerCompiler
static void	GenerateFastApiCall (MacroAssembler *masm, const CallOptimization &optimization, Handle< Map > receiver_map, Register receiver, Register scratch, bool is_store, int argc, Register *values)
static void	GenerateDictionaryNegativeLookup (MacroAssembler *masm, Label *miss_label, Register receiver, Handle< Name > name, Register r0, Register r1)
static void	GenerateCheckPropertyCell (MacroAssembler *masm, Handle< JSGlobalObject > global, Handle< Name > name, Register scratch, Label *miss)

Detailed Description

Definition at line 258 of file handler-compiler.h.

Constructor & Destructor Documentation

ElementHandlerCompiler()

v8::internal::ElementHandlerCompiler::ElementHandlerCompiler ( Isolate *  isolate )

inlineexplicit

Definition at line 260 of file handler-compiler.h.

      : PropertyHandlerCompiler(isolate, Code::KEYED_LOAD_IC,
                                Handle<HeapType>::null(),
                                Handle<JSObject>::null(), kCacheOnReceiver) {}

~ElementHandlerCompiler()

virtual v8::internal::ElementHandlerCompiler::~ElementHandlerCompiler ( )

inlinevirtual

Definition at line 265 of file handler-compiler.h.

{}

Member Function Documentation

CompileElementHandlers()

void v8::internal::ElementHandlerCompiler::CompileElementHandlers	(	MapHandleList *	receiver_maps,
		CodeHandleList *	handlers
	)

Definition at line 378 of file handler-compiler.cc.

                                                            {
  for (int i = 0; i < receiver_maps->length(); ++i) {
    Handle<Map> receiver_map = receiver_maps->at(i);
    Handle<Code> cached_stub;
 
    if ((receiver_map->instance_type() & kNotStringTag) == 0) {
      cached_stub = isolate()->builtins()->KeyedLoadIC_String();
    } else if (receiver_map->instance_type() < FIRST_JS_RECEIVER_TYPE) {
      cached_stub = isolate()->builtins()->KeyedLoadIC_Slow();
    } else {
      bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
      ElementsKind elements_kind = receiver_map->elements_kind();
      if (receiver_map->has_indexed_interceptor()) {
        cached_stub = LoadIndexedInterceptorStub(isolate()).GetCode();
      } else if (IsSloppyArgumentsElements(elements_kind)) {
        cached_stub = KeyedLoadSloppyArgumentsStub(isolate()).GetCode();
      } else if (IsFastElementsKind(elements_kind) ||
                 IsExternalArrayElementsKind(elements_kind) ||
                 IsFixedTypedArrayElementsKind(elements_kind)) {
        cached_stub = LoadFastElementStub(isolate(), is_js_array, elements_kind)
                          .GetCode();
      } else {
        DCHECK(elements_kind == DICTIONARY_ELEMENTS);
        cached_stub = LoadDictionaryElementStub(isolate()).GetCode();
      }
    }
 
    handlers->Add(cached_stub);
  }
}

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::List< T, AllocationPolicy >::at(), DCHECK, v8::internal::DICTIONARY_ELEMENTS, v8::internal::FIRST_JS_RECEIVER_TYPE, v8::internal::IsExternalArrayElementsKind(), v8::internal::IsFastElementsKind(), v8::internal::IsFixedTypedArrayElementsKind(), v8::internal::IsSloppyArgumentsElements(), v8::internal::JS_ARRAY_TYPE, and v8::internal::kNotStringTag.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateStoreSlow()

static void v8::internal::ElementHandlerCompiler::GenerateStoreSlow ( MacroAssembler *  masm )

static

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

Here is the caller graph for this function:

---

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

• /mnt/V8SourceCode/src/ic/handler-compiler.h
• /mnt/V8SourceCode/src/ic/handler-compiler.cc