Move recording of definition used from the value to the definition.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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 2221 matching lines @@
   for (Value* use = def->input_use_list();
        use != NULL;
        use = next_use) {
     next_use = use->next_use();
 
     // Skip dead phis.
     PhiInstr* phi = use->instruction()->AsPhi();
     if ((phi != NULL) && !phi->is_alive()) continue;
 
     if (IsDominatedUse(dom, use)) {
-      use->RemoveFromInputUseList();
+      use->definition()->RemoveInputUse(use);
       use->set_definition(other);
-      use->AddToInputUseList();
+      other->AddInputUse(use);
     }
   }
 }
 
 
 // For a comparison operation return an operation for the equivalent flipped
 // comparison: a (op) b === b (op') a.
 static Token::Kind FlipComparison(Token::Kind op) {
   switch (op) {
     case Token::kEQ: return Token::kEQ;
@@ skipping 55 matching lines @@
   }
 }
 
 
 ConstraintInstr* RangeAnalysis::InsertConstraintFor(Definition* defn,
                                                     Range* constraint_range,
                                                     Instruction* after) {
   // No need to constrain constants.
   if (defn->IsConstant()) return NULL;
 
-  ConstraintInstr* constraint =
-      new ConstraintInstr(new Value(defn), constraint_range);
+  Value* value = new Value(defn);
+  ConstraintInstr* constraint = new ConstraintInstr(value, constraint_range);
   constraint->InsertAfter(after);
   constraint->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
   RenameDominatedUses(defn, after, constraint);
   constraints_.Add(constraint);
-  constraint->value()->set_instruction(constraint);
-  constraint->value()->set_use_index(0);
-  constraint->value()->AddToInputUseList();
+  value->set_instruction(constraint);
+  value->set_use_index(0);
+  defn->AddInputUse(value);
   return constraint;
 }
 
 
 void RangeAnalysis::ConstrainValueAfterBranch(Definition* defn, Value* use) {
   BranchInstr* branch = use->instruction()->AsBranch();
   RelationalOpInstr* rel_op = branch->comparison()->AsRelationalOp();
   if ((rel_op != NULL) && (rel_op->operands_class_id() == kSmiCid)) {
     // Found comparison of two smis. Constrain defn at true and false
     // successors using the other operand as a boundary.
@@ skipping 623 matching lines @@
   ASSERT(last->env() != NULL);
   last->env()->DeepCopyTo(current);
   current->deopt_id_ = last->GetDeoptId();
 }
 
 
 void LICM::TryHoistCheckSmiThroughPhi(ForwardInstructionIterator* it,
                                       BlockEntryInstr* header,
                                       BlockEntryInstr* pre_header,
                                       CheckSmiInstr* current) {
-  PhiInstr* phi = current->InputAt(0)->definition()->AsPhi();
+  PhiInstr* phi = current->value()->definition()->AsPhi();
   if (!header->loop_info()->Contains(phi->block()->preorder_number())) {
     return;
   }
 
   if (phi->GetPropagatedCid() == kSmiCid) {
     it->RemoveCurrentFromGraph();
     return;
   }
 
   // Check if there is only a single kDynamicCid input to the phi that
@@ skipping 16 matching lines @@
   if ((non_smi_input == kNotFound) ||
       (phi->block()->PredecessorAt(non_smi_input) != pre_header)) {
     return;
   }
 
   // Host CheckSmi instruction and make this phi smi one.
   Hoist(it, pre_header, current);
 
   // Replace value we are checking with phi's input. Maintain use lists.
   Definition* non_smi_input_defn = phi->InputAt(non_smi_input)->definition();
-  current->value()->RemoveFromInputUseList();
+  phi->RemoveInputUse(current->value());
   current->value()->set_definition(non_smi_input_defn);
-  current->value()->AddToInputUseList();
+  non_smi_input_defn->AddInputUse(current->value());
 
   phi->SetPropagatedCid(kSmiCid);
 }
 
 
 void LICM::Optimize(FlowGraph* flow_graph) {
   GrowableArray<BlockEntryInstr*> loop_headers;
   flow_graph->ComputeLoops(&loop_headers);
 
   for (intptr_t i = 0; i < loop_headers.length(); ++i) {
@@ skipping 512 matching lines @@
       BlockEntryInstr* pred = block->PredecessorAt(i);
       ZoneGrowableArray<Definition*>* pred_out_values =
           out_values_[pred->preorder_number()];
       ASSERT((*pred_out_values)[expr_id] != NULL);
 
       // Sets of outgoing values are not linked into use lists so
       // they might contain values that were replaced and removed
       // from the graph by this iteration.
       // To prevent using them we additionally mark definitions themselves
       // as replaced and store a pointer to the replacement.
-      Value* input = new Value((*pred_out_values)[expr_id]->Replacement());
+      Definition* replacement = (*pred_out_values)[expr_id]->Replacement();
+      Value* input = new Value(replacement);
       phi->SetInputAt(i, input);
 
       // TODO(vegorov): add a helper function to handle input insertion.
       input->set_instruction(phi);
       input->set_use_index(i);
-      input->AddToInputUseList();
+      replacement->AddInputUse(input);
     }
 
     phi->set_ssa_temp_index(graph_->alloc_ssa_temp_index());
     phis_.Add(phi);  // Postpone phi insertion until after load forwarding.
 
     return phi;
   }
 
   // Iterate over basic blocks and replace exposed loads with incoming
   // values.
@@ skipping 1044 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart