StubCompiler gets extra_ic_state member.

src/stub-cache.h

 // Copyright 2012 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 346 matching lines @@
 DECLARE_RUNTIME_FUNCTION(MaybeObject*, KeyedLoadPropertyWithInterceptor);
 
 
 enum PrototypeCheckType { CHECK_ALL_MAPS, SKIP_RECEIVER };
 enum IcCheckType { ELEMENT, PROPERTY };
 
 
 // The stub compilers compile stubs for the stub cache.
 class StubCompiler BASE_EMBEDDED {
  public:
-  explicit StubCompiler(Isolate* isolate)
-      : isolate_(isolate), masm_(isolate, NULL, 256), failure_(NULL) { }
+  explicit StubCompiler(Isolate* isolate,
+                        ExtraICState extra_ic_state = kNoExtraICState)
+      : isolate_(isolate), extra_ic_state_(extra_ic_state),
+        masm_(isolate, NULL, 256), failure_(NULL) { }
 
   // Functions to compile either CallIC or KeyedCallIC.  The specific kind
   // is extracted from the code flags.
   Handle<Code> CompileCallInitialize(Code::Flags flags);
   Handle<Code> CompileCallPreMonomorphic(Code::Flags flags);
   Handle<Code> CompileCallNormal(Code::Flags flags);
   Handle<Code> CompileCallMegamorphic(Code::Flags flags);
   Handle<Code> CompileCallArguments(Code::Flags flags);
   Handle<Code> CompileCallMiss(Code::Flags flags);
 
@@ skipping 103 matching lines @@
                            int save_at_depth,
                            Label* miss,
                            PrototypeCheckType check = CHECK_ALL_MAPS);
 
   void GenerateBooleanCheck(Register object, Label* miss);
 
  protected:
   Handle<Code> GetCodeWithFlags(Code::Flags flags, const char* name);
   Handle<Code> GetCodeWithFlags(Code::Flags flags, Handle<Name> name);
 
+  ExtraICState extra_state() { return extra_ic_state_; }
+
   MacroAssembler* masm() { return &masm_; }
   void set_failure(Failure* failure) { failure_ = failure; }
 
   static void LookupPostInterceptor(Handle<JSObject> holder,
                                     Handle<Name> name,
                                     LookupResult* lookup);
 
   Isolate* isolate() { return isolate_; }
   Heap* heap() { return isolate()->heap(); }
   Factory* factory() { return isolate()->factory(); }
 
   static void GenerateTailCall(MacroAssembler* masm, Handle<Code> code);
 
  private:
   Isolate* isolate_;
+  const ExtraICState extra_ic_state_;
   MacroAssembler masm_;
   Failure* failure_;
 };
 
 
 enum FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS };
 
 
 class BaseLoadStoreStubCompiler: public StubCompiler {
  public:
   BaseLoadStoreStubCompiler(Isolate* isolate,
                             Code::Kind kind,
+                            ExtraICState extra_ic_state = kNoExtraICState,
                             InlineCacheHolderFlag cache_holder = OWN_MAP)
-      : StubCompiler(isolate), kind_(kind), cache_holder_(cache_holder) {
+      : StubCompiler(isolate, extra_ic_state),
+        kind_(kind),
+        cache_holder_(cache_holder) {
     InitializeRegisters();
   }
   virtual ~BaseLoadStoreStubCompiler() { }
 
   Handle<Code> CompileMonomorphicIC(Handle<Type> type,
                                     Handle<Code> handler,
                                     Handle<Name> name);
 
   Handle<Code> CompilePolymorphicIC(TypeHandleList* types,
                                     CodeHandleList* handlers,
@@ skipping 51 matching lines @@
     } else if (kind_ == Code::STORE_IC) {
       return code->ic_state() == MONOMORPHIC
           ? Logger::STORE_IC_TAG : Logger::STORE_POLYMORPHIC_IC_TAG;
     } else {
       return code->ic_state() == MONOMORPHIC
           ? Logger::KEYED_STORE_IC_TAG : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG;
     }
   }
   void JitEvent(Handle<Name> name, Handle<Code> code);
 
-  virtual ExtraICState extra_state() { return kNoExtraICState; }
   virtual Register receiver() = 0;
   virtual Register name() = 0;
   virtual Register scratch1() = 0;
   virtual Register scratch2() = 0;
   virtual Register scratch3() = 0;
 
   void InitializeRegisters();
 
   bool IncludesNumberType(TypeHandleList* types);
 
   Code::Kind kind_;
   InlineCacheHolderFlag cache_holder_;
   Register* registers_;
 };
 
 
 class LoadStubCompiler: public BaseLoadStoreStubCompiler {
  public:
   LoadStubCompiler(Isolate* isolate,
+                   ExtraICState extra_ic_state = kNoExtraICState,
                    InlineCacheHolderFlag cache_holder = OWN_MAP,
                    Code::Kind kind = Code::LOAD_IC)
-      : BaseLoadStoreStubCompiler(isolate, kind, cache_holder) { }
+      : BaseLoadStoreStubCompiler(isolate, kind, extra_ic_state,
+                                  cache_holder) { }
   virtual ~LoadStubCompiler() { }
 
   Handle<Code> CompileLoadField(Handle<Type> type,
                                 Handle<JSObject> holder,
                                 Handle<Name> name,
                                 PropertyIndex index,
                                 Representation representation);
 
   Handle<Code> CompileLoadCallback(Handle<Type> type,
                                    Handle<JSObject> holder,
@@ skipping 76 matching lines @@
   virtual Register scratch1() { return registers_[2]; }
   virtual Register scratch2() { return registers_[3]; }
   virtual Register scratch3() { return registers_[4]; }
   Register scratch4() { return registers_[5]; }
 };
 
 
 class KeyedLoadStubCompiler: public LoadStubCompiler {
  public:
   KeyedLoadStubCompiler(Isolate* isolate,
+                        ExtraICState extra_ic_state = kNoExtraICState,
                         InlineCacheHolderFlag cache_holder = OWN_MAP)
-      : LoadStubCompiler(isolate, cache_holder, Code::KEYED_LOAD_IC) { }
+      : LoadStubCompiler(isolate, extra_ic_state, cache_holder,
+                         Code::KEYED_LOAD_IC) { }
 
   Handle<Code> CompileLoadElement(Handle<Map> receiver_map);
 
   void CompileElementHandlers(MapHandleList* receiver_maps,
                               CodeHandleList* handlers);
 
   static void GenerateLoadDictionaryElement(MacroAssembler* masm);
 
  protected:
   static Register* registers();
 
  private:
   virtual void GenerateNameCheck(Handle<Name> name,
                                  Register name_reg,
                                  Label* miss);
   friend class BaseLoadStoreStubCompiler;
 };
 
 
 class StoreStubCompiler: public BaseLoadStoreStubCompiler {
  public:
   StoreStubCompiler(Isolate* isolate,
-                    StrictModeFlag strict_mode,
+                    ExtraICState extra_ic_state,
                     Code::Kind kind = Code::STORE_IC)
-      : BaseLoadStoreStubCompiler(isolate, kind),
-        strict_mode_(strict_mode) { }
+      : BaseLoadStoreStubCompiler(isolate, kind, extra_ic_state) {}
 
   virtual ~StoreStubCompiler() { }
 
   Handle<Code> CompileStoreTransition(Handle<JSObject> object,
                                       LookupResult* lookup,
                                       Handle<Map> transition,
                                       Handle<Name> name);
 
   Handle<Code> CompileStoreField(Handle<JSObject> object,
                                  LookupResult* lookup,
@@ skipping 70 matching lines @@
   void GenerateRestoreName(MacroAssembler* masm,
                            Label* label,
                            Handle<Name> name);
 
   virtual Register receiver() { return registers_[0]; }
   virtual Register name()     { return registers_[1]; }
   Register value()    { return registers_[2]; }
   virtual Register scratch1() { return registers_[3]; }
   virtual Register scratch2() { return registers_[4]; }
   virtual Register scratch3() { return registers_[5]; }
-  StrictModeFlag strict_mode() { return strict_mode_; }
-  virtual ExtraICState extra_state() {
-    return StoreIC::ComputeExtraICState(strict_mode_);
+  StrictModeFlag strict_mode() {
+    return StoreIC::GetStrictMode(extra_state());

[Toon Verwaest, 2013/12/02 11:44:31]

Is this method used?

[mvstanton, 2013/12/02 11:48:50]

I removed that one now, good catch.

   }
 
  protected:
   static Register* registers();
 
  private:
-  StrictModeFlag strict_mode_;
   friend class BaseLoadStoreStubCompiler;
 };
 
 
 class KeyedStoreStubCompiler: public StoreStubCompiler {
  public:
   KeyedStoreStubCompiler(Isolate* isolate,
-                         StrictModeFlag strict_mode,
-                         KeyedAccessStoreMode store_mode)
-      : StoreStubCompiler(isolate, strict_mode, Code::KEYED_STORE_IC),
-        store_mode_(store_mode) { }
+                         ExtraICState extra_ic_state)
+      : StoreStubCompiler(isolate, extra_ic_state, Code::KEYED_STORE_IC) {}
 
   Handle<Code> CompileStoreElement(Handle<Map> receiver_map);
 
   Handle<Code> CompileStorePolymorphic(MapHandleList* receiver_maps,
                                        CodeHandleList* handler_stubs,
                                        MapHandleList* transitioned_maps);
 
   Handle<Code> CompileStoreElementPolymorphic(MapHandleList* receiver_maps);
 
   static void GenerateStoreDictionaryElement(MacroAssembler* masm);
 
  protected:
-  virtual ExtraICState extra_state() {
-    return KeyedStoreIC::ComputeExtraICState(strict_mode(), store_mode_);
+  static Register* registers();
+
+  KeyedAccessStoreMode store_mode() {
+    return KeyedStoreIC::GetKeyedAccessStoreMode(extra_state());
   }
-  static Register* registers();
 
  private:
   Register transition_map() {
     return registers()[3];
   }
 
   virtual void GenerateNameCheck(Handle<Name> name,
                                  Register name_reg,
                                  Label* miss);
-  KeyedAccessStoreMode store_mode_;
   friend class BaseLoadStoreStubCompiler;
 };
 
 
 // Subset of FUNCTIONS_WITH_ID_LIST with custom constant/global call
 // IC stubs.
 #define CUSTOM_CALL_IC_GENERATORS(V)            \
   V(ArrayPush)                                  \
   V(ArrayPop)                                   \
   V(StringCharCodeAt)                           \
@@ skipping 107 matching lines @@
                                     Handle<JSFunction> function,
                                     Label* miss);
 
   void GenerateFunctionCheck(Register function, Register scratch, Label* miss);
 
   // Generates a jump to CallIC miss stub.
   void GenerateMissBranch();
 
   const ParameterCount arguments_;
   const Code::Kind kind_;
-  const ExtraICState extra_state_;
   const InlineCacheHolderFlag cache_holder_;
 };
 
 
 // Holds information about possible function call optimizations.
 class CallOptimization BASE_EMBEDDED {
  public:
   explicit CallOptimization(LookupResult* lookup);
 
   explicit CallOptimization(Handle<JSFunction> function);
@@ skipping 42 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_