Cache IC handlers on the prototype's map if possible

src/stub-cache.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_STUB_CACHE_H_
 #define V8_STUB_CACHE_H_
 
 #include "src/allocation.h"
 #include "src/arguments.h"
 #include "src/code-stubs.h"
@@ skipping 39 matching lines @@
     Name* key;
     Code* value;
     Map* map;
   };
 
   void Initialize();
 
   Handle<JSObject> StubHolder(Handle<JSObject> receiver,
                               Handle<JSObject> holder);
 
-  Handle<Code> FindIC(Handle<Name> name,
-                      Handle<Map> stub_holder_map,
+  Handle<Code> FindIC(Handle<Name> name, Handle<Map> stub_holder_map,
                       Code::Kind kind,
                       ExtraICState extra_state = kNoExtraICState,
-                      InlineCacheHolderFlag cache_holder = OWN_MAP);
+                      CacheHolderFlag cache_holder = kCacheOnReceiver);
 
-  Handle<Code> FindHandler(Handle<Name> name,
-                           Handle<Map> map,
-                           Code::Kind kind,
-                           InlineCacheHolderFlag cache_holder,
-                           Code::StubType type);
+  Handle<Code> FindHandler(Handle<Name> name, Handle<Map> map, Code::Kind kind,
+                           CacheHolderFlag cache_holder, Code::StubType type);
 
   Handle<Code> ComputeMonomorphicIC(Code::Kind kind,
                                     Handle<Name> name,
                                     Handle<HeapType> type,
                                     Handle<Code> handler,
                                     ExtraICState extra_ic_state);
 
   Handle<Code> ComputeLoadNonexistent(Handle<Name> name, Handle<HeapType> type);
 
   Handle<Code> ComputeKeyedLoadElement(Handle<Map> receiver_map);
@@ skipping 26 matching lines @@
                                     int number_of_valid_maps,
                                     Handle<Name> name,
                                     ExtraICState extra_ic_state);
 
   // Finds the Code object stored in the Heap::non_monomorphic_cache().
   Code* FindPreMonomorphicIC(Code::Kind kind, ExtraICState extra_ic_state);
 
   // Update cache for entry hash(name, map).
   Code* Set(Name* name, Map* map, Code* code);
 
+  Code* Get(Name* name, Map* map, Code::Flags flags);
+
   // Clear the lookup table (@ mark compact collection).
   void Clear();
 
   // Collect all maps that match the name and flags.
   void CollectMatchingMaps(SmallMapList* types,
                            Handle<Name> name,
                            Code::Flags flags,
                            Handle<Context> native_context,
                            Zone* zone);
 
@@ skipping 280 matching lines @@
   const ExtraICState extra_ic_state_;
   MacroAssembler masm_;
 };
 
 
 enum FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS };
 
 
 class BaseLoadStoreStubCompiler: public StubCompiler {
  public:
-  BaseLoadStoreStubCompiler(Isolate* isolate,
-                            Code::Kind kind,
+  BaseLoadStoreStubCompiler(Isolate* isolate, Code::Kind kind,
                             ExtraICState extra_ic_state = kNoExtraICState,
-                            InlineCacheHolderFlag cache_holder = OWN_MAP)
+                            CacheHolderFlag cache_holder = kCacheOnReceiver)
       : StubCompiler(isolate, extra_ic_state),
         kind_(kind),
         cache_holder_(cache_holder) {
     InitializeRegisters();
   }
   virtual ~BaseLoadStoreStubCompiler() { }
 
   Handle<Code> CompileMonomorphicIC(Handle<HeapType> type,
                                     Handle<Code> handler,
                                     Handle<Name> name);
@@ skipping 60 matching lines @@
   Register name()     { return registers_[1]; }
   Register scratch1() { return registers_[2]; }
   Register scratch2() { return registers_[3]; }
   Register scratch3() { return registers_[4]; }
 
   void InitializeRegisters();
 
   bool IncludesNumberType(TypeHandleList* types);
 
   Code::Kind kind_;
-  InlineCacheHolderFlag cache_holder_;
+  CacheHolderFlag cache_holder_;
   Register* registers_;
 };
 
 
 class LoadStubCompiler: public BaseLoadStoreStubCompiler {
  public:
   LoadStubCompiler(Isolate* isolate,
                    ExtraICState extra_ic_state = kNoExtraICState,
-                   InlineCacheHolderFlag cache_holder = OWN_MAP,
+                   CacheHolderFlag cache_holder = kCacheOnReceiver,
                    Code::Kind kind = Code::LOAD_IC)
-      : BaseLoadStoreStubCompiler(isolate, kind, extra_ic_state,
-                                  cache_holder) { }
+      : BaseLoadStoreStubCompiler(isolate, kind, extra_ic_state, cache_holder) {
+  }
   virtual ~LoadStubCompiler() { }
 
   Handle<Code> CompileLoadField(Handle<HeapType> type,
                                 Handle<JSObject> holder,
                                 Handle<Name> name,
                                 FieldIndex index,
                                 Representation representation);
 
   Handle<Code> CompileLoadCallback(Handle<HeapType> type,
                                    Handle<JSObject> holder,
@@ skipping 84 matching lines @@
   static Register* registers();
   Register scratch4() { return registers_[5]; }
   friend class BaseLoadStoreStubCompiler;
 };
 
 
 class KeyedLoadStubCompiler: public LoadStubCompiler {
  public:
   KeyedLoadStubCompiler(Isolate* isolate,
                         ExtraICState extra_ic_state = kNoExtraICState,
-                        InlineCacheHolderFlag cache_holder = OWN_MAP)
+                        CacheHolderFlag cache_holder = kCacheOnReceiver)
       : LoadStubCompiler(isolate, extra_ic_state, cache_holder,
-                         Code::KEYED_LOAD_IC) { }
+                         Code::KEYED_LOAD_IC) {}
 
   Handle<Code> CompileLoadElement(Handle<Map> receiver_map);
 
   void CompileElementHandlers(MapHandleList* receiver_maps,
                               CodeHandleList* handlers);
 
   static void GenerateLoadDictionaryElement(MacroAssembler* masm);
 
  private:
   static Register* registers();
@@ skipping 193 matching lines @@
   Handle<JSFunction> constant_function_;
   bool is_simple_api_call_;
   Handle<FunctionTemplateInfo> expected_receiver_type_;
   Handle<CallHandlerInfo> api_call_info_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_STUB_CACHE_H_