Landing: Remove the is_used_ field from BindInstr.

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 82 matching lines @@
           instr->AsPhi()->block()->PredecessorAt(use->use_index());
       instr = pred->last_instruction();
     } else {
       deopt_target = instr;
     }
 
     BindInstr* converted = InsertBefore(
       instr,
       CreateConversion(from_rep, to_rep, def, deopt_target),
       use->instruction()->env(),
-      BindInstr::kUsed);
+      Definition::kValue);
 
     use->set_definition(converted);
   }
 }
 
 void FlowGraphOptimizer::SelectRepresentations() {
   // Convervatively unbox all phis that were proven to be of type Double.
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     JoinEntryInstr* join_entry = block_order_[i]->AsJoinEntry();
     if (join_entry == NULL) continue;
@@ skipping 193 matching lines @@
 }
 
 
 void FlowGraphOptimizer::AddCheckClass(BindInstr* instr,
                                        InstanceCallComp* comp,
                                        Value* value) {
   // Type propagation has not run yet, we cannot eliminate the check.
   const ICData& unary_checks =
       ICData::ZoneHandle(comp->ic_data()->AsUnaryClassChecks());
   CheckClassComp* check = new CheckClassComp(value, comp, unary_checks);
-  InsertBefore(instr, check, instr->env(), BindInstr::kUnused);
+  InsertBefore(instr, check, instr->env(), Definition::kEffect);
 }
 
 
 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;
 
   const intptr_t class_id = ReceiverClassId(comp);
   switch (class_id) {
     case kImmutableArrayCid:
       // Stores are only specialized for Array and GrowableObjectArray,
       // not for ImmutableArray.
       if (op_kind == Token::kASSIGN_INDEX) return false;
       // Fall through.
     case kArrayCid:
     case kGrowableObjectArrayCid: {
       Value* array = comp->ArgumentAt(0)->value();
       Value* index = comp->ArgumentAt(1)->value();
       // Insert class check and index smi checks and attach a copy of the
       // original environment because the operation can still deoptimize.
       AddCheckClass(instr, comp, array->Copy());
       InsertBefore(instr,
                    new CheckSmiComp(index->Copy(), comp->deopt_id()),
                    instr->env(),
-                   BindInstr::kUnused);
+                   Definition::kEffect);
       // Insert array bounds check.
       InsertBefore(instr,
                    new CheckArrayBoundComp(array->Copy(),
                                            index->Copy(),
                                            class_id,
                                            comp),
                    instr->env(),
-                   BindInstr::kUnused);
+                   Definition::kEffect);
       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);
       }
       instr->set_computation(array_op);
       RemovePushArguments(comp);
       return true;
     }
     default:
       return false;
   }
 }
 
 
 BindInstr* FlowGraphOptimizer::InsertBefore(Instruction* instr,
                                             Computation* comp,
                                             Environment* env,
                                             BindInstr::UseKind use_kind) {
   BindInstr* bind = new BindInstr(use_kind, comp);
   if (env != NULL) env->CopyTo(bind);
-  if (use_kind == BindInstr::kUsed) {
+  if (use_kind == Definition::kValue) {
     bind->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
   }
   bind->InsertBefore(instr);
   return bind;
 }
 
 
 BindInstr* FlowGraphOptimizer::InsertAfter(Instruction* instr,
                                            Computation* comp,
                                            Environment* env,
                                            BindInstr::UseKind use_kind) {
   BindInstr* bind = new BindInstr(use_kind, comp);
   if (env != NULL) env->CopyTo(bind);
-  if (use_kind == BindInstr::kUsed) {
+  if (use_kind == Definition::kValue) {
     bind->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
   }
   bind->InsertAfter(instr);
   return bind;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithBinaryOp(BindInstr* instr,
                                                 InstanceCallComp* comp,
                                                 Token::Kind op_kind) {
@@ skipping 51 matching lines @@
     Value* left = comp->ArgumentAt(0)->value();
     Value* right = comp->ArgumentAt(1)->value();
 
     // Check that either left or right are not a smi.  Result or a
     // binary operation with two smis is a smi not a double.
     InsertBefore(instr,
                  new CheckEitherNonSmiComp(left->Copy(),
                                            right->Copy(),
                                            comp),
                  instr->env(),
-                 BindInstr::kUnused);
+                 Definition::kEffect);
 
     UnboxedDoubleBinaryOpComp* double_bin_op =
         new UnboxedDoubleBinaryOpComp(op_kind,
                                       left->Copy(),
                                       right->Copy(),
                                       comp);
     instr->set_computation(double_bin_op);
 
     RemovePushArguments(comp);
   } 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);
     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->deopt_id()),
                  instr->env(),
-                 BindInstr::kUnused);
+                 Definition::kEffect);
     InsertBefore(instr,
                  new CheckSmiComp(right->Copy(), comp->deopt_id()),
                  instr->env(),
-                 BindInstr::kUnused);
+                 Definition::kEffect);
     BinarySmiOpComp* bin_op = new BinarySmiOpComp(op_kind,
                                                   comp,
                                                   left,
                                                   right);
     instr->set_computation(bin_op);
     RemovePushArguments(comp);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithUnaryOp(BindInstr* instr,
                                                InstanceCallComp* comp,
                                                Token::Kind op_kind) {
   if (comp->ic_data()->NumberOfChecks() != 1) {
     // TODO(srdjan): Not yet supported.
     return false;
   }
   ASSERT(comp->ArgumentCount() == 1);
   Computation* unary_op = NULL;
   if (HasOneSmi(*comp->ic_data())) {
     Value* value = comp->ArgumentAt(0)->value();
     InsertBefore(instr,
                  new CheckSmiComp(value->Copy(), comp->deopt_id()),
                  instr->env(),
-                 BindInstr::kUnused);
+                 Definition::kEffect);
     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;
 
   instr->set_computation(unary_op);
   RemovePushArguments(comp);
@@ skipping 263 matching lines @@
   if (ic_data.NumberOfChecks() == 0) return;
   // TODO(srdjan): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return;
   ASSERT(HasOneTarget(ic_data));
 
   if (HasOnlyTwoSmi(ic_data)) {
     optimizer->InsertBefore(
         instr,
         new CheckSmiComp(comp->left()->Copy(), comp->deopt_id()),
         instr->env(),
-        BindInstr::kUnused);
+        Definition::kEffect);
     optimizer->InsertBefore(
         instr,
         new CheckSmiComp(comp->right()->Copy(), comp->deopt_id()),
         instr->env(),
-        BindInstr::kUnused);
+        Definition::kEffect);
     comp->set_operands_class_id(kSmiCid);
   } else if (ShouldSpecializeForDouble(ic_data)) {
     comp->set_operands_class_id(kDoubleCid);
   } else if (comp->ic_data()->AllReceiversAreNumbers()) {
     comp->set_operands_class_id(kNumberCid);
   }
 }
 
 void FlowGraphOptimizer::VisitRelationalOp(RelationalOpComp* comp,
                                            BindInstr* instr) {
@@ skipping 22 matching lines @@
     ASSERT(comp->ic_data()->num_args_tested() == 2);
     GrowableArray<intptr_t> class_ids;
     Function& target = Function::Handle();
     comp->ic_data()->GetCheckAt(0, &class_ids, &target);
     // TODO(srdjan): allow for mixed mode comparison.
     if ((class_ids[0] == kSmiCid) && (class_ids[1] == kSmiCid)) {
       optimizer->InsertBefore(
           instr,
           new CheckSmiComp(comp->left()->Copy(), comp->deopt_id()),
           instr->env(),
-          BindInstr::kUnused);
+          Definition::kEffect);
       optimizer->InsertBefore(
           instr,
           new CheckSmiComp(comp->right()->Copy(), comp->deopt_id()),
           instr->env(),
-          BindInstr::kUnused);
+          Definition::kEffect);
       comp->set_receiver_class_id(kSmiCid);
     } else if ((class_ids[0] == kDoubleCid) && (class_ids[1] == kDoubleCid)) {
       comp->set_receiver_class_id(kDoubleCid);
     } else {
       ASSERT(comp->receiver_class_id() == kIllegalCid);
     }
   } else if (comp->ic_data()->AllReceiversAreNumbers()) {
     comp->set_receiver_class_id(kNumberCid);
   }
 }
@@ skipping 331 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