Cleanup the copying of ICs to the Megamorphic Code Cache

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 992 matching lines @@
 void KeyedLoadIC::UpdateMonomorphicIC(Handle<JSObject> receiver,
                                       Handle<Code> handler,
                                       Handle<String> name) {
   if (handler->type() == Code::NORMAL) return set_target(*handler);
   Handle<Code> ic = isolate()->stub_cache()->ComputeKeyedMonomorphicIC(
       receiver, handler, name);
   set_target(*ic);
 }
 
 
+void IC::CopyICToMegamorphicCache(Handle<String> name) {
+  MapHandleList receiver_maps;
+  CodeHandleList handlers;
+  {
+    AssertNoAllocation no_gc;
+    target()->FindAllMaps(&receiver_maps);
+    target()->FindAllCode(&handlers, receiver_maps.length());
+  }
+  for (int i = 0; i < receiver_maps.length(); i++) {
+    UpdateMegamorphicCache(*receiver_maps.at(i), *name, *handlers.at(i));
+  }
+}
+
+
 // Since GC may have been invoked, by the time PatchCache is called, |state| is
 // not necessarily equal to target()->state().
 void IC::PatchCache(State state,
                     StrictModeFlag strict_mode,
                     Handle<JSObject> receiver,
                     Handle<String> name,
                     Handle<Code> code) {
   switch (state) {
     case UNINITIALIZED:
     case PREMONOMORPHIC:
     case MONOMORPHIC_PROTOTYPE_FAILURE:
       UpdateMonomorphicIC(receiver, code, name);
       break;
     case MONOMORPHIC:
       // Only move to megamorphic if the target changes.
       if (target() != *code) {
         if (target()->is_load_stub()) {
           if (UpdatePolymorphicIC(state, strict_mode, receiver, name, code)) {
             break;
           }
         }
         if (target()->type() != Code::NORMAL) {
-          // We are transitioning from monomorphic to megamorphic case. Place
-          // the stub compiled for the receiver into stub cache.
-          Map* map;
-          Code* handler;
-          {
-            AssertNoAllocation no_gc;
-            map = target()->FindFirstMap();
+          if (target()->is_load_stub()) {
+            CopyICToMegamorphicCache(name);
+          } else {
+            Code* handler = target();
+            Map* map = handler->FindFirstMap();
             if (map != NULL) {
-              if (target()->is_load_stub()) {
-                handler = target()->FindFirstCode();
-              } else {
-                handler = target();
-              }
-            } else {
-              // Avoid compiler warnings.
-              handler = NULL;
+              UpdateMegamorphicCache(map, *name, target());

[Jakob Kummerow, 2013/03/07 11:26:40]

You can s/target()/handler/ here.

[Toon Verwaest, 2013/03/11 15:11:19]

Done.

             }
           }
-          if (handler != NULL) {
-            UpdateMegamorphicCache(map, *name, handler);
-          }
         }
+
         UpdateMegamorphicCache(receiver->map(), *name, *code);
         set_target((strict_mode == kStrictMode)
                      ? *megamorphic_stub_strict()
                      : *megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
       // Update the stub cache.
       UpdateMegamorphicCache(receiver->map(), *name, *code);
       break;
     case POLYMORPHIC:
       if (target()->is_load_stub()) {
         if (UpdatePolymorphicIC(state, strict_mode, receiver, name, code)) {
           break;
         }
-        MapHandleList receiver_maps;
-        CodeHandleList handlers;
-        {
-          AssertNoAllocation no_gc;
-          target()->FindAllMaps(&receiver_maps);
-          target()->FindAllCode(&handlers, receiver_maps.length());
-        }
-        for (int i = 0; i < receiver_maps.length(); i++) {
-          UpdateMegamorphicCache(*receiver_maps.at(i), *name, *handlers.at(i));
-        }
+        CopyICToMegamorphicCache(name);
         UpdateMegamorphicCache(receiver->map(), *name, *code);
         set_target(*megamorphic_stub());
       } else {
         // When trying to patch a polymorphic keyed load/store element stub
         // with anything other than another polymorphic stub, go generic.
         set_target((strict_mode == kStrictMode)
                    ? *generic_stub_strict()
                    : *generic_stub());
       }
       break;
@@ skipping 1582 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal