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

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 608 matching lines @@
   }
 }
 
 
 void Instruction::RecordAssignedVars(BitVector* assigned_vars,
                                      intptr_t fixed_parameter_count) {
   // Nothing to do for the base class.
 }
 
 
-void Value::AddToInputUseList() {
-  Value* next = definition()->input_use_list();
-  definition()->set_input_use_list(this);
-  set_next_use(next);
-  set_previous_use(NULL);
-  if (next != NULL) next->set_previous_use(this);
+void Value::AddToList(Value* value, Value** list) {
+  Value* next = *list;
+  *list = value;
+  value->set_next_use(next);
+  value->set_previous_use(NULL);
+  if (next != NULL) next->set_previous_use(value);
 }
 
 
-void Value::AddToEnvUseList() {
-  Value* next = definition()->env_use_list();
-  definition()->set_env_use_list(this);
-  set_next_use(next);
+void Value::RemoveFromUseList() {
+  Definition* def = definition();
+  Value* next = next_use();
+  if (this == def->input_use_list()) {
+    def->set_input_use_list(next);
+    if (next != NULL) next->set_previous_use(NULL);
+  } else if (this == def->env_use_list()) {
+    def->set_env_use_list(next);
+    if (next != NULL) next->set_previous_use(NULL);
+  } else {
+    Value* prev = previous_use();
+    prev->set_next_use(next);

[Kevin Millikin (Google), 2013/02/01 09:35:24]

Here we still assume use lists are coherent.  If this use is the head of the use
list for some other definition, prev will be NULL.

+    if (next != NULL) next->set_previous_use(prev);
+  }
+
+  set_definition(NULL);
   set_previous_use(NULL);
-  if (next != NULL) next->set_previous_use(this);
-}
-
-
-void Value::RemoveFromInputUseList() {
-  Value* previous = previous_use();
-  Value* next = next_use();
-  if (previous == NULL) {
-    definition()->set_input_use_list(next);
-  } else {
-    previous->set_next_use(next);
-  }
-  if (next != NULL) next->set_previous_use(previous);
-  set_definition(NULL);
+  set_next_use(NULL);
 }
 
 
 void Definition::ReplaceUsesWith(Definition* other) {
   ASSERT(other != NULL);
   ASSERT(this != other);
+
+  Value* current = NULL;
   Value* next = input_use_list();
-  while (next != NULL) {
-    Value* current = next;
-    next = current->next_use();
-    current->set_definition(other);
-    current->AddToInputUseList();
+  if (next != NULL) {
+    // Change all the definitions.
+    while (next != NULL) {
+      current = next;
+      current->set_definition(other);
+      next = current->next_use();
+    }
+
+    // Concatenate the lists.
+    next = other->input_use_list();
+    current->set_next_use(next);
+    if (next != NULL) next->set_previous_use(current);
+    other->set_input_use_list(input_use_list());
+    set_input_use_list(NULL);
   }
 
+  // Repeat for environment uses.
+  current = NULL;
   next = env_use_list();
-  while (next != NULL) {
-    Value* current = next;
-    next = current->next_use();
-    current->set_definition(other);
-    current->AddToEnvUseList();
+  if (next != NULL) {
+    while (next != NULL) {
+      current = next;
+      current->set_definition(other);
+      next = current->next_use();
+    }
+    next = other->env_use_list();
+    current->set_next_use(next);

[Vyacheslav Egorov (Google), 2013/02/01 14:38:19]

There is a bit of duplicated code here with above one. Consider making a
function.

+    if (next != NULL) next->set_previous_use(current);
+    other->set_env_use_list(env_use_list());
+    set_env_use_list(NULL);
   }
-
-  set_input_use_list(NULL);
-  set_env_use_list(NULL);
 }
 
 
 void Definition::ReplaceWith(Definition* other,
                              ForwardInstructionIterator* iterator) {
   if ((iterator != NULL) && (this == iterator->Current())) {
     iterator->ReplaceCurrentWith(other);
   } else {
     ReplaceUsesWith(other);
     ASSERT(other->env() == NULL);
@@ skipping 1014 matching lines @@
       constant_type_args->value().IsTypeArguments()) {
     const TypeArguments& instantiator_type_args =
         TypeArguments::Cast(constant_type_args->value());
     const AbstractType& new_dst_type = AbstractType::Handle(
         dst_type().InstantiateFrom(instantiator_type_args));
     set_dst_type(AbstractType::ZoneHandle(new_dst_type.Canonicalize()));
     ConstantInstr* null_constant = new ConstantInstr(Object::ZoneHandle());
     // It is ok to insert instructions before the current during
     // forward iteration.
     optimizer->InsertBefore(this, null_constant, NULL, Definition::kValue);
-    instantiator_type_arguments()->RemoveFromInputUseList();
+    instantiator_type_arguments()->RemoveFromUseList();
     instantiator_type_arguments()->set_definition(null_constant);
-    instantiator_type_arguments()->AddToInputUseList();
+    null_constant->AddInputUse(instantiator_type_arguments());
   }
   return this;
 }
 
 
 Instruction* BranchInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
   // Only handle strict-compares.
   if (comparison()->IsStrictCompare()) {
     Definition* replacement = comparison()->Canonicalize(optimizer);
     if (replacement == comparison() || replacement == NULL) return this;
@@ skipping 332 matching lines @@
 
 
 // Copies the environment and updates the environment use lists.
 void Environment::DeepCopyTo(Instruction* instr) const {
   Environment* copy = DeepCopy();
   intptr_t use_index = 0;
   for (Environment::DeepIterator it(copy); !it.Done(); it.Advance()) {
     Value* value = it.CurrentValue();
     value->set_instruction(instr);
     value->set_use_index(use_index++);
-    value->AddToEnvUseList();
+    value->definition()->AddEnvUse(value);
   }
   instr->set_env(copy);
 }
 
 
 // Copies the environment as outer on an inlined instruction and updates the
 // environment use lists.
 void Environment::DeepCopyToOuter(Instruction* instr) const {
   ASSERT(instr->env()->outer() == NULL);
   // Create a deep copy removing caller arguments from the environment.
   intptr_t argument_count = instr->env()->fixed_parameter_count();
   Environment* copy =
       new Environment(values_.length() - argument_count,
                       fixed_parameter_count_,
                       deopt_id_,
                       function_,
                       (outer_ == NULL) ? NULL : outer_->DeepCopy());
   for (intptr_t i = 0; i < values_.length() - argument_count; ++i) {
     copy->values_.Add(values_[i]->Copy());
   }
   intptr_t use_index = instr->env()->Length();  // Start index after inner.
   for (Environment::DeepIterator it(copy); !it.Done(); it.Advance()) {
     Value* value = it.CurrentValue();
     value->set_instruction(instr);
     value->set_use_index(use_index++);
-    value->AddToEnvUseList();
+    value->definition()->AddEnvUse(value);
   }
   instr->env()->outer_ = copy;
 }
 
 
 RangeBoundary RangeBoundary::FromDefinition(Definition* defn, intptr_t offs) {
   if (defn->IsConstant() && defn->AsConstant()->value().IsSmi()) {
     return FromConstant(Smi::Cast(defn->AsConstant()->value()).Value() + offs);
   }
   return RangeBoundary(kSymbol, reinterpret_cast<intptr_t>(defn), offs);
@@ skipping 662 matching lines @@
     default:
       UNREACHABLE();
   }
   return kPowRuntimeEntry;
 }
 
 
 #undef __
 
 }  // namespace dart