Revert "Unify computation of load stubs in stub cache."

TBR=verwaest@chromium.org

Review URL: https://codereview.chromium.org/24095005

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16661 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/ic.cc

@@ -1318,7 +1318,7 @@ Handle<Code> LoadIC::ComputeLoadHandler(LookupResult* lookup,
   switch (lookup->type()) {
     case FIELD:
       return isolate()->stub_cache()->ComputeLoadField(
-          name, receiver, holder, Code::LOAD_IC,
+          name, receiver, holder,
           lookup->GetFieldIndex(), lookup->representation());
     case CONSTANT: {
       Handle<Object> constant(lookup->GetConstant(), isolate());
@@ -1326,7 +1326,7 @@ Handle<Code> LoadIC::ComputeLoadHandler(LookupResult* lookup,
       // be embedded into code.
       if (constant->IsConsString()) return Handle<Code>::null();
       return isolate()->stub_cache()->ComputeLoadConstant(
-          name, receiver, holder, Code::LOAD_IC, constant);
+          name, receiver, holder, constant);
     }
     case NORMAL:
       if (holder->IsGlobalObject()) {
@@ -1350,7 +1350,7 @@ Handle<Code> LoadIC::ComputeLoadHandler(LookupResult* lookup,
         if (v8::ToCData<Address>(info->getter()) == 0) break;
         if (!info->IsCompatibleReceiver(*receiver)) break;
         return isolate()->stub_cache()->ComputeLoadCallback(
-            name, receiver, holder, Code::LOAD_IC, info);
+            name, receiver, holder, info);
       } else if (callback->IsAccessorPair()) {
         Handle<Object> getter(Handle<AccessorPair>::cast(callback)->getter(),
                               isolate());
@@ -1363,7 +1363,7 @@ Handle<Code> LoadIC::ComputeLoadHandler(LookupResult* lookup,
             call_optimization.IsCompatibleReceiver(*receiver) &&
             FLAG_js_accessor_ics) {
           return isolate()->stub_cache()->ComputeLoadCallback(
-              name, receiver, holder, Code::LOAD_IC, call_optimization);
+              name, receiver, holder, call_optimization);
         }
         return isolate()->stub_cache()->ComputeLoadViaGetter(
             name, receiver, holder, function);
@@ -1372,8 +1372,7 @@ Handle<Code> LoadIC::ComputeLoadHandler(LookupResult* lookup,
         PropertyIndex lengthIndex =
           PropertyIndex::NewHeaderIndex(JSArray::kLengthOffset / kPointerSize);
         return isolate()->stub_cache()->ComputeLoadField(
-            name, receiver, holder, Code::LOAD_IC,
-            lengthIndex, Representation::Tagged());
+            name, receiver, holder, lengthIndex, Representation::Tagged());
       }
       // TODO(dcarney): Handle correctly.
       if (callback->IsDeclaredAccessorInfo()) break;
@@ -1384,7 +1383,7 @@ Handle<Code> LoadIC::ComputeLoadHandler(LookupResult* lookup,
     case INTERCEPTOR:
       ASSERT(HasInterceptorGetter(*holder));
       return isolate()->stub_cache()->ComputeLoadInterceptor(
-          name, receiver, holder, Code::LOAD_IC);
+          name, receiver, holder);
     default:
       break;
   }
@@ -1539,16 +1538,16 @@ Handle<Code> KeyedLoadIC::ComputeLoadHandler(LookupResult* lookup,
   Handle<JSObject> holder(lookup->holder(), isolate());
   switch (lookup->type()) {
     case FIELD:
-      return isolate()->stub_cache()->ComputeLoadField(
-          name, receiver, holder, Code::KEYED_LOAD_IC,
+      return isolate()->stub_cache()->ComputeKeyedLoadField(
+          name, receiver, holder,
           lookup->GetFieldIndex(), lookup->representation());
     case CONSTANT: {
       Handle<Object> constant(lookup->GetConstant(), isolate());
       // TODO(2803): Don't compute a stub for cons strings because they cannot
       // be embedded into code.
       if (constant->IsConsString()) return Handle<Code>::null();
-      return isolate()->stub_cache()->ComputeLoadConstant(
-          name, receiver, holder, Code::KEYED_LOAD_IC, constant);
+      return isolate()->stub_cache()->ComputeKeyedLoadConstant(
+          name, receiver, holder, constant);
     }
     case CALLBACKS: {
       Handle<Object> callback_object(lookup->GetCallbackObject(), isolate());
@@ -1558,8 +1557,8 @@ Handle<Code> KeyedLoadIC::ComputeLoadHandler(LookupResult* lookup,
             Handle<ExecutableAccessorInfo>::cast(callback_object);
         if (v8::ToCData<Address>(callback->getter()) == 0) break;
         if (!callback->IsCompatibleReceiver(*receiver)) break;
-        return isolate()->stub_cache()->ComputeLoadCallback(
-            name, receiver, holder, Code::KEYED_LOAD_IC, callback);
+        return isolate()->stub_cache()->ComputeKeyedLoadCallback(
+            name, receiver, holder, callback);
       } else if (callback_object->IsAccessorPair()) {
         Handle<Object> getter(
             Handle<AccessorPair>::cast(callback_object)->getter(),
@@ -1572,16 +1571,16 @@ Handle<Code> KeyedLoadIC::ComputeLoadHandler(LookupResult* lookup,
         if (call_optimization.is_simple_api_call() &&
             call_optimization.IsCompatibleReceiver(*receiver) &&
             FLAG_js_accessor_ics) {
-          return isolate()->stub_cache()->ComputeLoadCallback(
-              name, receiver, holder, Code::KEYED_LOAD_IC, call_optimization);
+          return isolate()->stub_cache()->ComputeKeyedLoadCallback(
+              name, receiver, holder, call_optimization);
         }
       }
       break;
     }
     case INTERCEPTOR:
       ASSERT(HasInterceptorGetter(lookup->holder()));
-      return isolate()->stub_cache()->ComputeLoadInterceptor(
-          name, receiver, holder, Code::KEYED_LOAD_IC);
+      return isolate()->stub_cache()->ComputeKeyedLoadInterceptor(
+          name, receiver, holder);
     default:
       // Always rewrite to the generic case so that we do not
       // repeatedly try to rewrite.

src/stub-cache.cc

@@ -272,29 +272,21 @@ Handle<Code> StubCache::ComputeLoadNonexistent(Handle<Name> name,
 Handle<Code> StubCache::ComputeLoadField(Handle<Name> name,
                                          Handle<JSObject> receiver,
                                          Handle<JSObject> holder,
-                                         Code::Kind kind,
                                          PropertyIndex field,
                                          Representation representation) {
   if (receiver.is_identical_to(holder)) {
-    if (kind == Code::LOAD_IC) {
-      LoadFieldStub stub(field.is_inobject(holder),
-                         field.translate(holder),
-                         representation);
-      return stub.GetCode(isolate());
-    } else {
-      KeyedLoadFieldStub stub(field.is_inobject(holder),
-                              field.translate(holder),
-                              representation);
-      return stub.GetCode(isolate());
-    }
+    LoadFieldStub stub(field.is_inobject(holder),
+                       field.translate(holder),
+                       representation);
+    return stub.GetCode(isolate());
   }
 
   Handle<JSObject> stub_holder = StubHolder(receiver, holder);
   Handle<Code> stub = FindLoadHandler(
-      name, receiver, stub_holder, kind, Code::FIELD);
+      name, receiver, stub_holder, Code::LOAD_IC, Code::FIELD);
   if (!stub.is_null()) return stub;
 
-  BaseLoadStubCompiler compiler(isolate_, kind);
+  LoadStubCompiler compiler(isolate_);
   Handle<Code> handler =
       compiler.CompileLoadField(receiver, holder, name, field, representation);
   JSObject::UpdateMapCodeCache(stub_holder, name, handler);
@@ -306,15 +298,14 @@ Handle<Code> StubCache::ComputeLoadCallback(
     Handle<Name> name,
     Handle<JSObject> receiver,
     Handle<JSObject> holder,
-    Code::Kind kind,
     Handle<ExecutableAccessorInfo> callback) {
   ASSERT(v8::ToCData<Address>(callback->getter()) != 0);
   Handle<JSObject> stub_holder = StubHolder(receiver, holder);
   Handle<Code> stub = FindLoadHandler(
-      name, receiver, stub_holder, kind, Code::CALLBACKS);
+      name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS);
   if (!stub.is_null()) return stub;
 
-  BaseLoadStubCompiler compiler(isolate_, kind);
+  LoadStubCompiler compiler(isolate_);
   Handle<Code> handler =
       compiler.CompileLoadCallback(receiver, holder, name, callback);
   JSObject::UpdateMapCodeCache(stub_holder, name, handler);
@@ -326,14 +317,13 @@ Handle<Code> StubCache::ComputeLoadCallback(
     Handle<Name> name,
     Handle<JSObject> receiver,
     Handle<JSObject> holder,
-    Code::Kind kind,
     const CallOptimization& call_optimization) {
   Handle<JSObject> stub_holder = StubHolder(receiver, holder);
   Handle<Code> stub = FindLoadHandler(
-      name, receiver, stub_holder, kind, Code::CALLBACKS);
+      name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS);
   if (!stub.is_null()) return stub;
 
-  BaseLoadStubCompiler compiler(isolate_, kind);
+  LoadStubCompiler compiler(isolate_);
   Handle<Code> handler =
       compiler.CompileLoadCallback(receiver, holder, name, call_optimization);
   JSObject::UpdateMapCodeCache(stub_holder, name, handler);
@@ -361,30 +351,29 @@ Handle<Code> StubCache::ComputeLoadViaGetter(Handle<Name> name,
 Handle<Code> StubCache::ComputeLoadConstant(Handle<Name> name,
                                             Handle<JSObject> receiver,
                                             Handle<JSObject> holder,
-                                            Code::Kind kind,
                                             Handle<Object> value) {
   Handle<JSObject> stub_holder = StubHolder(receiver, holder);
   Handle<Code> handler = FindLoadHandler(
-      name, receiver, stub_holder, kind, Code::CONSTANT);
+      name, receiver, stub_holder, Code::LOAD_IC, Code::CONSTANT);
   if (!handler.is_null()) return handler;
 
-  BaseLoadStubCompiler compiler(isolate_, kind);
+  LoadStubCompiler compiler(isolate_);
   handler = compiler.CompileLoadConstant(receiver, holder, name, value);
   JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+
   return handler;
 }
 
 
 Handle<Code> StubCache::ComputeLoadInterceptor(Handle<Name> name,
                                                Handle<JSObject> receiver,
-                                               Handle<JSObject> holder,
-                                               Code::Kind kind) {
+                                               Handle<JSObject> holder) {
   Handle<JSObject> stub_holder = StubHolder(receiver, holder);
   Handle<Code> stub = FindLoadHandler(
-      name, receiver, stub_holder, kind, Code::INTERCEPTOR);
+      name, receiver, stub_holder, Code::LOAD_IC, Code::INTERCEPTOR);
   if (!stub.is_null()) return stub;
 
-  BaseLoadStubCompiler compiler(isolate_, kind);
+  LoadStubCompiler compiler(isolate_);
   Handle<Code> handler =
         compiler.CompileLoadInterceptor(receiver, holder, name);
   JSObject::UpdateMapCodeCache(stub_holder, name, handler);
@@ -415,6 +404,101 @@ Handle<Code> StubCache::ComputeLoadGlobal(Handle<Name> name,
 }
 
 
+Handle<Code> StubCache::ComputeKeyedLoadField(Handle<Name> name,
+                                              Handle<JSObject> receiver,
+                                              Handle<JSObject> holder,
+                                              PropertyIndex field,
+                                              Representation representation) {
+  if (receiver.is_identical_to(holder)) {
+    // TODO(titzer): this should use an HObjectAccess
+    KeyedLoadFieldStub stub(field.is_inobject(holder),
+                            field.translate(holder),
+                            representation);
+    return stub.GetCode(isolate());
+  }
+
+  Handle<JSObject> stub_holder = StubHolder(receiver, holder);
+  Handle<Code> stub = FindLoadHandler(
+      name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::FIELD);
+  if (!stub.is_null()) return stub;
+
+  KeyedLoadStubCompiler compiler(isolate_);
+  Handle<Code> handler =
+      compiler.CompileLoadField(receiver, holder, name, field, representation);
+  JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+  return handler;
+}
+
+
+Handle<Code> StubCache::ComputeKeyedLoadConstant(Handle<Name> name,
+                                                 Handle<JSObject> receiver,
+                                                 Handle<JSObject> holder,
+                                                 Handle<Object> value) {
+  Handle<JSObject> stub_holder = StubHolder(receiver, holder);
+  Handle<Code> handler = FindLoadHandler(
+      name, receiver, stub_holder, Code::KEYED_LOAD_IC,
+      Code::CONSTANT);
+  if (!handler.is_null()) return handler;
+
+  KeyedLoadStubCompiler compiler(isolate_);
+  handler = compiler.CompileLoadConstant(receiver, holder, name, value);
+  JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+  return handler;
+}
+
+
+Handle<Code> StubCache::ComputeKeyedLoadInterceptor(Handle<Name> name,
+                                                    Handle<JSObject> receiver,
+                                                    Handle<JSObject> holder) {
+  Handle<JSObject> stub_holder = StubHolder(receiver, holder);
+  Handle<Code> stub = FindLoadHandler(
+      name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::INTERCEPTOR);
+  if (!stub.is_null()) return stub;
+
+  KeyedLoadStubCompiler compiler(isolate_);
+  Handle<Code> handler =
+      compiler.CompileLoadInterceptor(receiver, holder, name);
+  JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+  return handler;
+}
+
+
+Handle<Code> StubCache::ComputeKeyedLoadCallback(
+    Handle<Name> name,
+    Handle<JSObject> receiver,
+    Handle<JSObject> holder,
+    Handle<ExecutableAccessorInfo> callback) {
+  Handle<JSObject> stub_holder = StubHolder(receiver, holder);
+  Handle<Code> stub = FindLoadHandler(
+      name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS);
+  if (!stub.is_null()) return stub;
+
+  KeyedLoadStubCompiler compiler(isolate_);
+  Handle<Code> handler =
+      compiler.CompileLoadCallback(receiver, holder, name, callback);
+  JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+  return handler;
+}
+
+
+Handle<Code> StubCache::ComputeKeyedLoadCallback(
+    Handle<Name> name,
+    Handle<JSObject> receiver,
+    Handle<JSObject> holder,
+    const CallOptimization& call_optimization) {
+  Handle<JSObject> stub_holder = StubHolder(receiver, holder);
+  Handle<Code> stub = FindLoadHandler(
+      name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS);
+  if (!stub.is_null()) return stub;
+
+  KeyedLoadStubCompiler compiler(isolate_);
+  Handle<Code> handler =
+      compiler.CompileLoadCallback(receiver, holder, name, call_optimization);
+  JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+  return handler;
+}
+
+
 Handle<Code> StubCache::ComputeStoreField(Handle<Name> name,
                                           Handle<JSObject> receiver,
                                           LookupResult* lookup,
@@ -1873,15 +1957,23 @@ void StubCompiler::TailCallBuiltin(MacroAssembler* masm, Builtins::Name name) {
 }
 
 
-Register* BaseLoadStoreStubCompiler::GetRegisters(Code::Kind kind) {
-  switch (kind) {
-    case Code::LOAD_IC: return LoadStubCompiler::registers();
-    case Code::STORE_IC: return StoreStubCompiler::registers();
-    case Code::KEYED_LOAD_IC: return KeyedLoadStubCompiler::registers();
-    case Code::KEYED_STORE_IC: return KeyedStoreStubCompiler::registers();
-    default: UNREACHABLE();
-  }
-  return NULL;
+void LoadStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
+  GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
+}
+
+
+void KeyedLoadStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
+  GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
+}
+
+
+void StoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
+  GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
+}
+
+
+void KeyedStoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
+  GDBJIT(AddCode(GDBJITInterface::KEYED_STORE_IC, *name, *code));
 }
 
 

src/stub-cache.h

@@ -130,20 +130,17 @@ class StubCache {
   Handle<Code> ComputeLoadField(Handle<Name> name,
                                 Handle<JSObject> object,
                                 Handle<JSObject> holder,
-                                Code::Kind kind,
                                 PropertyIndex field_index,
                                 Representation representation);
 
   Handle<Code> ComputeLoadCallback(Handle<Name> name,
                                    Handle<JSObject> object,
                                    Handle<JSObject> holder,
-                                   Code::Kind kind,
                                    Handle<ExecutableAccessorInfo> callback);
 
   Handle<Code> ComputeLoadCallback(Handle<Name> name,
                                    Handle<JSObject> object,
                                    Handle<JSObject> holder,
-                                   Code::Kind kind,
                                    const CallOptimization& call_optimization);
 
   Handle<Code> ComputeLoadViaGetter(Handle<Name> name,
@@ -154,13 +151,11 @@ class StubCache {
   Handle<Code> ComputeLoadConstant(Handle<Name> name,
                                    Handle<JSObject> object,
                                    Handle<JSObject> holder,
-                                   Code::Kind kind,
                                    Handle<Object> value);
 
   Handle<Code> ComputeLoadInterceptor(Handle<Name> name,
                                       Handle<JSObject> object,
-                                      Handle<JSObject> holder,
-                                      Code::Kind kind);
+                                      Handle<JSObject> holder);
 
   Handle<Code> ComputeLoadNormal(Handle<Name> name,
                                  Handle<JSObject> object);
@@ -173,6 +168,35 @@ class StubCache {
 
   // ---
 
+  Handle<Code> ComputeKeyedLoadField(Handle<Name> name,
+                                     Handle<JSObject> object,
+                                     Handle<JSObject> holder,
+                                     PropertyIndex field_index,
+                                     Representation representation);
+
+  Handle<Code> ComputeKeyedLoadCallback(
+      Handle<Name> name,
+      Handle<JSObject> object,
+      Handle<JSObject> holder,
+      Handle<ExecutableAccessorInfo> callback);
+
+  Handle<Code> ComputeKeyedLoadCallback(
+      Handle<Name> name,
+      Handle<JSObject> object,
+      Handle<JSObject> holder,
+      const CallOptimization& call_optimization);
+
+  Handle<Code> ComputeKeyedLoadConstant(Handle<Name> name,
+                                        Handle<JSObject> object,
+                                        Handle<JSObject> holder,
+                                        Handle<Object> value);
+
+  Handle<Code> ComputeKeyedLoadInterceptor(Handle<Name> name,
+                                           Handle<JSObject> object,
+                                           Handle<JSObject> holder);
+
+  // ---
+
   Handle<Code> ComputeStoreField(Handle<Name> name,
                                  Handle<JSObject> object,
                                  LookupResult* lookup,
@@ -618,10 +642,8 @@ enum FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS };
 
 class BaseLoadStoreStubCompiler: public StubCompiler {
  public:
-  BaseLoadStoreStubCompiler(Isolate* isolate,
-                            Code::Kind kind,
-                            Register* registers)
-      : StubCompiler(isolate), kind_(kind), registers_(registers) { }
+  BaseLoadStoreStubCompiler(Isolate* isolate, Register* registers)
+      : StubCompiler(isolate), registers_(registers) { }
   virtual ~BaseLoadStoreStubCompiler() { }
 
   Handle<Code> CompileMonomorphicIC(Handle<Map> receiver_map,
@@ -649,17 +671,6 @@ class BaseLoadStoreStubCompiler: public StubCompiler {
     return Builtins::kLoadIC_Miss;
   }
 
-  static GDBJITInterface::CodeTag GetGDBJITCodeTag(Code::Kind kind) {
-    switch (kind) {
-      case Code::LOAD_IC: return GDBJITInterface::LOAD_IC;
-      case Code::STORE_IC: return GDBJITInterface::STORE_IC;
-      case Code::KEYED_LOAD_IC: return GDBJITInterface::KEYED_LOAD_IC;
-      case Code::KEYED_STORE_IC: return GDBJITInterface::KEYED_STORE_IC;
-      default: UNREACHABLE();
-    }
-    return static_cast<GDBJITInterface::CodeTag>(0);
-  }
-
  protected:
   virtual Register HandlerFrontendHeader(Handle<JSObject> object,
                                          Register object_reg,
@@ -682,48 +693,24 @@ class BaseLoadStoreStubCompiler: public StubCompiler {
                          Handle<Name> name,
                          InlineCacheState state = MONOMORPHIC);
 
-  virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {
-    if (!code->is_inline_cache_stub()) return Logger::STUB_TAG;
-    switch (kind()) {
-      case Code::LOAD_IC: return code->ic_state() == MONOMORPHIC
-          ? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG;
-      case Code::STORE_IC: return code->ic_state() == MONOMORPHIC
-          ? Logger::STORE_IC_TAG : Logger::STORE_POLYMORPHIC_IC_TAG;
-      case Code::KEYED_LOAD_IC: return code->ic_state() == MONOMORPHIC
-          ? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG;
-      case Code::KEYED_STORE_IC: return code->ic_state() == MONOMORPHIC
-          ? Logger::KEYED_STORE_IC_TAG : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG;
-      default: UNREACHABLE();
-    }
-    return static_cast<Logger::LogEventsAndTags>(0);
-  }
-
-  void JitEvent(Handle<Name> name, Handle<Code> code) {
-    GDBJIT(AddCode(GetGDBJITCodeTag(kind()), *name, *code));
-  }
-
-  Code::Kind kind() const { return kind_; }
-
   virtual Code::ExtraICState extra_state() { return Code::kNoExtraICState; }
+  virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) = 0;
+  virtual void JitEvent(Handle<Name> name, Handle<Code> code) = 0;
+  virtual Code::Kind kind() = 0;
   virtual Register receiver() = 0;
   virtual Register name() = 0;
   virtual Register scratch1() = 0;
   virtual Register scratch2() = 0;
   virtual Register scratch3() = 0;
 
-  static Register* GetRegisters(Code::Kind kind);
-
-  Code::Kind kind_;
   Register* registers_;
 };
 
 
 class BaseLoadStubCompiler: public BaseLoadStoreStubCompiler {
  public:
-  BaseLoadStubCompiler(Isolate* isolate, Code::Kind kind)
-      : BaseLoadStoreStubCompiler(isolate, kind, GetRegisters(kind)) { }
-  BaseLoadStubCompiler(Isolate* isolate, Code::Kind kind, Register* registers)
-      : BaseLoadStoreStubCompiler(isolate, kind, registers) { }
+  BaseLoadStubCompiler(Isolate* isolate, Register* registers)
+      : BaseLoadStoreStubCompiler(isolate, registers) { }
   virtual ~BaseLoadStubCompiler() { }
 
   Handle<Code> CompileLoadField(Handle<JSObject> object,
@@ -808,7 +795,7 @@ class BaseLoadStubCompiler: public BaseLoadStoreStubCompiler {
 class LoadStubCompiler: public BaseLoadStubCompiler {
  public:
   explicit LoadStubCompiler(Isolate* isolate)
-      : BaseLoadStubCompiler(isolate, Code::LOAD_IC, registers()) { }
+      : BaseLoadStubCompiler(isolate, registers()) { }
 
   Handle<Code> CompileLoadNonexistent(Handle<JSObject> object,
                                       Handle<JSObject> last,
@@ -829,14 +816,22 @@ class LoadStubCompiler: public BaseLoadStubCompiler {
                                  Handle<Name> name,
                                  bool is_dont_delete);
 
+ private:
   static Register* registers();
+  virtual Code::Kind kind() { return Code::LOAD_IC; }
+  virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {
+    if (!code->is_inline_cache_stub()) return Logger::STUB_TAG;
+    return code->ic_state() == MONOMORPHIC
+        ? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG;
+  }
+  virtual void JitEvent(Handle<Name> name, Handle<Code> code);
 };
 
 
 class KeyedLoadStubCompiler: public BaseLoadStubCompiler {
  public:
   explicit KeyedLoadStubCompiler(Isolate* isolate)
-      : BaseLoadStubCompiler(isolate, Code::KEYED_LOAD_IC, registers()) { }
+      : BaseLoadStubCompiler(isolate, registers()) { }
 
   Handle<Code> CompileLoadElement(Handle<Map> receiver_map);
 
@@ -845,9 +840,15 @@ class KeyedLoadStubCompiler: public BaseLoadStubCompiler {
 
   static void GenerateLoadDictionaryElement(MacroAssembler* masm);
 
-  static Register* registers();
-
  private:
+  static Register* registers();
+  virtual Code::Kind kind() { return Code::KEYED_LOAD_IC; }
+  virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {
+    if (!code->is_inline_cache_stub()) return Logger::STUB_TAG;
+    return code->ic_state() == MONOMORPHIC
+        ? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG;
+  }
+  virtual void JitEvent(Handle<Name> name, Handle<Code> code);
   virtual void GenerateNameCheck(Handle<Name> name,
                                  Register name_reg,
                                  Label* miss);
@@ -857,9 +858,9 @@ class KeyedLoadStubCompiler: public BaseLoadStubCompiler {
 class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler {
  public:
   BaseStoreStubCompiler(Isolate* isolate,
-                        Code::Kind kind,
-                        StrictModeFlag strict_mode)
-      : BaseLoadStoreStubCompiler(isolate, kind, GetRegisters(kind)),
+                        StrictModeFlag strict_mode,
+                        Register* registers)
+      : BaseLoadStoreStubCompiler(isolate, registers),
         strict_mode_(strict_mode) { }
 
   virtual ~BaseStoreStubCompiler() { }
@@ -957,7 +958,7 @@ class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler {
 class StoreStubCompiler: public BaseStoreStubCompiler {
  public:
   StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode)
-      : BaseStoreStubCompiler(isolate, Code::STORE_IC, strict_mode) { }
+      : BaseStoreStubCompiler(isolate, strict_mode, registers()) { }
 
 
   Handle<Code> CompileStoreCallback(Handle<JSObject> object,
@@ -981,7 +982,15 @@ class StoreStubCompiler: public BaseStoreStubCompiler {
   Handle<Code> CompileStoreInterceptor(Handle<JSObject> object,
                                        Handle<Name> name);
 
+ private:
   static Register* registers();
+  virtual Code::Kind kind() { return Code::STORE_IC; }
+  virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {
+    if (!code->is_inline_cache_stub()) return Logger::STUB_TAG;
+    return code->ic_state() == MONOMORPHIC
+        ? Logger::STORE_IC_TAG : Logger::STORE_POLYMORPHIC_IC_TAG;
+  }
+  virtual void JitEvent(Handle<Name> name, Handle<Code> code);
 };
 
 
@@ -990,7 +999,7 @@ class KeyedStoreStubCompiler: public BaseStoreStubCompiler {
   KeyedStoreStubCompiler(Isolate* isolate,
                          StrictModeFlag strict_mode,
                          KeyedAccessStoreMode store_mode)
-      : BaseStoreStubCompiler(isolate, Code::KEYED_STORE_IC, strict_mode),
+      : BaseStoreStubCompiler(isolate, strict_mode, registers()),
         store_mode_(store_mode) { }
 
   Handle<Code> CompileStoreElement(Handle<Map> receiver_map);
@@ -1003,8 +1012,6 @@ class KeyedStoreStubCompiler: public BaseStoreStubCompiler {
 
   static void GenerateStoreDictionaryElement(MacroAssembler* masm);
 
-  static Register* registers();
-
  protected:
   virtual Code::ExtraICState extra_state() {
     return Code::ComputeExtraICState(store_mode_, strict_mode());
@@ -1015,6 +1022,14 @@ class KeyedStoreStubCompiler: public BaseStoreStubCompiler {
     return registers()[3];
   }
 
+  static Register* registers();
+  virtual Code::Kind kind() { return Code::KEYED_STORE_IC; }
+  virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {
+    if (!code->is_inline_cache_stub()) return Logger::STUB_TAG;
+    return code->ic_state() == MONOMORPHIC
+        ? Logger::KEYED_STORE_IC_TAG : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG;
+  }
+  virtual void JitEvent(Handle<Name> name, Handle<Code> code);
   virtual void GenerateNameCheck(Handle<Name> name,
                                  Register name_reg,
                                  Label* miss);