[ic] Split megamorphic stub cache in two caches (for loads and for stores).

src/ic/ic.cc

 // 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.
 
 #include "src/ic/ic.h"
 
 #include "src/accessors.h"
 #include "src/api-arguments-inl.h"
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 945 matching lines @@
         }
       }
     }
     if (code.is_null()) code = ComputeHandler(lookup);
   }
 
   PatchCache(lookup->name(), code);
   TRACE_IC("LoadIC", lookup->name());
 }
 
+StubCache* IC::stub_cache() {
+  switch (kind()) {
+    case Code::LOAD_IC:
+    case Code::KEYED_LOAD_IC:
+      return isolate()->load_stub_cache();
+
+    case Code::STORE_IC:
+    case Code::KEYED_STORE_IC:
+      return isolate()->store_stub_cache();
+
+    default:
+      break;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
 
 void IC::UpdateMegamorphicCache(Map* map, Name* name, Code* code) {
-  isolate()->stub_cache()->Set(name, map, code);
+  stub_cache()->Set(name, map, code);
 }
 
 
 Handle<Code> IC::ComputeHandler(LookupIterator* lookup, Handle<Object> value) {
   // Try to find a globally shared handler stub.
   Handle<Code> code = GetMapIndependentHandler(lookup);
   if (!code.is_null()) return code;
 
   // Otherwise check the map's handler cache for a map-specific handler, and
   // compile one if the cache comes up empty.
@@ skipping 23 matching lines @@
         TRACE_HANDLER_STATS(isolate(), IC_HandlerCacheHit);
         return code;
       }
     } else {
       // maybe_handler_ is only populated for MONOMORPHIC and POLYMORPHIC ICs.
       // In MEGAMORPHIC case, check if the handler in the megamorphic stub
       // cache (which just missed) is different from the cached handler.
       if (state() == MEGAMORPHIC && lookup->GetReceiver()->IsHeapObject()) {
         Map* map = Handle<HeapObject>::cast(lookup->GetReceiver())->map();
         Code* megamorphic_cached_code =
-            isolate()->stub_cache()->Get(*lookup->name(), map, code->flags());
+            stub_cache()->Get(*lookup->name(), map, code->flags());
         if (megamorphic_cached_code != *code) {
           TRACE_HANDLER_STATS(isolate(), IC_HandlerCacheHit);
           return code;
         }
       } else {
         TRACE_HANDLER_STATS(isolate(), IC_HandlerCacheHit);
         return code;
       }
     }
   }
@@ skipping 1969 matching lines @@
     DCHECK_EQ(FeedbackVectorSlotKind::KEYED_LOAD_IC,
               vector->GetKind(vector_slot));
     KeyedLoadICNexus nexus(vector, vector_slot);
     KeyedLoadIC ic(IC::EXTRA_CALL_FRAME, isolate, &nexus);
     ic.UpdateState(receiver, key);
     RETURN_RESULT_OR_FAILURE(isolate, ic.Load(receiver, key));
   }
 }
 }  // namespace internal
 }  // namespace v8