Lines Matching full:code
6 // * Redistributions of source code must retain the above copyright
33 #include "code-stubs.h"
58 Code* StubCache::Set(Name* name, Map* map, Code* code) {
59 // Get the flags from the code.
60 Code::Flags flags = Code::RemoveTypeFromFlags(code->flags());
71 ASSERT(Code::ExtractICStateFromFlags(flags) == MONOMORPHIC);
72 STATIC_ASSERT((Code::ICStateField::kMask & 1) == 1);
74 // Make sure that the code type is not included in the hash.
75 ASSERT(Code::ExtractTypeFromFlags(flags) == 0);
80 Code* old_code = primary->value;
86 Code::Flags old_flags = Code::RemoveTypeFromFlags(old_code->flags());
95 primary->value = code;
98 return code;
102 Handle<Code> StubCache::FindIC(Handle<Name> name,
104 Code::Kind kind,
107 Code::Flags flags = Code::ComputeMonomorphicFlags(
110 if (probe->IsCode()) return Handle<Code>::cast(probe);
111 return Handle<Code>::null();
115 Handle<Code> StubCache::FindHandler(Handle<Name> name,
117 Code::Kind kind,
119 Code::Flags flags = Code::ComputeMonomorphicFlags(
120 Code::HANDLER, kNoExtraICState, cache_holder, Code::NORMAL, kind);
123 if (probe->IsCode()) return Handle<Code>::cast(probe);
124 return Handle<Code>::null();
128 Handle<Code> StubCache::ComputeMonomorphicIC(
131 Handle<Code> handler,
133 Code::Kind kind = handler->handler_kind();
137 Handle<Code> ic;
148 if (kind == Code::LOAD_IC) {
151 } else if (kind == Code::KEYED_LOAD_IC) {
154 } else if (kind == Code::STORE_IC) {
158 ASSERT(kind == Code::KEYED_STORE_IC);
170 Handle<Code> StubCache::ComputeLoadNonexistent(Handle<Name> name,
193 Handle<Code> handler = FindHandler(
194 cache_name, stub_holder, Code::LOAD_IC, flag);
204 Handle<Code> StubCache::ComputeKeyedLoadElement(Handle<Map> receiver_map) {
205 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
210 if (probe->IsCode()) return Handle<Code>::cast(probe);
213 Handle<Code> code = compiler.CompileLoadElement(receiver_map);
215 Map::UpdateCodeCache(receiver_map, name, code);
216 return code;
220 Handle<Code> StubCache::ComputeKeyedStoreElement(
226 Code::Flags flags = Code::ComputeMonomorphicFlags(
227 Code::KEYED_STORE_IC, extra_state);
237 if (probe->IsCode()) return Handle<Code>::cast(probe);
240 Handle<Code> code = compiler.CompileStoreElement(receiver_map);
242 Map::UpdateCodeCache(receiver_map, name, code);
243 ASSERT(KeyedStoreIC::GetKeyedAccessStoreMode(code->extra_ic_state())
245 return code;
250 (kind == Code::CALL_IC ? Logger::type : Logger::KEYED_##type)
252 Handle<Code> StubCache::ComputeCallConstant(int argc,
253 Code::Kind kind,
281 return Handle<Code>::null();
284 Code::Flags flags = Code::ComputeMonomorphicFlags(
285 kind, extra_state, cache_holder, Code::FAST, argc);
288 if (probe->IsCode()) return Handle<Code>::cast(probe);
291 Handle<Code> code =
293 code->set_check_type(check);
294 ASSERT(flags == code->flags());
296 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
297 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
300 HeapObject::UpdateMapCodeCache(stub_holder, name, code);
302 return code;
306 Handle<Code> StubCache::ComputeCallField(int argc,
307 Code::Kind kind,
326 Code::Flags flags = Code::ComputeMonomorphicFlags(
327 kind, extra_state, cache_holder, Code::FAST, argc);
330 if (probe->IsCode()) return Handle<Code>::cast(probe);
333 Handle<Code> code =
336 ASSERT(flags == code->flags());
338 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
339 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
340 HeapObject::UpdateMapCodeCache(stub_holder, name, code);
341 return code;
345 Handle<Code> StubCache::ComputeCallInterceptor(int argc,
346 Code::Kind kind,
364 Code::Flags flags = Code::ComputeMonomorphicFlags(
365 kind, extra_state, cache_holder, Code::FAST, argc);
368 if (probe->IsCode()) return Handle<Code>::cast(probe);
371 Handle<Code> code =
374 ASSERT(flags == code->flags());
376 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
377 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
378 HeapObject::UpdateMapCodeCache(stub_holder, name, code);
379 return code;
383 Handle<Code> StubCache::ComputeCallGlobal(int argc,
384 Code::Kind kind,
391 Code::Flags flags = Code::ComputeMonomorphicFlags(
392 kind, extra_state, OWN_MAP, Code::NORMAL, argc);
395 if (probe->IsCode()) return Handle<Code>::cast(probe);
398 Handle<Code> code =
400 ASSERT(flags == code
402 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
403 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
405 HeapObject::UpdateMapCodeCache(receiver, name, code);
407 return code;
411 static void FillCache(Isolate* isolate, Handle<Code> code) {
414 code->flags(),
415 code);
420 Code* StubCache::FindCallInitialize(int argc,
422 Code::Kind kind) {
427 Code::Flags flags =
428 Code::ComputeFlags(kind, UNINITIALIZED, extra_state, Code::NORMAL, argc);
433 Object* code = dictionary->ValueAt(entry);
436 return reinterpret_cast<Code*>(code);
440 Handle<Code> StubCache::ComputeCallInitialize(int argc,
442 Code::Kind kind) {
447 Code::Flags flags =
448 Code::ComputeFlags(kind, UNINITIALIZED, extra_state, Code::NORMAL, argc);
452 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
455 Handle<Code> code = compiler.CompileCallInitialize(flags);
456 FillCache(isolate_, code);
457 return code;
461 Handle<Code> StubCache::ComputeCallInitialize(int argc, RelocInfo::Mode mode) {
462 return ComputeCallInitialize(argc, mode, Code::CALL_IC);
466 Handle<Code> StubCache::ComputeKeyedCallInitialize(int argc) {
468 Code::KEYED_CALL_IC);
472 Handle<Code> StubCache::ComputeCallPreMonomorphic(
474 Code::Kind kind,
476 Code::Flags flags =
477 Code::ComputeFlags(kind, PREMONOMORPHIC, extra_state, Code::NORMAL, argc);
481 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
484 Handle<Code> code = compiler.CompileCallPreMonomorphic(flags);
485 FillCache(isolate_, code);
486 return code;
490 Handle<Code> StubCache::ComputeCallNormal(int argc,
491 Code::Kind kind,
493 Code::Flags flags =
494 Code::ComputeFlags(kind, MONOMORPHIC, extra_state, Code::NORMAL, argc);
498 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
501 Handle<Code> code = compiler.CompileCallNormal(flags);
502 FillCache(isolate_, code);
503 return code;
507 Handle<Code> StubCache::ComputeCallArguments(int argc) {
508 Code::Flags flags =
509 Code::ComputeFlags(Code::KEYED_CALL_IC, MEGAMORPHIC,
510 kNoExtraICState, Code::NORMAL, argc);
514 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
517 Handle<Code> code = compiler.CompileCallArguments(flags);
518 FillCache(isolate_, code);
519 return code;
523 Handle<Code> StubCache::ComputeCallMegamorphic(
525 Code::Kind kind,
527 Code::Flags flags =
528 Code::ComputeFlags(kind, MEGAMORPHIC, extra_state,
529 Code::NORMAL, argc);
533 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
536 Handle<Code> code = compiler.CompileCallMegamorphic(flags);
537 FillCache(isolate_, code);
538 return code;
542 Handle<Code> StubCache::ComputeCallMiss(int argc,
543 Code::Kind kind,
547 Code::Flags flags =
548 Code::ComputeFlags(kind, MONOMORPHIC_PROTOTYPE_FAILURE, extra_state,
549 Code::NORMAL, argc, OWN_MAP);
553 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
556 Handle<Code> code = compiler.CompileCallMiss(flags);
557 FillCache(isolate_, code);
558 return code;
562 Handle<Code> StubCache::ComputeCompareNil(Handle<Map> receiver_map,
566 Handle<Code> cached_ic = FindIC(name, receiver_map, Code::COMPARE_NIL_IC,
571 Handle<Code> ic = stub.GetCodeCopyFromTemplate(isolate_);
583 Handle<Code> StubCache::ComputeLoadElementPolymorphic(
585 Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);
589 if (probe->IsCode()) return Handle<Code>::cast(probe);
598 Handle<Code> code = compiler.CompilePolymorphicIC(
599 &types, &handlers, factory()->empty_string(), Code::NORMAL, ELEMENT);
603 PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
604 return code;
608 Handle<Code> StubCache::ComputePolymorphicIC(
615 Handle<Code> handler = handlers->at(0);
616 Code::Kind kind = handler->handler_kind();
617 Code::StubType type = number_of_valid_types == 1 ? handler->type()
618 : Code::NORMAL;
619 if (kind == Code::LOAD_IC) {
624 ASSERT(kind == Code::STORE_IC);
633 Handle<Code> StubCache::ComputeStoreElementPolymorphic(
645 Code::Flags flags =
646 Code::ComputeFlags(Code::KEYED_STORE_IC, POLYMORPHIC, extra_state);
648 if (probe->IsCode()) return Handle<Code>::cast(probe);
651 Handle<Code> code = compiler.CompileStoreElementPolymorphic(receiver_maps);
652 PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
653 return code;
658 Handle<Code> StubCache::ComputeCallDebugBreak(int argc,
659 Code::Kind kind) {
662 Code::Flags flags =
663 Code::ComputeFlags(kind, DEBUG_STUB, DEBUG_BREAK,
664 Code::NORMAL, argc);
668 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
671 Handle<Code> code = compiler.CompileCallDebugBreak(flags);
672 FillCache(isolate_, code);
673 return code;
677 Handle<Code> StubCache::ComputeCallDebugPrepareStepIn(int argc,
678 Code::Kind kind) {
681 Code::Flags flags =
682 Code::ComputeFlags(kind, DEBUG_STUB, DEBUG_PREPARE_STEP_IN,
683 Code::NORMAL, argc);
687 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
690 Handle<Code> code = compiler.CompileCallDebugPrepareStepIn(flags);
691 FillCache(isolate_, code);
692 return code;
698 Code* empty = isolate_->builtins()->builtin(Builtins::kIllegal);
714 Code::Flags flags,
949 Handle<Code> StubCompiler::CompileCallInitialize(Code::Flags flags) {
950 int argc = Code::ExtractArgumentsCountFromFlags(flags);
951 Code::Kind kind = Code::ExtractKindFromFlags(flags);
952 ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
953 if (kind == Code::CALL_IC) {
958 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallInitialize");
962 *code, code->arguments_count()));
963 GDBJIT(AddCode(GDBJITInterface::CALL_INITIALIZE, *code));
964 return code;
968 Handle<Code> StubCompiler::CompileCallPreMonomorphic(Code::Flags flags) {
969 int argc = Code::ExtractArgumentsCountFromFlags(flags);
970 // The code of the PreMonomorphic stub is the same as the code
971 // of the Initialized stub. They just differ on the code object flags.
972 Code::Kind kind = Code::ExtractKindFromFlags(flags);
973 ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
974 if (kind == Code::CALL_IC) {
979 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallPreMonomorphic");
983 *code, code->arguments_count()));
984 GDBJIT(AddCode(GDBJITInterface::CALL_PRE_MONOMORPHIC, *code));
985 return code;
989 Handle<Code> StubCompiler::CompileCallNormal(Code::Flags flags) {
990 int argc = Code::ExtractArgumentsCountFromFlags(flags);
991 Code::Kind kind = Code::ExtractKindFromFlags(flags);
992 if (kind == Code::CALL_IC) {
995 Code::ExtractExtraICStateFromFlags(flags)));
1000 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallNormal");
1004 *code, code->arguments_count()));
1005 GDBJIT(AddCode(GDBJITInterface::CALL_NORMAL, *code));
1006 return code;
1010 Handle<Code> StubCompiler::CompileCallMegamorphic(Code::Flags flags) {
1011 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1012 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1013 ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1014 if (kind == Code::CALL_IC) {
1019 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallMegamorphic");
1023 *code, code->arguments_count()));
1024 GDBJIT(AddCode(GDBJITInterface::CALL_MEGAMORPHIC, *code));
1025 return code;
1029 Handle<Code> StubCompiler::CompileCallArguments(Code::Flags flags) {
1030 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1032 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallArguments");
1034 CodeCreateEvent(CALL_LOGGER_TAG(Code::ExtractKindFromFlags(flags),
1036 *code, code->arguments_count()));
1037 GDBJIT(AddCode(GDBJITInterface::CALL_MEGAMORPHIC, *code));
1038 return code;
1042 Handle<Code> StubCompiler::CompileCallMiss(Code::Flags flags) {
1043 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1044 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1045 ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1046 if (kind == Code::CALL_IC) {
1051 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallMiss");
1055 *code, code->arguments_count()));
1056 GDBJIT(AddCode(GDBJITInterface::CALL_MISS, *code));
1057 return code;
1062 Handle<Code> StubCompiler::CompileCallDebugBreak(Code::Flags flags) {
1064 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallDebugBreak");
1066 CodeCreateEvent(CALL_LOGGER_TAG(Code::ExtractKindFromFlags(flags),
1068 *code, code->arguments_count()));
1069 return code;
1073 Handle<Code> StubCompiler::CompileCallDebugPrepareStepIn(Code::Flags flags) {
1074 // Use the same code for the the step in preparations as we do for the
1076 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1077 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1078 if (kind == Code::CALL_IC) {
1084 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallDebugPrepareStepIn");
1088 *code,
1089 code->arguments_count()));
1090 return code;
1097 Handle<Code> StubCompiler::GetCodeWithFlags(Code::Flags flags,
1099 // Create code object in the heap.
1102 Handle<Code> code = factory()->NewCode(desc, flags, masm_.CodeObject());
1103 if (code->has_major_key()) {
1104 code->set_major_key(CodeStub::NoCache);
1107 if (FLAG_print_code_stubs) code->Disassemble(name);
1109 return code;
1113 Handle<Code> StubCompiler::GetCodeWithFlags(Code::Flags flags,
1172 Handle<Code> CallStubCompiler::CompileCallConstant(
1179 Handle<Code> code = CompileCustomCall(object, holder,
1182 Code::FAST);
1183 // A null handle means bail out to the regular compiler code below.
1184 if (!code.is_null()) return code;
1192 // Return the generated code.
1315 Handle<Code> LoadStubCompiler::CompileLoadField(
1330 // Return the generated code.
1331 return GetCode(kind(), Code::FAST, name);
1335 Handle<Code> LoadStubCompiler::CompileLoadConstant(
1343 // Return the generated code.
1344 return GetCode(kind(), Code::FAST, name);
1348 Handle<Code> LoadStubCompiler::CompileLoadCallback(
1357 // Return the generated code.
1358 return GetCode(kind(), Code::FAST, name);
1362 Handle<Code> LoadStubCompiler::CompileLoadCallback(
1372 // Return the generated code.
1373 return GetCode(kind(), Code::FAST, name);
1377 Handle<Code> LoadStubCompiler::CompileLoadInterceptor(
1389 // Return the generated code.
1390 return GetCode(kind(), Code::FAST, name);
1430 Handle<Code> BaseLoadStoreStubCompiler::CompileMonomorphicIC(
1432 Handle<Code> handler,
1438 Code::StubType stub_type = handler->type();
1443 Handle<Code> LoadStubCompiler::CompileLoadViaGetter(
1451 // Return the generated code.
1452 return GetCode(kind(), Code::FAST, name);
1456 Handle<Code> StoreStubCompiler::CompileStoreTransition(
1508 // Return the generated code.
1509 return GetCode(kind(), Code::FAST, name);
1513 Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object,
1521 // Generate store field code.
1532 // Return the generated code.
1533 return GetCode(kind(), Code::FAST, name);
1537 Handle<Code> StoreStubCompiler::CompileStoreViaSetter(
1546 return GetCode(kind(), Code::FAST, name);
1550 Handle<Code> KeyedLoadStubCompiler::CompileLoadElement(
1555 Handle<Code> stub = KeyedLoadFastElementStub(
1560 Handle<Code> stub = FLAG_compiled_keyed_dictionary_loads
1568 // Return the generated code.
1569 return GetICCode(kind(), Code::NORMAL, factory()->empty_string());
1573 Handle<Code> KeyedStoreStubCompiler::CompileStoreElement(
1577 Handle<Code> stub;
1594 // Return the generated code.
1595 return GetICCode(kind(), Code::NORMAL, factory()->empty_string());
1603 Handle<Code> code(masm->isolate()->builtins()->builtin(name));
1604 GenerateTailCall(masm, code);
1608 void BaseLoadStoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
1611 if (kind_ == Code::LOAD_IC) {
1613 } else if (kind_ == Code::KEYED_LOAD_IC) {
1615 } else if (kind_ == Code::STORE_IC) {
1620 GDBJIT(AddCode(tag, *name, *code));
1626 if (kind_ == Code::LOAD_IC) {
1628 } else if (kind_ == Code::KEYED_LOAD_IC) {
1630 } else if (kind_ == Code::STORE_IC) {
1638 Handle<Code> BaseLoadStoreStubCompiler::GetICCode(Code::Kind kind,
1639 Code::StubType type,
1642 Code::Flags flags = Code::ComputeFlags(kind, state, extra_state(), type);
1643 Handle<Code> code = GetCodeWithFlags(flags, name);
1644 PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
1645 JitEvent(name, code);
1646 return code;
1650 Handle<Code> BaseLoadStoreStubCompiler::GetCode(Code::Kind kind,
1651 Code::StubType type,
1653 Code::Flags flags = Code::ComputeFlags(
1654 Code::HANDLER, MONOMORPHIC, extra_state(), type, kind, cache_holder_);
1655 Handle<Code> code = GetCodeWithFlags(flags, name);
1656 PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
1657 JitEvent(name, code);
1658 return code;
1666 Handle<Code> cached_stub;
1692 Handle<Code> KeyedStoreStubCompiler::CompileStoreElementPolymorphic(
1699 Handle<Code> cached_stub;
1703 // TODO(mvstanton): The code below is doing pessimistic elements
1736 Handle<Code> code =
1740 CodeCreateEvent(Logger::KEYED_STORE_POLYMORPHIC_IC_TAG, *code, 0));
1741 return code;
1753 Code::Kind kind,
1788 Handle<Code> CallStubCompiler::CompileCustomCall(
1794 Code::StubType type) {
1822 Handle<Code> CallStubCompiler::GetCode(Code::StubType type,
1825 Code::Flags flags = Code::ComputeMonomorphicFlags(
1831 Handle<Code> CallStubCompiler::GetCode(Handle<JSFunction> function) {
1836 return GetCode(Code::FAST, function_name);
