Lines Matching defs:code
6 // * Redistributions of source code must retain the above copyright
61 Code* StubCache::Set(String* name, Map* map, Code* code) {
62 // Get the flags from the code.
63 Code::Flags flags = Code::RemoveTypeFromFlags(code->flags());
74 ASSERT(Code::ExtractICStateFromFlags(flags) == MONOMORPHIC);
75 ASSERT(Code::kFlagsICStateShift == 0);
77 // Make sure that the code type is not included in the hash.
78 ASSERT(Code::ExtractTypeFromFlags(flags) == 0);
83 Code* hit = primary->value;
88 Code::Flags primary_flags = Code::RemoveTypeFromFlags(hit->flags());
97 primary->value = code;
98 return code;
120 Code::Flags flags =
121 Code::ComputeMonomorphicFlags(Code::LOAD_IC, NONEXISTENT);
122 Object* code = receiver->map()->FindInCodeCache(cache_name, flags);
123 if (code->IsUndefined()) {
127 if (!maybe_code->ToObject(&code)) return maybe_code;
130 CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), cache_name));
131 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, cache_name, Code::cast(code)));
134 receiver->UpdateMapCodeCache(cache_name, Code::cast(code));
138 return code;
147 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, FIELD);
148 Object* code = receiver->map()->FindInCodeCache(name, flags);
149 if (code->IsUndefined()) {
153 if (!maybe_code->ToObject(&code)) return maybe_code;
156 CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
157 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
160 receiver->UpdateMapCodeCache(name, Code::cast(code));
164 return code;
174 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, CALLBACKS);
175 Object* code = receiver->map()->FindInCodeCache(name, flags);
176 if (code->IsUndefined()) {
180 if (!maybe_code->ToObject(&code)) return maybe_code;
183 CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
184 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
187 receiver->UpdateMapCodeCache(name, Code::cast(code));
191 return code;
200 Code::Flags flags =
201 Code::ComputeMonomorphicFlags(Code::LOAD_IC, CONSTANT_FUNCTION);
202 Object* code = receiver->map()->FindInCodeCache(name, flags);
203 if (code->IsUndefined()) {
207 if (!maybe_code->ToObject(&code)) return maybe_code;
210 CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
211 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
214 receiver->UpdateMapCodeCache(name, Code::cast(code));
218 return code;
226 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, INTERCEPTOR);
227 Object* code = receiver->map()->FindInCodeCache(name, flags);
228 if (code->IsUndefined()) {
232 if (!maybe_code->ToObject(&code)) return maybe_code;
235 CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
236 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
239 receiver->UpdateMapCodeCache(name, Code::cast(code));
243 return code;
258 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, NORMAL);
259 Object* code = receiver->map()->FindInCodeCache(name, flags);
260 if (code->IsUndefined()) {
267 if (!maybe_code->ToObject(&code)) return maybe_code;
270 CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
271 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
274 receiver->UpdateMapCodeCache(name, Code::cast(code));
278 return code;
287 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, FIELD);
288 Object* code = receiver->map()->FindInCodeCache(name, flags);
289 if (code->IsUndefined()) {
293 if (!maybe_code->ToObject(&code)) return maybe_code;
296 CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
297 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, name, Code::cast(code)));
300 receiver->UpdateMapCodeCache(name, Code::cast(code));
304 return code;
313 Code::Flags flags =
314 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CONSTANT_FUNCTION);
315 Object* code = receiver->map()->FindInCodeCache(name, flags);
316 if (code->IsUndefined()) {
320 if (!maybe_code->ToObject(&code)) return maybe_code;
323 CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
324 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, name, Code::cast(code)));
327 receiver->UpdateMapCodeCache(name, Code::cast(code));
331 return code;
339 Code::Flags flags =
340 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, INTERCEPTOR);
341 Object* code = receiver->map()->FindInCodeCache(name, flags);
342 if (code->IsUndefined()) {
346 if (!maybe_code->ToObject(&code)) return maybe_code;
349 CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
350 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, name, Code::cast(code)));
353 receiver->UpdateMapCodeCache(name, Code::cast(code));
357 return code;
366 Code::Flags flags =
367 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
368 Object* code = receiver->map()->FindInCodeCache(name, flags);
369 if (code->IsUndefined()) {
373 if (!maybe_code->ToObject(&code)) return maybe_code;
376 CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
377 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, name, Code::cast(code)));
380 receiver->UpdateMapCodeCache(name, Code::cast(code));
384 return code;
391 Code::Flags flags =
392 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
394 Object* code = receiver->map()->FindInCodeCache(name, flags);
395 if (code->IsUndefined()) {
398 if (!maybe_code->ToObject(&code)) return maybe_code;
401 CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Codecode), name));
402 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, name, Code::cast(code)));
405 receiver->UpdateMapCodeCache(name, Code::cast(code));
409 return code;
415 Code::Flags flags =
416 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
418 Object* code = map->FindInCodeCache(name, flags);
419 if (code->IsUndefined()) {
422 if (!maybe_code->ToObject(&code)) return maybe_code;
425 CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
426 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, name, Code::cast(code)));
428 { MaybeObject* maybe_result = map->UpdateCodeCache(name, Code::cast(code));
432 return code;
439 Code::Flags flags =
440 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
441 Object* code = receiver->map()->FindInCodeCache(name, flags);
442 if (code->IsUndefined()) {
445 if (!maybe_code->ToObject(&code)) return maybe_code;
448 CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
449 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, name, Code::cast(code)));
452 receiver->UpdateMapCodeCache(name, Code::cast(code));
456 return code;
467 Code::Flags flags =
468 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, NORMAL);
470 Object* code = receiver->map()->FindInCodeCache(name, flags);
471 if (code->IsUndefined()) {
474 if (!maybe_code->ToObject(&code)) return maybe_code;
477 CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), 0));
480 receiver->UpdateMapCodeCache(name, Code::cast(code));
484 return code;
494 Code::Flags flags = Code::ComputeMonomorphicFlags(
495 Code::STORE_IC, type, strict_mode);
496 Object* code = receiver->map()->FindInCodeCache(name, flags);
497 if (code->IsUndefined()) {
501 if (!maybe_code->ToObject(&code)) return maybe_code;
504 CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
505 GDBJIT(AddCode(GDBJITInterface::STORE_IC, name, Code::cast(code)));
508 receiver->UpdateMapCodeCache(name, Code::cast(code));
512 return code;
519 Code::Flags flags =
520 Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, NORMAL, strict_mode);
522 Object* code = receiver->map()->FindInCodeCache(name, flags);
523 if (code->IsUndefined()) {
526 if (!maybe_code->ToObject(&code)) return maybe_code;
529 CodeCreateEvent(Logger::KEYED_STORE_IC_TAG, Code::cast(code), 0));
532 receiver->UpdateMapCodeCache(name, Code::cast(code));
536 return code;
623 Code::Flags flags =
624 Code::ComputeMonomorphicFlags(
625 is_store ? Code::KEYED_EXTERNAL_ARRAY_STORE_IC :
626 Code::KEYED_EXTERNAL_ARRAY_LOAD_IC,
632 Object* code = receiver->map()->FindInCodeCache(name, flags);
633 if (code->IsUndefined()) {
639 if (!maybe_code->ToObject(&code)) return maybe_code;
641 Code::cast(code)->set_external_array_type(array_type);
645 Code::cast(code), 0));
649 Code::cast(code), 0));
653 receiver->UpdateMapCodeCache(name, Code::cast(code));
657 return code;
672 Code::Flags flags = Code::ComputeMonomorphicFlags(
673 Code::STORE_IC, NORMAL, strict_mode);
674 Object* code = receiver->map()->FindInCodeCache(name, flags);
675 if (code->IsUndefined()) {
679 if (!maybe_code->ToObject(&code)) return maybe_code;
682 CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
683 GDBJIT(AddCode(GDBJITInterface::STORE_IC, name, Code::cast(code)));
686 receiver->UpdateMapCodeCache(name, Code::cast(code));
690 return code;
700 Code::Flags flags = Code::ComputeMonomorphicFlags(
701 Code::STORE_IC, CALLBACKS, strict_mode);
702 Object* code = receiver->map()->FindInCodeCache(name, flags);
703 if (code->IsUndefined()) {
707 if (!maybe_code->ToObject(&code)) return maybe_code;
710 CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
711 GDBJIT(AddCode(GDBJITInterface::STORE_IC, name, Code::cast(code)));
714 receiver->UpdateMapCodeCache(name, Code::cast(code));
718 return code;
726 Code::Flags flags = Code::ComputeMonomorphicFlags(
727 Code::STORE_IC, INTERCEPTOR, strict_mode);
728 Object* code = receiver->map()->FindInCodeCache(name, flags);
729 if (code->IsUndefined()) {
733 if (!maybe_code->ToObject(&code)) return maybe_code;
736 CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
737 GDBJIT(AddCode(GDBJITInterface::STORE_IC, name, Code::cast(code)));
740 receiver->UpdateMapCodeCache(name, Code::cast(code));
744 return code;
754 Code::Flags flags = Code::ComputeMonomorphicFlags(
755 Code::KEYED_STORE_IC, type, strict_mode);
756 Object* code = receiver->map()->FindInCodeCache(name, flags);
757 if (code->IsUndefined()) {
761 if (!maybe_code->ToObject(&code)) return maybe_code;
765 Code::cast(code), name));
766 GDBJIT(AddCode(GDBJITInterface::KEYED_STORE_IC, name, Code::cast(code)));
769 receiver->UpdateMapCodeCache(name, Code::cast(code));
773 return code;
777 (kind == Code::CALL_IC ? Logger::type : Logger::KEYED_##type)
781 Code::Kind kind,
782 Code::ExtraICState extra_ic_state,
802 Code::Flags flags = Code::ComputeMonomorphicFlags(kind,
808 Object* code = map_holder->map()->FindInCodeCache(name, flags);
809 if (code->IsUndefined()) {
820 if (!maybe_code->ToObject(&code)) return maybe_code;
822 Code::cast(code)->set_check_type(check);
823 Code::cast(code)->flags());
826 Code::cast(code), name));
827 GDBJIT(AddCode(GDBJITInterface::CALL_IC, name, Code::cast(code)));
830 map_holder->UpdateMapCodeCache(name, Code::cast(code));
834 return code;
840 Code::Kind kind,
857 Code::Flags flags = Code::ComputeMonomorphicFlags(kind,
859 Code::kNoExtraICState,
863 Object* code = map_holder->map()->FindInCodeCache(name, flags);
864 if (code->IsUndefined()) {
866 argc, in_loop, kind, Code::kNoExtraICState, cache_holder);
872 if (!maybe_code->ToObject(&code)) return maybe_code;
874 ASSERT_EQ(flags, Code::cast(code)->flags());
877 Code::cast(code), name));
878 GDBJIT(AddCode(GDBJITInterface::CALL_IC, name, Code::cast(code)));
881 map_holder->UpdateMapCodeCache(name, Code::cast(code));
885 return code;
890 Code::Kind kind,
906 Code::Flags flags = Code::ComputeMonomorphicFlags(kind,
908 Code::kNoExtraICState,
912 Object* code = map_holder->map()->FindInCodeCache(name, flags);
913 if (code->IsUndefined()) {
915 argc, NOT_IN_LOOP, kind, Code::kNoExtraICState, cache_holder);
918 if (!maybe_code->ToObject(&code)) return maybe_code;
920 ASSERT_EQ(flags, Code::cast(code)->flags());
923 Code::cast(code), name));
924 GDBJIT(AddCode(GDBJITInterface::CALL_IC, name, Code::cast(code)));
927 map_holder->UpdateMapCodeCache(name, Code::cast(code));
931 return code;
937 Code::Kind kind,
940 Object* code;
942 if (!maybe_code->ToObject(&code)) return maybe_code;
944 return code;
950 Code::Kind kind,
959 Code::Flags flags = Code::ComputeMonomorphicFlags(kind,
961 Code::kNoExtraICState,
965 Object* code = map_holder->map()->FindInCodeCache(name, flags);
966 if (code->IsUndefined()) {
973 argc, in_loop, kind, Code::kNoExtraICState, cache_holder);
976 if (!maybe_code->ToObject(&code)) return maybe_code;
978 ASSERT_EQ(flags, Code::cast(code)->flags());
981 Code::cast(code), name));
982 GDBJIT(AddCode(GDBJITInterface::CALL_IC, name, Code::cast(code)));
985 map_holder->UpdateMapCodeCache(name, Code::cast(code));
989 return code;
993 static Object* GetProbeValue(Isolate* isolate, Code::Flags flags) {
1004 Code::Flags flags) {
1009 // generated code object can always be inserted into the cache
1023 Object* code;
1024 if (maybe_code->ToObject(&code)) {
1025 if (code->IsCode()) {
1028 Code::cast(code)->flags());
1033 heap->non_monomorphic_cache()->ValueAtPut(entry, code);
1034 CHECK(GetProbeValue(isolate, Code::cast(code)->flags()) == code);
1041 Code* StubCache::FindCallInitialize(int argc,
1043 Code::Kind kind) {
1044 Code::Flags flags = Code::ComputeFlags(kind,
1047 Code::kNoExtraICState,
1054 return reinterpret_cast<Code*>(result);
1060 Code::Kind kind) {
1061 Code::Flags flags = Code::ComputeFlags(kind,
1064 Code::kNoExtraICState,
1077 Handle<Code> StubCache::ComputeCallInitialize(int argc, InLoopFlag in_loop) {
1082 // information, and the IC clearing code can't generate a stub
1087 ComputeCallInitialize(argc, in_loop, Code::CALL_IC), Code);
1091 Handle<Code> StubCache::ComputeKeyedCallInitialize(int argc,
1097 // information, and the IC clearing code can't generate a stub
1103 ComputeCallInitialize(argc, in_loop, Code::KEYED_CALL_IC), Code);
1109 Code::Kind kind) {
1110 Code::Flags flags = Code::ComputeFlags(kind,
1113 Code::kNoExtraICState,
1128 Code::Kind kind) {
1129 Code::Flags flags = Code::ComputeFlags(kind,
1132 Code::kNoExtraICState,
1147 Code::Kind kind) {
1148 Code::Flags flags = Code::ComputeFlags(kind,
1151 Code::kNoExtraICState,
1164 MaybeObject* StubCache::ComputeCallMiss(int argc, Code::Kind kind) {
1167 Code::Flags flags = Code::ComputeFlags(kind,
1170 Code::kNoExtraICState,
1185 MaybeObject* StubCache::ComputeCallDebugBreak(int argc, Code::Kind kind) {
1186 Code::Flags flags = Code::ComputeFlags(kind,
1189 Code::kNoExtraICState,
1203 Code::Kind kind) {
1204 Code::Flags flags = Code::ComputeFlags(kind,
1207 Code::kNoExtraICState,
1237 Code::Flags flags) {
1483 MaybeObject* StubCompiler::CompileCallInitialize(Code::Flags flags) {
1485 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1486 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1487 if (kind == Code::CALL_IC) {
1498 Code* code = Code::cast(result);
1499 USE(code);
1502 code, code->arguments_count()));
1503 GDBJIT(AddCode(GDBJITInterface::CALL_INITIALIZE, Code::cast(code)));
1508 MaybeObject* StubCompiler::CompileCallPreMonomorphic(Code::Flags flags) {
1510 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1511 // The code of the PreMonomorphic stub is the same as the code
1512 // of the Initialized stub. They just differ on the code object flags.
1513 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1514 if (kind == Code::CALL_IC) {
1525 Code* code = Code::cast(result);
1526 USE(code);
1529 code, code->arguments_count()));
1530 GDBJIT(AddCode(GDBJITInterface::CALL_PRE_MONOMORPHIC, Code::cast(code)));
1535 MaybeObject* StubCompiler::CompileCallNormal(Code::Flags flags) {
1537 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1538 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1539 if (kind == Code::CALL_IC) {
1549 Code* code = Code::cast(result);
1550 USE(code);
1553 code, code->arguments_count()));
1554 GDBJIT(AddCode(GDBJITInterface::CALL_NORMAL, Code::cast(code)));
1559 MaybeObject* StubCompiler::CompileCallMegamorphic(Code::Flags flags) {
1561 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1562 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1563 if (kind == Code::CALL_IC) {
1574 Code* code = Code::cast(result);
1575 USE(code);
1578 code, code->arguments_count()));
1579 GDBJIT(AddCode(GDBJITInterface::CALL_MEGAMORPHIC, Code::cast(code)));
1584 MaybeObject* StubCompiler::CompileCallMiss(Code::Flags flags) {
1586 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1587 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1588 if (kind == Code::CALL_IC) {
1598 Code* code = Code::cast(result);
1599 USE(code);
1602 code, code->arguments_count()));
1603 GDBJIT(AddCode(GDBJITInterface::CALL_MISS, Code::cast(code)));
1609 MaybeObject* StubCompiler::CompileCallDebugBreak(Code::Flags flags) {
1617 Code* code = Code::cast(result);
1618 USE(code);
1619 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1623 code, code->arguments_count()));
1628 MaybeObject* StubCompiler::CompileCallDebugPrepareStepIn(Code::Flags flags) {
1630 // Use the same code for the the step in preparations as we do for
1632 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1633 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1634 if (kind == Code::CALL_IC) {
1644 Code* code = Code::cast(result);
1645 USE(code);
1649 code,
1650 code->arguments_count()));
1657 MaybeObject* StubCompiler::GetCodeWithFlags(Code::Flags flags,
1662 // Create code object in the heap.
1668 Code::cast(result->ToObjectUnchecked())->Disassemble(name);
1675 MaybeObject* StubCompiler::GetCodeWithFlags(Code::Flags flags, String* name) {
1699 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, type);
1704 Code::cast(result->ToObjectUnchecked()),
1708 Code::cast(result->ToObjectUnchecked())));
1715 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, type);
1720 Code::cast(result->ToObjectUnchecked()),
1724 Code::cast(result->ToObjectUnchecked())));
1731 Code::Flags flags = Code::ComputeMonomorphicFlags(
1732 Code::STORE_IC, type, strict_mode_);
1737 Code::cast(result->ToObjectUnchecked()),
1741 Code::cast(result->ToObjectUnchecked())));
1748 Code::Flags flags = Code::ComputeMonomorphicFlags(
1749 Code::KEYED_STORE_IC, type, strict_mode_);
1754 Code::cast(result->ToObjectUnchecked()),
1758 Code::cast(result->ToObjectUnchecked())));
1766 Code::Kind kind,
1767 Code::ExtraICState extra_ic_state,
1827 Code::Flags flags = Code::ComputeMonomorphicFlags(kind_,
1847 Code::Flags flags = Code::ComputeFlags(Code::STUB);
1852 Code* code = Code::cast(result);
1853 USE(code);
1854 PROFILE(isolate(), CodeCreateEvent(Logger::STUB_TAG, code, "ConstructStub"));
1855 GDBJIT(AddCode(GDBJITInterface::STUB, "ConstructStub", Code::cast(code)));
1927 MaybeObject* ExternalArrayStubCompiler::GetCode(Code::Flags flags) {
1932 Code* code = Code::cast(result);
1933 USE(code);
1935 CodeCreateEvent(Logger::STUB_TAG, code, "ExternalArrayStub"));
