Separate MEGAMORPHIC and GENERIC ic states

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 29 matching lines @@
 namespace internal {
 
 #ifdef DEBUG
 char IC::TransitionMarkFromState(IC::State state) {
   switch (state) {
     case UNINITIALIZED: return '0';
     case PREMONOMORPHIC: return '.';
     case MONOMORPHIC: return '1';
     case MONOMORPHIC_PROTOTYPE_FAILURE: return '^';
     case POLYMORPHIC: return 'P';
-    case MEGAMORPHIC: return IsGeneric() ? 'G' : 'N';
+    case MEGAMORPHIC: return 'N';
+    case GENERIC: return 'G';
 
     // 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_STUB: break;
   }
   UNREACHABLE();
   return 0;
 }
 
@@ skipping 704 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_STUB:
       break;
     case POLYMORPHIC:
+    case GENERIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC(kind_ == Code::CALL_IC ? "CallIC" : "KeyedCallIC",
            name, state, target());
 }
 
 
 MaybeObject* KeyedCallIC::LoadFunction(State state,
                                        Handle<Object> object,
                                        Handle<Object> key) {
   if (key->IsSymbol()) {
     return CallICBase::LoadFunction(state,
                                     Code::kNoExtraICState,
                                     object,
                                     Handle<String>::cast(key));
   }
 
   if (object->IsUndefined() || object->IsNull()) {
     return TypeError("non_object_property_call", object, key);
   }
 
   if (FLAG_use_ic && state != MEGAMORPHIC && object->IsHeapObject()) {
+    ASSERT(state != GENERIC);
     int argc = target()->arguments_count();
     Handle<Map> map =
         isolate()->factory()->non_strict_arguments_elements_map();
     if (object->IsJSObject() &&
         Handle<JSObject>::cast(object)->elements()->map() == *map) {
       Handle<Code> code = isolate()->stub_cache()->ComputeCallArguments(
           argc, Code::KEYED_CALL_IC);
       set_target(*code);
       TRACE_IC("KeyedCallIC", key, state, target());
     } else if (!object->IsAccessCheckNeeded()) {
@@ skipping 39 matching lines @@
       Handle<Code> stub;
       if (state == UNINITIALIZED) {
         stub = pre_monomorphic_stub();
       } else if (state == PREMONOMORPHIC) {
         stub = object->IsString()
             ? isolate()->builtins()->LoadIC_StringLength()
             : isolate()->builtins()->LoadIC_StringWrapperLength();
       } else if (state == MONOMORPHIC && object->IsStringWrapper()) {
         stub = isolate()->builtins()->LoadIC_StringWrapperLength();
       } else if (state != MEGAMORPHIC) {
+        ASSERT(state != GENERIC);
         stub = megamorphic_stub();
       }
       if (!stub.is_null()) {
         set_target(*stub);
 #ifdef DEBUG
         if (FLAG_trace_ic) PrintF("[LoadIC : +#length /string]\n");
 #endif
       }
       // Get the string if we have a string wrapper object.
       Handle<Object> string = object->IsJSValue()
           ? Handle<Object>(Handle<JSValue>::cast(object)->value())
           : object;
       return Smi::FromInt(String::cast(*string)->length());
     }
 
     // Use specialized code for getting the length of arrays.
     if (object->IsJSArray() &&
         name->Equals(isolate()->heap()->length_symbol())) {
       Handle<Code> stub;
       if (state == UNINITIALIZED) {
         stub = pre_monomorphic_stub();
       } else if (state == PREMONOMORPHIC) {
         stub = isolate()->builtins()->LoadIC_ArrayLength();
       } else if (state != MEGAMORPHIC) {
+        ASSERT(state != GENERIC);
         stub = megamorphic_stub();
       }
       if (!stub.is_null()) {
         set_target(*stub);
 #ifdef DEBUG
         if (FLAG_trace_ic) PrintF("[LoadIC : +#length /array]\n");
 #endif
       }
       return JSArray::cast(*object)->length();
     }
 
     // Use specialized code for getting prototype of functions.
     if (object->IsJSFunction() &&
         name->Equals(isolate()->heap()->prototype_symbol()) &&
         Handle<JSFunction>::cast(object)->should_have_prototype()) {
       Handle<Code> stub;
       if (state == UNINITIALIZED) {
         stub = pre_monomorphic_stub();
       } else if (state == PREMONOMORPHIC) {
         stub = isolate()->builtins()->LoadIC_FunctionPrototype();
       } else if (state != MEGAMORPHIC) {
+        ASSERT(state != GENERIC);
         stub = megamorphic_stub();
       }
       if (!stub.is_null()) {
         set_target(*stub);
 #ifdef DEBUG
         if (FLAG_trace_ic) PrintF("[LoadIC : +#prototype /function]\n");
 #endif
       }
       return Accessors::FunctionGetPrototype(*object, 0);
     }
@@ skipping 147 matching lines @@
       }
       break;
     case MEGAMORPHIC:
       // Cache code holding map should be consistent with
       // GenerateMonomorphicCacheProbe.
       isolate()->stub_cache()->Set(*name, receiver->map(), *code);
       break;
     case DEBUG_STUB:
       break;
     case POLYMORPHIC:
+    case GENERIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("LoadIC", name, state, target());
 }
 
 
 Handle<Code> KeyedLoadIC::GetElementStubWithoutMapCheck(
     bool is_js_array,
@@ skipping 252 matching lines @@
     case MONOMORPHIC:
       // Only move to megamorphic if the target changes.
       if (target() != *code) {
         set_target(*megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
     case DEBUG_STUB:
       break;
     case MONOMORPHIC_PROTOTYPE_FAILURE:
+    case GENERIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("KeyedLoadIC", name, state, target());
 }
 
 
 static bool StoreICableLookup(LookupResult* lookup) {
   // Bail out if we didn't find a result.
@@ skipping 255 matching lines @@
                      : megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
       // Update the stub cache.
       isolate()->stub_cache()->Set(*name, receiver->map(), *code);
       break;
     case DEBUG_STUB:
       break;
     case POLYMORPHIC:
+    case GENERIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("StoreIC", name, state, target());
 }
 
 
 static bool AddOneReceiverMapIfMissing(MapHandleList* receiver_maps,
                                        Handle<Map> new_receiver_map) {
@@ skipping 24 matching lines @@
         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:
+      case GENERIC:
         break;
       case UNINITIALIZED:
       case PREMONOMORPHIC:
       case MONOMORPHIC_PROTOTYPE_FAILURE:
       case DEBUG_STUB:
         UNREACHABLE();
         break;
     }
   }
 }
@@ skipping 433 matching lines @@
       if (target() != *code) {
         set_target((strict_mode == kStrictMode)
                      ? *megamorphic_stub_strict()
                      : *megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
     case DEBUG_STUB:
       break;
     case MONOMORPHIC_PROTOTYPE_FAILURE:
+    case GENERIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("KeyedStoreIC", name, state, target());
 }
 
 
 #undef TRACE_IC
 
@@ skipping 223 matching lines @@
 
 
 UnaryOpIC::State UnaryOpIC::ToState(TypeInfo type_info) {
   switch (type_info) {
     case UNINITIALIZED:
       return ::v8::internal::UNINITIALIZED;
     case SMI:
     case HEAP_NUMBER:
       return MONOMORPHIC;
     case GENERIC:
-      return MEGAMORPHIC;
+      return ::v8::internal::GENERIC;
   }
   UNREACHABLE();
   return ::v8::internal::UNINITIALIZED;
 }
 
 UnaryOpIC::TypeInfo UnaryOpIC::GetTypeInfo(Handle<Object> operand) {
   ::v8::internal::TypeInfo operand_type =
       ::v8::internal::TypeInfo::TypeFromValue(operand);
   if (operand_type.IsSmi()) {
     return SMI;
@@ skipping 50 matching lines @@
   switch (type_info) {
     case UNINITIALIZED:
       return ::v8::internal::UNINITIALIZED;
     case SMI:
     case INT32:
     case HEAP_NUMBER:
     case ODDBALL:
     case STRING:
       return MONOMORPHIC;
     case GENERIC:
-      return MEGAMORPHIC;
+      return ::v8::internal::GENERIC;
   }
   UNREACHABLE();
   return ::v8::internal::UNINITIALIZED;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, UnaryOp_Patch) {
   ASSERT(args.length() == 4);
 
   HandleScope scope(isolate);
@@ skipping 418 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal