Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
33 #include "code-stubs.h"
58 Code* StubCache::Set(String* 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::ComputeLoadNonexistent(Handle<String> name,
120 Code::Flags flags =
121 Code::ComputeMonomorphicFlags(Code::LOAD_IC, NONEXISTENT);
123 if (probe->IsCode()) return Handle<Code>::cast(probe);
126 Handle<Code> code =
128 PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *cache_name));
129 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *cache_name, *code));
130 JSObject::UpdateMapCodeCache(receiver, cache_name, code);
131 return code;
135 Handle<Code> StubCache::ComputeLoadField(Handle<String> name,
140 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, FIELD);
142 if (probe->IsCode()) return Handle<Code>::cast(probe);
145 Handle<Code> code =
147 PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
148 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
149 JSObject::UpdateMapCodeCache(receiver, name, code);
150 return code;
154 Handle<Code> StubCache::ComputeLoadCallback(Handle<String> name,
160 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, CALLBACKS);
162 if (probe->IsCode()) return Handle<Code>::cast(probe);
165 Handle<Code> code =
167 PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
168 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
169 JSObject::UpdateMapCodeCache(receiver, name, code);
170 return code;
174 Handle<Code> StubCache::ComputeLoadConstant(Handle<String> name,
179 Code::Flags flags =
180 Code::ComputeMonomorphicFlags(Code::LOAD_IC, CONSTANT_FUNCTION);
182 if (probe->IsCode()) return Handle<Code>::cast(probe);
185 Handle<Code> code =
187 PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
188 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
189 JSObject::UpdateMapCodeCache(receiver, name, code);
190 return code;
194 Handle<Code> StubCache::ComputeLoadInterceptor(Handle<String> name,
198 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, INTERCEPTOR);
200 if (probe->IsCode()) return Handle<Code>::cast(probe);
203 Handle<Code> code =
205 PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
206 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
207 JSObject::UpdateMapCodeCache(receiver, name, code);
208 return code;
212 Handle<Code> StubCache::ComputeLoadNormal() {
217 Handle<Code> StubCache::ComputeLoadGlobal(Handle<String> name,
223 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, NORMAL);
225 if (probe->IsCode()) return Handle<Code>::cast(probe);
228 Handle<Code> code =
230 PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
231 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
232 JSObject::UpdateMapCodeCache(receiver, name, code);
233 return code;
237 Handle<Code> StubCache::ComputeKeyedLoadField(Handle<String> name,
242 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, FIELD);
244 if (probe->IsCode()) return Handle<Code>::cast(probe);
247 Handle<Code> code =
249 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
250 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
251 JSObject::UpdateMapCodeCache(receiver, name, code);
252 return code;
256 Handle<Code> StubCache::ComputeKeyedLoadConstant(Handle<String> name,
261 Code::Flags flags =
262 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CONSTANT_FUNCTION);
264 if (probe->IsCode()) return Handle<Code>::cast(probe);
267 Handle<Code> code =
269 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
270 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
271 JSObject::UpdateMapCodeCache(receiver, name, code);
272 return code;
276 Handle<Code> StubCache::ComputeKeyedLoadInterceptor(Handle<String> name,
280 Code::Flags flags =
281 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, INTERCEPTOR);
283 if (probe->IsCode()) return Handle<Code>::cast(probe);
286 Handle<Code> code = compiler.CompileLoadInterceptor(receiver, holder, name);
287 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
288 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
289 JSObject::UpdateMapCodeCache(receiver, name, code);
290 return code;
294 Handle<Code> StubCache::ComputeKeyedLoadCallback(
300 Code::Flags flags =
301 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
303 if (probe->IsCode()) return Handle<Code>::cast(probe);
306 Handle<Code> code =
308 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
309 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
310 JSObject::UpdateMapCodeCache(receiver, name, code);
311 return code;
315 Handle<Code> StubCache::ComputeKeyedLoadArrayLength(Handle<String> name,
317 Code::Flags flags =
318 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
320 if (probe->IsCode()) return Handle<Code>::cast(probe);
323 Handle<Code> code = compiler.CompileLoadArrayLength(name);
324 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
325 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
326 JSObject::UpdateMapCodeCache(receiver, name, code);
327 return code;
331 Handle<Code> StubCache::ComputeKeyedLoadStringLength(Handle<String> name,
333 Code::Flags flags =
334 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
337 if (probe->IsCode()) return Handle<Code>::cast(probe);
340 Handle<Code> code = compiler.CompileLoadStringLength(name);
341 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
342 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
343 Map::UpdateCodeCache(map, name, code);
344 return code;
348 Handle<Code> StubCache::ComputeKeyedLoadFunctionPrototype(
351 Code::Flags flags =
352 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
354 if (probe->IsCode()) return Handle<Code>::cast(probe);
357 Handle<Code> code = compiler.CompileLoadFunctionPrototype(name);
358 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
359 GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
360 JSObject::UpdateMapCodeCache(receiver, name, code);
361 return code;
365 Handle<Code> StubCache::ComputeStoreField(Handle<String> name,
371 Code::Flags flags = Code::ComputeMonomorphicFlags(
372 Code::STORE_IC, type, strict_mode);
374 if (probe->IsCode()) return Handle<Code>::cast(probe);
377 Handle<Code> code =
379 PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
380 GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
381 JSObject::UpdateMapCodeCache(receiver, name, code);
382 return code;
386 Handle<Code> StubCache::ComputeKeyedLoadOrStoreElement(
392 Code::ExtraICState extra_state =
393 Code::ComputeExtraICState(grow_mode, strict_mode);
394 Code::Flags flags =
395 Code::ComputeMonomorphicFlags(
396 stub_kind == KeyedIC::LOAD ? Code::KEYED_LOAD_IC
397 : Code::KEYED_STORE_IC,
417 if (probe->IsCode()) return Handle<Code>::cast(probe);
419 Handle<Code> code;
423 code = compiler.CompileLoadElement(receiver_map);
429 code = compiler.CompileStoreElement(receiver_map);
435 code = compiler.CompileStoreElement(receiver_map);
443 ASSERT(!code.is_null());
446 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, 0));
448 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_STORE_IC_TAG, *code, 0));
450 JSObject::UpdateMapCodeCache(receiver, name, code);
451 return code;
455 Handle<Code> StubCache::ComputeStoreNormal(StrictModeFlag strict_mode) {
462 Handle<Code> StubCache::ComputeStoreGlobal(Handle<String> name,
466 Code::Flags flags = Code::ComputeMonomorphicFlags(
467 Code::STORE_IC, NORMAL, strict_mode);
469 if (probe->IsCode()) return Handle<Code>::cast(probe);
472 Handle<Code> code = compiler.CompileStoreGlobal(receiver, cell, name);
473 PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
474 GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
475 JSObject::UpdateMapCodeCache(receiver, name, code);
476 return code;
480 Handle<Code> StubCache::ComputeStoreCallback(Handle<String> name,
485 Code::Flags flags = Code::ComputeMonomorphicFlags(
486 Code::STORE_IC, CALLBACKS, strict_mode);
488 if (probe->IsCode()) return Handle<Code>::cast(probe);
491 Handle<Code> code = compiler.CompileStoreCallback(receiver, callback, name);
492 PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
493 GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
494 JSObject::UpdateMapCodeCache(receiver, name, code);
495 return code;
499 Handle<Code> StubCache::ComputeStoreInterceptor(Handle<String> name,
502 Code::Flags flags = Code::ComputeMonomorphicFlags(
503 Code::STORE_IC, INTERCEPTOR, strict_mode);
505 if (probe->IsCode()) return Handle<Code>::cast(probe);
508 Handle<Code> code = compiler.CompileStoreInterceptor(receiver, name);
509 PROFILE(isolate_, CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
510 GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
511 JSObject::UpdateMapCodeCache(receiver, name, code);
512 return code;
515 Handle<Code> StubCache::ComputeKeyedStoreField(Handle<String> name,
521 Code::Flags flags = Code::ComputeMonomorphicFlags(
522 Code::KEYED_STORE_IC, type, strict_mode);
524 if (probe->IsCode()) return Handle<Code>::cast(probe);
528 Handle<Code> code =
530 PROFILE(isolate_, CodeCreateEvent(Logger::KEYED_STORE_IC_TAG, *code, *name));
531 GDBJIT(AddCode(GDBJITInterface::KEYED_STORE_IC, *name, *code));
532 JSObject::UpdateMapCodeCache(receiver, name, code);
533 return code;
538 (kind == Code::CALL_IC ? Logger::type : Logger::KEYED_##type)
540 Handle<Code> StubCache::ComputeCallConstant(int argc,
541 Code::Kind kind,
542 Code::ExtraICState extra_state,
562 Code::Flags flags =
563 Code::ComputeMonomorphicFlags(kind, CONSTANT_FUNCTION, extra_state,
566 if (probe->IsCode()) return Handle<Code>::cast(probe);
569 Handle<Code> code =
571 code->set_check_type(check);
572 ASSERT_EQ(flags, code->flags());
574 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
575 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
576 JSObject::UpdateMapCodeCache(map_holder, name, code);
577 return code;
581 Handle<Code> StubCache::ComputeCallField(int argc,
582 Code::Kind kind,
583 Code::ExtraICState extra_state,
600 Code::Flags flags =
601 Code::ComputeMonomorphicFlags(kind, FIELD, extra_state,
604 if (probe->IsCode()) return Handle<Code>::cast(probe);
607 Handle<Code> code =
610 ASSERT_EQ(flags, code->flags());
612 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
613 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
614 JSObject::UpdateMapCodeCache(map_holder, name, code);
615 return code;
619 Handle<Code> StubCache::ComputeCallInterceptor(int argc,
620 Code::Kind kind,
621 Code::ExtraICState extra_state,
637 Code::Flags flags =
638 Code::ComputeMonomorphicFlags(kind, INTERCEPTOR, extra_state,
641 if (probe->IsCode()) return Handle<Code>::cast(probe);
644 Handle<Code> code =
647 ASSERT_EQ(flags, code->flags());
649 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
650 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
651 JSObject::UpdateMapCodeCache(map_holder, name, code);
652 return code;
656 Handle<Code> StubCache::ComputeCallGlobal(int argc,
657 Code::Kind kind,
658 Code::ExtraICState extra_state,
667 Code::Flags flags =
668 Code::ComputeMonomorphicFlags(kind, NORMAL, extra_state,
671 if (probe->IsCode()) return Handle<Code>::cast(probe);
674 Handle<Code> code =
676 ASSERT_EQ(flags, code->flags());
678 CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name));
679 GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code));
680 JSObject::UpdateMapCodeCache(map_holder, name, code);
681 return code;
685 static void FillCache(Isolate* isolate, Handle<Code> code) {
688 code->flags(),
689 code);
694 Code* StubCache::FindCallInitialize(int argc,
696 Code::Kind kind) {
697 Code::ExtraICState extra_state =
700 Code::Flags flags =
701 Code::ComputeFlags(kind, UNINITIALIZED, extra_state, NORMAL, argc);
708 Object* code = dictionary->ValueAt(entry);
711 return reinterpret_cast<Code*>(code);
715 Handle<Code> StubCache::ComputeCallInitialize(int argc,
717 Code::Kind kind) {
718 Code::ExtraICState extra_state =
721 Code::Flags flags =
722 Code::ComputeFlags(kind, UNINITIALIZED, extra_state, NORMAL, argc);
726 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
729 Handle<Code> code = compiler.CompileCallInitialize(flags);
730 FillCache(isolate_, code);
731 return code;
735 Handle<Code> StubCache::ComputeCallInitialize(int argc, RelocInfo::Mode mode) {
736 return ComputeCallInitialize(argc, mode, Code::CALL_IC);
740 Handle<Code> StubCache::ComputeKeyedCallInitialize(int argc) {
742 Code::KEYED_CALL_IC);
746 Handle<Code> StubCache::ComputeCallPreMonomorphic(
748 Code::Kind kind,
749 Code::ExtraICState extra_state) {
750 Code::Flags flags =
751 Code::ComputeFlags(kind, PREMONOMORPHIC, extra_state, NORMAL, argc);
755 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
758 Handle<Code> code = compiler.CompileCallPreMonomorphic(flags);
759 FillCache(isolate_, code);
760 return code;
764 Handle<Code> StubCache::ComputeCallNormal(int argc,
765 Code::Kind kind,
766 Code::ExtraICState extra_state) {
767 Code::Flags flags =
768 Code::ComputeFlags(kind, MONOMORPHIC, extra_state, NORMAL, argc);
772 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
775 Handle<Code> code = compiler.CompileCallNormal(flags);
776 FillCache(isolate_, code);
777 return code;
781 Handle<Code> StubCache::ComputeCallArguments(int argc, Code::Kind kind) {
782 ASSERT(kind == Code::KEYED_CALL_IC);
783 Code::Flags flags =
784 Code::ComputeFlags(kind, MEGAMORPHIC, Code::kNoExtraICState,
789 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
792 Handle<Code> code = compiler.CompileCallArguments(flags);
793 FillCache(isolate_, code);
794 return code;
798 Handle<Code> StubCache::ComputeCallMegamorphic(
800 Code::Kind kind,
801 Code::ExtraICState extra_state) {
802 Code::Flags flags =
803 Code::ComputeFlags(kind, MEGAMORPHIC, extra_state,
808 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
811 Handle<Code> code = compiler.CompileCallMegamorphic(flags);
812 FillCache(isolate_, code);
813 return code;
817 Handle<Code> StubCache::ComputeCallMiss(int argc,
818 Code::Kind kind,
819 Code::ExtraICState extra_state) {
822 Code::Flags flags =
823 Code::ComputeFlags(kind, MONOMORPHIC_PROTOTYPE_FAILURE, extra_state,
828 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
831 Handle<Code> code = compiler.CompileCallMiss(flags);
832 FillCache(isolate_, code);
833 return code;
838 Handle<Code> StubCache::ComputeCallDebugBreak(int argc,
839 Code::Kind kind) {
842 Code::Flags flags =
843 Code::ComputeFlags(kind, DEBUG_BREAK, Code::kNoExtraICState,
848 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
851 Handle<Code> code = compiler.CompileCallDebugBreak(flags);
852 FillCache(isolate_, code);
853 return code;
857 Handle<Code> StubCache::ComputeCallDebugPrepareStepIn(int argc,
858 Code::Kind kind) {
861 Code::Flags flags =
862 Code::ComputeFlags(kind, DEBUG_PREPARE_STEP_IN, Code::kNoExtraICState,
867 if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
870 Handle<Code> code = compiler.CompileCallDebugPrepareStepIn(flags);
871 FillCache(isolate_, code);
872 return code;
878 Code* empty = isolate_->builtins()->builtin(Builtins::kIllegal);
892 Code::Flags flags,
1140 Handle<Code> StubCompiler::CompileCallInitialize(Code::Flags flags) {
1141 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1142 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1143 Code::ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1144 if (kind == Code::CALL_IC) {
1149 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallInitialize");
1153 *code, code->arguments_count()));
1154 GDBJIT(AddCode(GDBJITInterface::CALL_INITIALIZE, *code));
1155 return code;
1159 Handle<Code> StubCompiler::CompileCallPreMonomorphic(Code::Flags flags) {
1160 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1161 // The code of the PreMonomorphic stub is the same as the code
1162 // of the Initialized stub. They just differ on the code object flags.
1163 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1164 Code::ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1165 if (kind == Code::CALL_IC) {
1170 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallPreMonomorphic");
1174 *code, code->arguments_count()));
1175 GDBJIT(AddCode(GDBJITInterface::CALL_PRE_MONOMORPHIC, *code));
1176 return code;
1180 Handle<Code> StubCompiler::CompileCallNormal(Code::Flags flags) {
1181 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1182 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1183 if (kind == Code::CALL_IC) {
1186 Code::ExtractExtraICStateFromFlags(flags)));
1191 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallNormal");
1195 *code, code->arguments_count()));
1196 GDBJIT(AddCode(GDBJITInterface::CALL_NORMAL, *code));
1197 return code;
1201 Handle<Code> StubCompiler::CompileCallMegamorphic(Code::Flags flags) {
1202 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1203 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1204 Code::ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1205 if (kind == Code::CALL_IC) {
1210 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallMegamorphic");
1214 *code, code->arguments_count()));
1215 GDBJIT(AddCode(GDBJITInterface::CALL_MEGAMORPHIC, *code));
1216 return code;
1220 Handle<Code> StubCompiler::CompileCallArguments(Code::Flags flags) {
1221 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1223 Handle<Codecode = GetCodeWithFlags(flags, "CompileCallArguments");
1225 CodeCreateEvent(CALL_LOGGER_TAG(Code::ExtractKindFromFlags(flags),
1227 *code, code->arguments_count()));
1228 GDBJIT(AddCode(GDBJITInterface::CALL_MEGAMORPHIC, *code));
1229 return code;
1233 Handle<Code> StubCompiler::CompileCallMiss(Code::Flags flags) {
1234 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1235 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1236 Code::ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
1237 if (kind == Code::CALL_IC) {
1242 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallMiss");
1246 *code, code->arguments_count()));
1247 GDBJIT(AddCode(GDBJITInterface::CALL_MISS, *code));
1248 return code;
1253 Handle<Code> StubCompiler::CompileCallDebugBreak(Code::Flags flags) {
1255 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallDebugBreak");
1257 CodeCreateEvent(CALL_LOGGER_TAG(Code::ExtractKindFromFlags(flags),
1259 *code, code->arguments_count()));
1260 return code;
1264 Handle<Code> StubCompiler::CompileCallDebugPrepareStepIn(Code::Flags flags) {
1265 // Use the same code for the the step in preparations as we do for the
1267 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1268 Code::Kind kind = Code::ExtractKindFromFlags(flags);
1269 if (kind == Code::CALL_IC) {
1271 CallIC::GenerateMiss(masm(), argc, Code::kNoExtraICState);
1275 Handle<Code> code = GetCodeWithFlags(flags, "CompileCallDebugPrepareStepIn");
1279 *code,
1280 code->arguments_count()));
1281 return code;
1288 Handle<Code> StubCompiler::GetCodeWithFlags(Code::Flags flags,
1290 // Create code object in the heap.
1293 Handle<Code> code = factory()->NewCode(desc, flags, masm_.CodeObject());
1295 if (FLAG_print_code_stubs) code->Disassemble(name);
1297 return code;
1301 Handle<Code> StubCompiler::GetCodeWithFlags(Code::Flags flags,
1322 Handle<Code> LoadStubCompiler::GetCode(PropertyType type, Handle<String> name) {
1323 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, type);
1324 Handle<Code> code = GetCodeWithFlags(flags, name);
1325 PROFILE(isolate(), CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
1326 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
1327 return code;
1331 Handle<Code> KeyedLoadStubCompiler::GetCode(PropertyType type,
1334 Code::Flags flags = Code::ComputeFlags(
1335 Code::KEYED_LOAD_IC, state, Code::kNoExtraICState, type);
1336 Handle<Code> code = GetCodeWithFlags(flags, name);
1337 PROFILE(isolate(), CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code, *name));
1338 GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
1339 return code;
1343 Handle<Code> StoreStubCompiler::GetCode(PropertyType type,
1345 Code::Flags flags =
1346 Code::ComputeMonomorphicFlags(Code::STORE_IC, type, strict_mode_);
1347 Handle<Code> code = GetCodeWithFlags(flags, name);
1348 PROFILE(isolate(), CodeCreateEvent(Logger::STORE_IC_TAG, *code, *name));
1349 GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
1350 return code;
1354 Handle<Code> KeyedStoreStubCompiler::GetCode(PropertyType type,
1357 Code::ExtraICState extra_state =
1358 Code::ComputeExtraICState(grow_mode_, strict_mode_);
1359 Code::Flags flags =
1360 Code::ComputeFlags(Code::KEYED_STORE_IC, state, extra_state, type);
1361 Handle<Code> code = GetCodeWithFlags(flags, name);
1362 PROFILE(isolate(), CodeCreateEvent(Logger::KEYED_STORE_IC_TAG, *code, *name));
1363 GDBJIT(AddCode(GDBJITInterface::KEYED_STORE_IC, *name, *code));
1364 return code;
1376 Code::Kind kind,
1377 Code::ExtraICState extra_state,
1400 Handle<Code> CallStubCompiler::CompileCustomCall(
1432 Handle<Code> CallStubCompiler::GetCode(PropertyType type, Handle<String> name) {
1434 Code::Flags flags = Code::ComputeMonomorphicFlags(kind_,
1443 Handle<Code> CallStubCompiler::GetCode(Handle<JSFunction> function) {
1452 Handle<Code> ConstructStubCompiler::GetCode() {
1453 Code::Flags flags = Code::ComputeFlags(Code::STUB);
1454 Handle<Code> code = GetCodeWithFlags(flags, "ConstructStub");
1455 PROFILE(isolate(), CodeCreateEvent(Logger::STUB_TAG, *code, "ConstructStub"));
1456 GDBJIT(AddCode(GDBJITInterface::STUB, "ConstructStub", *code));
1457 return code;
