Use POLYMORPHIC for polymorphic Keyed(Load|Store)IC

src/ic.cc

 // 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 1091 matching lines @@
     Handle<Map> receiver_map = receiver_maps->at(i);
     Handle<Code> cached_stub = ComputeMonomorphicStubWithoutMapCheck(
         receiver_map, strict_mode, growth_mode);
     handler_ics.Add(cached_stub);
   }
   KeyedLoadStubCompiler compiler(isolate());
   Handle<Code> code = compiler.CompileLoadPolymorphic(
       receiver_maps, &handler_ics);
   isolate()->counters()->keyed_load_polymorphic_stubs()->Increment();
   PROFILE(isolate(),
-          CodeCreateEvent(Logger::KEYED_LOAD_MEGAMORPHIC_IC_TAG, *code, 0));
+          CodeCreateEvent(Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG, *code, 0));
   return code;
 }
 
 
 static Handle<Object> TryConvertKey(Handle<Object> key, Isolate* isolate) {
   // This helper implements a few common fast cases for converting
   // non-smi keys of keyed loads/stores to a smi or a string.
   if (key->IsHeapNumber()) {
     double value = Handle<HeapNumber>::cast(key)->value();
     if (isnan(value)) {
@@ skipping 199 matching lines @@
         // repeatedly try to rewrite.
         code = generic_stub();
         break;
     }
   }
 
   // Patch the call site depending on the state of the cache.
   switch (state) {
     case UNINITIALIZED:
     case PREMONOMORPHIC:
+    case POLYMORPHIC:
       set_target(*code);
       break;
     case MONOMORPHIC:
       // Only move to megamorphic if the target changes.
       if (target() != *code) {
         set_target(*megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
     case DEBUG_BREAK:
     case DEBUG_PREPARE_STEP_IN:
       break;
     case MONOMORPHIC_PROTOTYPE_FAILURE:
-    case POLYMORPHIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("KeyedLoadIC", name, state, target());
 }
 
 
 static bool StoreICableLookup(LookupResult* lookup) {
   // Bail out if we didn't find a result.
@@ skipping 288 matching lines @@
 void KeyedIC::GetReceiverMapsForStub(Handle<Code> stub,
                                      MapHandleList* result) {
   ASSERT(stub->is_inline_cache_stub());
   if (!string_stub().is_null() && stub.is_identical_to(string_stub())) {
     return result->Add(isolate()->factory()->string_map());
   } else if (stub->is_keyed_load_stub() || stub->is_keyed_store_stub()) {
     switch (stub->ic_state()) {
       case MONOMORPHIC:
         result->Add(Handle<Map>(stub->FindFirstMap()));
         break;
-      case MEGAMORPHIC: {
+      case POLYMORPHIC: {
         AssertNoAllocation no_allocation;
         int mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
         for (RelocIterator it(*stub, mask); !it.done(); it.next()) {
           RelocInfo* info = it.rinfo();
           Handle<Object> object(info->target_object());
           ASSERT(object->IsMap());
           AddOneReceiverMapIfMissing(result, Handle<Map>::cast(object));
         }
         break;
       }
+      case MEGAMORPHIC:
+        break;
       case UNINITIALIZED:
       case PREMONOMORPHIC:
       case MONOMORPHIC_PROTOTYPE_FAILURE:
-      case POLYMORPHIC:
       case DEBUG_BREAK:
       case DEBUG_PREPARE_STEP_IN:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
 Handle<Code> KeyedIC::ComputeStub(Handle<JSObject> receiver,
@@ skipping 191 matching lines @@
     }
     ASSERT(!cached_stub.is_null());
     handler_ics.Add(cached_stub);
     transitioned_maps.Add(transitioned_map);
   }
   KeyedStoreStubCompiler compiler(isolate(), strict_mode, grow_mode);
   Handle<Code> code = compiler.CompileStorePolymorphic(
       receiver_maps, &handler_ics, &transitioned_maps);
   isolate()->counters()->keyed_store_polymorphic_stubs()->Increment();
   PROFILE(isolate(),
-          CodeCreateEvent(Logger::KEYED_STORE_MEGAMORPHIC_IC_TAG, *code, 0));
+          CodeCreateEvent(Logger::KEYED_STORE_POLYMORPHIC_IC_TAG, *code, 0));
   return code;
 }
 
 
 KeyedIC::StubKind KeyedStoreIC::GetStubKind(Handle<JSObject> receiver,
                                             Handle<Object> key,
                                             Handle<Object> value) {
   ASSERT(key->IsSmi());
   int index = Smi::cast(*key)->value();
   bool allow_growth = receiver->IsJSArray() &&
@@ skipping 203 matching lines @@
       UNREACHABLE();
       return;
   }
 
   ASSERT(!code.is_null());
 
   // Patch the call site depending on the state of the cache.
   switch (state) {
     case UNINITIALIZED:
     case PREMONOMORPHIC:
+    case POLYMORPHIC:
       set_target(*code);
       break;
     case MONOMORPHIC:
       // Only move to megamorphic if the target changes.
       if (target() != *code) {
         set_target((strict_mode == kStrictMode)
                      ? *megamorphic_stub_strict()
                      : *megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
     case DEBUG_BREAK:
     case DEBUG_PREPARE_STEP_IN:
       break;
     case MONOMORPHIC_PROTOTYPE_FAILURE:
-    case POLYMORPHIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("KeyedStoreIC", name, state, target());
 }
 
 
 #undef TRACE_IC
 
@@ skipping 733 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal