Various little cleanups to avoid excessive allocation of handles.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 255 matching lines @@
       if (def != NULL) {
         InsertConversionsFor(def);
       }
     }
   }
 }
 
 
 static bool ICDataHasReceiverClassId(const ICData& ic_data, intptr_t class_id) {
   ASSERT(ic_data.num_args_tested() > 0);
-  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+  const intptr_t len = ic_data.NumberOfChecks();
+  for (intptr_t i = 0; i < len; i++) {
     const intptr_t test_class_id = ic_data.GetReceiverClassIdAt(i);
     if (test_class_id == class_id) {
       return true;
     }
   }
   return false;
 }
 
 
 static bool ICDataHasReceiverArgumentClassIds(const ICData& ic_data,
                                               intptr_t receiver_class_id,
                                               intptr_t argument_class_id) {
   ASSERT(receiver_class_id != kIllegalCid);
   ASSERT(argument_class_id != kIllegalCid);
   if (ic_data.num_args_tested() != 2) return false;
 
   Function& target = Function::Handle();
-  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+  const intptr_t len = ic_data.NumberOfChecks();
+  for (intptr_t i = 0; i < len; i++) {
     GrowableArray<intptr_t> class_ids;
     ic_data.GetCheckAt(i, &class_ids, &target);
     ASSERT(class_ids.length() == 2);
     if ((class_ids[0] == receiver_class_id) &&
         (class_ids[1] == argument_class_id)) {
       return true;
     }
   }
   return false;
 }
@@ skipping 11 matching lines @@
 
 
 // Returns true if ICData tests two arguments and all ICData cids are in the
 // required sets 'receiver_class_ids' or 'argument_class_ids', respectively.
 static bool ICDataHasOnlyReceiverArgumentClassIds(
     const ICData& ic_data,
     const GrowableArray<intptr_t>& receiver_class_ids,
     const GrowableArray<intptr_t>& argument_class_ids) {
   if (ic_data.num_args_tested() != 2) return false;
   Function& target = Function::Handle();
-  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+  const intptr_t len = ic_data.NumberOfChecks();
+  for (intptr_t i = 0; i < len; i++) {
     GrowableArray<intptr_t> class_ids;
     ic_data.GetCheckAt(i, &class_ids, &target);
     ASSERT(class_ids.length() == 2);
     if (!ClassIdIsOneOf(class_ids[0], receiver_class_ids) ||
         !ClassIdIsOneOf(class_ids[1], argument_class_ids)) {
       return false;
     }
   }
   return true;
 }
@@ skipping 103 matching lines @@
   }
   InsertBefore(call, check, call->env(), Definition::kEffect);
 }
 
 
 static bool ArgIsAlwaysSmi(const ICData& ic_data, intptr_t arg_n) {
   ASSERT(ic_data.num_args_tested() > arg_n);
   if (ic_data.NumberOfChecks() == 0) return false;
   GrowableArray<intptr_t> class_ids;
   Function& target = Function::Handle();
-  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+  const intptr_t len = ic_data.NumberOfChecks();
+  for (intptr_t i = 0; i < len; i++) {
     ic_data.GetCheckAt(i, &class_ids, &target);
     if (class_ids[arg_n] != kSmiCid) return false;
   }
   return true;
 }
 
 
 // Returns array classid to load from, array and idnex value
 
 intptr_t FlowGraphOptimizer::PrepareIndexedOp(InstanceCallInstr* call,
@@ skipping 704 matching lines @@
   if (!instr->HasICData() || (instr->ic_data()->NumberOfChecks() == 0)) {
     // An instance call without ICData will trigger deoptimization.
     return;
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(instr->ic_data()->AsUnaryClassChecks());
   if ((unary_checks.NumberOfChecks() > FLAG_max_polymorphic_checks) &&
       InstanceCallNeedsClassCheck(instr)) {
     // Too many checks, leave it megamorphic.
+    instr->set_ic_data(&unary_checks);

[siva, 2012/11/02 01:09:18]

The comment says 'too many checks, leave it megamorphic' but
looks like you are changing stuff here.

[srdjan, 2012/11/02 15:32:45]

Changed the comment:
    // Too many checks it will be megamorphic which needs unary checks.

     return;
   }
 
   const Token::Kind op_kind = instr->token_kind();
   if ((op_kind == Token::kASSIGN_INDEX) &&
       TryReplaceWithStoreIndexed(instr)) {
     return;
   }
   if ((op_kind == Token::kINDEX) && TryReplaceWithLoadIndexed(instr)) {
     return;
@@ skipping 2516 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart