Move extra_ic_state to the PropertyICCompiler

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 271 matching lines @@
       default:
         UNREACHABLE();
     }
     return Builtins::kLoadIC_Miss;
   }
 
   static void TailCallBuiltin(MacroAssembler* masm, Builtins::Name name);
 
  protected:
   PropertyAccessCompiler(Isolate* isolate, Code::Kind kind,
-                         ExtraICState extra_ic_state,
                          CacheHolderFlag cache_holder)
       : registers_(GetCallingConvention(kind)),
         kind_(kind),
         cache_holder_(cache_holder),
         isolate_(isolate),
-        extra_ic_state_(extra_ic_state),
         masm_(isolate, NULL, 256) {}
 
   Code::Kind kind() const { return kind_; }
   CacheHolderFlag cache_holder() const { return cache_holder_; }
-  ExtraICState extra_state() const { return extra_ic_state_; }
   MacroAssembler* masm() { return &masm_; }
   Isolate* isolate() const { return isolate_; }
   Heap* heap() const { return isolate()->heap(); }
   Factory* factory() const { return isolate()->factory(); }
 
   Register receiver() const { return registers_[0]; }
   Register name() const { return registers_[1]; }
   Register scratch1() const { return registers_[2]; }
   Register scratch2() const { return registers_[3]; }
   Register scratch3() const { return registers_[4]; }
@@ skipping 11 matching lines @@
   static void GenerateTailCall(MacroAssembler* masm, Handle<Code> code);
 
   Handle<Code> GetCodeWithFlags(Code::Flags flags, const char* name);
   Handle<Code> GetCodeWithFlags(Code::Flags flags, Handle<Name> name);
 
  private:
   Code::Kind kind_;
   CacheHolderFlag cache_holder_;
 
   Isolate* isolate_;
-  const ExtraICState extra_ic_state_;
   MacroAssembler masm_;
 };
 
 
 class PropertyICCompiler : public PropertyAccessCompiler {
  public:
   PropertyICCompiler(Isolate* isolate, Code::Kind kind,
                      ExtraICState extra_ic_state = kNoExtraICState,
                      CacheHolderFlag cache_holder = kCacheOnReceiver)
-      : PropertyAccessCompiler(isolate, kind, extra_ic_state, cache_holder) {}
+      : 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_state = kNoExtraICState,
+                           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);
 
@@ skipping 30 matching lines @@
       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:
   PropertyHandlerCompiler(Isolate* isolate, Code::Kind kind,
-                          ExtraICState extra_ic_state,
                           CacheHolderFlag cache_holder)
-      : PropertyAccessCompiler(isolate, kind, extra_ic_state, cache_holder) {}
+      : PropertyAccessCompiler(isolate, kind, cache_holder) {}
 
   virtual ~PropertyHandlerCompiler() {}
 
   virtual Register FrontendHeader(Handle<HeapType> type, Register object_reg,
                                   Handle<JSObject> holder, Handle<Name> name,
                                   Label* miss) {
     UNREACHABLE();
     return receiver();
   }
 
@@ skipping 51 matching lines @@
                            Handle<Name> name,
                            Label* miss,
                            PrototypeCheckType check = CHECK_ALL_MAPS);
 
   Handle<Code> GetCode(Code::Kind kind, Code::StubType type, Handle<Name> name);
 };
 
 
 class NamedLoadHandlerCompiler : public PropertyHandlerCompiler {
  public:
-  NamedLoadHandlerCompiler(Isolate* isolate, Code::Kind kind = Code::LOAD_IC,
-                           ExtraICState extra_ic_state = kNoExtraICState,
+  NamedLoadHandlerCompiler(Isolate* isolate,
                            CacheHolderFlag cache_holder = kCacheOnReceiver)
-      : PropertyHandlerCompiler(isolate, kind, extra_ic_state, cache_holder) {}
+      : PropertyHandlerCompiler(isolate, Code::LOAD_IC, cache_holder) {}
 
   virtual ~NamedLoadHandlerCompiler() {}
 
   Handle<Code> CompileLoadField(Handle<HeapType> type,
                                 Handle<JSObject> holder,
                                 Handle<Name> name,
                                 FieldIndex index,
                                 Representation representation);
 
   Handle<Code> CompileLoadCallback(Handle<HeapType> type,
@@ skipping 89 matching lines @@
                                                         Register prototype,
                                                         Label* miss);
 
 
   Register scratch4() { return registers_[5]; }
 };
 
 
 class NamedStoreHandlerCompiler : public PropertyHandlerCompiler {
  public:
-  NamedStoreHandlerCompiler(Isolate* isolate, Code::Kind kind = Code::STORE_IC)
+  explicit NamedStoreHandlerCompiler(Isolate* isolate)
       // Handlers do not use strict mode.

[Igor Sheludko, 2014/07/28 08:35:58]

Does this comment still make sense?

-      : PropertyHandlerCompiler(isolate, kind, kNoExtraICState,
-                                kCacheOnReceiver) {}
+      : PropertyHandlerCompiler(isolate, Code::STORE_IC, kCacheOnReceiver) {}
 
   virtual ~NamedStoreHandlerCompiler() {}
 
   Handle<Code> CompileStoreTransition(Handle<JSObject> object,
                                       LookupResult* lookup,
                                       Handle<Map> transition,
                                       Handle<Name> name);
 
   Handle<Code> CompileStoreField(Handle<JSObject> object,
                                  LookupResult* lookup,
@@ skipping 78 matching lines @@
     }
     return Builtins::kStoreIC_Slow;
   }
 
   static Register value();
 };
 
 
 class IndexedHandlerCompiler : public PropertyHandlerCompiler {
  public:
-  IndexedHandlerCompiler(Isolate* isolate,
-                         ExtraICState extra_ic_state = kNoExtraICState)
-      : PropertyHandlerCompiler(isolate, Code::KEYED_LOAD_IC, extra_ic_state,
+  explicit IndexedHandlerCompiler(Isolate* isolate)
+      : PropertyHandlerCompiler(isolate, Code::KEYED_LOAD_IC,
                                 kCacheOnReceiver) {}
 
   virtual ~IndexedHandlerCompiler() {}
 
   void CompileElementHandlers(MapHandleList* receiver_maps,
                               CodeHandleList* handlers);
 
   static void GenerateLoadDictionaryElement(MacroAssembler* masm);
   static void GenerateStoreDictionaryElement(MacroAssembler* masm);
 };
@@ skipping 52 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_