Tag previously GENERIC stubs that potentially IC_Miss as MONOMORPHIC.

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 986 matching lines @@
     case POLYMORPHIC:
       // When trying to patch a polymorphic stub with anything other than
       // another polymorphic stub, go generic.
       // TODO(verwaest): Currently we always go generic since no polymorphic
       // stubs enter this code path. Replace with proper updating once named
       // load/store can also be polymorphic.
       set_target((strict_mode == kStrictMode)
                  ? *generic_stub_strict()
                  : *generic_stub());
       break;
+    case DEBUG_STUB:
+      break;
     case GENERIC:
-    case DEBUG_STUB:
+      UNREACHABLE();
       break;
   }
 }
 
 
 void LoadIC::UpdateCaches(LookupResult* lookup,
                           State state,
                           Handle<Object> object,
                           Handle<String> name) {
   // Bail out if the result is not cacheable.
@@ skipping 143 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 GENERIC:
     case DEBUG_STUB:
       UNREACHABLE();
       break;
   }
 }
 
 
 Handle<Code> KeyedLoadIC::LoadElementStub(Handle<JSObject> receiver) {
   State ic_state = target()->ic_state();
 
@@ skipping 29 matching lines @@
   // monomorphic. If this optimistic assumption is not true, the IC will
   // miss again and it will become polymorphic and support both the
   // untransitioned and transitioned maps.
   if (ic_state == MONOMORPHIC &&
       IsMoreGeneralElementsKindTransition(
           target_receiver_maps.at(0)->elements_kind(),
           receiver->GetElementsKind())) {
     return isolate()->stub_cache()->ComputeKeyedLoadElement(receiver_map);
   }
 
-  ASSERT(target() != *generic_stub());
+  ASSERT(ic_state != GENERIC);
 
   // Determine the list of receiver maps that this call site has seen,
   // adding the map that was just encountered.
   if (!AddOneReceiverMapIfMissing(&target_receiver_maps, receiver_map)) {
     // If the miss wasn't due to an unseen map, a polymorphic stub
     // won't help, use the generic stub.
     TRACE_GENERIC_IC("KeyedIC", "same map added twice");
     return generic_stub();
   }
 
@@ skipping 361 matching lines @@
       IsMoreGeneralElementsKindTransition(
           target_receiver_maps.at(0)->elements_kind(),
           receiver->GetElementsKind())) {
     Handle<Map> monomorphic_map = ComputeTransitionedMap(receiver, stub_kind);
     ASSERT(*monomorphic_map != *receiver_map);
     stub_kind = GetNoTransitionStubKind(stub_kind);
     return isolate()->stub_cache()->ComputeKeyedStoreElement(
         monomorphic_map, stub_kind, strict_mode, grow_mode);
   }
 
-  ASSERT(target() != *generic_stub() && target() != *generic_stub_strict());
+  ASSERT(ic_state != GENERIC);
 
   bool map_added =
       AddOneReceiverMapIfMissing(&target_receiver_maps, receiver_map);
 
   if (IsTransitionStubKind(stub_kind)) {
     Handle<Map> new_map = ComputeTransitionedMap(receiver, stub_kind);
     map_added |= AddOneReceiverMapIfMissing(&target_receiver_maps, new_map);
   }
 
   if (!map_added) {
@@ skipping 953 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal