Add MEGAMORPHIC state support for KeyedLoadIC

src/code-stubs-hydrogen.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/bailout-reason.h"
 #include "src/code-stubs.h"
 #include "src/field-index.h"
 #include "src/hydrogen.h"
@@ skipping 1889 matching lines @@
       hash = AddUncasted<HShr>(hash, Add<HConstant>(Name::kHashShift));
 
       HValue* value = BuildUncheckedDictionaryElementLoad(receiver,
                                                           properties,
                                                           key,
                                                           hash);
       Push(value);
     }
     if_dict_properties.Else();
     {
+      // TODO(dcarney): don't use keyed lookup cache, but convert to use
+      // megamorphic stub cache.
+      UNREACHABLE();
       //  Key is string, properties are fast mode
       HValue* hash = BuildKeyedLookupCacheHash(receiver, key);
 
       ExternalReference cache_keys_ref =
           ExternalReference::keyed_lookup_cache_keys(isolate());
       HValue* cache_keys = Add<HConstant>(cache_keys_ref);
 
       HValue* map =
           Add<HLoadNamedField>(receiver, nullptr, HObjectAccess::ForMap());
       HValue* base_index = AddUncasted<HMul>(hash, Add<HConstant>(2));
@@ skipping 249 matching lines @@
   array_checker.Else();
   {
     // Check if the IC is in generic state.
     IfBuilder generic_checker(this);
     HConstant* generic_symbol =
         Add<HConstant>(isolate()->factory()->generic_symbol());
     generic_checker.If<HCompareObjectEqAndBranch>(feedback, generic_symbol);
     generic_checker.Then();
     {
       // Tail-call to the generic KeyedLoadIC, treating it like a handler.
-      Handle<Code> stub = KeyedLoadIC::generic_stub(isolate());
+      Handle<Code> stub = KeyedLoadIC::megamorphic_stub(isolate());
       HValue* constant_stub = Add<HConstant>(stub);
       LoadDescriptor descriptor(isolate());
       HValue* op_vals[] = {context(), receiver, name};
       Add<HCallWithDescriptor>(constant_stub, 0, descriptor,
                                Vector<HValue*>(op_vals, 3), TAIL_CALL);
       // We never return here, it is a tail call.
     }
     generic_checker.End();
   }
   array_checker.End();
@@ skipping 22 matching lines @@
   // megamorphic case is handled as part of the default stub.
   DCHECK(!FLAG_vector_ics);
 
   // Probe the stub cache.
   Add<HTailCallThroughMegamorphicCache>(receiver, name);
 
   // We never continue.
   return graph()->GetConstant0();
 }
 } }  // namespace v8::internal