Convert some compiler passes to preserve valid def-use chains.

runtime/vm/flow_graph.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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 42 matching lines @@
 }
 
 void FlowGraph::AddToInitialDefinitions(Definition* defn) {
   // TODO(zerny): Set previous to the graph entry so it is accessible by
   // GetBlock. Remove this once there is a direct pointer to the block.
   defn->set_previous(graph_entry_);
   graph_entry_->initial_definitions()->Add(defn);
 }
 
 
+void FlowGraph::InsertBefore(Instruction* next,
+                             Instruction* instr,
+                             Environment* env,
+                             Definition::UseKind use_kind) {
+  InsertAfter(next->previous(), instr, env, use_kind);
+}
+
+
+void FlowGraph::InsertAfter(Instruction* prev,
+                            Instruction* instr,
+                            Environment* env,
+                            Definition::UseKind use_kind) {
+  for (intptr_t i = instr->InputCount() - 1; i >= 0; --i) {
+    Value* input = instr->InputAt(i);
+    input->definition()->AddInputUse(input);
+    input->set_instruction(instr);
+    input->set_use_index(i);
+  }
+  ASSERT(instr->env() == NULL);
+  if (env != NULL) env->DeepCopyTo(instr);
+  if (use_kind == Definition::kValue) {
+    ASSERT(instr->IsDefinition());
+    instr->AsDefinition()->set_ssa_temp_index(alloc_ssa_temp_index());
+  }
+  instr->InsertAfter(prev);
+}
+
+
 void FlowGraph::DiscoverBlocks() {
   // Initialize state.
   preorder_.Clear();
   postorder_.Clear();
   reverse_postorder_.Clear();
   parent_.Clear();
   assigned_vars_.Clear();
   // Perform a depth-first traversal of the graph to build preorder and
   // postorder block orders.
   graph_entry_->DiscoverBlocks(NULL,  // Entry block predecessor.
@@ skipping 69 matching lines @@
   }
   return true;  // Return true so we can ASSERT the reset code.
 }
 
 
 static void ValidateUseListsInInstruction(Instruction* instr) {
   ASSERT(instr != NULL);
   ASSERT(!instr->IsJoinEntry());
   for (intptr_t i = 0; i < instr->InputCount(); ++i) {
     Value* use = instr->InputAt(i);
+    ASSERT(use->definition() != NULL);
+    ASSERT(use->definition() != instr);
+    ASSERT(use->instruction() == instr);
     ASSERT(use->use_index() == i);
     ASSERT(!FLAG_verify_compiler ||
            (1 == MembershipCount(use, use->definition()->input_use_list())));
   }
   if (instr->env() != NULL) {
     intptr_t use_index = 0;
     for (Environment::DeepIterator it(instr->env()); !it.Done(); it.Advance()) {
       Value* use = it.CurrentValue();
+      ASSERT(use->definition() != NULL);
+      ASSERT(use->definition() != instr);
+      ASSERT(use->instruction() == instr);
       ASSERT(use->use_index() == use_index++);
       ASSERT(!FLAG_verify_compiler ||
              (1 == MembershipCount(use, use->definition()->env_use_list())));
     }
   }
   Definition* defn = instr->AsDefinition();
   if (defn != NULL) {
     Value* prev = NULL;
     Value* curr = defn->input_use_list();
     while (curr != NULL) {
       ASSERT(prev == curr->previous_use());
       ASSERT(defn == curr->definition());
       Instruction* instr = curr->instruction();
-      // The instruction should not be removed from the graph (phis are not
-      // removed until register allocation.)
-      ASSERT(instr->IsPhi() || (instr->previous() != NULL));
+      // The instruction should not be removed from the graph.  Removed
+      // instructions have a NULL previous link.  Phis are not removed until
+      // register allocation.  Comparisons used only in a branch will have a
+      // NULL previous link though they are still in the graph.
+      ASSERT(instr->IsPhi() ||
+             (instr->IsDefinition() && instr->AsDefinition()->IsComparison()) ||
+             (instr->previous() != NULL));
       ASSERT(curr == instr->InputAt(curr->use_index()));
       prev = curr;
       curr = curr->next_use();
     }
 
     prev = NULL;
     curr = defn->env_use_list();
     while (curr != NULL) {
       ASSERT(prev == curr->previous_use());
       ASSERT(defn == curr->definition());
       Instruction* instr = curr->instruction();
       ASSERT(curr == instr->env()->ValueAtUseIndex(curr->use_index()));
-      // The instruction should not be removed from the graph (phis are not
-      // removed until register allocation.)
-      ASSERT(instr->IsPhi() || (instr->previous() != NULL));
+      ASSERT(instr->IsPhi() ||
+             (instr->IsDefinition() && instr->AsDefinition()->IsComparison()) ||
+             (instr->previous() != NULL));
       prev = curr;
       curr = curr->next_use();
     }
   }
 }
 
 
 bool FlowGraph::ValidateUseLists() {
   // Validate initial definitions.
   for (intptr_t i = 0; i < graph_entry_->initial_definitions()->length(); ++i) {
@@ skipping 591 matching lines @@
          !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
 
 }  // namespace dart