Implement class id checks as a separate instruction and add a local CSE optimization pass.

runtime/vm/code_generator.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 860 matching lines @@
     }
     // Do not add an entry twice!
     ASSERT(!matches);
   }
 #endif  // DEBUG
 
   if (args.length() == 1) {
     ic_data.AddReceiverCheck(Class::Handle(args[0]->clazz()).id(),
                              target_function);
   } else {
-    GrowableArray<intptr_t> class_ids;
+    GrowableArray<intptr_t> class_ids(args.length());
     ASSERT(ic_data.num_args_tested() == args.length());
     for (intptr_t i = 0; i < args.length(); i++) {
       class_ids.Add(Class::Handle(args[i]->clazz()).id());
     }
     ic_data.AddCheck(class_ids, target_function);
   }
   if (FLAG_trace_ic) {
     OS::Print("InlineCacheMissHandler %d call at 0x%x' "
               "adding <%s> id:%d -> <%s>\n",
         args.length(),
         caller_frame->pc(),
         Class::Handle(receiver.clazz()).ToCString(),
         Class::Handle(receiver.clazz()).id(),
         target_function.ToCString());
   }
   return target_function.raw();
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerOneArg, 1) {
   ASSERT(arguments.Count() ==
       kInlineCacheMissHandlerOneArgRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  GrowableArray<const Instance*> args;
+  GrowableArray<const Instance*> args(1);
   args.Add(&receiver);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(isolate, args));
   arguments.SetReturn(result);
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerTwoArgs, 2) {
   ASSERT(arguments.Count() ==
       kInlineCacheMissHandlerTwoArgsRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
   const Instance& other = Instance::CheckedHandle(arguments.At(1));
-  GrowableArray<const Instance*> args;
+  GrowableArray<const Instance*> args(2);
   args.Add(&receiver);
   args.Add(&other);
   const Function& result =
       Function::Handle(InlineCacheMissHandler(isolate, args));
   arguments.SetReturn(result);
 }
 
 
 static RawFunction* LookupDynamicFunction(Isolate* isolate,
                                           const Class& in_cls,
@@ skipping 667 matching lines @@
   function.set_usage_counter(0);
   function.set_deoptimization_counter(function.deoptimization_counter() + 1);
 
   if (function.HasOptimizedCode()) {
     function.SwitchToUnoptimizedCode();
   }
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart