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

src/stub-cache.h

 // 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 109 matching lines @@
   // ---
 
   static Object* ComputeKeyedStoreField(String* name,
                                         JSObject* receiver,
                                         int field_index,
                                         Map* transition = NULL);
 
   // ---
 
   static Object* ComputeCallField(int argc,
+                                  InlineCacheInLoop in_loop,
                                   String* name,
                                   Object* object,
                                   JSObject* holder,
                                   int index);
 
   static Object* ComputeCallConstant(int argc,
+                                     InlineCacheInLoop in_loop,
                                      String* name,
                                      Object* object,
                                      JSObject* holder,
                                      JSFunction* function);
 
-  static Object* ComputeCallNormal(int argc, String* name, JSObject* receiver);
+  static Object* ComputeCallNormal(int argc,
+                                   InlineCacheInLoop in_loop,
+                                   String* name,
+                                   JSObject* receiver);
 
   static Object* ComputeCallInterceptor(int argc,
                                         String* name,
                                         Object* object,
                                         JSObject* holder);
 
   // ---
 
-  static Object* ComputeCallInitialize(int argc);
-  static Object* ComputeCallInitializeInLoop(int argc);
-  static Object* ComputeCallPreMonomorphic(int argc);
-  static Object* ComputeCallNormal(int argc);
-  static Object* ComputeCallMegamorphic(int argc);
+  static Object* ComputeCallInitialize(int argc, InlineCacheInLoop in_loop);
+  static Object* ComputeCallPreMonomorphic(int argc, InlineCacheInLoop in_loop);
+  static Object* ComputeCallNormal(int argc, InlineCacheInLoop in_loop);
+  static Object* ComputeCallMegamorphic(int argc, InlineCacheInLoop in_loop);
   static Object* ComputeCallMiss(int argc);
 
   // Finds the Code object stored in the Heap::non_monomorphic_cache().
-  static Code* FindCallInitialize(int argc);
+  static Code* FindCallInitialize(int argc, InlineCacheInLoop in_loop);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   static Object* ComputeCallDebugBreak(int argc);
   static Object* ComputeCallDebugPrepareStepIn(int argc);
 #endif
 
   static Object* ComputeLazyCompile(int argc);
 
 
   // Update cache for entry hash(name, map).
@@ skipping 32 matching lines @@
     // code.
     ASSERT(kHeapObjectTagSize == String::kHashShift);
     // Compute the hash of the name (use entire length field).
     ASSERT(name->HasHashCode());
     uint32_t field = name->length_field();
     // Using only the low bits in 64-bit mode is unlikely to increase the
     // risk of collision even if the heap is spread over an area larger than
     // 4Gb (and not at all if it isn't).
     uint32_t map_low32bits =
         static_cast<uint32_t>(reinterpret_cast<uintptr_t>(map));
+    // We always set the in_loop bit to zero when generating the lookup code
+    // so do it here too so the hash codes match.
+    uint32_t iflags =
+        (static_cast<uint32_t>(flags) & ~Code::kFlagsICInLoopMask);
     // Base the offset on a simple combination of name, flags, and map.
-    uint32_t key = (map_low32bits + field) ^ flags;
+    uint32_t key = (map_low32bits + field) ^ iflags;
     return key & ((kPrimaryTableSize - 1) << kHeapObjectTagSize);
   }
 
   static int SecondaryOffset(String* name, Code::Flags flags, int seed) {
     // Use the seed from the primary cache in the secondary cache.
     uint32_t string_low32bits =
         static_cast<uint32_t>(reinterpret_cast<uintptr_t>(name));
-    uint32_t key = seed - string_low32bits + flags;
+    // We always set the in_loop bit to zero when generating the lookup code
+    // so do it here too so the hash codes match.
+    uint32_t iflags =
+        (static_cast<uint32_t>(flags) & ~Code::kFlagsICInLoopMask);
+    uint32_t key = seed - string_low32bits + iflags;
     return key & ((kSecondaryTableSize - 1) << kHeapObjectTagSize);
   }
 
   // Compute the entry for a given offset in exactly the same way as
   // we done in generated code. This makes it a lot easier to avoid
   // making mistakes in the hashed offset computations.
   static Entry* entry(Entry* table, int offset) {
     return reinterpret_cast<Entry*>(
         reinterpret_cast<Address>(table) + (offset << 1));
   }
@@ skipping 230 matching lines @@
 };
 
 
 class CallStubCompiler: public StubCompiler {
  public:
   explicit CallStubCompiler(int argc) : arguments_(argc) { }
 
   Object* CompileCallField(Object* object,
                            JSObject* holder,
                            int index,
-                           String* name);
+                           String* name,
+                           Code::Flags flags);
   Object* CompileCallConstant(Object* object,
                               JSObject* holder,
                               JSFunction* function,
-                              CheckType check);
+                              CheckType check,
+                              Code::Flags flags);
   Object* CompileCallInterceptor(Object* object,
                                  JSObject* holder,
                                  String* name);
 
  private:
   const ParameterCount arguments_;
 
   const ParameterCount& arguments() { return arguments_; }
 
   Object* GetCode(PropertyType type, String* name);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_STUB_CACHE_H_