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.
7 #include "src/ic/handler-compiler.h"
8 #include "src/ic/ic-inl.h"
9 #include "src/ic/ic-compiler.h"
16 Handle<Code> PropertyICCompiler::Find(Handle<Name> name,
17 Handle<Map> stub_holder, Code::Kind kind,
18 ExtraICState extra_state,
19 CacheHolderFlag cache_holder) {
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();
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;
36 Handle<Code> PropertyICCompiler::CompileMonomorphic(Handle<HeapType> type,
40 TypeHandleList types(1);
41 CodeHandleList handlers(1);
43 handlers.Add(handler);
44 Code::StubType stub_type = handler->type();
45 return CompilePolymorphic(&types, &handlers, name, stub_type, check);
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();
59 Handle<Map> stub_holder = IC::GetICCacheHolder(*type, isolate, &flag);
60 if (kind == Code::KEYED_STORE_IC) {
61 // Always set the "property" bit.
63 KeyedStoreIC::IcCheckTypeField::update(extra_ic_state, PROPERTY);
64 DCHECK(STANDARD_STORE ==
65 KeyedStoreIC::GetKeyedAccessStoreMode(extra_ic_state));
66 } else if (kind == Code::KEYED_LOAD_IC) {
67 extra_ic_state = KeyedLoadIC::IcCheckTypeField::update(extra_ic_state,
72 // There are multiple string maps that all use the same prototype. That
73 // prototype cannot hold multiple handlers, one for each of the string maps,
74 // for a single name. Hence, turn off caching of the IC.
75 bool can_be_cached = !type->Is(HeapType::String());
77 ic = Find(name, stub_holder, kind, extra_ic_state, flag);
78 if (!ic.is_null()) return ic;
81 PropertyICCompiler ic_compiler(isolate, kind, extra_ic_state, flag);
82 ic = ic_compiler.CompileMonomorphic(type, handler, name, PROPERTY);
84 if (can_be_cached) Map::UpdateCodeCache(stub_holder, name, ic);
89 Handle<Code> PropertyICCompiler::ComputeKeyedLoadMonomorphic(
90 Handle<Map> receiver_map) {
91 Isolate* isolate = receiver_map->GetIsolate();
92 DCHECK(KeyedLoadIC::GetKeyType(kNoExtraICState) == ELEMENT);
93 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
94 Handle<Name> name = isolate->factory()->KeyedLoadMonomorphic_string();
96 Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate);
97 if (probe->IsCode()) return Handle<Code>::cast(probe);
99 Handle<Code> stub = ComputeKeyedLoadMonomorphicHandler(receiver_map);
100 PropertyICCompiler compiler(isolate, Code::KEYED_LOAD_IC);
102 compiler.CompileMonomorphic(HeapType::Class(receiver_map, isolate), stub,
103 isolate->factory()->empty_string(), ELEMENT);
105 Map::UpdateCodeCache(receiver_map, name, code);
110 Handle<Code> PropertyICCompiler::ComputeKeyedLoadMonomorphicHandler(
111 Handle<Map> receiver_map) {
112 Isolate* isolate = receiver_map->GetIsolate();
113 ElementsKind elements_kind = receiver_map->elements_kind();
115 if (receiver_map->has_indexed_interceptor()) {
116 stub = LoadIndexedInterceptorStub(isolate).GetCode();
117 } else if (receiver_map->IsStringMap()) {
119 stub = LoadIndexedStringStub(isolate).GetCode();
120 } else if (receiver_map->has_sloppy_arguments_elements()) {
121 stub = KeyedLoadSloppyArgumentsStub(isolate).GetCode();
122 } else if (receiver_map->has_fast_elements() ||
123 receiver_map->has_external_array_elements() ||
124 receiver_map->has_fixed_typed_array_elements()) {
125 stub = LoadFastElementStub(isolate,
126 receiver_map->instance_type() == JS_ARRAY_TYPE,
127 elements_kind).GetCode();
129 stub = LoadDictionaryElementStub(isolate).GetCode();
135 Handle<Code> PropertyICCompiler::ComputeKeyedStoreMonomorphic(
136 Handle<Map> receiver_map, StrictMode strict_mode,
137 KeyedAccessStoreMode store_mode) {
138 Isolate* isolate = receiver_map->GetIsolate();
139 ExtraICState extra_state =
140 KeyedStoreIC::ComputeExtraICState(strict_mode, store_mode);
142 Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, extra_state);
144 DCHECK(store_mode == STANDARD_STORE ||
145 store_mode == STORE_AND_GROW_NO_TRANSITION ||
146 store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS ||
147 store_mode == STORE_NO_TRANSITION_HANDLE_COW);
149 Handle<String> name = isolate->factory()->KeyedStoreMonomorphic_string();
150 Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate);
151 if (probe->IsCode()) return Handle<Code>::cast(probe);
153 PropertyICCompiler compiler(isolate, Code::KEYED_STORE_IC, extra_state);
155 compiler.CompileKeyedStoreMonomorphic(receiver_map, store_mode);
157 Map::UpdateCodeCache(receiver_map, name, code);
158 DCHECK(KeyedStoreIC::GetKeyedAccessStoreMode(code->extra_ic_state()) ==
164 Code* PropertyICCompiler::FindPreMonomorphic(Isolate* isolate, Code::Kind kind,
165 ExtraICState state) {
166 Code::Flags flags = Code::ComputeFlags(kind, PREMONOMORPHIC, state);
167 UnseededNumberDictionary* dictionary =
168 isolate->heap()->non_monomorphic_cache();
169 int entry = dictionary->FindEntry(isolate, flags);
171 Object* code = dictionary->ValueAt(entry);
172 // This might be called during the marking phase of the collector
173 // hence the unchecked cast.
174 return reinterpret_cast<Code*>(code);
178 static void FillCache(Isolate* isolate, Handle<Code> code) {
179 Handle<UnseededNumberDictionary> dictionary = UnseededNumberDictionary::Set(
180 isolate->factory()->non_monomorphic_cache(), code->flags(), code);
181 isolate->heap()->public_set_non_monomorphic_cache(*dictionary);
185 Handle<Code> PropertyICCompiler::ComputeLoad(Isolate* isolate,
186 InlineCacheState ic_state,
187 ExtraICState extra_state) {
188 Code::Flags flags = Code::ComputeFlags(Code::LOAD_IC, ic_state, extra_state);
189 Handle<UnseededNumberDictionary> cache =
190 isolate->factory()->non_monomorphic_cache();
191 int entry = cache->FindEntry(isolate, flags);
192 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
194 PropertyICCompiler compiler(isolate, Code::LOAD_IC);
196 if (ic_state == UNINITIALIZED) {
197 code = compiler.CompileLoadInitialize(flags);
198 } else if (ic_state == PREMONOMORPHIC) {
199 code = compiler.CompileLoadPreMonomorphic(flags);
203 FillCache(isolate, code);
208 Handle<Code> PropertyICCompiler::ComputeStore(Isolate* isolate,
209 InlineCacheState ic_state,
210 ExtraICState extra_state) {
211 Code::Flags flags = Code::ComputeFlags(Code::STORE_IC, ic_state, extra_state);
212 Handle<UnseededNumberDictionary> cache =
213 isolate->factory()->non_monomorphic_cache();
214 int entry = cache->FindEntry(isolate, flags);
215 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
217 PropertyICCompiler compiler(isolate, Code::STORE_IC);
219 if (ic_state == UNINITIALIZED) {
220 code = compiler.CompileStoreInitialize(flags);
221 } else if (ic_state == PREMONOMORPHIC) {
222 code = compiler.CompileStorePreMonomorphic(flags);
223 } else if (ic_state == GENERIC) {
224 code = compiler.CompileStoreGeneric(flags);
225 } else if (ic_state == MEGAMORPHIC) {
226 code = compiler.CompileStoreMegamorphic(flags);
231 FillCache(isolate, code);
236 Handle<Code> PropertyICCompiler::ComputeCompareNil(Handle<Map> receiver_map,
237 CompareNilICStub* stub) {
238 Isolate* isolate = receiver_map->GetIsolate();
239 Handle<String> name(isolate->heap()->empty_string());
240 if (!receiver_map->is_dictionary_map()) {
241 Handle<Code> cached_ic =
242 Find(name, receiver_map, Code::COMPARE_NIL_IC, stub->GetExtraICState());
243 if (!cached_ic.is_null()) return cached_ic;
246 Code::FindAndReplacePattern pattern;
247 Handle<WeakCell> cell = Map::WeakCellForMap(receiver_map);
248 pattern.Add(isolate->factory()->meta_map(), cell);
249 Handle<Code> ic = stub->GetCodeCopy(pattern);
251 if (!receiver_map->is_dictionary_map()) {
252 Map::UpdateCodeCache(receiver_map, name, ic);
259 // TODO(verwaest): Change this method so it takes in a TypeHandleList.
260 Handle<Code> PropertyICCompiler::ComputeKeyedLoadPolymorphic(
261 MapHandleList* receiver_maps) {
262 Isolate* isolate = receiver_maps->at(0)->GetIsolate();
263 DCHECK(KeyedLoadIC::GetKeyType(kNoExtraICState) == ELEMENT);
264 Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);
265 Handle<PolymorphicCodeCache> cache =
266 isolate->factory()->polymorphic_code_cache();
267 Handle<Object> probe = cache->Lookup(receiver_maps, flags);
268 if (probe->IsCode()) return Handle<Code>::cast(probe);
270 TypeHandleList types(receiver_maps->length());
271 for (int i = 0; i < receiver_maps->length(); i++) {
272 types.Add(HeapType::Class(receiver_maps->at(i), isolate));
274 CodeHandleList handlers(receiver_maps->length());
275 ElementHandlerCompiler compiler(isolate);
276 compiler.CompileElementHandlers(receiver_maps, &handlers);
277 PropertyICCompiler ic_compiler(isolate, Code::KEYED_LOAD_IC);
278 Handle<Code> code = ic_compiler.CompilePolymorphic(
279 &types, &handlers, isolate->factory()->empty_string(), Code::NORMAL,
282 isolate->counters()->keyed_load_polymorphic_stubs()->Increment();
284 PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
289 Handle<Code> PropertyICCompiler::ComputePolymorphic(
290 Code::Kind kind, TypeHandleList* types, CodeHandleList* handlers,
291 int valid_types, Handle<Name> name, ExtraICState extra_ic_state) {
292 Handle<Code> handler = handlers->at(0);
293 Code::StubType type = valid_types == 1 ? handler->type() : Code::NORMAL;
294 DCHECK(kind == Code::LOAD_IC || kind == Code::STORE_IC);
295 PropertyICCompiler ic_compiler(name->GetIsolate(), kind, extra_ic_state);
296 return ic_compiler.CompilePolymorphic(types, handlers, name, type, PROPERTY);
300 Handle<Code> PropertyICCompiler::ComputeKeyedStorePolymorphic(
301 MapHandleList* receiver_maps, KeyedAccessStoreMode store_mode,
302 StrictMode strict_mode) {
303 Isolate* isolate = receiver_maps->at(0)->GetIsolate();
304 DCHECK(store_mode == STANDARD_STORE ||
305 store_mode == STORE_AND_GROW_NO_TRANSITION ||
306 store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS ||
307 store_mode == STORE_NO_TRANSITION_HANDLE_COW);
308 Handle<PolymorphicCodeCache> cache =
309 isolate->factory()->polymorphic_code_cache();
310 ExtraICState extra_state =
311 KeyedStoreIC::ComputeExtraICState(strict_mode, store_mode);
313 Code::ComputeFlags(Code::KEYED_STORE_IC, POLYMORPHIC, extra_state);
314 Handle<Object> probe = cache->Lookup(receiver_maps, flags);
315 if (probe->IsCode()) return Handle<Code>::cast(probe);
317 PropertyICCompiler compiler(isolate, Code::KEYED_STORE_IC, extra_state);
319 compiler.CompileKeyedStorePolymorphic(receiver_maps, store_mode);
320 PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
325 Handle<Code> PropertyICCompiler::CompileLoadInitialize(Code::Flags flags) {
326 LoadIC::GenerateInitialize(masm());
327 Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadInitialize");
328 PROFILE(isolate(), CodeCreateEvent(Logger::LOAD_INITIALIZE_TAG, *code, 0));
333 Handle<Code> PropertyICCompiler::CompileLoadPreMonomorphic(Code::Flags flags) {
334 LoadIC::GeneratePreMonomorphic(masm());
335 Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadPreMonomorphic");
337 CodeCreateEvent(Logger::LOAD_PREMONOMORPHIC_TAG, *code, 0));
342 Handle<Code> PropertyICCompiler::CompileStoreInitialize(Code::Flags flags) {
343 StoreIC::GenerateInitialize(masm());
344 Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreInitialize");
345 PROFILE(isolate(), CodeCreateEvent(Logger::STORE_INITIALIZE_TAG, *code, 0));
350 Handle<Code> PropertyICCompiler::CompileStorePreMonomorphic(Code::Flags flags) {
351 StoreIC::GeneratePreMonomorphic(masm());
352 Handle<Code> code = GetCodeWithFlags(flags, "CompileStorePreMonomorphic");
354 CodeCreateEvent(Logger::STORE_PREMONOMORPHIC_TAG, *code, 0));
359 Handle<Code> PropertyICCompiler::CompileStoreGeneric(Code::Flags flags) {
360 ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
361 StrictMode strict_mode = StoreIC::GetStrictMode(extra_state);
362 GenerateRuntimeSetProperty(masm(), strict_mode);
363 Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreGeneric");
364 PROFILE(isolate(), CodeCreateEvent(Logger::STORE_GENERIC_TAG, *code, 0));
369 Handle<Code> PropertyICCompiler::CompileStoreMegamorphic(Code::Flags flags) {
370 StoreIC::GenerateMegamorphic(masm());
371 Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreMegamorphic");
372 PROFILE(isolate(), CodeCreateEvent(Logger::STORE_MEGAMORPHIC_TAG, *code, 0));
377 Handle<Code> PropertyICCompiler::GetCode(Code::Kind kind, Code::StubType type,
379 InlineCacheState state) {
381 Code::ComputeFlags(kind, state, extra_ic_state_, type, cache_holder());
382 Handle<Code> code = GetCodeWithFlags(flags, name);
383 PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
388 Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic(
389 MapHandleList* receiver_maps, KeyedAccessStoreMode store_mode) {
390 // Collect MONOMORPHIC stubs for all |receiver_maps|.
391 CodeHandleList handlers(receiver_maps->length());
392 MapHandleList transitioned_maps(receiver_maps->length());
393 for (int i = 0; i < receiver_maps->length(); ++i) {
394 Handle<Map> receiver_map(receiver_maps->at(i));
395 Handle<Code> cached_stub;
396 Handle<Map> transitioned_map =
397 receiver_map->FindTransitionedMap(receiver_maps);
399 // TODO(mvstanton): The code below is doing pessimistic elements
400 // transitions. I would like to stop doing that and rely on Allocation Site
401 // Tracking to do a better job of ensuring the data types are what they need
402 // to be. Not all the elements are in place yet, pessimistic elements
403 // transitions are still important for performance.
404 bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
405 ElementsKind elements_kind = receiver_map->elements_kind();
406 if (!transitioned_map.is_null()) {
408 ElementsTransitionAndStoreStub(isolate(), elements_kind,
409 transitioned_map->elements_kind(),
410 is_js_array, store_mode).GetCode();
411 } else if (receiver_map->instance_type() < FIRST_JS_RECEIVER_TYPE) {
412 cached_stub = isolate()->builtins()->KeyedStoreIC_Slow();
414 if (receiver_map->has_fast_elements() ||
415 receiver_map->has_external_array_elements() ||
416 receiver_map->has_fixed_typed_array_elements()) {
417 cached_stub = StoreFastElementStub(isolate(), is_js_array,
418 elements_kind, store_mode).GetCode();
420 cached_stub = StoreElementStub(isolate(), elements_kind).GetCode();
423 DCHECK(!cached_stub.is_null());
424 handlers.Add(cached_stub);
425 transitioned_maps.Add(transitioned_map);
428 Handle<Code> code = CompileKeyedStorePolymorphic(receiver_maps, &handlers,
430 isolate()->counters()->keyed_store_polymorphic_stubs()->Increment();
431 PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, 0));
436 #define __ ACCESS_MASM(masm())
439 Handle<Code> PropertyICCompiler::CompileKeyedStoreMonomorphic(
440 Handle<Map> receiver_map, KeyedAccessStoreMode store_mode) {
441 ElementsKind elements_kind = receiver_map->elements_kind();
442 bool is_jsarray = receiver_map->instance_type() == JS_ARRAY_TYPE;
444 if (receiver_map->has_fast_elements() ||
445 receiver_map->has_external_array_elements() ||
446 receiver_map->has_fixed_typed_array_elements()) {
447 stub = StoreFastElementStub(isolate(), is_jsarray, elements_kind,
448 store_mode).GetCode();
450 stub = StoreElementStub(isolate(), elements_kind).GetCode();
453 Handle<WeakCell> cell = Map::WeakCellForMap(receiver_map);
455 __ DispatchWeakMap(receiver(), scratch1(), scratch2(), cell, stub,
458 TailCallBuiltin(masm(), Builtins::kKeyedStoreIC_Miss);
460 return GetCode(kind(), Code::NORMAL, factory()->empty_string());
466 } // namespace v8::internal