v8::internal::PropertyICCompiler Class Reference

#include <ic-compiler.h>

Inheritance diagram for v8::internal::PropertyICCompiler:

Collaboration diagram for v8::internal::PropertyICCompiler:

Static Public Member Functions
static Code *	FindPreMonomorphic (Isolate *isolate, Code::Kind kind, ExtraICState extra_ic_state)
static Handle< Code >	ComputeLoad (Isolate *isolate, InlineCacheState ic_state, ExtraICState extra_state)
static Handle< Code >	ComputeStore (Isolate *isolate, InlineCacheState ic_state, ExtraICState extra_state)
static Handle< Code >	ComputeMonomorphic (Code::Kind kind, Handle< Name > name, Handle< HeapType > type, Handle< Code > handler, ExtraICState extra_ic_state)
static Handle< Code >	ComputePolymorphic (Code::Kind kind, TypeHandleList *types, CodeHandleList *handlers, int number_of_valid_maps, Handle< Name > name, ExtraICState extra_ic_state)
static Handle< Code >	ComputeKeyedLoadMonomorphic (Handle< Map > receiver_map)
static Handle< Code >	ComputeKeyedStoreMonomorphic (Handle< Map > receiver_map, StrictMode strict_mode, KeyedAccessStoreMode store_mode)
static Handle< Code >	ComputeKeyedLoadPolymorphic (MapHandleList *receiver_maps)
static Handle< Code >	ComputeKeyedStorePolymorphic (MapHandleList *receiver_maps, KeyedAccessStoreMode store_mode, StrictMode strict_mode)
static Handle< Code >	ComputeCompareNil (Handle< Map > receiver_map, CompareNilICStub *stub)
static void	GenerateRuntimeSetProperty (MacroAssembler *masm, StrictMode strict_mode)

Private Member Functions
	PropertyICCompiler (Isolate *isolate, Code::Kind kind, ExtraICState extra_ic_state=kNoExtraICState, CacheHolderFlag cache_holder=kCacheOnReceiver)
Handle< Code >	CompileLoadInitialize (Code::Flags flags)
Handle< Code >	CompileLoadPreMonomorphic (Code::Flags flags)
Handle< Code >	CompileStoreInitialize (Code::Flags flags)
Handle< Code >	CompileStorePreMonomorphic (Code::Flags flags)
Handle< Code >	CompileStoreGeneric (Code::Flags flags)
Handle< Code >	CompileStoreMegamorphic (Code::Flags flags)
Handle< Code >	CompileMonomorphic (Handle< HeapType > type, Handle< Code > handler, Handle< Name > name, IcCheckType check)
Handle< Code >	CompilePolymorphic (TypeHandleList *types, CodeHandleList *handlers, Handle< Name > name, Code::StubType type, IcCheckType check)
Handle< Code >	CompileKeyedStoreMonomorphic (Handle< Map > receiver_map, KeyedAccessStoreMode store_mode)
Handle< Code >	CompileKeyedStorePolymorphic (MapHandleList *receiver_maps, KeyedAccessStoreMode store_mode)
Handle< Code >	CompileKeyedStorePolymorphic (MapHandleList *receiver_maps, CodeHandleList *handler_stubs, MapHandleList *transitioned_maps)
bool	IncludesNumberType (TypeHandleList *types)
Handle< Code >	GetCode (Code::Kind kind, Code::StubType type, Handle< Name > name, InlineCacheState state=MONOMORPHIC)
Logger::LogEventsAndTags	log_kind (Handle< Code > code)

Static Private Member Functions
static Handle< Code >	Find (Handle< Name > name, Handle< Map > stub_holder_map, Code::Kind kind, ExtraICState extra_ic_state=kNoExtraICState, CacheHolderFlag cache_holder=kCacheOnReceiver)

Private Attributes
const ExtraICState	extra_ic_state_

Detailed Description

Definition at line 17 of file ic-compiler.h.

Constructor & Destructor Documentation

PropertyICCompiler()

v8::internal::PropertyICCompiler::PropertyICCompiler ( Isolate *  isolate, Code::Kind  kind, ExtraICState  extra_ic_state = kNoExtraICState, CacheHolderFlag  cache_holder = kCacheOnReceiver  )

inlineprivate

Definition at line 62 of file ic-compiler.h.

      : PropertyAccessCompiler(isolate, kind, cache_holder),
        extra_ic_state_(extra_ic_state) {}

Member Function Documentation

CompileKeyedStoreMonomorphic()

Handle< Code > v8::internal::PropertyICCompiler::CompileKeyedStoreMonomorphic ( Handle< Map >  receiver_map, KeyedAccessStoreMode  store_mode  )

private

Definition at line 423 of file ic-compiler.cc.

                                                               {
  ElementsKind elements_kind = receiver_map->elements_kind();
  bool is_jsarray = receiver_map->instance_type() == JS_ARRAY_TYPE;
  Handle<Code> stub;
  if (receiver_map->has_fast_elements() ||
      receiver_map->has_external_array_elements() ||
      receiver_map->has_fixed_typed_array_elements()) {
    stub = StoreFastElementStub(isolate(), is_jsarray, elements_kind,
                                store_mode).GetCode();
  } else {
    stub = StoreElementStub(isolate(), elements_kind).GetCode();
  }
 
  __ DispatchMap(receiver(), scratch1(), receiver_map, stub, DO_SMI_CHECK);
 
  TailCallBuiltin(masm(), Builtins::kKeyedStoreIC_Miss);
 
  return GetCode(kind(), Code::NORMAL, factory()->empty_string());
}

References __, v8::internal::DO_SMI_CHECK, GetCode(), v8::internal::JS_ARRAY_TYPE, and v8::internal::Code::NORMAL.

Referenced by ComputeKeyedStoreMonomorphic().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileKeyedStorePolymorphic() [1/2]

Handle<Code> v8::internal::PropertyICCompiler::CompileKeyedStorePolymorphic ( MapHandleList *  receiver_maps, CodeHandleList *  handler_stubs, MapHandleList *  transitioned_maps  )

private

CompileKeyedStorePolymorphic() [2/2]

Handle< Code > v8::internal::PropertyICCompiler::CompileKeyedStorePolymorphic ( MapHandleList *  receiver_maps, KeyedAccessStoreMode  store_mode  )

private

Definition at line 372 of file ic-compiler.cc.

                                                                   {
  // Collect MONOMORPHIC stubs for all |receiver_maps|.
  CodeHandleList handlers(receiver_maps->length());
  MapHandleList transitioned_maps(receiver_maps->length());
  for (int i = 0; i < receiver_maps->length(); ++i) {
    Handle<Map> receiver_map(receiver_maps->at(i));
    Handle<Code> cached_stub;
    Handle<Map> transitioned_map =
        receiver_map->FindTransitionedMap(receiver_maps);
 
    // TODO(mvstanton): The code below is doing pessimistic elements
    // transitions. I would like to stop doing that and rely on Allocation Site
    // Tracking to do a better job of ensuring the data types are what they need
    // to be. Not all the elements are in place yet, pessimistic elements
    // transitions are still important for performance.
    bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
    ElementsKind elements_kind = receiver_map->elements_kind();
    if (!transitioned_map.is_null()) {
      cached_stub =
          ElementsTransitionAndStoreStub(isolate(), elements_kind,
                                         transitioned_map->elements_kind(),
                                         is_js_array, store_mode).GetCode();
    } else if (receiver_map->instance_type() < FIRST_JS_RECEIVER_TYPE) {
      cached_stub = isolate()->builtins()->KeyedStoreIC_Slow();
    } else {
      if (receiver_map->has_fast_elements() ||
          receiver_map->has_external_array_elements() ||
          receiver_map->has_fixed_typed_array_elements()) {
        cached_stub = StoreFastElementStub(isolate(), is_js_array,
                                           elements_kind, store_mode).GetCode();
      } else {
        cached_stub = StoreElementStub(isolate(), elements_kind).GetCode();
      }
    }
    DCHECK(!cached_stub.is_null());
    handlers.Add(cached_stub);
    transitioned_maps.Add(transitioned_map);
  }
 
  Handle<Code> code = CompileKeyedStorePolymorphic(receiver_maps, &handlers,
                                                   &transitioned_maps);
  isolate()->counters()->keyed_store_polymorphic_stubs()->Increment();
  PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, 0));
  return code;
}

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::List< T, AllocationPolicy >::at(), DCHECK, v8::internal::FIRST_JS_RECEIVER_TYPE, v8::internal::Handle< T >::is_null(), v8::internal::JS_ARRAY_TYPE, log_kind(), and PROFILE.

Referenced by ComputeKeyedStorePolymorphic().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileLoadInitialize()

Handle< Code > v8::internal::PropertyICCompiler::CompileLoadInitialize ( Code::Flags  flags )

private

Definition at line 308 of file ic-compiler.cc.

                                                                      {
  LoadIC::GenerateInitialize(masm());
  Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadInitialize");
  PROFILE(isolate(), CodeCreateEvent(Logger::LOAD_INITIALIZE_TAG, *code, 0));
  return code;
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::LoadIC::GenerateInitialize(), and PROFILE.

Referenced by ComputeLoad().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileLoadPreMonomorphic()

Handle< Code > v8::internal::PropertyICCompiler::CompileLoadPreMonomorphic ( Code::Flags  flags )

private

Definition at line 316 of file ic-compiler.cc.

                                                                          {
  LoadIC::GeneratePreMonomorphic(masm());
  Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadPreMonomorphic");
  PROFILE(isolate(),
          CodeCreateEvent(Logger::LOAD_PREMONOMORPHIC_TAG, *code, 0));
  return code;
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::LoadIC::GeneratePreMonomorphic(), and PROFILE.

Referenced by ComputeLoad().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileMonomorphic()

Handle< Code > v8::internal::PropertyICCompiler::CompileMonomorphic ( Handle< HeapType >  type, Handle< Code >  handler, Handle< Name >  name, IcCheckType  check  )

private

Definition at line 36 of file ic-compiler.cc.

                                                                       {
  TypeHandleList types(1);
  CodeHandleList handlers(1);
  types.Add(type);
  handlers.Add(handler);
  Code::StubType stub_type = handler->type();
  return CompilePolymorphic(&types, &handlers, name, stub_type, check);
}

References v8::internal::List< T, AllocationPolicy >::Add(), CompilePolymorphic(), and name.

Referenced by ComputeKeyedLoadMonomorphic(), and ComputeMonomorphic().

Here is the call graph for this function:

Here is the caller graph for this function:

CompilePolymorphic()

Handle<Code> v8::internal::PropertyICCompiler::CompilePolymorphic ( TypeHandleList *  types, CodeHandleList *  handlers, Handle< Name >  name, Code::StubType  type, IcCheckType  check  )

private

Referenced by CompileMonomorphic(), ComputeKeyedLoadPolymorphic(), and ComputePolymorphic().

Here is the caller graph for this function:

CompileStoreGeneric()

Handle< Code > v8::internal::PropertyICCompiler::CompileStoreGeneric ( Code::Flags  flags )

private

Definition at line 342 of file ic-compiler.cc.

                                                                    {
  ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
  StrictMode strict_mode = StoreIC::GetStrictMode(extra_state);
  GenerateRuntimeSetProperty(masm(), strict_mode);
  Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreGeneric");
  PROFILE(isolate(), CodeCreateEvent(Logger::STORE_GENERIC_TAG, *code, 0));
  return code;
}

References v8::internal::Code::ExtractExtraICStateFromFlags(), v8::internal::anonymous_namespace{flags.cc}::flags, GenerateRuntimeSetProperty(), v8::internal::StoreIC::GetStrictMode(), and PROFILE.

Referenced by ComputeStore().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileStoreInitialize()

Handle< Code > v8::internal::PropertyICCompiler::CompileStoreInitialize ( Code::Flags  flags )

private

Definition at line 325 of file ic-compiler.cc.

                                                                       {
  StoreIC::GenerateInitialize(masm());
  Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreInitialize");
  PROFILE(isolate(), CodeCreateEvent(Logger::STORE_INITIALIZE_TAG, *code, 0));
  return code;
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::StoreIC::GenerateInitialize(), and PROFILE.

Referenced by ComputeStore().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileStoreMegamorphic()

Handle< Code > v8::internal::PropertyICCompiler::CompileStoreMegamorphic ( Code::Flags  flags )

private

Definition at line 352 of file ic-compiler.cc.

                                                                        {
  StoreIC::GenerateMegamorphic(masm());
  Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreMegamorphic");
  PROFILE(isolate(), CodeCreateEvent(Logger::STORE_MEGAMORPHIC_TAG, *code, 0));
  return code;
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::StoreIC::GenerateMegamorphic(), and PROFILE.

Referenced by ComputeStore().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileStorePreMonomorphic()

Handle< Code > v8::internal::PropertyICCompiler::CompileStorePreMonomorphic ( Code::Flags  flags )

private

Definition at line 333 of file ic-compiler.cc.

                                                                           {
  StoreIC::GeneratePreMonomorphic(masm());
  Handle<Code> code = GetCodeWithFlags(flags, "CompileStorePreMonomorphic");
  PROFILE(isolate(),
          CodeCreateEvent(Logger::STORE_PREMONOMORPHIC_TAG, *code, 0));
  return code;
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::StoreIC::GeneratePreMonomorphic(), and PROFILE.

Referenced by ComputeStore().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCompareNil()

Handle< Code > v8::internal::PropertyICCompiler::ComputeCompareNil ( Handle< Map >  receiver_map, CompareNilICStub *  stub  )

static

Definition at line 221 of file ic-compiler.cc.

                                                                           {
  Isolate* isolate = receiver_map->GetIsolate();
  Handle<String> name(isolate->heap()->empty_string());
  if (!receiver_map->is_dictionary_map()) {
    Handle<Code> cached_ic =
        Find(name, receiver_map, Code::COMPARE_NIL_IC, stub->GetExtraICState());
    if (!cached_ic.is_null()) return cached_ic;
  }
 
  Code::FindAndReplacePattern pattern;
  pattern.Add(isolate->factory()->meta_map(), receiver_map);
  Handle<Code> ic = stub->GetCodeCopy(pattern);
 
  if (!receiver_map->is_dictionary_map()) {
    Map::UpdateCodeCache(receiver_map, name, ic);
  }
 
  return ic;
}

References v8::internal::Code::FindAndReplacePattern::Add(), v8::internal::Isolate::factory(), Find(), v8::internal::CompareNilICStub::GetExtraICState(), v8::internal::Isolate::heap(), v8::internal::Handle< T >::is_null(), name, and v8::internal::Map::UpdateCodeCache().

Referenced by v8::internal::CompareNilIC::CompareNil().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeKeyedLoadMonomorphic()

Handle< Code > v8::internal::PropertyICCompiler::ComputeKeyedLoadMonomorphic ( Handle< Map >  receiver_map )

static

Definition at line 86 of file ic-compiler.cc.

                              {
  Isolate* isolate = receiver_map->GetIsolate();
  Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
  Handle<Name> name = isolate->factory()->KeyedLoadMonomorphic_string();
 
  Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate);
  if (probe->IsCode()) return Handle<Code>::cast(probe);
 
  ElementsKind elements_kind = receiver_map->elements_kind();
  Handle<Code> stub;
  if (receiver_map->has_indexed_interceptor()) {
    stub = LoadIndexedInterceptorStub(isolate).GetCode();
  } else if (receiver_map->has_sloppy_arguments_elements()) {
    stub = KeyedLoadSloppyArgumentsStub(isolate).GetCode();
  } else if (receiver_map->has_fast_elements() ||
             receiver_map->has_external_array_elements() ||
             receiver_map->has_fixed_typed_array_elements()) {
    stub = LoadFastElementStub(isolate,
                               receiver_map->instance_type() == JS_ARRAY_TYPE,
                               elements_kind).GetCode();
  } else {
    stub = LoadDictionaryElementStub(isolate).GetCode();
  }
  PropertyICCompiler compiler(isolate, Code::KEYED_LOAD_IC);
  Handle<Code> code =
      compiler.CompileMonomorphic(HeapType::Class(receiver_map, isolate), stub,
                                  isolate->factory()->empty_string(), ELEMENT);
 
  Map::UpdateCodeCache(receiver_map, name, code);
  return code;
}

References v8::internal::Handle< T >::cast(), v8::internal::TypeImpl< Config >::Class(), CompileMonomorphic(), v8::internal::Code::ComputeMonomorphicFlags(), v8::internal::ELEMENT, v8::internal::Isolate::factory(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::JS_ARRAY_TYPE, name, and v8::internal::Map::UpdateCodeCache().

Referenced by v8::internal::KeyedLoadIC::LoadElementStub().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeKeyedLoadPolymorphic()

Handle< Code > v8::internal::PropertyICCompiler::ComputeKeyedLoadPolymorphic ( MapHandleList *  receiver_maps )

static

Definition at line 244 of file ic-compiler.cc.

                                  {
  Isolate* isolate = receiver_maps->at(0)->GetIsolate();
  Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);
  Handle<PolymorphicCodeCache> cache =
      isolate->factory()->polymorphic_code_cache();
  Handle<Object> probe = cache->Lookup(receiver_maps, flags);
  if (probe->IsCode()) return Handle<Code>::cast(probe);
 
  TypeHandleList types(receiver_maps->length());
  for (int i = 0; i < receiver_maps->length(); i++) {
    types.Add(HeapType::Class(receiver_maps->at(i), isolate));
  }
  CodeHandleList handlers(receiver_maps->length());
  ElementHandlerCompiler compiler(isolate);
  compiler.CompileElementHandlers(receiver_maps, &handlers);
  PropertyICCompiler ic_compiler(isolate, Code::KEYED_LOAD_IC);
  Handle<Code> code = ic_compiler.CompilePolymorphic(
      &types, &handlers, isolate->factory()->empty_string(), Code::NORMAL,
      ELEMENT);
 
  isolate->counters()->keyed_load_polymorphic_stubs()->Increment();
 
  PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
  return code;
}

References v8::internal::List< T, AllocationPolicy >::Add(), v8::internal::List< T, AllocationPolicy >::at(), v8::internal::Handle< T >::cast(), v8::internal::TypeImpl< Config >::Class(), v8::internal::ElementHandlerCompiler::CompileElementHandlers(), CompilePolymorphic(), v8::internal::Code::ComputeFlags(), v8::internal::Isolate::counters(), v8::internal::ELEMENT, v8::internal::Isolate::factory(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::Code::NORMAL, v8::internal::POLYMORPHIC, and v8::internal::PolymorphicCodeCache::Update().

Referenced by v8::internal::KeyedLoadIC::LoadElementStub().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeKeyedStoreMonomorphic()

Handle< Code > v8::internal::PropertyICCompiler::ComputeKeyedStoreMonomorphic ( Handle< Map >  receiver_map, StrictMode  strict_mode, KeyedAccessStoreMode  store_mode  )

static

Definition at line 120 of file ic-compiler.cc.

                                     {
  Isolate* isolate = receiver_map->GetIsolate();
  ExtraICState extra_state =
      KeyedStoreIC::ComputeExtraICState(strict_mode, store_mode);
  Code::Flags flags =
      Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, extra_state);
 
  DCHECK(store_mode == STANDARD_STORE ||
         store_mode == STORE_AND_GROW_NO_TRANSITION ||
         store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS ||
         store_mode == STORE_NO_TRANSITION_HANDLE_COW);
 
  Handle<String> name = isolate->factory()->KeyedStoreMonomorphic_string();
  Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate);
  if (probe->IsCode()) return Handle<Code>::cast(probe);
 
  PropertyICCompiler compiler(isolate, Code::KEYED_STORE_IC, extra_state);
  Handle<Code> code =
      compiler.CompileKeyedStoreMonomorphic(receiver_map, store_mode);
 
  Map::UpdateCodeCache(receiver_map, name, code);
  DCHECK(KeyedStoreIC::GetKeyedAccessStoreMode(code->extra_ic_state()) ==
         store_mode);
  return code;
}

References v8::internal::Handle< T >::cast(), CompileKeyedStoreMonomorphic(), v8::internal::KeyedStoreIC::ComputeExtraICState(), v8::internal::Code::ComputeMonomorphicFlags(), DCHECK, v8::internal::Isolate::factory(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::KeyedStoreIC::GetKeyedAccessStoreMode(), name, v8::internal::STANDARD_STORE, v8::internal::STORE_AND_GROW_NO_TRANSITION, v8::internal::STORE_NO_TRANSITION_HANDLE_COW, v8::internal::STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS, and v8::internal::Map::UpdateCodeCache().

Referenced by v8::internal::KeyedStoreIC::StoreElementStub().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeKeyedStorePolymorphic()

Handle< Code > v8::internal::PropertyICCompiler::ComputeKeyedStorePolymorphic ( MapHandleList *  receiver_maps, KeyedAccessStoreMode  store_mode, StrictMode  strict_mode  )

static

Definition at line 283 of file ic-compiler.cc.

                            {
  Isolate* isolate = receiver_maps->at(0)->GetIsolate();
  DCHECK(store_mode == STANDARD_STORE ||
         store_mode == STORE_AND_GROW_NO_TRANSITION ||
         store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS ||
         store_mode == STORE_NO_TRANSITION_HANDLE_COW);
  Handle<PolymorphicCodeCache> cache =
      isolate->factory()->polymorphic_code_cache();
  ExtraICState extra_state =
      KeyedStoreIC::ComputeExtraICState(strict_mode, store_mode);
  Code::Flags flags =
      Code::ComputeFlags(Code::KEYED_STORE_IC, POLYMORPHIC, extra_state);
  Handle<Object> probe = cache->Lookup(receiver_maps, flags);
  if (probe->IsCode()) return Handle<Code>::cast(probe);
 
  PropertyICCompiler compiler(isolate, Code::KEYED_STORE_IC, extra_state);
  Handle<Code> code =
      compiler.CompileKeyedStorePolymorphic(receiver_maps, store_mode);
  PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
  return code;
}

References v8::internal::List< T, AllocationPolicy >::at(), v8::internal::Handle< T >::cast(), CompileKeyedStorePolymorphic(), v8::internal::KeyedStoreIC::ComputeExtraICState(), v8::internal::Code::ComputeFlags(), DCHECK, v8::internal::Isolate::factory(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::POLYMORPHIC, v8::internal::STANDARD_STORE, v8::internal::STORE_AND_GROW_NO_TRANSITION, v8::internal::STORE_NO_TRANSITION_HANDLE_COW, v8::internal::STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS, and v8::internal::PolymorphicCodeCache::Update().

Referenced by v8::internal::KeyedStoreIC::StoreElementStub().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeLoad()

Handle< Code > v8::internal::PropertyICCompiler::ComputeLoad ( Isolate *  isolate, InlineCacheState  ic_state, ExtraICState  extra_state  )

static

Definition at line 170 of file ic-compiler.cc.

                                                                       {
  Code::Flags flags = Code::ComputeFlags(Code::LOAD_IC, ic_state, extra_state);
  Handle<UnseededNumberDictionary> cache =
      isolate->factory()->non_monomorphic_cache();
  int entry = cache->FindEntry(isolate, flags);
  if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
 
  PropertyICCompiler compiler(isolate, Code::LOAD_IC);
  Handle<Code> code;
  if (ic_state == UNINITIALIZED) {
    code = compiler.CompileLoadInitialize(flags);
  } else if (ic_state == PREMONOMORPHIC) {
    code = compiler.CompileLoadPreMonomorphic(flags);
  } else {
    UNREACHABLE();
  }
  FillCache(isolate, code);
  return code;
}

References CompileLoadInitialize(), CompileLoadPreMonomorphic(), v8::internal::Code::ComputeFlags(), v8::internal::Isolate::factory(), v8::internal::FillCache(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::PREMONOMORPHIC, v8::internal::UNINITIALIZED, and UNREACHABLE.

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

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeMonomorphic()

Handle< Code > v8::internal::PropertyICCompiler::ComputeMonomorphic ( Code::Kind  kind, Handle< Name >  name, Handle< HeapType >  type, Handle< Code >  handler, ExtraICState  extra_ic_state  )

static

Definition at line 49 of file ic-compiler.cc.

                                                       {
  Isolate* isolate = name->GetIsolate();
  if (handler.is_identical_to(isolate->builtins()->LoadIC_Normal()) ||
      handler.is_identical_to(isolate->builtins()->StoreIC_Normal())) {
    name = isolate->factory()->normal_ic_symbol();
  }
 
  CacheHolderFlag flag;
  Handle<Map> stub_holder = IC::GetICCacheHolder(*type, isolate, &flag);
 
  Handle<Code> ic;
  // There are multiple string maps that all use the same prototype. That
  // prototype cannot hold multiple handlers, one for each of the string maps,
  // for a single name. Hence, turn off caching of the IC.
  bool can_be_cached = !type->Is(HeapType::String());
  if (can_be_cached) {
    ic = Find(name, stub_holder, kind, extra_ic_state, flag);
    if (!ic.is_null()) return ic;
  }
 
#ifdef DEBUG
  if (kind == Code::KEYED_STORE_IC) {
    DCHECK(STANDARD_STORE ==
           KeyedStoreIC::GetKeyedAccessStoreMode(extra_ic_state));
  }
#endif
 
  PropertyICCompiler ic_compiler(isolate, kind, extra_ic_state, flag);
  ic = ic_compiler.CompileMonomorphic(type, handler, name, PROPERTY);
 
  if (can_be_cached) Map::UpdateCodeCache(stub_holder, name, ic);
  return ic;
}

References v8::internal::Isolate::builtins(), CompileMonomorphic(), DCHECK, v8::internal::Isolate::factory(), Find(), v8::internal::flag, v8::internal::IC::GetICCacheHolder(), v8::internal::KeyedStoreIC::GetKeyedAccessStoreMode(), v8::internal::Handle< T >::is_null(), name, v8::internal::PROPERTY, v8::internal::STANDARD_STORE, and v8::internal::Map::UpdateCodeCache().

Referenced by v8::internal::IC::UpdateMonomorphicIC(), and v8::internal::IC::UpdatePolymorphicIC().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputePolymorphic()

Handle< Code > v8::internal::PropertyICCompiler::ComputePolymorphic ( Code::Kind  kind, TypeHandleList *  types, CodeHandleList *  handlers, int  number_of_valid_maps, Handle< Name >  name, ExtraICState  extra_ic_state  )

static

Definition at line 272 of file ic-compiler.cc.

                                                                     {
  Handle<Code> handler = handlers->at(0);
  Code::StubType type = valid_types == 1 ? handler->type() : Code::NORMAL;
  DCHECK(kind == Code::LOAD_IC || kind == Code::STORE_IC);
  PropertyICCompiler ic_compiler(name->GetIsolate(), kind, extra_ic_state);
  return ic_compiler.CompilePolymorphic(types, handlers, name, type, PROPERTY);
}

References v8::internal::List< T, AllocationPolicy >::at(), CompilePolymorphic(), DCHECK, name, v8::internal::Code::NORMAL, and v8::internal::PROPERTY.

Referenced by v8::internal::IC::UpdatePolymorphicIC().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeStore()

Handle< Code > v8::internal::PropertyICCompiler::ComputeStore ( Isolate *  isolate, InlineCacheState  ic_state, ExtraICState  extra_state  )

static

Definition at line 193 of file ic-compiler.cc.

                                                                        {
  Code::Flags flags = Code::ComputeFlags(Code::STORE_IC, ic_state, extra_state);
  Handle<UnseededNumberDictionary> cache =
      isolate->factory()->non_monomorphic_cache();
  int entry = cache->FindEntry(isolate, flags);
  if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
 
  PropertyICCompiler compiler(isolate, Code::STORE_IC);
  Handle<Code> code;
  if (ic_state == UNINITIALIZED) {
    code = compiler.CompileStoreInitialize(flags);
  } else if (ic_state == PREMONOMORPHIC) {
    code = compiler.CompileStorePreMonomorphic(flags);
  } else if (ic_state == GENERIC) {
    code = compiler.CompileStoreGeneric(flags);
  } else if (ic_state == MEGAMORPHIC) {
    code = compiler.CompileStoreMegamorphic(flags);
  } else {
    UNREACHABLE();
  }
 
  FillCache(isolate, code);
  return code;
}

References CompileStoreGeneric(), CompileStoreInitialize(), CompileStoreMegamorphic(), CompileStorePreMonomorphic(), v8::internal::Code::ComputeFlags(), v8::internal::Isolate::factory(), v8::internal::FillCache(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::GENERIC, v8::internal::MEGAMORPHIC, v8::internal::PREMONOMORPHIC, v8::internal::UNINITIALIZED, and UNREACHABLE.

Referenced by v8::internal::StoreIC::generic_stub(), v8::internal::StoreIC::initialize_stub(), v8::internal::StoreIC::megamorphic_stub(), and v8::internal::StoreIC::pre_monomorphic_stub().

Here is the call graph for this function:

Here is the caller graph for this function:

Find()

Handle< Code > v8::internal::PropertyICCompiler::Find ( Handle< Name >  name, Handle< Map >  stub_holder_map, Code::Kind  kind, ExtraICState  extra_ic_state = kNoExtraICState, CacheHolderFlag  cache_holder = kCacheOnReceiver  )

staticprivate

Definition at line 16 of file ic-compiler.cc.

                                                                    {
  Code::Flags flags =
      Code::ComputeMonomorphicFlags(kind, extra_state, cache_holder);
  Object* probe = stub_holder->FindInCodeCache(*name, flags);
  if (probe->IsCode()) return handle(Code::cast(probe));
  return Handle<Code>::null();
}

References v8::internal::Code::ComputeMonomorphicFlags(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::handle(), name, and v8::internal::Handle< T >::null().

Referenced by ComputeCompareNil(), and ComputeMonomorphic().

Here is the call graph for this function:

Here is the caller graph for this function:

FindPreMonomorphic()

Code * v8::internal::PropertyICCompiler::FindPreMonomorphic ( Isolate *  isolate, Code::Kind  kind, ExtraICState  extra_ic_state  )

static

Definition at line 149 of file ic-compiler.cc.

                                                                 {
  Code::Flags flags = Code::ComputeFlags(kind, PREMONOMORPHIC, state);
  UnseededNumberDictionary* dictionary =
      isolate->heap()->non_monomorphic_cache();
  int entry = dictionary->FindEntry(isolate, flags);
  DCHECK(entry != -1);
  Object* code = dictionary->ValueAt(entry);
  // This might be called during the marking phase of the collector
  // hence the unchecked cast.
  return reinterpret_cast<Code*>(code);
}

References v8::internal::Code::ComputeFlags(), DCHECK, v8::internal::HashTable< Derived, Shape, Key >::FindEntry(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::Isolate::heap(), v8::internal::PREMONOMORPHIC, and v8::internal::Dictionary< Derived, Shape, Key >::ValueAt().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateRuntimeSetProperty()

static void v8::internal::PropertyICCompiler::GenerateRuntimeSetProperty ( MacroAssembler *  masm, StrictMode  strict_mode  )

static

Referenced by CompileStoreGeneric().

Here is the caller graph for this function:

GetCode()

Handle< Code > v8::internal::PropertyICCompiler::GetCode ( Code::Kind  kind, Code::StubType  type, Handle< Name >  name, InlineCacheState  state = MONOMORPHIC  )

private

Definition at line 360 of file ic-compiler.cc.

                                                                 {
  Code::Flags flags =
      Code::ComputeFlags(kind, state, extra_ic_state_, type, cache_holder());
  Handle<Code> code = GetCodeWithFlags(flags, name);
  IC::RegisterWeakMapDependency(code);
  PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
  return code;
}

References v8::internal::Code::ComputeFlags(), extra_ic_state_, v8::internal::anonymous_namespace{flags.cc}::flags, log_kind(), name, PROFILE, and v8::internal::IC::RegisterWeakMapDependency().

Referenced by CompileKeyedStoreMonomorphic().

Here is the call graph for this function:

Here is the caller graph for this function:

IncludesNumberType()

bool v8::internal::PropertyICCompiler::IncludesNumberType ( TypeHandleList *  types )

private

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

                                                                 {
  for (int i = 0; i < types->length(); ++i) {
    if (types->at(i)->Is(HeapType::Number())) return true;
  }
  return false;
}

References v8::internal::List< T, AllocationPolicy >::at().

Here is the call graph for this function:

log_kind()

Logger::LogEventsAndTags v8::internal::PropertyICCompiler::log_kind ( Handle< Code >  code )

inlineprivate

Definition at line 99 of file ic-compiler.h.

                                                     {
    if (kind() == Code::LOAD_IC) {
      return code->ic_state() == MONOMORPHIC ? Logger::LOAD_IC_TAG
                                             : Logger::LOAD_POLYMORPHIC_IC_TAG;
    } else if (kind() == Code::KEYED_LOAD_IC) {
      return code->ic_state() == MONOMORPHIC
                 ? Logger::KEYED_LOAD_IC_TAG
                 : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG;
    } else if (kind() == Code::STORE_IC) {
      return code->ic_state() == MONOMORPHIC ? Logger::STORE_IC_TAG
                                             : Logger::STORE_POLYMORPHIC_IC_TAG;
    } else {
      DCHECK_EQ(Code::KEYED_STORE_IC, kind());
      return code->ic_state() == MONOMORPHIC
                 ? Logger::KEYED_STORE_IC_TAG
                 : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG;
    }
  }

References DCHECK_EQ, and v8::internal::MONOMORPHIC.

Referenced by CompileKeyedStorePolymorphic(), and GetCode().

Here is the caller graph for this function:

Member Data Documentation

extra_ic_state_

const ExtraICState v8::internal::PropertyICCompiler::extra_ic_state_

private

Definition at line 118 of file ic-compiler.h.

Referenced by GetCode().

---

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

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