Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
33 #include "code-stubs.h"
60 Code* StubCache::Set(Name* name, Map* map, Code* code) {
61 // Get the flags from the code.
62 Code::Flags flags = Code::RemoveTypeFromFlags(code->flags());
73 ASSERT(Code::ExtractICStateFromFlags(flags) == MONOMORPHIC);
74 STATIC_ASSERT((Code::ICStateField::kMask & 1) == 1);
76 // Make sure that the code type is not included in the hash.
77 ASSERT(Code::ExtractTypeFromFlags(flags) == 0);
82 Code* old_code = primary->value;
88 Code::Flags old_flags = Code::RemoveTypeFromFlags(old_code->flags());
97 primary->value = code;
100 return code;
113 Handle<Code> StubCache::FindIC(Handle<Name> name,
115 Code::Kind kind,
116 Code::StubType type,
117 Code::ExtraICState extra_state) {
118 Code::Flags flags = Code::ComputeMonomorphicFlags(kind, extra_state, type);
121 if (probe->IsCode()) return Handle<Code>::cast(probe);
122 return Handle<Code>::null();
126 Handle<Code> StubCache::FindIC(Handle<Name> name,
128 Code::Kind kind,
129 Code::StubType type,
130 Code::ExtraICState extra_ic_state) {
136 Handle<Code> StubCache::FindLoadHandler(Handle<Name> name,
139 Code::Kind kind,
140 Code::StubType type) {
141 Code::ExtraICState extra_ic_state = Code::ComputeExtraICState(
142 receiver.is_identical_to(stub_holder) ? Code::OWN_STUB
143 : Code::PROTOTYPE_STUB);
144 ASSERT(type != Code::NORMAL);
145 Code::Flags flags = Code::ComputeMonomorphicFlags(
146 Code::STUB, extra_ic_state, type, kind);
149 if (probe->IsCode()) return Handle<Code>::cast(probe);
150 return Handle<Code>::null();
154 Handle<Code> StubCache::FindStoreHandler(Handle<Name> name,
156 Code::Kind kind,
157 Code::StubType type,
159 Code::ExtraICState extra_ic_state = Code::ComputeExtraICState(
161 ASSERT(type != Code::NORMAL);
162 Code::Flags flags = Code::ComputeMonomorphicFlags(
163 Code::STUB, extra_ic_state, type, kind);
166 if (probe->IsCode()) return Handle<Code>::cast(probe);
167 return Handle<Code>::null();
171 Handle<Code> StubCache::ComputeMonomorphicLoadIC(Handle<JSObject> receiver,
172 Handle<Code> handler,
174 Handle<Code> ic = FindIC(name, receiver, Code::LOAD_IC, handler->type());
186 Handle<Code> StubCache::ComputeMonomorphicKeyedLoadIC(Handle<JSObject> receiver,
187 Handle<Code> handler,
189 Handle<Code> ic = FindIC(
190 name, receiver, Code::KEYED_LOAD_IC, handler->type());
202 Handle<Code> StubCache::ComputeMonomorphicStoreIC(Handle<JSObject> receiver,
203 Handle<Code> handler,
206 Handle<Code> ic = FindIC(
207 name, receiver, Code::STORE_IC, handler->type(), strict_mode);
219 Handle<Code> StubCache::ComputeMonomorphicKeyedStoreIC(
221 Handle<Code> handler,
224 Handle<Code> ic = FindIC(
225 name, receiver, Code::KEYED_STORE_IC, handler->type(), strict_mode);
237 Handle<Code> StubCache::ComputeLoadNonexistent(Handle<Name> name,
262 Handle<Code> handler = FindLoadHandler(
263 cache_name, receiver, receiver, Code::LOAD_IC, Code::NONEXISTENT);
274 Handle<Code> StubCache::ComputeLoadField(Handle<Name> name,
287 Handle<Code> stub = FindLoadHandler(
288 name, receiver, stub_holder, Code::LOAD_IC, Code::FIELD);
292 Handle<Code> handler =
299 Handle<Code> StubCache::ComputeLoadCallback(
306 Handle<Code> stub = FindLoadHandler(
307 name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS);
311 Handle<Code> handler =
318 Handle<Code> StubCache::ComputeLoadViaGetter(Handle<Name> name,
323 Handle<Code> stub = FindLoadHandler(
324 name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS);
328 Handle<Code> handler =
335 Handle<Code> StubCache::ComputeLoadConstant(Handle<Name> name,
340 Handle<Code> handler = FindLoadHandler(
341 name, receiver, stub_holder, Code::LOAD_IC, Code::CONSTANT);
352 Handle<Code> StubCache::ComputeLoadInterceptor(Handle<Name> name,
356 Handle<Code> stub = FindLoadHandler(
357 name, receiver, stub_holder, Code::LOAD_IC, Code::INTERCEPTOR);
361 Handle<Code> handler =
368 Handle<Code> StubCache::ComputeLoadNormal(Handle<Name> name,
374 Handle<Code> StubCache::ComputeLoadGlobal(Handle<Name> name,
380 Handle<Code> stub = FindIC(name, stub_holder, Code::LOAD_IC, Code::NORMAL);
384 Handle<Code> ic =
391 Handle<Code> StubCache::ComputeKeyedLoadField(Handle<Name> name,
405 Handle<Code> stub = FindLoadHandler(
406 name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::FIELD);
410 Handle<Code> handler =
417 Handle<Code> StubCache::ComputeKeyedLoadConstant(Handle<Name> name,
422 Handle<Code> handler = FindLoadHandler(
423 name, receiver, stub_holder, Code::KEYED_LOAD_IC,
424 Code::CONSTANT);
434 Handle<Code> StubCache::ComputeKeyedLoadInterceptor(Handle<Name> name,
438 Handle<Code> stub = FindLoadHandler(
439 name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::INTERCEPTOR);
443 Handle<Code> handler =
450 Handle<Code> StubCache::ComputeKeyedLoadCallback(
456 Handle<Code> stub = FindLoadHandler(
457 name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS);
461 Handle<Code> handler =
468 Handle<Code> StubCache::ComputeStoreField(Handle<Name> name,
472 Handle<Code> stub = FindStoreHandler(
473 name, receiver, Code::STORE_IC, Code::FIELD, strict_mode);
477 Handle<Code> handler = compiler.CompileStoreField(receiver, lookup, name);
483 Handle<Code> StubCache::ComputeStoreTransition(Handle<Name> name,
488 Handle<Code> stub = FindStoreHandler(
489 name, receiver, Code::STORE_IC, Code::MAP_TRANSITION, strict_mode);
493 Handle<Code> handler =
500 Handle<Code> StubCache::ComputeKeyedLoadElement(Handle<Map> receiver_map) {
501 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
506 if (probe->IsCode()) return Handle<Code>::cast(probe);
509 Handle<Code> code = compiler.CompileLoadElement(receiver_map);
511 Map::UpdateCodeCache(receiver_map, name, code);
512 return code;
516 Handle<Code> StubCache::ComputeKeyedStoreElement(
520 Code::ExtraICState extra_state =
521 Code::ComputeExtraICState(store_mode, strict_mode);
522 Code::Flags flags = Code::ComputeMonomorphicFlags(
523 Code::KEYED_STORE_IC, extra_state);
533 if (probe->IsCode()) return Handle<Code>::cast(probe);
536 Handle<Code> code = compiler.CompileStoreElement(receiver_map);
538 Map::UpdateCodeCache(receiver_map, name, code);
539 ASSERT(Code::GetKeyedAccessStoreMode(code->extra_ic_state()) == store_mode);
540 return code;
544 Handle<Code> StubCache::ComputeStoreNormal(StrictModeFlag strict_mode) {
551 Handle<Code> StubCache::ComputeStoreGlobal(Handle<Name> name,
561 Handle<Code> code = FindIC(
563 Code::STORE_IC, Code::NORMAL, stub.GetExtraICState());
564 if (!code.is_null()) return code;
570 code = stub.GetCodeCopyFromTemplate(isolate_);
571 code->ReplaceNthObject(1, *meta_map, *receiver_map);
573 code->ReplaceNthObject(1, *cell_map, *cell);
575 JSObject::UpdateMapCodeCache(receiver, name, code);
577 return code;
581 Handle<Code> StubCache::ComputeStoreCallback(
588 Handle<Code> stub = FindStoreHandler(
589 name, receiver, Code::STORE_IC, Code::CALLBACKS, strict_mode);
593 Handle<Code> handler = compiler.CompileStoreCallback(
600 Handle<Code> StubCache::ComputeStoreViaSetter(Handle<Name> name,
605 Handle<Code> stub = FindStoreHandler(
606 name, receiver, Code::STORE_IC, Code::CALLBACKS, strict_mode);
610 Handle<Code> handler = compiler.CompileStoreViaSetter(
617 Handle<Code> StubCache::ComputeStoreInterceptor(Handle<Name> name,
620 Handle<Code> stub = FindStoreHandler(
621 name, receiver, Code::STORE_IC, Code::INTERCEPTOR, strict_mode);
625 Handle<Code> handler = compiler.CompileStoreInterceptor(receiver, name);
631 Handle<Code> StubCache::ComputeKeyedStoreField(Handle<Name> name,
635 Handle<Code> stub = FindStoreHandler(
636 name, receiver, Code::KEYED_STORE_IC, Code::FIELD, strict_mode);
640 Handle<Code> handler = compiler.CompileStoreField(receiver, lookup, name);
646 Handle<Code> StubCache::ComputeKeyedStoreTransition(
652 Handle<Code> stub = FindStoreHandler(
653 name, receiver, Code::KEYED_STORE_IC, Code::MAP_TRANSITION, strict_mode);
657 Handle<Code> handler =
665 (kind == Code::CALL_IC ? Logger::type : Logger::KEYED_##type)
667 Handle<Code> StubCache::ComputeCallConstant(int argc,
668 Code::Kind kind,
669 Code::ExtraICState extra_state,
697 return Handle<Code>::null();
700 Code::Flags flags = Code::ComputeMonomorphicFlags(
701 kind, extra_state, Code::CONSTANT, argc, cache_holder);
704 if (probe->IsCode()) return Handle<Code>::cast(probe);
707 Handle<Code> code =
709 code->set_check_type(check);
710 ASSERT(flags == code->flags());
712 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
713 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
716 JSObject::UpdateMapCodeCache(stub_holder, name, code);
718 return code;
722 Handle<Code> StubCache::ComputeCallField(int argc,
723 Code::Kind kind,
724 Code::ExtraICState extra_state,
743 Code::Flags flags = Code::ComputeMonomorphicFlags(
744 kind, extra_state, Code::FIELD, argc, cache_holder);
747 if (probe->IsCode()) return Handle<Code>::cast(probe);
750 Handle<Code> code =
753 ASSERT(flags == code->flags());
755 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
756 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
757 JSObject::UpdateMapCodeCache(stub_holder, name, code);
758 return code;
762 Handle<Code> StubCache::ComputeCallInterceptor(int argc,
763 Code::Kind kind,
764 Code::ExtraICState extra_state,
782 Code::Flags flags = Code::ComputeMonomorphicFlags(
783 kind, extra_state, Code::INTERCEPTOR, argc, cache_holder);
786 if (probe->IsCode()) return Handle<Code>::cast(probe);
789 Handle<Code> code =
792 ASSERT(flags == code->flags());
794 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
795 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
796 JSObject::UpdateMapCodeCache(stub_holder, name, code);
797 return code;
801 Handle<Code> StubCache::ComputeCallGlobal(int argc,
802 Code::Kind kind,
803 Code::ExtraICState extra_state,
813 Code::Flags flags = Code::ComputeMonomorphicFlags(
814 kind, extra_state, Code::NORMAL, argc, cache_holder);
817 if (probe->IsCode()) return Handle<Code>::cast(probe);
820 Handle<Code> code =
822 ASSERT(flags == code->flags());
824 code, *name));
825 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
827 JSObject::UpdateMapCodeCache(stub_holder, name, code);
829 return code;
833 static void FillCache(Isolate* isolate, Handle<Code> code) {
836 code->flags(),
837 code);
842 Code* StubCache::FindCallInitialize(int argc,
844 Code::Kind kind) {
845 Code::ExtraICState extra_state =
848 Code::Flags flags =
849 Code::ComputeFlags(kind, UNINITIALIZED, extra_state, Code::NORMAL, argc);
854 Object* code = dictionary->ValueAt(entry);
857 return reinterpret_cast<Code*>(code);
861 Handle<Code> StubCache::ComputeCallInitialize(int argc,
863 Code::Kind kind) {
864 Code::ExtraICState extra_state =
867 Code::Flags flags =
868 Code::ComputeFlags(kind, UNINITIALIZED, extra_state, Code::NORMAL, argc);
872 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
875 Handle<Code> code = compiler.CompileCallInitialize(flags);
876 FillCache(isolate_, code);
877 return code;
881 Handle<Code> StubCache::ComputeCallInitialize(int argc, RelocInfo::Mode mode) {
882 return ComputeCallInitialize(argc, mode, Code::CALL_IC);
886 Handle<Code> StubCache::ComputeKeyedCallInitialize(int argc) {
888 Code::KEYED_CALL_IC);
892 Handle<Code> StubCache::ComputeCallPreMonomorphic(
894 Code::Kind kind,
895 Code::ExtraICState extra_state) {
896 Code::Flags flags =
897 Code::ComputeFlags(kind, PREMONOMORPHIC, extra_state, Code::NORMAL, argc);
901 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
904 Handle<Code> code = compiler.CompileCallPreMonomorphic(flags);
905 FillCache(isolate_, code);
906 return code;
910 Handle<Code> StubCache::ComputeCallNormal(int argc,
911 Code::Kind kind,
912 Code::ExtraICState extra_state) {
913 Code::Flags flags =
914 Code::ComputeFlags(kind, MONOMORPHIC, extra_state, Code::NORMAL, argc);
918 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
921 Handle<Code> code = compiler.CompileCallNormal(flags);
922 FillCache(isolate_, code);
923 return code;
927 Handle<Code> StubCache::ComputeCallArguments(int argc) {
928 Code::Flags flags =
929 Code::ComputeFlags(Code::KEYED_CALL_IC, MEGAMORPHIC,
930 Code::kNoExtraICState, Code::NORMAL, argc);
934 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
937 Handle<Code> code = compiler.CompileCallArguments(flags);
938 FillCache(isolate_, code);
939 return code;
943 Handle<Code> StubCache::ComputeCallMegamorphic(
945 Code::Kind kind,
946 Code::ExtraICState extra_state) {
947 Code::Flags flags =
948 Code::ComputeFlags(kind, MEGAMORPHIC, extra_state,
949 Code::NORMAL, argc);
953 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
956 Handle<Code> code = compiler.CompileCallMegamorphic(flags);
957 FillCache(isolate_, code);
958 return code;
962 Handle<Code> StubCache::ComputeCallMiss(int argc,
963 Code::Kind kind,
964 Code::ExtraICState extra_state) {
967 Code::Flags flags =
968 Code::ComputeFlags(kind, MONOMORPHIC_PROTOTYPE_FAILURE, extra_state,
969 Code::NORMAL, argc, OWN_MAP);
973 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
976 Handle<Code> code = compiler.CompileCallMiss(flags);
977 FillCache(isolate_, code);
978 return code;
982 Handle<Code> StubCache::ComputeCompareNil(Handle<Map> receiver_map,
986 Handle<Code> cached_ic = FindIC(name, receiver_map, Code::COMPARE_NIL_IC,
987 Code::NORMAL, stub.GetExtraICState());
991 Handle<Code> ic = stub.GetCodeCopyFromTemplate(isolate_);
1002 Handle<Code> StubCache::ComputeLoadElementPolymorphic(
1004 Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);
1008 if (probe->IsCode()) return Handle<Code>::cast(probe);
1013 Handle<Code> code = compiler.CompilePolymorphicIC(
1015 Code::NORMAL, ELEMENT);
1019 PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
1020 return code;
1024 Handle<Code> StubCache::ComputePolymorphicLoadIC(MapHandleList* receiver_maps,
1029 Code::StubType type = number_of_valid_maps == 1 ? handlers->at(0)->type()
1030 : Code::NORMAL;
1031 Handle<Code> ic = ic_compiler.CompilePolymorphicIC(
1037 Handle<Code> StubCache::ComputePolymorphicStoreIC(MapHandleList* receiver_maps,
1043 Code::StubType type = number_of_valid_maps == 1 ? handlers->at(0)->type()
1044 : Code::NORMAL;
1045 Handle<Code> ic = ic_compiler.CompilePolymorphicIC(
1051 Handle<Code> StubCache::ComputeStoreElementPolymorphic(
1061 Code::ExtraICState extra_state = Code::ComputeExtraICState(store_mode,
1063 Code::Flags flags =
1064 Code::ComputeFlags(Code::KEYED_STORE_IC, POLYMORPHIC, extra_state);
1066 if (probe->IsCode()) return Handle<Code>::cast(probe);
1069 Handle<Code> code = compiler.CompileStoreElementPolymorphic(receiver_maps);
1070 PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
1071 return code;
1076 Handle<Code> StubCache::ComputeCallDebugBreak(int argc,
1077 Code::Kind kind) {
1080 Code::Flags flags =
1081 Code::ComputeFlags(kind, DEBUG_STUB, DEBUG_BREAK,
1082 Code::NORMAL, argc);
1086 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
1089 Handle<Code> code = compiler.CompileCallDebugBreak(flags);
1090 FillCache(isolate_, code);
1091 return code;
1095 Handle<Code> StubCache::ComputeCallDebugPrepareStepIn(int argc,
1096 Code::Kind kind) {
1099 Code::Flags flags =
1100 Code::ComputeFlags(kind, DEBUG_STUB, DEBUG_PREPARE_STEP_IN,
1101 Code::NORMAL, argc);
1105 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
1108 Handle<Code> code = compiler.CompileCallDebugPrepareStepIn(flags);
1109 FillCache(isolate_, code);
1110 return code;
1116 Code* empty = isolate_->builtins()->builtin(Builtins::kIllegal);
1132 Code::Flags flags,
1376 Handle<Code> StubCompiler::CompileCallInitialize(Code::Flags flags) {
1377 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1378 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1379 Code::ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1380 if (kind == Code::CALL_IC) {
1385 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallInitialize");
1389 *code, code->arguments_count()));
1390 GDBJIT(AddCode(GDBJITInterface::CALL_INITIALIZE, *code));
1391 return code;
1395 Handle<Code> StubCompiler::CompileCallPreMonomorphic(Code::Flags flags) {
1396 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1397 // The code of the PreMonomorphic stub is the same as the code
1398 // of the Initialized stub. They just differ on the code object flags.
1399 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1400 Code::ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1401 if (kind == Code::CALL_IC) {
1406 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallPreMonomorphic");
1410 *code, code->arguments_count()));
1411 GDBJIT(AddCode(GDBJITInterface::CALL_PRE_MONOMORPHIC, *code));
1412 return code;
1416 Handle<Code> StubCompiler::CompileCallNormal(Code::Flags flags) {
1417 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1418 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1419 if (kind == Code::CALL_IC) {
1422 Code::ExtractExtraICStateFromFlags(flags)));
1427 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallNormal");
1431 *code, code->arguments_count()));
1432 GDBJIT(AddCode(GDBJITInterface::CALL_NORMAL, *code));
1433 return code;
1437 Handle<Code> StubCompiler::CompileCallMegamorphic(Code::Flags flags) {
1438 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1439 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1440 Code::ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1441 if (kind == Code::CALL_IC) {
1446 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallMegamorphic");
1450 *code, code->arguments_count()));
1451 GDBJIT(AddCode(GDBJITInterface::CALL_MEGAMORPHIC, *code));
1452 return code;
1456 Handle<Code> StubCompiler::CompileCallArguments(Code::Flags flags) {
1457 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1459 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallArguments");
1461 CodeCreateEvent(CALL_LOGGER_TAG(Code::ExtractKindFromFlags(flags),
1463 *code, code->arguments_count()));
1464 GDBJIT(AddCode(GDBJITInterface::CALL_MEGAMORPHIC, *code));
1465 return code;
1469 Handle<Code> StubCompiler::CompileCallMiss(Code::Flags flags) {
1470 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1471 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1472 Code::ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1473 if (kind == Code::CALL_IC) {
1478 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallMiss");
1482 *code, code->arguments_count()));
1483 GDBJIT(AddCode(GDBJITInterface::CALL_MISS, *code));
1484 return code;
1489 Handle<Code> StubCompiler::CompileCallDebugBreak(Code::Flags flags) {
1491 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallDebugBreak");
1493 CodeCreateEvent(CALL_LOGGER_TAG(Code::ExtractKindFromFlags(flags),
1495 *code, code->arguments_count()));
1496 return code;
1500 Handle<Code> StubCompiler::CompileCallDebugPrepareStepIn(Code::Flags flags) {
1501 // Use the same code for the the step in preparations as we do for the
1503 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1504 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1505 if (kind == Code::CALL_IC) {
1507 CallIC::GenerateMiss(masm(), argc, Code::kNoExtraICState);
1511 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallDebugPrepareStepIn");
1515 *code,
1516 code->arguments_count()));
1517 return code;
1524 Handle<Code> StubCompiler::GetCodeWithFlags(Code::Flags flags,
1526 // Create code object in the heap.
1529 Handle<Code> code = factory()->NewCode(desc, flags, masm_.CodeObject());
1531 if (FLAG_print_code_stubs) code->Disassemble(name);
1533 return code;
1537 Handle<Code> StubCompiler::GetCodeWithFlags(Code::Flags flags,
1598 Handle<Code> BaseLoadStubCompiler::CompileLoadField(
1613 // Return the generated code.
1614 return GetCode(kind(), Code::FIELD, name);
1618 Handle<Code> BaseLoadStubCompiler::CompileLoadConstant(
1628 // Return the generated code.
1629 return GetCode(kind(), Code::CONSTANT, name);
1633 Handle<Code> BaseLoadStubCompiler::CompileLoadCallback(
1645 // Return the generated code.
1646 return GetCode(kind(), Code::CALLBACKS, name);
1650 Handle<Code> BaseLoadStubCompiler::CompileLoadInterceptor(
1665 // Return the generated code.
1666 return GetCode(kind(), Code::INTERCEPTOR, name);
1707 Handle<Code> BaseLoadStoreStubCompiler::CompileMonomorphicIC(
1709 Handle<Code> handler,
1715 Code::StubType type = handler->type();
1720 Handle<Code> LoadStubCompiler::CompileLoadViaGetter(
1731 // Return the generated code.
1732 return GetCode(kind(), Code::CALLBACKS, name);
1736 Handle<Code> BaseStoreStubCompiler::CompileStoreTransition(
1788 // Return the generated code.
1789 return GetCode(kind(), Code::MAP_TRANSITION, name);
1793 Handle<Code> BaseStoreStubCompiler::CompileStoreField(Handle<JSObject> object,
1800 // Generate store field code.
1811 // Return the generated code.
1812 return GetCode(kind(), Code::FIELD, name);
1816 Handle<Code> StoreStubCompiler::CompileStoreViaSetter(
1827 return GetCode(kind(), Code::CALLBACKS, name);
1831 Handle<Code> KeyedLoadStubCompiler::CompileLoadElement(
1836 Handle<Code> stub = KeyedLoadFastElementStub(
1841 Handle<Code> stub =
1848 // Return the generated code.
1849 return GetICCode(kind(), Code::NORMAL, factory()->empty_string());
1853 Handle<Code> KeyedStoreStubCompiler::CompileStoreElement(
1857 Handle<Code> stub;
1875 // Return the generated code.
1876 return GetICCode(kind(), Code::NORMAL, factory()->empty_string());
1884 Handle<Code> code(masm->isolate()->builtins()->builtin(name));
1885 GenerateTailCall(masm, code);
1889 void LoadStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
1890 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
1894 void KeyedLoadStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
1895 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
1899 void StoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
1900 GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
1904 void KeyedStoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
1905 GDBJIT(AddCode(GDBJITInterface::KEYED_STORE_IC, *name, *code));
1909 Handle<Code> BaseLoadStoreStubCompiler::GetICCode(Code::Kind kind,
1910 Code::StubType type,
1913 Code::Flags flags = Code::ComputeFlags(
1915 Handle<Code> code = GetCodeWithFlags(flags, name);
1916 PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
1917 JitEvent(name, code);
1918 return code;
1922 Handle<Code> BaseLoadStubCompiler::GetCode(Code::Kind kind,
1923 Code::StubType type,
1925 ASSERT(type != Code::NORMAL);
1926 Code::Flags flags = Code::ComputeFlags(
1927 Code::STUB, MONOMORPHIC, Code::kNoExtraICState, type, kind);
1928 Handle<Code> code = GetCodeWithFlags(flags, name);
1929 PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
1930 JitEvent(name, code);
1931 return code;
1935 Handle<Code> BaseStoreStubCompiler::GetCode(Code::Kind kind,
1936 Code::StubType type,
1938 ASSERT(type != Code::NORMAL);
1939 Code::Flags flags = Code::ComputeFlags(
1940 Code::STUB, MONOMORPHIC, extra_state(), type, kind);
1941 Handle<Code> code = GetCodeWithFlags(flags, name);
1942 PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
1943 JitEvent(name, code);
1944 return code;
1952 Handle<Code> cached_stub;
1976 Handle<Code> KeyedStoreStubCompiler::CompileStoreElementPolymorphic(
1983 Handle<Code> cached_stub;
1987 // TODO(mvstanton): The code below is doing pessimistic elements
2019 Handle<Code> code =
2023 CodeCreateEvent(Logger::KEYED_STORE_POLYMORPHIC_IC_TAG, *code, 0));
2024 return code;
2036 Code::Kind kind,
2037 Code::ExtraICState extra_state,
2072 Handle<Code> CallStubCompiler::CompileCustomCall(
2078 Code::StubType type) {
2106 Handle<Code> CallStubCompiler::GetCode(Code::StubType type,
2109 Code::Flags flags = Code::ComputeMonomorphicFlags(kind_,
2118 Handle<Code> CallStubCompiler::GetCode(Handle<JSFunction> function) {
2123 return GetCode(Code::CONSTANT, function_name);
