This patch much improves our tracking of whether function is...

src/stub-cache.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 351 matching lines @@
     if (code->IsFailure()) return code;
     LOG(CodeCreateEvent("KeyedStoreIC", Code::cast(code), name));
     Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code));
     if (result->IsFailure()) return result;
   }
   return code;
 }
 
 
 Object* StubCache::ComputeCallConstant(int argc,
+                                       InlineCacheInLoop in_loop,
                                        String* name,
                                        Object* object,
                                        JSObject* holder,
                                        JSFunction* function) {
   // Compute the check type and the map.
   Map* map = IC::GetCodeCacheMapForObject(object);
 
   // Compute check type based on receiver/holder.
   StubCompiler::CheckType check = StubCompiler::RECEIVER_MAP_CHECK;
   if (object->IsString()) {
     check = StubCompiler::STRING_CHECK;
   } else if (object->IsNumber()) {
     check = StubCompiler::NUMBER_CHECK;
   } else if (object->IsBoolean()) {
     check = StubCompiler::BOOLEAN_CHECK;
   }
 
   Code::Flags flags =
-      Code::ComputeMonomorphicFlags(Code::CALL_IC, CONSTANT_FUNCTION, argc);
+      Code::ComputeMonomorphicFlags(Code::CALL_IC,
+                                    CONSTANT_FUNCTION,
+                                    in_loop,
+                                    argc);
   Object* code = map->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
     if (object->IsJSObject()) {
       Object* opt =
           Top::LookupSpecialFunction(JSObject::cast(object), holder, function);
       if (opt->IsJSFunction()) {
         check = StubCompiler::JSARRAY_HAS_FAST_ELEMENTS_CHECK;
         function = JSFunction::cast(opt);
       }
     }
     // If the function hasn't been compiled yet, we cannot do it now
     // because it may cause GC. To avoid this issue, we return an
     // internal error which will make sure we do not update any
     // caches.
     if (!function->is_compiled()) return Failure::InternalError();
     // Compile the stub - only create stubs for fully compiled functions.
     CallStubCompiler compiler(argc);
-    code = compiler.CompileCallConstant(object, holder, function, check);
+    code = compiler.CompileCallConstant(object, holder, function, check, flags);
     if (code->IsFailure()) return code;
     LOG(CodeCreateEvent("CallIC", Code::cast(code), name));
     Object* result = map->UpdateCodeCache(name, Code::cast(code));
     if (result->IsFailure()) return result;
   }
   return Set(name, map, Code::cast(code));
 }
 
 
 Object* StubCache::ComputeCallField(int argc,
+                                    InlineCacheInLoop in_loop,
                                     String* name,
                                     Object* object,
                                     JSObject* holder,
                                     int index) {
   // Compute the check type and the map.
   Map* map = IC::GetCodeCacheMapForObject(object);
 
   // TODO(1233596): We cannot do receiver map check for non-JS objects
   // because they may be represented as immediates without a
   // map. Instead, we check against the map in the holder.
   if (object->IsNumber() || object->IsBoolean() || object->IsString()) {
     object = holder;
   }
 
-  Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC, FIELD, argc);
+  Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC,
+                                                    FIELD,
+                                                    in_loop,
+                                                    argc);
   Object* code = map->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
     CallStubCompiler compiler(argc);
-    code = compiler.CompileCallField(object, holder, index, name);
+    code = compiler.CompileCallField(object, holder, index, name, flags);
     if (code->IsFailure()) return code;
     LOG(CodeCreateEvent("CallIC", Code::cast(code), name));
     Object* result = map->UpdateCodeCache(name, Code::cast(code));
     if (result->IsFailure()) return result;
   }
   return Set(name, map, Code::cast(code));
 }
 
 
 Object* StubCache::ComputeCallInterceptor(int argc,
                                           String* name,
                                           Object* object,
                                           JSObject* holder) {
   // Compute the check type and the map.
   // If the object is a value, we use the prototype map for the cache.
   Map* map = IC::GetCodeCacheMapForObject(object);
 
   // TODO(1233596): We cannot do receiver map check for non-JS objects
   // because they may be represented as immediates without a
   // map. Instead, we check against the map in the holder.
   if (object->IsNumber() || object->IsBoolean() || object->IsString()) {
     object = holder;
   }
 
   Code::Flags flags =
-      Code::ComputeMonomorphicFlags(Code::CALL_IC, INTERCEPTOR, argc);
+      Code::ComputeMonomorphicFlags(Code::CALL_IC,
+                                    INTERCEPTOR,
+                                    NOT_IN_LOOP,
+                                    argc);
   Object* code = map->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
     CallStubCompiler compiler(argc);
     code = compiler.CompileCallInterceptor(object, holder, name);
     if (code->IsFailure()) return code;
     LOG(CodeCreateEvent("CallIC", Code::cast(code), name));
     Object* result = map->UpdateCodeCache(name, Code::cast(code));
     if (result->IsFailure()) return result;
   }
   return Set(name, map, Code::cast(code));
 }
 
 
 Object* StubCache::ComputeCallNormal(int argc,
+                                     InlineCacheInLoop in_loop,
                                      String* name,
                                      JSObject* receiver) {
-  Object* code = ComputeCallNormal(argc);
+  Object* code = ComputeCallNormal(argc, in_loop);
   if (code->IsFailure()) return code;
   return Set(name, receiver->map(), Code::cast(code));
 }
 
 
 static Object* GetProbeValue(Code::Flags flags) {
   Dictionary* dictionary = Heap::non_monomorphic_cache();
   int entry = dictionary->FindNumberEntry(flags);
   if (entry != -1) return dictionary->ValueAt(entry);
   return Heap::undefined_value();
@@ skipping 24 matching lines @@
     ASSERT(entry != -1);
     ASSERT(Heap::non_monomorphic_cache()->ValueAt(entry) ==
            Heap::undefined_value());
     Heap::non_monomorphic_cache()->ValueAtPut(entry, code);
     CHECK(GetProbeValue(Code::cast(code)->flags()) == code);
   }
   return code;
 }
 
 
-Code* StubCache::FindCallInitialize(int argc) {
+Code* StubCache::FindCallInitialize(int argc, InlineCacheInLoop in_loop) {
   Code::Flags flags =
-      Code::ComputeFlags(Code::CALL_IC, UNINITIALIZED, NORMAL, argc);
+      Code::ComputeFlags(Code::CALL_IC, in_loop, UNINITIALIZED, NORMAL, argc);
   Object* result = ProbeCache(flags);
   ASSERT(!result->IsUndefined());
   // This might be called during the marking phase of the collector
   // hence the unchecked cast.
   return reinterpret_cast<Code*>(result);
 }
 
 
-Object* StubCache::ComputeCallInitialize(int argc) {
+Object* StubCache::ComputeCallInitialize(int argc, InlineCacheInLoop in_loop) {
   Code::Flags flags =
-      Code::ComputeFlags(Code::CALL_IC, UNINITIALIZED, NORMAL, argc);
+      Code::ComputeFlags(Code::CALL_IC, in_loop, UNINITIALIZED, NORMAL, argc);
   Object* probe = ProbeCache(flags);
   if (!probe->IsUndefined()) return probe;
   StubCompiler compiler;
   return FillCache(compiler.CompileCallInitialize(flags));
 }
 
 
-Object* StubCache::ComputeCallInitializeInLoop(int argc) {
+Object* StubCache::ComputeCallPreMonomorphic(int argc,
+                                             InlineCacheInLoop in_loop) {
   Code::Flags flags =
-      Code::ComputeFlags(Code::CALL_IC, UNINITIALIZED_IN_LOOP, NORMAL, argc);
-  Object* probe = ProbeCache(flags);
-  if (!probe->IsUndefined()) return probe;
-  StubCompiler compiler;
-  return FillCache(compiler.CompileCallInitialize(flags));
-}
-
-
-
-Object* StubCache::ComputeCallPreMonomorphic(int argc) {
-  Code::Flags flags =
-      Code::ComputeFlags(Code::CALL_IC, PREMONOMORPHIC, NORMAL, argc);
+      Code::ComputeFlags(Code::CALL_IC, in_loop, PREMONOMORPHIC, NORMAL, argc);
   Object* probe = ProbeCache(flags);
   if (!probe->IsUndefined()) return probe;
   StubCompiler compiler;
   return FillCache(compiler.CompileCallPreMonomorphic(flags));
 }
 
 
-Object* StubCache::ComputeCallNormal(int argc) {
+Object* StubCache::ComputeCallNormal(int argc, InlineCacheInLoop in_loop) {
   Code::Flags flags =
-      Code::ComputeFlags(Code::CALL_IC, MONOMORPHIC, NORMAL, argc);
+      Code::ComputeFlags(Code::CALL_IC, in_loop, MONOMORPHIC, NORMAL, argc);
   Object* probe = ProbeCache(flags);
   if (!probe->IsUndefined()) return probe;
   StubCompiler compiler;
   return FillCache(compiler.CompileCallNormal(flags));
 }
 
 
-Object* StubCache::ComputeCallMegamorphic(int argc) {
+Object* StubCache::ComputeCallMegamorphic(int argc, InlineCacheInLoop in_loop) {
   Code::Flags flags =
-      Code::ComputeFlags(Code::CALL_IC, MEGAMORPHIC, NORMAL, argc);
+      Code::ComputeFlags(Code::CALL_IC, in_loop, MEGAMORPHIC, NORMAL, argc);
   Object* probe = ProbeCache(flags);
   if (!probe->IsUndefined()) return probe;
   StubCompiler compiler;
   return FillCache(compiler.CompileCallMegamorphic(flags));
 }
 
 
 Object* StubCache::ComputeCallMiss(int argc) {
   Code::Flags flags =
-      Code::ComputeFlags(Code::STUB, MEGAMORPHIC, NORMAL, argc);
+      Code::ComputeFlags(Code::STUB, NOT_IN_LOOP, MEGAMORPHIC, NORMAL, argc);
   Object* probe = ProbeCache(flags);
   if (!probe->IsUndefined()) return probe;
   StubCompiler compiler;
   return FillCache(compiler.CompileCallMiss(flags));
 }
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 Object* StubCache::ComputeCallDebugBreak(int argc) {
   Code::Flags flags =
-      Code::ComputeFlags(Code::CALL_IC, DEBUG_BREAK, NORMAL, argc);
+      Code::ComputeFlags(Code::CALL_IC, NOT_IN_LOOP, DEBUG_BREAK, NORMAL, argc);
   Object* probe = ProbeCache(flags);
   if (!probe->IsUndefined()) return probe;
   StubCompiler compiler;
   return FillCache(compiler.CompileCallDebugBreak(flags));
 }
 
 
 Object* StubCache::ComputeCallDebugPrepareStepIn(int argc) {
   Code::Flags flags =
-      Code::ComputeFlags(Code::CALL_IC, DEBUG_PREPARE_STEP_IN, NORMAL, argc);
+      Code::ComputeFlags(Code::CALL_IC,
+                         NOT_IN_LOOP,
+                         DEBUG_PREPARE_STEP_IN,
+                         NORMAL,
+                         argc);
   Object* probe = ProbeCache(flags);
   if (!probe->IsUndefined()) return probe;
   StubCompiler compiler;
   return FillCache(compiler.CompileCallDebugPrepareStepIn(flags));
 }
 #endif
 
 
 Object* StubCache::ComputeLazyCompile(int argc) {
   Code::Flags flags =
-      Code::ComputeFlags(Code::STUB, UNINITIALIZED, NORMAL, argc);
+      Code::ComputeFlags(Code::STUB, NOT_IN_LOOP, UNINITIALIZED, NORMAL, argc);
   Object* probe = ProbeCache(flags);
   if (!probe->IsUndefined()) return probe;
   StubCompiler compiler;
   Object* result = FillCache(compiler.CompileLazyCompile(flags));
   if (result->IsCode()) {
     Code* code = Code::cast(result);
     USE(code);
     LOG(CodeCreateEvent("LazyCompile", code, code->arguments_count()));
   }
   return result;
@@ skipping 278 matching lines @@
 
 
 Object* KeyedStoreStubCompiler::GetCode(PropertyType type, String* name) {
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, type);
   return GetCodeWithFlags(flags, name);
 }
 
 
 Object* CallStubCompiler::GetCode(PropertyType type, String* name) {
   int argc = arguments_.immediate();
-  Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC, type, argc);
+  Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC,
+                                                    type,
+                                                    NOT_IN_LOOP,
+                                                    argc);
   return GetCodeWithFlags(flags, name);
 }
 
 
 } }  // namespace v8::internal