Home | History | Annotate | Download | only in ic 
      1 // Copyright 2014 the V8 project authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "src/v8.h"
      6 
      7 #include "src/ic/handler-compiler.h"
      8 #include "src/ic/ic-inl.h"
      9 #include "src/ic/ic-compiler.h"
     10 
     11 
     12 namespace v8 {
     13 namespace internal {
     14 
     15 
     16 Handle<Code> PropertyICCompiler::Find(Handle<Name> name,
     17                                       Handle<Map> stub_holder, Code::Kind kind,
     18                                       ExtraICState extra_state,
     19                                       CacheHolderFlag cache_holder) {
     20   Code::Flags flags =
     21       Code::ComputeMonomorphicFlags(kind, extra_state, cache_holder);
     22   Object* probe = stub_holder->FindInCodeCache(*name, flags);
     23   if (probe->IsCode()) return handle(Code::cast(probe));
     24   return Handle<Code>::null();
     25 }
     26 
     27 
     28 bool PropertyICCompiler::IncludesNumberType(TypeHandleList* types) {
     29   for (int i = 0; i < types->length(); ++i) {
     30     if (types->at(i)->Is(HeapType::Number())) return true;
     31   }
     32   return false;
     33 }
     34 
     35 
     36 Handle<Code> PropertyICCompiler::CompileMonomorphic(Handle<HeapType> type,
     37                                                     Handle<Code> handler,
     38                                                     Handle<Name> name,
     39                                                     IcCheckType check) {
     40   TypeHandleList types(1);
     41   CodeHandleList handlers(1);
     42   types.Add(type);
     43   handlers.Add(handler);
     44   Code::StubType stub_type = handler->type();
     45   return CompilePolymorphic(&types, &handlers, name, stub_type, check);
     46 }
     47 
     48 
     49 Handle<Code> PropertyICCompiler::ComputeMonomorphic(
     50     Code::Kind kind, Handle<Name> name, Handle<HeapType> type,
     51     Handle<Code> handler, ExtraICState extra_ic_state) {
     52   Isolate* isolate = name->GetIsolate();
     53   if (handler.is_identical_to(isolate->builtins()->LoadIC_Normal()) ||
     54       handler.is_identical_to(isolate->builtins()->StoreIC_Normal())) {
     55     name = isolate->factory()->normal_ic_symbol();
     56   }
     57 
     58   CacheHolderFlag flag;
     59   Handle<Map> stub_holder = IC::GetICCacheHolder(*type, isolate, &flag);
     60 
     61   Handle<Code> ic;
     62   // There are multiple string maps that all use the same prototype. That
     63   // prototype cannot hold multiple handlers, one for each of the string maps,
     64   // for a single name. Hence, turn off caching of the IC.
     65   bool can_be_cached = !type->Is(HeapType::String());
     66   if (can_be_cached) {
     67     ic = Find(name, stub_holder, kind, extra_ic_state, flag);
     68     if (!ic.is_null()) return ic;
     69   }
     70 
     71 #ifdef DEBUG
     72   if (kind == Code::KEYED_STORE_IC) {
     73     DCHECK(STANDARD_STORE ==
     74            KeyedStoreIC::GetKeyedAccessStoreMode(extra_ic_state));
     75   }
     76 #endif
     77 
     78   PropertyICCompiler ic_compiler(isolate, kind, extra_ic_state, flag);
     79   ic = ic_compiler.CompileMonomorphic(type, handler, name, PROPERTY);
     80 
     81   if (can_be_cached) Map::UpdateCodeCache(stub_holder, name, ic);
     82   return ic;
     83 }
     84 
     85 
     86 Handle<Code> PropertyICCompiler::ComputeKeyedLoadMonomorphic(
     87     Handle<Map> receiver_map) {
     88   Isolate* isolate = receiver_map->GetIsolate();
     89   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
     90   Handle<Name> name = isolate->factory()->KeyedLoadMonomorphic_string();
     91 
     92   Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate);
     93   if (probe->IsCode()) return Handle<Code>::cast(probe);
     94 
     95   ElementsKind elements_kind = receiver_map->elements_kind();
     96   Handle<Code> stub;
     97   if (receiver_map->has_indexed_interceptor()) {
     98     stub = LoadIndexedInterceptorStub(isolate).GetCode();
     99   } else if (receiver_map->has_sloppy_arguments_elements()) {
    100     stub = KeyedLoadSloppyArgumentsStub(isolate).GetCode();
    101   } else if (receiver_map->has_fast_elements() ||
    102              receiver_map->has_external_array_elements() ||
    103              receiver_map->has_fixed_typed_array_elements()) {
    104     stub = LoadFastElementStub(isolate,
    105                                receiver_map->instance_type() == JS_ARRAY_TYPE,
    106                                elements_kind).GetCode();
    107   } else {
    108     stub = LoadDictionaryElementStub(isolate).GetCode();
    109   }
    110   PropertyICCompiler compiler(isolate, Code::KEYED_LOAD_IC);
    111   Handle<Code> code =
    112       compiler.CompileMonomorphic(HeapType::Class(receiver_map, isolate), stub,
    113                                   isolate->factory()->empty_string(), ELEMENT);
    114 
    115   Map::UpdateCodeCache(receiver_map, name, code);
    116   return code;
    117 }
    118 
    119 
    120 Handle<Code> PropertyICCompiler::ComputeKeyedStoreMonomorphic(
    121     Handle<Map> receiver_map, StrictMode strict_mode,
    122     KeyedAccessStoreMode store_mode) {
    123   Isolate* isolate = receiver_map->GetIsolate();
    124   ExtraICState extra_state =
    125       KeyedStoreIC::ComputeExtraICState(strict_mode, store_mode);
    126   Code::Flags flags =
    127       Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, extra_state);
    128 
    129   DCHECK(store_mode == STANDARD_STORE ||
    130          store_mode == STORE_AND_GROW_NO_TRANSITION ||
    131          store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS ||
    132          store_mode == STORE_NO_TRANSITION_HANDLE_COW);
    133 
    134   Handle<String> name = isolate->factory()->KeyedStoreMonomorphic_string();
    135   Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate);
    136   if (probe->IsCode()) return Handle<Code>::cast(probe);
    137 
    138   PropertyICCompiler compiler(isolate, Code::KEYED_STORE_IC, extra_state);
    139   Handle<Code> code =
    140       compiler.CompileKeyedStoreMonomorphic(receiver_map, store_mode);
    141 
    142   Map::UpdateCodeCache(receiver_map, name, code);
    143   DCHECK(KeyedStoreIC::GetKeyedAccessStoreMode(code->extra_ic_state()) ==
    144          store_mode);
    145   return code;
    146 }
    147 
    148 
    149 Code* PropertyICCompiler::FindPreMonomorphic(Isolate* isolate, Code::Kind kind,
    150                                              ExtraICState state) {
    151   Code::Flags flags = Code::ComputeFlags(kind, PREMONOMORPHIC, state);
    152   UnseededNumberDictionary* dictionary =
    153       isolate->heap()->non_monomorphic_cache();
    154   int entry = dictionary->FindEntry(isolate, flags);
    155   DCHECK(entry != -1);
    156   Object* code = dictionary->ValueAt(entry);
    157   // This might be called during the marking phase of the collector
    158   // hence the unchecked cast.
    159   return reinterpret_cast<Code*>(code);
    160 }
    161 
    162 
    163 static void FillCache(Isolate* isolate, Handle<Code> code) {
    164   Handle<UnseededNumberDictionary> dictionary = UnseededNumberDictionary::Set(
    165       isolate->factory()->non_monomorphic_cache(), code->flags(), code);
    166   isolate->heap()->public_set_non_monomorphic_cache(*dictionary);
    167 }
    168 
    169 
    170 Handle<Code> PropertyICCompiler::ComputeLoad(Isolate* isolate,
    171                                              InlineCacheState ic_state,
    172                                              ExtraICState extra_state) {
    173   Code::Flags flags = Code::ComputeFlags(Code::LOAD_IC, ic_state, extra_state);
    174   Handle<UnseededNumberDictionary> cache =
    175       isolate->factory()->non_monomorphic_cache();
    176   int entry = cache->FindEntry(isolate, flags);
    177   if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
    178 
    179   PropertyICCompiler compiler(isolate, Code::LOAD_IC);
    180   Handle<Code> code;
    181   if (ic_state == UNINITIALIZED) {
    182     code = compiler.CompileLoadInitialize(flags);
    183   } else if (ic_state == PREMONOMORPHIC) {
    184     code = compiler.CompileLoadPreMonomorphic(flags);
    185   } else {
    186     UNREACHABLE();
    187   }
    188   FillCache(isolate, code);
    189   return code;
    190 }
    191 
    192 
    193 Handle<Code> PropertyICCompiler::ComputeStore(Isolate* isolate,
    194                                               InlineCacheState ic_state,
    195                                               ExtraICState extra_state) {
    196   Code::Flags flags = Code::ComputeFlags(Code::STORE_IC, ic_state, extra_state);
    197   Handle<UnseededNumberDictionary> cache =
    198       isolate->factory()->non_monomorphic_cache();
    199   int entry = cache->FindEntry(isolate, flags);
    200   if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
    201 
    202   PropertyICCompiler compiler(isolate, Code::STORE_IC);
    203   Handle<Code> code;
    204   if (ic_state == UNINITIALIZED) {
    205     code = compiler.CompileStoreInitialize(flags);
    206   } else if (ic_state == PREMONOMORPHIC) {
    207     code = compiler.CompileStorePreMonomorphic(flags);
    208   } else if (ic_state == GENERIC) {
    209     code = compiler.CompileStoreGeneric(flags);
    210   } else if (ic_state == MEGAMORPHIC) {
    211     code = compiler.CompileStoreMegamorphic(flags);
    212   } else {
    213     UNREACHABLE();
    214   }
    215 
    216   FillCache(isolate, code);
    217   return code;
    218 }
    219 
    220 
    221 Handle<Code> PropertyICCompiler::ComputeCompareNil(Handle<Map> receiver_map,
    222                                                    CompareNilICStub* stub) {
    223   Isolate* isolate = receiver_map->GetIsolate();
    224   Handle<String> name(isolate->heap()->empty_string());
    225   if (!receiver_map->is_dictionary_map()) {
    226     Handle<Code> cached_ic =
    227         Find(name, receiver_map, Code::COMPARE_NIL_IC, stub->GetExtraICState());
    228     if (!cached_ic.is_null()) return cached_ic;
    229   }
    230 
    231   Code::FindAndReplacePattern pattern;
    232   pattern.Add(isolate->factory()->meta_map(), receiver_map);
    233   Handle<Code> ic = stub->GetCodeCopy(pattern);
    234 
    235   if (!receiver_map->is_dictionary_map()) {
    236     Map::UpdateCodeCache(receiver_map, name, ic);
    237   }
    238 
    239   return ic;
    240 }
    241 
    242 
    243 // TODO(verwaest): Change this method so it takes in a TypeHandleList.
    244 Handle<Code> PropertyICCompiler::ComputeKeyedLoadPolymorphic(
    245     MapHandleList* receiver_maps) {
    246   Isolate* isolate = receiver_maps->at(0)->GetIsolate();
    247   Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);
    248   Handle<PolymorphicCodeCache> cache =
    249       isolate->factory()->polymorphic_code_cache();
    250   Handle<Object> probe = cache->Lookup(receiver_maps, flags);
    251   if (probe->IsCode()) return Handle<Code>::cast(probe);
    252 
    253   TypeHandleList types(receiver_maps->length());
    254   for (int i = 0; i < receiver_maps->length(); i++) {
    255     types.Add(HeapType::Class(receiver_maps->at(i), isolate));
    256   }
    257   CodeHandleList handlers(receiver_maps->length());
    258   ElementHandlerCompiler compiler(isolate);
    259   compiler.CompileElementHandlers(receiver_maps, &handlers);
    260   PropertyICCompiler ic_compiler(isolate, Code::KEYED_LOAD_IC);
    261   Handle<Code> code = ic_compiler.CompilePolymorphic(
    262       &types, &handlers, isolate->factory()->empty_string(), Code::NORMAL,
    263       ELEMENT);
    264 
    265   isolate->counters()->keyed_load_polymorphic_stubs()->Increment();
    266 
    267   PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
    268   return code;
    269 }
    270 
    271 
    272 Handle<Code> PropertyICCompiler::ComputePolymorphic(
    273     Code::Kind kind, TypeHandleList* types, CodeHandleList* handlers,
    274     int valid_types, Handle<Name> name, ExtraICState extra_ic_state) {
    275   Handle<Code> handler = handlers->at(0);
    276   Code::StubType type = valid_types == 1 ? handler->type() : Code::NORMAL;
    277   DCHECK(kind == Code::LOAD_IC || kind == Code::STORE_IC);
    278   PropertyICCompiler ic_compiler(name->GetIsolate(), kind, extra_ic_state);
    279   return ic_compiler.CompilePolymorphic(types, handlers, name, type, PROPERTY);
    280 }
    281 
    282 
    283 Handle<Code> PropertyICCompiler::ComputeKeyedStorePolymorphic(
    284     MapHandleList* receiver_maps, KeyedAccessStoreMode store_mode,
    285     StrictMode strict_mode) {
    286   Isolate* isolate = receiver_maps->at(0)->GetIsolate();
    287   DCHECK(store_mode == STANDARD_STORE ||
    288          store_mode == STORE_AND_GROW_NO_TRANSITION ||
    289          store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS ||
    290          store_mode == STORE_NO_TRANSITION_HANDLE_COW);
    291   Handle<PolymorphicCodeCache> cache =
    292       isolate->factory()->polymorphic_code_cache();
    293   ExtraICState extra_state =
    294       KeyedStoreIC::ComputeExtraICState(strict_mode, store_mode);
    295   Code::Flags flags =
    296       Code::ComputeFlags(Code::KEYED_STORE_IC, POLYMORPHIC, extra_state);
    297   Handle<Object> probe = cache->Lookup(receiver_maps, flags);
    298   if (probe->IsCode()) return Handle<Code>::cast(probe);
    299 
    300   PropertyICCompiler compiler(isolate, Code::KEYED_STORE_IC, extra_state);
    301   Handle<Code> code =
    302       compiler.CompileKeyedStorePolymorphic(receiver_maps, store_mode);
    303   PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
    304   return code;
    305 }
    306 
    307 
    308 Handle<Code> PropertyICCompiler::CompileLoadInitialize(Code::Flags flags) {
    309   LoadIC::GenerateInitialize(masm());
    310   Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadInitialize");
    311   PROFILE(isolate(), CodeCreateEvent(Logger::LOAD_INITIALIZE_TAG, *code, 0));
    312   return code;
    313 }
    314 
    315 
    316 Handle<Code> PropertyICCompiler::CompileLoadPreMonomorphic(Code::Flags flags) {
    317   LoadIC::GeneratePreMonomorphic(masm());
    318   Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadPreMonomorphic");
    319   PROFILE(isolate(),
    320           CodeCreateEvent(Logger::LOAD_PREMONOMORPHIC_TAG, *code, 0));
    321   return code;
    322 }
    323 
    324 
    325 Handle<Code> PropertyICCompiler::CompileStoreInitialize(Code::Flags flags) {
    326   StoreIC::GenerateInitialize(masm());
    327   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreInitialize");
    328   PROFILE(isolate(), CodeCreateEvent(Logger::STORE_INITIALIZE_TAG, *code, 0));
    329   return code;
    330 }
    331 
    332 
    333 Handle<Code> PropertyICCompiler::CompileStorePreMonomorphic(Code::Flags flags) {
    334   StoreIC::GeneratePreMonomorphic(masm());
    335   Handle<Code> code = GetCodeWithFlags(flags, "CompileStorePreMonomorphic");
    336   PROFILE(isolate(),
    337           CodeCreateEvent(Logger::STORE_PREMONOMORPHIC_TAG, *code, 0));
    338   return code;
    339 }
    340 
    341 
    342 Handle<Code> PropertyICCompiler::CompileStoreGeneric(Code::Flags flags) {
    343   ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
    344   StrictMode strict_mode = StoreIC::GetStrictMode(extra_state);
    345   GenerateRuntimeSetProperty(masm(), strict_mode);
    346   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreGeneric");
    347   PROFILE(isolate(), CodeCreateEvent(Logger::STORE_GENERIC_TAG, *code, 0));
    348   return code;
    349 }
    350 
    351 
    352 Handle<Code> PropertyICCompiler::CompileStoreMegamorphic(Code::Flags flags) {
    353   StoreIC::GenerateMegamorphic(masm());
    354   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreMegamorphic");
    355   PROFILE(isolate(), CodeCreateEvent(Logger::STORE_MEGAMORPHIC_TAG, *code, 0));
    356   return code;
    357 }
    358 
    359 
    360 Handle<Code> PropertyICCompiler::GetCode(Code::Kind kind, Code::StubType type,
    361                                          Handle<Name> name,
    362                                          InlineCacheState state) {
    363   Code::Flags flags =
    364       Code::ComputeFlags(kind, state, extra_ic_state_, type, cache_holder());
    365   Handle<Code> code = GetCodeWithFlags(flags, name);
    366   IC::RegisterWeakMapDependency(code);
    367   PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
    368   return code;
    369 }
    370 
    371 
    372 Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic(
    373     MapHandleList* receiver_maps, KeyedAccessStoreMode store_mode) {
    374   // Collect MONOMORPHIC stubs for all |receiver_maps|.
    375   CodeHandleList handlers(receiver_maps->length());
    376   MapHandleList transitioned_maps(receiver_maps->length());
    377   for (int i = 0; i < receiver_maps->length(); ++i) {
    378     Handle<Map> receiver_map(receiver_maps->at(i));
    379     Handle<Code> cached_stub;
    380     Handle<Map> transitioned_map =
    381         receiver_map->FindTransitionedMap(receiver_maps);
    382 
    383     // TODO(mvstanton): The code below is doing pessimistic elements
    384     // transitions. I would like to stop doing that and rely on Allocation Site
    385     // Tracking to do a better job of ensuring the data types are what they need
    386     // to be. Not all the elements are in place yet, pessimistic elements
    387     // transitions are still important for performance.
    388     bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
    389     ElementsKind elements_kind = receiver_map->elements_kind();
    390     if (!transitioned_map.is_null()) {
    391       cached_stub =
    392           ElementsTransitionAndStoreStub(isolate(), elements_kind,
    393                                          transitioned_map->elements_kind(),
    394                                          is_js_array, store_mode).GetCode();
    395     } else if (receiver_map->instance_type() < FIRST_JS_RECEIVER_TYPE) {
    396       cached_stub = isolate()->builtins()->KeyedStoreIC_Slow();
    397     } else {
    398       if (receiver_map->has_fast_elements() ||
    399           receiver_map->has_external_array_elements() ||
    400           receiver_map->has_fixed_typed_array_elements()) {
    401         cached_stub = StoreFastElementStub(isolate(), is_js_array,
    402                                            elements_kind, store_mode).GetCode();
    403       } else {
    404         cached_stub = StoreElementStub(isolate(), elements_kind).GetCode();
    405       }
    406     }
    407     DCHECK(!cached_stub.is_null());
    408     handlers.Add(cached_stub);
    409     transitioned_maps.Add(transitioned_map);
    410   }
    411 
    412   Handle<Code> code = CompileKeyedStorePolymorphic(receiver_maps, &handlers,
    413                                                    &transitioned_maps);
    414   isolate()->counters()->keyed_store_polymorphic_stubs()->Increment();
    415   PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, 0));
    416   return code;
    417 }
    418 
    419 
    420 #define __ ACCESS_MASM(masm())
    421 
    422 
    423 Handle<Code> PropertyICCompiler::CompileKeyedStoreMonomorphic(
    424     Handle<Map> receiver_map, KeyedAccessStoreMode store_mode) {
    425   ElementsKind elements_kind = receiver_map->elements_kind();
    426   bool is_jsarray = receiver_map->instance_type() == JS_ARRAY_TYPE;
    427   Handle<Code> stub;
    428   if (receiver_map->has_fast_elements() ||
    429       receiver_map->has_external_array_elements() ||
    430       receiver_map->has_fixed_typed_array_elements()) {
    431     stub = StoreFastElementStub(isolate(), is_jsarray, elements_kind,
    432                                 store_mode).GetCode();
    433   } else {
    434     stub = StoreElementStub(isolate(), elements_kind).GetCode();
    435   }
    436 
    437   __ DispatchMap(receiver(), scratch1(), receiver_map, stub, DO_SMI_CHECK);
    438 
    439   TailCallBuiltin(masm(), Builtins::kKeyedStoreIC_Miss);
    440 
    441   return GetCode(kind(), Code::NORMAL, factory()->empty_string());
    442 }
    443 
    444 
    445 #undef __
    446 }
    447 }  // namespace v8::internal
    448