Introduce POLYMORPHIC

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 25 matching lines @@
 #include "runtime.h"
 #include "stub-cache.h"
 
 namespace v8 {
 namespace internal {
 
 #ifdef DEBUG
 char IC::TransitionMarkFromState(IC::State state) {
   switch (state) {
     case UNINITIALIZED: return '0';
-    case PREMONOMORPHIC: return 'P';
+    case PREMONOMORPHIC: return '.';
     case MONOMORPHIC: return '1';
     case MONOMORPHIC_PROTOTYPE_FAILURE: return '^';
+    case POLYMORPHIC: return 'P';
     case MEGAMORPHIC: return IsGeneric() ? 'G' : 'N';
 
     // We never see the debugger states here, because the state is
     // computed from the original code - not the patched code. Let
     // these cases fall through to the unreachable code below.
     case DEBUG_BREAK: break;
     case DEBUG_PREPARE_STEP_IN: break;
   }
   UNREACHABLE();
   return 0;
@@ skipping 706 matching lines @@
       Handle<JSObject> cache_object = object->IsJSObject()
           ? Handle<JSObject>::cast(object)
           : Handle<JSObject>(JSObject::cast(object->GetPrototype()));
       // Update the stub cache.
       isolate()->stub_cache()->Set(*name, cache_object->map(), *code);
       break;
     }
     case DEBUG_BREAK:
     case DEBUG_PREPARE_STEP_IN:
       break;
+    case POLYMORPHIC:
+      UNREACHABLE();
+      break;
   }
 
   TRACE_IC(kind_ == Code::CALL_IC ? "CallIC" : "KeyedCallIC",
            name, state, target());
 }
 
 
 MaybeObject* KeyedCallIC::LoadFunction(State state,
                                        Handle<Object> object,
                                        Handle<Object> key) {
@@ skipping 272 matching lines @@
         set_target(*megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
       // Cache code holding map should be consistent with
       // GenerateMonomorphicCacheProbe.
       isolate()->stub_cache()->Set(*name, receiver->map(), *code);
     case DEBUG_BREAK:
     case DEBUG_PREPARE_STEP_IN:
       break;
+    case POLYMORPHIC:
+      UNREACHABLE();
+      break;
   }
 
   TRACE_IC("LoadIC", name, state, target());
 }
 
 
 Handle<Code> KeyedLoadIC::GetElementStubWithoutMapCheck(
     bool is_js_array,
     ElementsKind elements_kind,
     KeyedAccessGrowMode grow_mode) {
@@ skipping 249 matching lines @@
     case MONOMORPHIC:
       // Only move to megamorphic if the target changes.
       if (target() != *code) {
         set_target(*megamorphic_stub());
       }
     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 252 matching lines @@
                      : megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
       // Update the stub cache.
       isolate()->stub_cache()->Set(*name, receiver->map(), *code);
       break;
     case DEBUG_BREAK:
     case DEBUG_PREPARE_STEP_IN:
       break;
+    case POLYMORPHIC:
+      UNREACHABLE();
+      break;
   }
 
   TRACE_IC("StoreIC", name, state, target());
 }
 
 
 static bool AddOneReceiverMapIfMissing(MapHandleList* receiver_maps,
                                        Handle<Map> new_receiver_map) {
   ASSERT(!new_receiver_map.is_null());
   for (int current = 0; current < receiver_maps->length(); ++current) {
@@ skipping 24 matching lines @@
           RelocInfo* info = it.rinfo();
           Handle<Object> object(info->target_object());
           ASSERT(object->IsMap());
           AddOneReceiverMapIfMissing(result, Handle<Map>::cast(object));
         }
         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 73 matching lines @@
 
   if ((Code::GetKeyedAccessGrowMode(target()->extra_ic_state()) ==
        ALLOW_JSARRAY_GROWTH)) {
     grow_mode = ALLOW_JSARRAY_GROWTH;
   }
 
   Handle<PolymorphicCodeCache> cache =
       isolate()->factory()->polymorphic_code_cache();
   Code::ExtraICState extra_state = Code::ComputeExtraICState(grow_mode,
                                                              strict_mode);
-  Code::Flags flags = Code::ComputeFlags(kind(), MEGAMORPHIC, extra_state);
+  Code::Flags flags = Code::ComputeFlags(kind(), POLYMORPHIC, extra_state);
   Handle<Object> probe = cache->Lookup(&target_receiver_maps, flags);
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   Handle<Code> stub =
       ComputePolymorphicStub(&target_receiver_maps, strict_mode, grow_mode);
   PolymorphicCodeCache::Update(cache, &target_receiver_maps, flags, stub);
   return stub;
 }
 
 
@@ skipping 336 matching lines @@
         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