Lines Matching full:code
6 // * Redistributions of source code must retain the above copyright
55 Code* StubCache::Set(String* name, Map* map, Code* code) {
56 // Get the flags from the code.
57 Code::Flags flags = Code::RemoveTypeFromFlags(code->flags());
68 ASSERT(Code::ExtractICStateFromFlags(flags) == MONOMORPHIC);
69 ASSERT(Code::kFlagsICStateShift == 0);
71 // Make sure that the code type is not included in the hash.
72 ASSERT(Code::ExtractTypeFromFlags(flags) == 0);
77 Code* hit = primary->value;
82 Code::Flags primary_flags = Code::RemoveTypeFromFlags(hit->flags());
91 primary->value = code;
92 return code;
100 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, FIELD);
101 Object* code = receiver->map()->FindInCodeCache(name, flags);
102 if (code->IsUndefined()) {
104 code = compiler.CompileLoadField(receiver, holder, field_index, name);
105 if (code->IsFailure()) return code;
106 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
107 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
110 return Set(name, receiver->map(), Code::cast(code));
119 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, CALLBACKS);
120 Object* code = receiver->map()->FindInCodeCache(name, flags);
121 if (code->IsUndefined()) {
123 code = compiler.CompileLoadCallback(name, receiver, holder, callback);
124 if (code->IsFailure()) return code;
125 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
126 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
129 return Set(name, receiver->map(), Code::cast(code));
137 Code::Flags flags =
138 Code::ComputeMonomorphicFlags(Code::LOAD_IC, CONSTANT_FUNCTION);
139 Object* code = receiver->map()->FindInCodeCache(name, flags);
140 if (code->IsUndefined()) {
142 code = compiler.CompileLoadConstant(receiver, holder, value, name);
143 if (code->IsFailure()) return code;
144 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
145 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
148 return Set(name, receiver->map(), Code::cast(code));
155 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, INTERCEPTOR);
156 Object* code = receiver->map()->FindInCodeCache(name, flags);
157 if (code->IsUndefined()) {
159 code = compiler.CompileLoadInterceptor(receiver, holder, name);
160 if (code->IsFailure()) return code;
161 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
162 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
165 return Set(name, receiver->map(), Code::cast(code));
170 Code* code = Builtins::builtin(Builtins::LoadIC_Normal);
171 return Set(name, receiver->map(), code);
180 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, NORMAL);
181 Object* code = receiver->map()->FindInCodeCache(name, flags);
182 if (code->IsUndefined()) {
184 code = compiler.CompileLoadGlobal(receiver,
189 if (code->IsFailure()) return code;
190 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
191 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
194 return Set(name, receiver->map(), Code::cast(code));
202 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, FIELD);
203 Object* code = receiver->map()->FindInCodeCache(name, flags);
204 if (code->IsUndefined()) {
206 code = compiler.CompileLoadField(name, receiver, holder, field_index);
207 if (code->IsFailure()) return code;
208 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
209 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
212 return code;
220 Code::Flags flags =
221 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CONSTANT_FUNCTION);
222 Object* code = receiver->map()->FindInCodeCache(name, flags);
223 if (code->IsUndefined()) {
225 code = compiler.CompileLoadConstant(name, receiver, holder, value);
226 if (code->IsFailure()) return code;
227 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
228 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
231 return code;
238 Code::Flags flags =
239 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, INTERCEPTOR);
240 Object* code = receiver->map()->FindInCodeCache(name, flags);
241 if (code->IsUndefined()) {
243 code = compiler.CompileLoadInterceptor(receiver, holder, name);
244 if (code->IsFailure()) return code;
245 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
246 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
249 return code;
257 Code::Flags flags =
258 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
259 Object* code = receiver->map()->FindInCodeCache(name, flags);
260 if (code->IsUndefined()) {
262 code = compiler.CompileLoadCallback(name, receiver, holder, callback);
263 if (code->IsFailure()) return code;
264 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
265 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
268 return code;
275 Code::Flags flags =
276 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
277 Object* code = receiver->map()->FindInCodeCache(name, flags);
278 if (code->IsUndefined()) {
280 code = compiler.CompileLoadArrayLength(name);
281 if (code->IsFailure()) return code;
282 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
283 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
286 return code;
292 Code::Flags flags =
293 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
294 Object* code = receiver->map()->FindInCodeCache(name, flags);
295 if (code->IsUndefined()) {
297 code = compiler.CompileLoadStringLength(name);
298 if (code->IsFailure()) return code;
299 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
300 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
303 return code;
309 Code::Flags flags =
310 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
311 Object* code = receiver->map()->FindInCodeCache(name, flags);
312 if (code->IsUndefined()) {
314 code = compiler.CompileLoadFunctionPrototype(name);
315 if (code->IsFailure()) return code;
316 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name));
317 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
320 return code;
329 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::STORE_IC, type);
330 Object* code = receiver->map()->FindInCodeCache(name, flags);
331 if (code->IsUndefined()) {
333 code = compiler.CompileStoreField(receiver, field_index, transition, name);
334 if (code->IsFailure()) return code;
335 LOG(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
336 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
339 return Set(name, receiver->map(), Code::cast(code));
346 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::STORE_IC, NORMAL);
347 Object* code = receiver->map()->FindInCodeCache(name, flags);
348 if (code->IsUndefined()) {
350 code = compiler.CompileStoreGlobal(receiver, cell, name);
351 if (code->IsFailure()) return code;
352 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
353 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
356 return Set(name, receiver->map(), Code::cast(code));
364 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::STORE_IC, CALLBACKS);
365 Object* code = receiver->map()->FindInCodeCache(name, flags);
366 if (code->IsUndefined()) {
368 code = compiler.CompileStoreCallback(receiver, callback, name);
369 if (code->IsFailure()) return code;
370 LOG(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
371 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
374 return Set(name, receiver->map(), Code::cast(code));
380 Code::Flags flags =
381 Code::ComputeMonomorphicFlags(Code::STORE_IC, INTERCEPTOR);
382 Object* code = receiver->map()->FindInCodeCache(name, flags);
383 if (code->IsUndefined()) {
385 code = compiler.CompileStoreInterceptor(receiver, name);
386 if (code->IsFailure()) return code;
387 LOG(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name));
388 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
391 return Set(name, receiver->map(), Code::cast(code));
398 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, type);
399 Object* code = receiver->map()->FindInCodeCache(name, flags);
400 if (code->IsUndefined()) {
402 code = compiler.CompileStoreField(receiver, field_index, transition, name);
403 if (code->IsFailure()) return code;
404 LOG(CodeCreateEvent(Logger::KEYED_STORE_IC_TAG, Code::cast(code), name));
405 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
408 return code;
431 Code::Flags flags =
432 Code::ComputeMonomorphicFlags(Code::CALL_IC,
436 Object* code = map->FindInCodeCache(name, flags);
437 if (code->IsUndefined()) {
453 code = compiler.CompileCallConstant(object, holder, function, name, check);
454 if (code->IsFailure()) return code;
455 ASSERT_EQ(flags, Code::cast(code)->flags());
456 LOG(CodeCreateEvent(Logger::CALL_IC_TAG, Code::cast(code), name));
457 Object* result = map->UpdateCodeCache(name, Code::cast(code));
460 return Set(name, map, Code::cast(code));
480 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC,
484 Object* code = map->FindInCodeCache(name, flags);
485 if (code->IsUndefined()) {
487 code = compiler.CompileCallField(JSObject::cast(object),
491 if (code->IsFailure()) return code;
492 ASSERT_EQ(flags, Code::cast(code)->flags());
493 LOG(CodeCreateEvent(Logger::CALL_IC_TAG, Code::cast(code), name));
494 Object* result = map->UpdateCodeCache(name, Code::cast(code));
497 return Set(name, map, Code::cast(code));
516 Code::Flags flags =
517 Code::ComputeMonomorphicFlags(Code::CALL_IC,
521 Object* code = map->FindInCodeCache(name, flags);
522 if (code->IsUndefined()) {
524 code = compiler.CompileCallInterceptor(JSObject::cast(object),
527 if (code->IsFailure()) return code;
528 ASSERT_EQ(flags, Code::cast(code)->flags());
529 LOG(CodeCreateEvent(Logger::CALL_IC_TAG, Code::cast(code), name));
530 Object* result = map->UpdateCodeCache(name, Code::cast(code));
533 return Set(name, map, Code::cast(code));
541 Object* code = ComputeCallNormal(argc, in_loop);
542 if (code->IsFailure()) return code;
543 return Set(name, receiver->map(), Code::cast(code));
554 Code::Flags flags =
555 Code::ComputeMonomorphicFlags(Code::CALL_IC, NORMAL, in_loop, argc);
556 Object* code = receiver->map()->FindInCodeCache(name, flags);
557 if (code->IsUndefined()) {
564 code = compiler.CompileCallGlobal(receiver, holder, cell, function, name);
565 if (code->IsFailure()) return code;
566 ASSERT_EQ(flags, Code::cast(code)->flags());
567 LOG(CodeCreateEvent(Logger::CALL_IC_TAG, Code::cast(code), name));
568 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
571 return Set(name, receiver->map(), Code::cast(code));
575 static Object* GetProbeValue(Code::Flags flags) {
584 static Object* ProbeCache(Code::Flags flags) {
588 // generated code object can always be inserted into the cache
599 static Object* FillCache(Object* code) {
600 if (code->IsCode()) {
603 Code::cast(code)->flags());
608 Heap::non_monomorphic_cache()->ValueAtPut(entry, code);
609 CHECK(GetProbeValue(Code::cast(code)->flags()) == code);
611 return code;
615 Code* StubCache::FindCallInitialize(int argc, InLoopFlag in_loop) {
616 Code::Flags flags =
617 Code::ComputeFlags(Code::CALL_IC, in_loop, UNINITIALIZED, NORMAL, argc);
622 return reinterpret_cast<Code*>(result);
627 Code::Flags flags =
628 Code::ComputeFlags(Code::CALL_IC, in_loop, UNINITIALIZED, NORMAL, argc);
637 Code::Flags flags =
638 Code::ComputeFlags(Code::CALL_IC, in_loop, PREMONOMORPHIC, NORMAL, argc);
647 Code::Flags flags =
648 Code::ComputeFlags(Code::CALL_IC, in_loop, MONOMORPHIC, NORMAL, argc);
657 Code::Flags flags =
658 Code::ComputeFlags(Code::CALL_IC, in_loop, MEGAMORPHIC, NORMAL, argc);
667 Code::Flags flags =
668 Code::ComputeFlags(Code::STUB, NOT_IN_LOOP, MEGAMORPHIC, NORMAL, argc);
678 Code::Flags flags =
679 Code::ComputeFlags(Code::CALL_IC, NOT_IN_LOOP, DEBUG_BREAK, NORMAL, argc);
688 Code::Flags flags =
689 Code::ComputeFlags(Code::CALL_IC,
703 Code::Flags flags =
704 Code::ComputeFlags(Code::STUB, NOT_IN_LOOP, UNINITIALIZED, NORMAL, argc);
710 Code* code = Code::cast(result);
711 USE(code);
713 code, code->arguments_count()));
736 Handle<Code> ComputeCallMiss(int argc) {
737 CALL_HEAP_FUNCTION(StubCache::ComputeCallMiss(argc), Code);
935 Object* StubCompiler::CompileCallInitialize(Code::Flags flags) {
937 int argc = Code::ExtractArgumentsCountFromFlags(flags);
942 Code* code = Code::cast(result);
943 USE(code);
945 code, code->arguments_count()));
951 Object* StubCompiler::CompileCallPreMonomorphic(Code::Flags flags) {
953 int argc = Code::ExtractArgumentsCountFromFlags(flags);
954 // The code of the PreMonomorphic stub is the same as the code
955 // of the Initialized stub. They just differ on the code object flags.
960 Code* code = Code::cast(result);
961 USE(code);
963 code, code->arguments_count()));
969 Object* StubCompiler::CompileCallNormal(Code::Flags flags) {
971 int argc = Code::ExtractArgumentsCountFromFlags(flags);
976 Code* code = Code::cast(result);
977 USE(code);
979 code, code->arguments_count()));
985 Object* StubCompiler::CompileCallMegamorphic(Code::Flags flags) {
987 int argc = Code::ExtractArgumentsCountFromFlags(flags);
992 Code* code = Code::cast(result);
993 USE(code);
995 code, code->arguments_count()));
1001 Object* StubCompiler::CompileCallMiss(Code::Flags flags) {
1003 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1008 Code* code = Code::cast(result);
1009 USE(code);
1010 LOG(CodeCreateEvent(Logger::CALL_MISS_TAG, code, code->arguments_count()));
1017 Object* StubCompiler::CompileCallDebugBreak(Code::Flags flags) {
1022 Code* code = Code::cast(result);
1023 USE(code);
1025 code, code->arguments_count()));
1031 Object* StubCompiler::CompileCallDebugPrepareStepIn(Code::Flags flags) {
1033 // Use the same code for the the step in preparations as we do for
1035 int argc = Code::ExtractArgumentsCountFromFlags(flags);
1039 Code* code = Code::cast(result);
1040 USE(code);
1042 code, code->arguments_count()));
1049 Object* StubCompiler::GetCodeWithFlags(Code::Flags flags, const char* name) {
1053 // Create code object in the heap.
1059 Code::cast(result)->Disassemble(name);
1066 Object* StubCompiler::GetCodeWithFlags(Code::Flags flags, String* name) {
1090 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, type);
1096 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, type);
1102 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::STORE_IC, type);
1108 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, type);
1115 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC,
1124 Code::Flags flags = Code::ComputeFlags(Code::STUB);
1127 Code* code = Code::cast(result);
1128 USE(code);
1129 LOG(CodeCreateEvent(Logger::STUB_TAG, code, "ConstructStub"));
