Only generate a single normal IC per kind per slow-mode map.

src/stub-cache.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/v8.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/ast.h"
 #include "src/code-stubs.h"
@@ skipping 114 matching lines @@
   Handle<Object> probe(stub_holder->FindInCodeCache(*name, flags),
                        name->GetIsolate());
   if (probe->IsCode()) return Handle<Code>::cast(probe);
   return Handle<Code>::null();
 }
 
 
 Handle<Code> PropertyICCompiler::ComputeMonomorphic(
     Code::Kind kind, Handle<Name> name, Handle<HeapType> type,
     Handle<Code> handler, ExtraICState extra_ic_state) {
+  Isolate* isolate = name->GetIsolate();
+  if (handler.is_identical_to(isolate->builtins()->LoadIC_Normal()) ||
+      handler.is_identical_to(isolate->builtins()->StoreIC_Normal())) {
+    name = isolate->factory()->normal_ic_symbol();
+  }
+
   CacheHolderFlag flag;
-  Isolate* isolate = name->GetIsolate();
   Handle<Map> stub_holder = IC::GetICCacheHolder(*type, isolate, &flag);
 
   Handle<Code> ic;
   // There are multiple string maps that all use the same prototype. That
   // prototype cannot hold multiple handlers, one for each of the string maps,
   // for a single name. Hence, turn off caching of the IC.
   bool can_be_cached = !type->Is(HeapType::String());
   if (can_be_cached) {
     ic = Find(name, stub_holder, kind, extra_ic_state, flag);
     if (!ic.is_null()) return ic;
@@ skipping 1203 matching lines @@
           Handle<FunctionTemplateInfo>(
               FunctionTemplateInfo::cast(signature->receiver()));
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal