Remove all compilation related interface from the StubCache

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"
 #include "src/ic-inl.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/zone-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
-// The stub cache is used for megamorphic calls and property accesses.
-// It maps (map, name, type)->Code*
-
-// The design of the table uses the inline cache stubs used for
-// mono-morphic calls. The beauty of this, we do not have to
-// invalidate the cache whenever a prototype map is changed.  The stub
-// validates the map chain as in the mono-morphic case.
+// The stub cache is used for megamorphic property accesses.
+// It maps (map, name, type) to property access handlers. The cache does not
+// need explicit invalidation when a prototype chain is modified, since the
+// handlers verify the chain.
 
 
 class CallOptimization;
 class SmallMapList;
 class StubCache;
 
 
 class SCTableReference {
  public:
   Address address() const { return address_; }
 
  private:
   explicit SCTableReference(Address address) : address_(address) {}
 
   Address address_;
 
   friend class StubCache;
 };
 
 
 class StubCache {
  public:
   struct Entry {
     Name* key;
     Code* value;
     Map* map;
   };
 
   void Initialize();
-
-  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);
-
-  Handle<Code> ComputeKeyedStoreElement(Handle<Map> receiver_map,
-                                        StrictMode strict_mode,
-                                        KeyedAccessStoreMode store_mode);
-
-  // ---
-
-  Handle<Code> ComputeLoad(InlineCacheState ic_state, ExtraICState extra_state);
-  Handle<Code> ComputeStore(InlineCacheState ic_state,
-                            ExtraICState extra_state);
-
-  // ---
-
-  Handle<Code> ComputeCompareNil(Handle<Map> receiver_map,
-                                 CompareNilICStub* stub);
-
-  // ---
-
-  Handle<Code> ComputeLoadElementPolymorphic(MapHandleList* receiver_maps);
-  Handle<Code> ComputeStoreElementPolymorphic(MapHandleList* receiver_maps,
-                                              KeyedAccessStoreMode store_mode,
-                                              StrictMode strict_mode);
-
-  Handle<Code> ComputePolymorphicIC(Code::Kind kind,
-                                    TypeHandleList* types,
-                                    CodeHandleList* handlers,
-                                    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).
+  // Access 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);
-
   // Generate code for probing the stub cache table.
   // Arguments extra, extra2 and extra3 may be used to pass additional scratch
   // registers. Set to no_reg if not needed.
   void GenerateProbe(MacroAssembler* masm,
                      Code::Flags flags,
                      Register receiver,
                      Register name,
                      Register scratch,
                      Register extra,
                      Register extra2 = no_reg,
                      Register extra3 = no_reg);
 
   enum Table {
     kPrimary,
     kSecondary
   };
 
-
   SCTableReference key_reference(StubCache::Table table) {
     return SCTableReference(
         reinterpret_cast<Address>(&first_entry(table)->key));
   }
 
-
   SCTableReference map_reference(StubCache::Table table) {
     return SCTableReference(
         reinterpret_cast<Address>(&first_entry(table)->map));
   }
 
-
   SCTableReference value_reference(StubCache::Table table) {
     return SCTableReference(
         reinterpret_cast<Address>(&first_entry(table)->value));
   }
 
-
   StubCache::Entry* first_entry(StubCache::Table table) {
     switch (table) {
       case StubCache::kPrimary: return StubCache::primary_;
       case StubCache::kSecondary: return StubCache::secondary_;
     }
     UNREACHABLE();
     return NULL;
   }
 
   Isolate* isolate() { return isolate_; }
-  Heap* heap() { return isolate()->heap(); }
-  Factory* factory() { return isolate()->factory(); }
-
-  // These constants describe the structure of the interceptor arguments on the
-  // stack. The arguments are pushed by the (platform-specific)
-  // PushInterceptorArguments and read by LoadPropertyWithInterceptorOnly and
-  // LoadWithInterceptor.
-  static const int kInterceptorArgsNameIndex = 0;
-  static const int kInterceptorArgsInfoIndex = 1;
-  static const int kInterceptorArgsThisIndex = 2;
-  static const int kInterceptorArgsHolderIndex = 3;
-  static const int kInterceptorArgsLength = 4;
 
   // Setting the entry size such that the index is shifted by Name::kHashShift
   // is convenient; shifting down the length field (to extract the hash code)
   // automatically discards the hash bit field.
   static const int kCacheIndexShift = Name::kHashShift;
 
  private:
   explicit StubCache(Isolate* isolate);
 
   // The stub cache has a primary and secondary level.  The two levels have
@@ skipping 146 matching lines @@
   Code::Kind kind_;
   CacheHolderFlag cache_holder_;
 
   Isolate* isolate_;
   MacroAssembler masm_;
 };
 
 
 class PropertyICCompiler : public PropertyAccessCompiler {
  public:
+  // Finds the Code object stored in the Heap::non_monomorphic_cache().
+  static Code* FindPreMonomorphicIC(Isolate* isolate, Code::Kind kind,
+                                    ExtraICState extra_ic_state);
+
+  // Named
+  static Handle<Code> ComputeLoad(Isolate* isolate, InlineCacheState ic_state,
+                                  ExtraICState extra_state);
+  static Handle<Code> ComputeStore(Isolate* isolate, InlineCacheState ic_state,
+                                   ExtraICState extra_state);
+
+  static Handle<Code> ComputeMonomorphicIC(Code::Kind kind, Handle<Name> name,
+                                           Handle<HeapType> type,
+                                           Handle<Code> handler,
+                                           ExtraICState extra_ic_state);
+  static Handle<Code> ComputePolymorphicIC(
+      Code::Kind kind, TypeHandleList* types, CodeHandleList* handlers,
+      int number_of_valid_maps, Handle<Name> name, ExtraICState extra_ic_state);
+
+  // Keyed
+  static Handle<Code> ComputeKeyedLoadElement(Handle<Map> receiver_map);
+
+  static Handle<Code> ComputeKeyedStoreElement(Handle<Map> receiver_map,
+                                               StrictMode strict_mode,
+                                               KeyedAccessStoreMode store_mode);
+  static Handle<Code> ComputeLoadElementPolymorphic(
+      MapHandleList* receiver_maps);
+  static Handle<Code> ComputeStoreElementPolymorphic(
+      MapHandleList* receiver_maps, KeyedAccessStoreMode store_mode,
+      StrictMode strict_mode);
+
+  // Compare nil
+  static Handle<Code> ComputeCompareNil(Handle<Map> receiver_map,
+                                        CompareNilICStub* stub);
+
+
+ private:
   PropertyICCompiler(Isolate* isolate, Code::Kind kind,
                      ExtraICState extra_ic_state = kNoExtraICState,
                      CacheHolderFlag cache_holder = kCacheOnReceiver)
       : PropertyAccessCompiler(isolate, kind, cache_holder),
         extra_ic_state_(extra_ic_state) {}
 
   static Handle<Code> Find(Handle<Name> name, Handle<Map> stub_holder_map,
                            Code::Kind kind,
                            ExtraICState extra_ic_state = kNoExtraICState,
                            CacheHolderFlag cache_holder = kCacheOnReceiver);
 
   Handle<Code> CompileLoadInitialize(Code::Flags flags);
   Handle<Code> CompileLoadPreMonomorphic(Code::Flags flags);
   Handle<Code> CompileLoadMegamorphic(Code::Flags flags);
   Handle<Code> CompileStoreInitialize(Code::Flags flags);
   Handle<Code> CompileStorePreMonomorphic(Code::Flags flags);
   Handle<Code> CompileStoreGeneric(Code::Flags flags);
   Handle<Code> CompileStoreMegamorphic(Code::Flags flags);
 
   Handle<Code> CompileMonomorphic(Handle<HeapType> type, Handle<Code> handler,
                                   Handle<Name> name, IcCheckType check);
-
   Handle<Code> CompilePolymorphic(TypeHandleList* types,
                                   CodeHandleList* handlers, Handle<Name> name,
                                   Code::StubType type, IcCheckType check);
 
   Handle<Code> CompileIndexedStoreMonomorphic(Handle<Map> receiver_map,
                                               KeyedAccessStoreMode store_mode);
   Handle<Code> CompileIndexedStorePolymorphic(MapHandleList* receiver_maps,
                                               KeyedAccessStoreMode store_mode);
+  Handle<Code> CompileIndexedStorePolymorphic(MapHandleList* receiver_maps,
+                                              CodeHandleList* handler_stubs,
+                                              MapHandleList* transitioned_maps);
 
- private:
   bool IncludesNumberType(TypeHandleList* types);
 
   Handle<Code> GetCode(Code::Kind kind, Code::StubType type, Handle<Name> name,
                        InlineCacheState state = MONOMORPHIC);
 
   Logger::LogEventsAndTags log_kind(Handle<Code> code) {
     if (kind() == Code::LOAD_IC) {
       return code->ic_state() == MONOMORPHIC ? Logger::LOAD_IC_TAG
                                              : Logger::LOAD_POLYMORPHIC_IC_TAG;
     } else if (kind() == Code::KEYED_LOAD_IC) {
       return code->ic_state() == MONOMORPHIC
                  ? Logger::KEYED_LOAD_IC_TAG
                  : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG;
     } else if (kind() == Code::STORE_IC) {
       return code->ic_state() == MONOMORPHIC ? Logger::STORE_IC_TAG
                                              : Logger::STORE_POLYMORPHIC_IC_TAG;
     } else {
       ASSERT_EQ(Code::KEYED_STORE_IC, kind());
       return code->ic_state() == MONOMORPHIC
                  ? Logger::KEYED_STORE_IC_TAG
                  : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG;
     }
   }
 
-  Handle<Code> CompileIndexedStorePolymorphic(MapHandleList* receiver_maps,
-                                              CodeHandleList* handler_stubs,
-                                              MapHandleList* transitioned_maps);
   const ExtraICState extra_ic_state_;
 };
 
 
 class PropertyHandlerCompiler : public PropertyAccessCompiler {
  public:
   static Handle<Code> Find(Handle<Name> name, Handle<Map> map, Code::Kind kind,
                            CacheHolderFlag cache_holder, Code::StubType type);
 
  protected:
@@ skipping 100 matching lines @@
 
   Handle<Code> CompileLoadInterceptor(Handle<HeapType> type,
                                       Handle<JSObject> holder,
                                       Handle<Name> name);
 
   Handle<Code> CompileLoadViaGetter(Handle<HeapType> type,
                                     Handle<JSObject> holder,
                                     Handle<Name> name,
                                     Handle<JSFunction> getter);
 
-  Handle<Code> CompileLoadNonexistent(Handle<HeapType> type,
-                                      Handle<JSObject> last,
-                                      Handle<Name> name);
+  static Handle<Code> ComputeLoadNonexistent(Handle<Name> name,
+                                             Handle<HeapType> type);
 
   Handle<Code> CompileLoadGlobal(Handle<HeapType> type,
                                  Handle<GlobalObject> holder,
                                  Handle<PropertyCell> cell,
                                  Handle<Name> name,
                                  bool is_dont_delete);
 
   static void GenerateLoadViaGetter(MacroAssembler* masm, Handle<HeapType> type,
                                     Register receiver,
                                     Handle<JSFunction> getter);
 
   static void GenerateLoadViaGetterForDeopt(MacroAssembler* masm) {
     GenerateLoadViaGetter(masm, Handle<HeapType>::null(), no_reg,
                           Handle<JSFunction>());
   }
 
   static void GenerateLoadFunctionPrototype(MacroAssembler* masm,
                                             Register receiver,
                                             Register scratch1,
                                             Register scratch2,
                                             Label* miss_label);
 
+  // These constants describe the structure of the interceptor arguments on the
+  // stack. The arguments are pushed by the (platform-specific)
+  // PushInterceptorArguments and read by LoadPropertyWithInterceptorOnly and
+  // LoadWithInterceptor.
+  static const int kInterceptorArgsNameIndex = 0;
+  static const int kInterceptorArgsInfoIndex = 1;
+  static const int kInterceptorArgsThisIndex = 2;
+  static const int kInterceptorArgsHolderIndex = 3;
+  static const int kInterceptorArgsLength = 4;
+
  protected:
   virtual Register FrontendHeader(Handle<HeapType> type, Register object_reg,
                                   Handle<JSObject> holder, Handle<Name> name,
                                   Label* miss);
 
   virtual void FrontendFooter(Handle<Name> name, Label* miss);
 
  private:
   Register CallbackFrontend(Handle<HeapType> type, Register object_reg,
                             Handle<JSObject> holder, Handle<Name> name,
                             Handle<Object> callback);
+  Handle<Code> CompileLoadNonexistent(Handle<HeapType> type,
+                                      Handle<JSObject> last, Handle<Name> name);
   void NonexistentFrontend(Handle<HeapType> type, Handle<JSObject> last,
                            Handle<Name> name);
 
   void GenerateLoadField(Register reg,
                          Handle<JSObject> holder,
                          FieldIndex field,
                          Representation representation);
   void GenerateLoadConstant(Handle<Object> value);
   void GenerateLoadCallback(Register reg,
                             Handle<ExecutableAccessorInfo> callback);
@@ skipping 194 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_