Only store IC data with instructions that collect type feedback.

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/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
@@ skipping 158 matching lines @@
   for (intptr_t i = 1; i < ic_data.NumberOfChecks(); i++) {
     test_target = ic_data.GetTargetAt(i);
     if (first_target.raw() != test_target.raw()) {
       return false;
     }
   }
   return true;
 }
 
 
-static intptr_t ReceiverClassId(Computation* comp) {
+static intptr_t ReceiverClassId(InstanceCallComp* comp) {
   if (!comp->HasICData()) return kIllegalCid;
 
   const ICData& ic_data = *comp->ic_data();
 
   if (ic_data.NumberOfChecks() == 0) return kIllegalCid;
   // TODO(vegorov): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return kIllegalCid;
   ASSERT(HasOneTarget(ic_data));
 
   Function& target = Function::Handle();
   intptr_t class_id;
   ic_data.GetOneClassCheckAt(0, &class_id, &target);
   return class_id;
 }
 
 
 void FlowGraphOptimizer::AddCheckClass(BindInstr* instr,
                                        InstanceCallComp* comp,
                                        Value* value) {
   // Type propagation has not run yet, we cannot eliminate the check.
-  CheckClassComp* check = new CheckClassComp(value, comp);
   const ICData& unary_checks =
       ICData::ZoneHandle(comp->ic_data()->AsUnaryClassChecks());
-  check->set_ic_data(&unary_checks);
+  CheckClassComp* check = new CheckClassComp(value, comp, unary_checks);
   InsertBefore(instr, check, instr->env(), BindInstr::kUnused);
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithArrayOp(BindInstr* instr,
                                                InstanceCallComp* comp,
                                                Token::Kind op_kind) {
   // TODO(fschneider): Optimize []= operator in checked mode as well.
   if (op_kind == Token::kASSIGN_INDEX && FLAG_enable_type_checks) return false;
 
@@ skipping 23 matching lines @@
                                            comp),
                    instr->env(),
                    BindInstr::kUnused);
       Computation* array_op = NULL;
       if (op_kind == Token::kINDEX) {
         array_op = new LoadIndexedComp(array, index, class_id);
       } else {
         Value* value = comp->ArgumentAt(2)->value();
         array_op = new StoreIndexedComp(array, index, value, class_id);
       }
-      array_op->set_ic_data(comp->ic_data());
       instr->set_computation(array_op);
       RemovePushArguments(comp);
       return true;
     }
     default:
       return false;
   }
 }
 
 
@@ skipping 96 matching lines @@
       BindInstr* unbox_right = InsertBefore(
           instr,
           new UnboxDoubleComp(right->Copy(), comp),
           instr->env(),
           BindInstr::kUsed);
 
       UnboxedDoubleBinaryOpComp* double_bin_op =
           new UnboxedDoubleBinaryOpComp(op_kind,
                                         new Value(unbox_left),
                                         new Value(unbox_right));
-      double_bin_op->set_ic_data(comp->ic_data());
       instr->set_computation(double_bin_op);
 
       if (instr->is_used()) {
         // Box result.
         Value* value = new Value(instr);
         BindInstr* bind = InsertAfter(instr,
                                       new BoxDoubleComp(value, comp),
                                       NULL,
                                       BindInstr::kUsed);
         instr->ReplaceUsesWith(bind);
       }
 
       RemovePushArguments(comp);
     } else {
       BinaryDoubleOpComp* double_bin_op = new BinaryDoubleOpComp(op_kind, comp);
-      double_bin_op->set_ic_data(comp->ic_data());
       instr->set_computation(double_bin_op);
     }
   } else if (operands_type == kMintCid) {
     Value* left = comp->ArgumentAt(0)->value();
     Value* right = comp->ArgumentAt(1)->value();
     BinaryMintOpComp* bin_op = new BinaryMintOpComp(op_kind,
                                                     comp,
                                                     left,
                                                     right);
-    bin_op->set_ic_data(comp->ic_data());
     instr->set_computation(bin_op);
     RemovePushArguments(comp);
   } else {
     ASSERT(operands_type == kSmiCid);
     Value* left = comp->ArgumentAt(0)->value();
     Value* right = comp->ArgumentAt(1)->value();
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
     InsertBefore(instr,
                  new CheckSmiComp(left->Copy(), comp),
                  instr->env(),
                  BindInstr::kUnused);
     InsertBefore(instr,
                  new CheckSmiComp(right->Copy(), comp),
                  instr->env(),
                  BindInstr::kUnused);
     BinarySmiOpComp* bin_op = new BinarySmiOpComp(op_kind,
                                                   comp,
                                                   left,
                                                   right);
-    bin_op->set_ic_data(comp->ic_data());
     instr->set_computation(bin_op);
     RemovePushArguments(comp);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithUnaryOp(BindInstr* instr,
                                                InstanceCallComp* comp,
                                                Token::Kind op_kind) {
@@ skipping 10 matching lines @@
                  instr->env(),
                  BindInstr::kUnused);
     unary_op = new UnarySmiOpComp(op_kind,
                                   (op_kind == Token::kNEGATE) ? comp : NULL,
                                   value);
   } else if (HasOneDouble(*comp->ic_data()) && (op_kind == Token::kNEGATE)) {
     unary_op = new NumberNegateComp(comp, comp->ArgumentAt(0)->value());
   }
   if (unary_op == NULL) return false;
 
-  unary_op->set_ic_data(comp->ic_data());
   instr->set_computation(unary_op);
   RemovePushArguments(comp);
   return true;
 }
 
 
 // Using field class
 static RawField* GetField(intptr_t class_id, const String& field_name) {
   Class& cls = Class::Handle(Isolate::Current()->class_table()->At(class_id));
   Field& field = Field::Handle();
@@ skipping 171 matching lines @@
       if (HasOneTarget(unary_checks) &&
           (unary_checks.GetReceiverClassIdAt(0) != kSmiCid)) {
         // Type propagation has not run yet, we cannot eliminate the check.
         AddCheckClass(instr, comp, comp->ArgumentAt(0)->value()->Copy());
         // Call can still deoptimize, do not detach environment from instr.
         call_with_checks = false;
       } else {
         call_with_checks = true;
       }
       PolymorphicInstanceCallComp* call =
-          new PolymorphicInstanceCallComp(comp, call_with_checks);
-      call->set_ic_data(&unary_checks);
+          new PolymorphicInstanceCallComp(comp,
+                                          unary_checks,
+                                          call_with_checks);
       instr->set_computation(call);
     }
   }
   // An instance call without ICData should continue calling via IC calls
   // which should trigger reoptimization of optimized code.
 }
 
 
 void FlowGraphOptimizer::VisitStaticCall(StaticCallComp* comp,
                                          BindInstr* instr) {
@@ skipping 420 matching lines @@
       DirectChainedHashMap<BindInstr*> child_map(*map);  // Copy map.
       OptimizeRecursive(child, &child_map);
     } else {
       OptimizeRecursive(child, map);  // Reuse map for the last child.
     }
   }
 }
 
 
 }  // namespace dart