v8::internal::NamedLoadHandlerCompiler Class Reference

#include <handler-compiler.h>

Inheritance diagram for v8::internal::NamedLoadHandlerCompiler:

Collaboration diagram for v8::internal::NamedLoadHandlerCompiler:

Public Member Functions
	NamedLoadHandlerCompiler (Isolate *isolate, Handle< HeapType > type, Handle< JSObject > holder, CacheHolderFlag cache_holder)
virtual	~NamedLoadHandlerCompiler ()
Handle< Code >	CompileLoadField (Handle< Name > name, FieldIndex index)
Handle< Code >	CompileLoadCallback (Handle< Name > name, Handle< ExecutableAccessorInfo > callback)
Handle< Code >	CompileLoadCallback (Handle< Name > name, const CallOptimization &call_optimization)
Handle< Code >	CompileLoadConstant (Handle< Name > name, int constant_index)
Handle< Code >	CompileLoadInterceptor (LookupIterator *it)
Handle< Code >	CompileLoadViaGetter (Handle< Name > name, Handle< JSFunction > getter)
Handle< Code >	CompileLoadGlobal (Handle< PropertyCell > cell, Handle< Name > name, bool is_configurable)

Static Public Member Functions
static Handle< Code >	ComputeLoadNonexistent (Handle< Name > name, Handle< HeapType > type)
static void	GenerateLoadViaGetter (MacroAssembler *masm, Handle< HeapType > type, Register receiver, Handle< JSFunction > getter)
static void	GenerateLoadViaGetterForDeopt (MacroAssembler *masm)
static void	GenerateLoadFunctionPrototype (MacroAssembler *masm, Register receiver, Register scratch1, Register scratch2, Label *miss_label)
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)

Static Public Attributes
static const int	kInterceptorArgsNameIndex = 0
static const int	kInterceptorArgsInfoIndex = 1
static const int	kInterceptorArgsThisIndex = 2
static const int	kInterceptorArgsHolderIndex = 3
static const int	kInterceptorArgsLength = 4

Protected Member Functions
virtual Register	FrontendHeader (Register object_reg, Handle< Name > name, Label *miss)
virtual void	FrontendFooter (Handle< Name > name, Label *miss)
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 ()
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

Private Member Functions
Handle< Code >	CompileLoadNonexistent (Handle< Name > name)
void	GenerateLoadConstant (Handle< Object > value)
void	GenerateLoadCallback (Register reg, Handle< ExecutableAccessorInfo > callback)
void	GenerateLoadCallback (const CallOptimization &call_optimization, Handle< Map > receiver_map)
void	GenerateLoadInterceptor (Register holder_reg)
void	GenerateLoadInterceptorWithFollowup (LookupIterator *it, Register holder_reg)
void	GenerateLoadPostInterceptor (LookupIterator *it, Register reg)
Register	scratch4 ()

Static Private Member Functions
static void	GenerateDirectLoadGlobalFunctionPrototype (MacroAssembler *masm, int index, Register prototype, Label *miss)

Additional Inherited Members
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 100 of file handler-compiler.h.

Constructor & Destructor Documentation

NamedLoadHandlerCompiler()

v8::internal::NamedLoadHandlerCompiler::NamedLoadHandlerCompiler ( Isolate *  isolate, Handle< HeapType >  type, Handle< JSObject >  holder, CacheHolderFlag  cache_holder  )

inline

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

      : PropertyHandlerCompiler(isolate, Code::LOAD_IC, type, holder,
                                cache_holder) {}

~NamedLoadHandlerCompiler()

virtual v8::internal::NamedLoadHandlerCompiler::~NamedLoadHandlerCompiler ( )

inlinevirtual

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

{}

Member Function Documentation

CompileLoadCallback() [1/2]

Handle< Code > v8::internal::NamedLoadHandlerCompiler::CompileLoadCallback	(	Handle< Name >	name,
		const CallOptimization &	call_optimization
	)

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

                                                                  {
  DCHECK(call_optimization.is_simple_api_call());
  Frontend(receiver(), name);
  Handle<Map> receiver_map = IC::TypeToMap(*type(), isolate());
  GenerateFastApiCall(masm(), call_optimization, receiver_map, receiver(),
                      scratch1(), false, 0, NULL);
  return GetCode(kind(), Code::FAST, name);
}

References DCHECK, v8::internal::Code::FAST, v8::internal::PropertyHandlerCompiler::Frontend(), v8::internal::PropertyHandlerCompiler::GenerateFastApiCall(), v8::internal::PropertyHandlerCompiler::GetCode(), name, NULL, v8::internal::PropertyHandlerCompiler::type(), and v8::internal::IC::TypeToMap().

Here is the call graph for this function:

CompileLoadCallback() [2/2]

Handle< Code > v8::internal::NamedLoadHandlerCompiler::CompileLoadCallback	(	Handle< Name >	name,
		Handle< ExecutableAccessorInfo >	callback
	)

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

                                                                {
  Register reg = Frontend(receiver(), name);
  GenerateLoadCallback(reg, callback);
  return GetCode(kind(), Code::FAST, name);
}

References v8::internal::Code::FAST, v8::internal::PropertyHandlerCompiler::Frontend(), GenerateLoadCallback(), v8::internal::PropertyHandlerCompiler::GetCode(), and name.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CompileLoadConstant()

Handle< Code > v8::internal::NamedLoadHandlerCompiler::CompileLoadConstant	(	Handle< Name >	name,
		int	constant_index
	)

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

                                                                               {
  Register reg = Frontend(receiver(), name);
  __ Move(receiver(), reg);
  LoadConstantStub stub(isolate(), constant_index);
  GenerateTailCall(masm(), stub.GetCode());
  return GetCode(kind(), Code::FAST, name);
}

References __, v8::internal::Code::FAST, v8::internal::PropertyHandlerCompiler::Frontend(), v8::internal::PropertyHandlerCompiler::GetCode(), and name.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CompileLoadField()

Handle< Code > v8::internal::NamedLoadHandlerCompiler::CompileLoadField	(	Handle< Name >	name,
		FieldIndex	index
	)

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

                                                                          {
  Register reg = Frontend(receiver(), name);
  __ Move(receiver(), reg);
  LoadFieldStub stub(isolate(), field);
  GenerateTailCall(masm(), stub.GetCode());
  return GetCode(kind(), Code::FAST, name);
}

References __, v8::internal::Code::FAST, v8::internal::PropertyHandlerCompiler::Frontend(), v8::internal::PropertyHandlerCompiler::GetCode(), and name.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CompileLoadGlobal()

Handle<Code> v8::internal::NamedLoadHandlerCompiler::CompileLoadGlobal	(	Handle< PropertyCell >	cell,
		Handle< Name >	name,
		bool	is_configurable
	)

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

Here is the caller graph for this function:

CompileLoadInterceptor()

Handle< Code > v8::internal::NamedLoadHandlerCompiler::CompileLoadInterceptor

(

LookupIterator *

it

)

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

                        {
  // So far the most popular follow ups for interceptor loads are FIELD and
  // ExecutableAccessorInfo, so inline only them. Other cases may be added
  // later.
  bool inline_followup = false;
  switch (it->state()) {
    case LookupIterator::TRANSITION:
      UNREACHABLE();
    case LookupIterator::ACCESS_CHECK:
    case LookupIterator::INTERCEPTOR:
    case LookupIterator::JSPROXY:
    case LookupIterator::NOT_FOUND:
      break;
    case LookupIterator::DATA:
      inline_followup = it->property_details().type() == FIELD;
      break;
    case LookupIterator::ACCESSOR: {
      Handle<Object> accessors = it->GetAccessors();
      inline_followup = accessors->IsExecutableAccessorInfo();
      if (!inline_followup) break;
      Handle<ExecutableAccessorInfo> info =
          Handle<ExecutableAccessorInfo>::cast(accessors);
      inline_followup = info->getter() != NULL &&
                        ExecutableAccessorInfo::IsCompatibleReceiverType(
                            isolate(), info, type());
    }
  }
 
  Register reg = Frontend(receiver(), it->name());
  if (inline_followup) {
    // TODO(368): Compile in the whole chain: all the interceptors in
    // prototypes and ultimate answer.
    GenerateLoadInterceptorWithFollowup(it, reg);
  } else {
    GenerateLoadInterceptor(reg);
  }
  return GetCode(kind(), Code::FAST, it->name());
}

References v8::internal::ACCESSOR, v8::internal::Handle< T >::cast(), v8::internal::Code::FAST, v8::internal::FIELD, v8::internal::PropertyHandlerCompiler::Frontend(), GenerateLoadInterceptor(), GenerateLoadInterceptorWithFollowup(), v8::internal::PropertyHandlerCompiler::GetCode(), v8::internal::AccessorInfo::IsCompatibleReceiverType(), NULL, v8::internal::PropertyHandlerCompiler::type(), and UNREACHABLE.

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

Here is the call graph for this function:

Here is the caller graph for this function:

CompileLoadNonexistent()

Handle< Code > v8::internal::NamedLoadHandlerCompiler::CompileLoadNonexistent ( Handle< Name >  name )

private

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

                       {
  Label miss;
  NonexistentFrontendHeader(name, &miss, scratch2(), scratch3());
  GenerateLoadConstant(isolate()->factory()->undefined_value());
  FrontendFooter(name, &miss);
  return GetCode(kind(), Code::FAST, name);
}

References v8::internal::Code::FAST, FrontendFooter(), GenerateLoadConstant(), v8::internal::PropertyHandlerCompiler::GetCode(), name, and v8::internal::PropertyHandlerCompiler::NonexistentFrontendHeader().

Referenced by ComputeLoadNonexistent().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileLoadViaGetter()

Handle< Code > v8::internal::NamedLoadHandlerCompiler::CompileLoadViaGetter	(	Handle< Name >	name,
		Handle< JSFunction >	getter
	)

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

                                                  {
  Frontend(receiver(), name);
  GenerateLoadViaGetter(masm(), type(), receiver(), getter);
  return GetCode(kind(), Code::FAST, name);
}

References v8::internal::Code::FAST, v8::internal::PropertyHandlerCompiler::Frontend(), GenerateLoadViaGetter(), v8::internal::PropertyHandlerCompiler::GetCode(), name, and v8::internal::PropertyHandlerCompiler::type().

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

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeLoadNonexistent()

Handle< Code > v8::internal::NamedLoadHandlerCompiler::ComputeLoadNonexistent ( Handle< Name >  name, Handle< HeapType >  type  )

static

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

                                              {
  Isolate* isolate = name->GetIsolate();
  Handle<Map> receiver_map = IC::TypeToMap(*type, isolate);
  if (receiver_map->prototype()->IsNull()) {
    // TODO(jkummerow/verwaest): If there is no prototype and the property
    // is nonexistent, introduce a builtin to handle this (fast properties
    // -> return undefined, dictionary properties -> do negative lookup).
    return Handle<Code>();
  }
  CacheHolderFlag flag;
  Handle<Map> stub_holder_map =
      IC::GetHandlerCacheHolder(*type, false, isolate, &flag);
 
  // If no dictionary mode objects are present in the prototype chain, the load
  // nonexistent IC stub can be shared for all names for a given map and we use
  // the empty string for the map cache in that case. If there are dictionary
  // mode objects involved, we need to do negative lookups in the stub and
  // therefore the stub will be specific to the name.
  Handle<Name> cache_name =
      receiver_map->is_dictionary_map()
          ? name
          : Handle<Name>::cast(isolate->factory()->nonexistent_symbol());
  Handle<Map> current_map = stub_holder_map;
  Handle<JSObject> last(JSObject::cast(receiver_map->prototype()));
  while (true) {
    if (current_map->is_dictionary_map()) cache_name = name;
    if (current_map->prototype()->IsNull()) break;
    last = handle(JSObject::cast(current_map->prototype()));
    current_map = handle(last->map());
  }
  // Compile the stub that is either shared for all names or
  // name specific if there are global objects involved.
  Handle<Code> handler = PropertyHandlerCompiler::Find(
      cache_name, stub_holder_map, Code::LOAD_IC, flag, Code::FAST);
  if (!handler.is_null()) return handler;
 
  NamedLoadHandlerCompiler compiler(isolate, type, last, flag);
  handler = compiler.CompileLoadNonexistent(cache_name);
  Map::UpdateCodeCache(stub_holder_map, cache_name, handler);
  return handler;
}

References v8::internal::Handle< T >::cast(), CompileLoadNonexistent(), v8::internal::Isolate::factory(), v8::internal::Code::FAST, v8::internal::PropertyHandlerCompiler::Find(), v8::internal::flag, v8::internal::IC::GetHandlerCacheHolder(), v8::internal::handle(), v8::internal::Handle< T >::is_null(), name, v8::internal::PropertyHandlerCompiler::type(), v8::internal::IC::TypeToMap(), and v8::internal::Map::UpdateCodeCache().

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

Here is the call graph for this function:

Here is the caller graph for this function:

FrontendFooter()

virtual void v8::internal::NamedLoadHandlerCompiler::FrontendFooter ( Handle< Name >  name, Label *  miss  )

protectedvirtual

Reimplemented from v8::internal::PropertyHandlerCompiler.

Referenced by CompileLoadNonexistent().

Here is the caller graph for this function:

FrontendHeader()

Register v8::internal::NamedLoadHandlerCompiler::FrontendHeader ( Register  object_reg, Handle< Name >  name, Label *  miss  )

protectedvirtual

Reimplemented from v8::internal::PropertyHandlerCompiler.

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

                                                               {
  PrototypeCheckType check_type = CHECK_ALL_MAPS;
  int function_index = -1;
  if (type()->Is(HeapType::String())) {
    function_index = Context::STRING_FUNCTION_INDEX;
  } else if (type()->Is(HeapType::Symbol())) {
    function_index = Context::SYMBOL_FUNCTION_INDEX;
  } else if (type()->Is(HeapType::Number())) {
    function_index = Context::NUMBER_FUNCTION_INDEX;
  } else if (type()->Is(HeapType::Boolean())) {
    function_index = Context::BOOLEAN_FUNCTION_INDEX;
  } else {
    check_type = SKIP_RECEIVER;
  }
 
  if (check_type == CHECK_ALL_MAPS) {
    GenerateDirectLoadGlobalFunctionPrototype(masm(), function_index,
                                              scratch1(), miss);
    Object* function = isolate()->native_context()->get(function_index);
    Object* prototype = JSFunction::cast(function)->instance_prototype();
    set_type_for_object(handle(prototype, isolate()));
    object_reg = scratch1();
  }
 
  // Check that the maps starting from the prototype haven't changed.
  return CheckPrototypes(object_reg, scratch1(), scratch2(), scratch3(), name,
                         miss, check_type);
}

References v8::internal::Context::BOOLEAN_FUNCTION_INDEX, v8::internal::CHECK_ALL_MAPS, v8::internal::PropertyHandlerCompiler::CheckPrototypes(), GenerateDirectLoadGlobalFunctionPrototype(), v8::internal::handle(), v8::internal::Is(), name, v8::internal::Context::NUMBER_FUNCTION_INDEX, v8::internal::PropertyHandlerCompiler::set_type_for_object(), v8::internal::SKIP_RECEIVER, v8::internal::Context::STRING_FUNCTION_INDEX, v8::internal::Context::SYMBOL_FUNCTION_INDEX, and v8::internal::PropertyHandlerCompiler::type().

Here is the call graph for this function:

GenerateDirectLoadGlobalFunctionPrototype()

static void v8::internal::NamedLoadHandlerCompiler::GenerateDirectLoadGlobalFunctionPrototype ( MacroAssembler *  masm, int  index, Register  prototype, Label *  miss  )

staticprivate

Referenced by FrontendHeader().

Here is the caller graph for this function:

GenerateLoadCallback() [1/2]

void v8::internal::NamedLoadHandlerCompiler::GenerateLoadCallback ( const CallOptimization &  call_optimization, Handle< Map >  receiver_map  )

private

GenerateLoadCallback() [2/2]

void v8::internal::NamedLoadHandlerCompiler::GenerateLoadCallback ( Register  reg, Handle< ExecutableAccessorInfo >  callback  )

private

Referenced by CompileLoadCallback(), and GenerateLoadPostInterceptor().

Here is the caller graph for this function:

GenerateLoadConstant()

void v8::internal::NamedLoadHandlerCompiler::GenerateLoadConstant ( Handle< Object >  value )

private

Referenced by CompileLoadNonexistent().

Here is the caller graph for this function:

GenerateLoadFunctionPrototype()

static void v8::internal::NamedLoadHandlerCompiler::GenerateLoadFunctionPrototype ( MacroAssembler *  masm, Register  receiver, Register  scratch1, Register  scratch2, Label *  miss_label  )

static

GenerateLoadInterceptor()

void v8::internal::NamedLoadHandlerCompiler::GenerateLoadInterceptor ( Register  holder_reg )

private

Referenced by CompileLoadInterceptor().

Here is the caller graph for this function:

GenerateLoadInterceptorWithFollowup()

void v8::internal::NamedLoadHandlerCompiler::GenerateLoadInterceptorWithFollowup ( LookupIterator *  it, Register  holder_reg  )

private

Referenced by CompileLoadInterceptor().

Here is the caller graph for this function:

GenerateLoadPostInterceptor()

void v8::internal::NamedLoadHandlerCompiler::GenerateLoadPostInterceptor ( LookupIterator *  it, Register  reg  )

private

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

                                                  {
  Handle<JSObject> real_named_property_holder(it->GetHolder<JSObject>());
 
  set_type_for_object(holder());
  set_holder(real_named_property_holder);
  Register reg = Frontend(interceptor_reg, it->name());
 
  switch (it->state()) {
    case LookupIterator::ACCESS_CHECK:
    case LookupIterator::INTERCEPTOR:
    case LookupIterator::JSPROXY:
    case LookupIterator::NOT_FOUND:
    case LookupIterator::TRANSITION:
      UNREACHABLE();
    case LookupIterator::DATA: {
      DCHECK_EQ(FIELD, it->property_details().type());
      __ Move(receiver(), reg);
      LoadFieldStub stub(isolate(), it->GetFieldIndex());
      GenerateTailCall(masm(), stub.GetCode());
      break;
    }
    case LookupIterator::ACCESSOR:
      Handle<ExecutableAccessorInfo> info =
          Handle<ExecutableAccessorInfo>::cast(it->GetAccessors());
      DCHECK_NE(NULL, info->getter());
      GenerateLoadCallback(reg, info);
  }
}

References __, v8::internal::ACCESSOR, v8::internal::Handle< T >::cast(), DCHECK_EQ, DCHECK_NE, v8::internal::FIELD, v8::internal::PropertyHandlerCompiler::Frontend(), GenerateLoadCallback(), v8::internal::PropertyHandlerCompiler::holder(), NULL, v8::internal::PropertyHandlerCompiler::set_holder(), v8::internal::PropertyHandlerCompiler::set_type_for_object(), and UNREACHABLE.

Here is the call graph for this function:

GenerateLoadViaGetter()

static void v8::internal::NamedLoadHandlerCompiler::GenerateLoadViaGetter ( MacroAssembler *  masm, Handle< HeapType >  type, Register  receiver, Handle< JSFunction >  getter  )

static

Referenced by CompileLoadViaGetter(), and GenerateLoadViaGetterForDeopt().

Here is the caller graph for this function:

GenerateLoadViaGetterForDeopt()

static void v8::internal::NamedLoadHandlerCompiler::GenerateLoadViaGetterForDeopt ( MacroAssembler *  masm )

inlinestatic

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

                                                                  {
    GenerateLoadViaGetter(masm, Handle<HeapType>::null(), no_reg,
                          Handle<JSFunction>());
  }

References GenerateLoadViaGetter(), and v8::internal::no_reg.

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

Here is the call graph for this function:

Here is the caller graph for this function:

scratch4()

Register v8::internal::NamedLoadHandlerCompiler::scratch4 ( )

inlineprivate

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

{ return registers_[5]; }

Member Data Documentation

kInterceptorArgsHolderIndex

const int v8::internal::NamedLoadHandlerCompiler::kInterceptorArgsHolderIndex = 3

static

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

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

kInterceptorArgsInfoIndex

const int v8::internal::NamedLoadHandlerCompiler::kInterceptorArgsInfoIndex = 1

static

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

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

kInterceptorArgsLength

const int v8::internal::NamedLoadHandlerCompiler::kInterceptorArgsLength = 4

static

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

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

kInterceptorArgsNameIndex

const int v8::internal::NamedLoadHandlerCompiler::kInterceptorArgsNameIndex = 0

static

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

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

kInterceptorArgsThisIndex

const int v8::internal::NamedLoadHandlerCompiler::kInterceptorArgsThisIndex = 2

static

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

Referenced by v8::internal::RUNTIME_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