Add functions for setting an environment and rebinding a use.

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 300 matching lines @@
 #define DEFINE_ACCEPT(ShortName)                                               \
 void ShortName##Instr::Accept(FlowGraphVisitor* visitor) {                     \
   visitor->Visit##ShortName(this);                                             \
 }
 
 FOR_EACH_INSTRUCTION(DEFINE_ACCEPT)
 
 #undef DEFINE_ACCEPT
 
 
+void Instruction::SetEnvironment(Environment* deopt_env) {
+  intptr_t use_index = 0;
+  for (Environment::DeepIterator it(deopt_env); !it.Done(); it.Advance()) {
+    Value* use = it.CurrentValue();
+    use->set_instruction(this);
+    use->set_use_index(use_index++);
+  }
+  env_ = deopt_env;
+}
+
+
+void Instruction::RemoveEnvironment() {
+  for (Environment::DeepIterator it(env()); !it.Done(); it.Advance()) {
+    it.CurrentValue()->RemoveFromUseList();
+  }
+  env_ = NULL;
+}
+
+
 Instruction* Instruction::RemoveFromGraph(bool return_previous) {
   ASSERT(!IsBlockEntry());
   ASSERT(!IsControl());
   ASSERT(!IsThrow());
   ASSERT(!IsReturn());
   ASSERT(!IsReThrow());
   ASSERT(!IsGoto());
   ASSERT(previous() != NULL);
+  // We cannot assert that the instruction, if it is a definition, has no
+  // uses.  This function is used to remove instructions from the graph and
+  // reinsert them elsewhere (e.g., hoisting).
   Instruction* prev_instr = previous();
   Instruction* next_instr = next();
   ASSERT(next_instr != NULL);
   ASSERT(!next_instr->IsBlockEntry());
   prev_instr->LinkTo(next_instr);
-  // Reset successor and previous instruction to indicate
-  // that the instruction is removed from the graph.
+  UnuseAllInputs();
+  // Reset the successor and previous instruction to indicate that the
+  // instruction is removed from the graph.
   set_previous(NULL);
   set_next(NULL);
   return return_previous ? prev_instr : next_instr;
 }
 
 
-void Instruction::InsertBefore(Instruction* next) {
-  ASSERT(previous_ == NULL);
-  ASSERT(next_ == NULL);
-  next_ = next;
-  previous_ = next->previous_;
-  next->previous_ = this;
-  previous_->next_ = this;
-}
-
-
 void Instruction::InsertAfter(Instruction* prev) {
   ASSERT(previous_ == NULL);
   ASSERT(next_ == NULL);
   previous_ = prev;
   next_ = prev->next_;
   next_->previous_ = this;
   previous_->next_ = this;
+
+  // Update def-use chains whenever instructions are added to the graph
+  // after initial graph construction.
+  for (intptr_t i = InputCount() - 1; i >= 0; --i) {
+    Value* input = InputAt(i);
+    input->definition()->AddInputUse(input);
+  }
 }
 
 
 BlockEntryInstr* Instruction::GetBlock() const {
   // TODO(fschneider): Implement a faster way to get the block of an
   // instruction.
   ASSERT(previous() != NULL);
   Instruction* result = previous();
   while (!result->IsBlockEntry()) result = result->previous();
   return result->AsBlockEntry();
@@ skipping 96 matching lines @@
     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);
     if (next != NULL) next->set_previous_use(prev);
   }
 
-  set_definition(NULL);
   set_previous_use(NULL);
   set_next_use(NULL);
 }
 
 
 void Definition::ReplaceUsesWith(Definition* other) {
   ASSERT(other != NULL);
   ASSERT(this != other);
 
   Value* current = NULL;
@@ skipping 44 matching lines @@
 
 void Definition::ReplaceWith(Definition* other,
                              ForwardInstructionIterator* iterator) {
   // Record other's input uses.
   for (intptr_t i = other->InputCount() - 1; i >= 0; --i) {
     Value* input = other->InputAt(i);
     input->definition()->AddInputUse(input);
   }
   // Take other's environment from this definition.
   ASSERT(other->env() == NULL);
-  intptr_t use_index = 0;
-  for (Environment::DeepIterator it(env()); !it.Done(); it.Advance()) {
-    Value* use = it.CurrentValue();
-    use->set_instruction(other);
-    use->set_use_index(use_index++);
-  }
-  other->set_env(env());
-  set_env(NULL);
+  other->SetEnvironment(env());
+  env_ = NULL;
   // Replace all uses of this definition with other.
   ReplaceUsesWith(other);
   // Reuse this instruction's SSA name for other.
   ASSERT(!other->HasSSATemp());
   if (HasSSATemp()) other->set_ssa_temp_index(ssa_temp_index());
-  // Remove this definition's input uses.
-  UnuseAllInputs();
 
-  // Finally remove this definition from the graph.
+  // Finally insert the other definition in place of this one in the graph.
   previous()->LinkTo(other);
   if ((iterator != NULL) && (this == iterator->Current())) {
     // Remove through the iterator.
     other->LinkTo(this);
     iterator->RemoveCurrentFromGraph();
   } else {
     other->LinkTo(next());
+    // Remove this definition's input uses.
+    UnuseAllInputs();
   }
   set_previous(NULL);
   set_next(NULL);
 }
 
 
 BranchInstr::BranchInstr(ComparisonInstr* comparison, bool is_checked)
     : comparison_(comparison), is_checked_(is_checked) {
   for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
     comparison->InputAt(i)->set_instruction(this);
   }
 }
 
 
 void BranchInstr::RawSetInputAt(intptr_t i, Value* value) {
   comparison()->RawSetInputAt(i, value);
 }
 
 
 // A misleadingly named function for use in template functions that replace
 // both definitions with definitions and branch comparisons with
 // comparisons.  In the branch case, leave the branch intact and replace its
-// comparison with another comparison.
+// comparison with a new comparison not currently in the graph.
 void BranchInstr::ReplaceWith(ComparisonInstr* other,
                               ForwardInstructionIterator* ignored) {
-  // Record the new comparison's input uses.
-  for (intptr_t i = other->InputCount() - 1; i >= 0; --i) {
-    Value* input = other->InputAt(i);
-    input->definition()->AddInputUse(input);
-  }
   SetComparison(other);
 }
 
 
 void BranchInstr::SetComparison(ComparisonInstr* comp) {
-  // The new comparison's input uses are already recorded in their
-  // definition's use lists.
   for (intptr_t i = comp->InputCount() - 1; i >= 0; --i) {
-    comp->InputAt(i)->set_instruction(this);
+    Value* input = comp->InputAt(i);
+    input->definition()->AddInputUse(input);
+    input->set_instruction(this);
   }
   // There should be no need to copy or unuse an environment.
   ASSERT(comparison()->env() == NULL);
   // Remove the current comparison's input uses.
   comparison()->UnuseAllInputs();
   ASSERT(!comp->HasUses());
   comparison_ = comp;
 }
 
 
@@ skipping 554 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()->RemoveFromUseList();
-    instantiator_type_arguments()->set_definition(null_constant);
-    null_constant->AddInputUse(instantiator_type_arguments());
+    instantiator_type_arguments()->BindTo(null_constant);
   }
   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;
     ComparisonInstr* comp = replacement->AsComparison();
     if ((comp == NULL) || comp->CanDeoptimize()) return this;
 
     // Check that comparison is not serving as a pending deoptimization target
     // for conversions.
     for (intptr_t i = 0; i < comp->InputCount(); i++) {
       if (comp->RequiredInputRepresentation(i) !=
           comp->InputAt(i)->definition()->representation()) {
         return this;
       }
     }
 
     // Replace the comparison if the replacement is used at this branch,
     // and has exactly one use.
     if ((comp->input_use_list()->instruction() == this) &&
         (comp->input_use_list()->next_use() == NULL) &&
         (comp->env_use_list() == NULL)) {
       comp->RemoveFromGraph();
-      // It is safe to pass a NULL iterator because we're replacing the
-      // comparison wrapped in a BranchInstr which does not modify the
-      // linked list of instructions.
       SetComparison(comp);
       if (FLAG_trace_optimization) {
         OS::Print("Merging comparison v%"Pd"\n", comp->ssa_temp_index());
       }
       // Clear the comparison's temp index and ssa temp index since the
       // value of the comparison is not used outside the branch anymore.
       ASSERT(comp->input_use_list() == NULL);
       comp->ClearSSATempIndex();
       comp->ClearTempIndex();
     }
@@ skipping 313 matching lines @@
 }
 
 
 // Copies the environment and updates the environment use lists.
 void Environment::DeepCopyTo(Instruction* instr) const {
   for (Environment::DeepIterator it(instr->env()); !it.Done(); it.Advance()) {
     it.CurrentValue()->RemoveFromUseList();
   }
 
   Environment* copy = DeepCopy();
-  intptr_t use_index = 0;
+  instr->SetEnvironment(copy);
   for (Environment::DeepIterator it(copy); !it.Done(); it.Advance()) {
     Value* value = it.CurrentValue();
-    value->set_instruction(instr);
-    value->set_use_index(use_index++);
     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 {
   // Create a deep copy removing caller arguments from the environment.
   ASSERT(this != NULL);
   ASSERT(instr->env()->outer() == NULL);
   intptr_t argument_count = instr->env()->fixed_parameter_count();
   Environment* copy = DeepCopy(values_.length() - argument_count);
+  instr->env()->outer_ = 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->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 677 matching lines @@
     default:
       UNREACHABLE();
   }
   return kPowRuntimeEntry;
 }
 
 
 #undef __
 
 }  // namespace dart