Set previous instruction pointers when building the graph.

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/assert.h"
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
@@ skipping 33 matching lines @@
   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.
                                &preorder_,
                                &postorder_,
                                &parent_,
                                &assigned_vars_,
                                variable_count(),
                                num_non_copied_params());
-  // Number blocks in reverse postorder.
+  // Create an array of blocks in reverse postorder.
   intptr_t block_count = postorder_.length();
   for (intptr_t i = 0; i < block_count; ++i) {
     reverse_postorder_.Add(postorder_[block_count - i - 1]);
   }
-  // Link instructions backwards for optimized compilation.
-  // TODO(zerny): The builder should do this at construction time.
-  for (intptr_t i = 0; i < block_count; ++i) {
-    BlockEntryInstr* entry = postorder_[i];
-    Instruction* previous = entry;
-    for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
-      Instruction* current = it.Current();
-      current->set_previous(previous);
-      previous = current;
-    }
-  }
 }
 
 
 #ifdef DEBUG
 // Debugging code to verify the construction of use lists.
 
 static intptr_t MembershipCount(Value* use, Value* list) {
   intptr_t count = 0;
   while (list != NULL) {
     if (list == use) ++count;
@@ skipping 680 matching lines @@
       phi->SetInputAt(i, use);
       use->set_use_index(i);
     }
     // Write the predecessor use at the end.
     phi->SetInputAt(pred_count - 1, pred_use);
     pred_use->set_use_index(pred_count - 1);
   }
 }
 
 
-// Helper to link two instructions in the graph.
-static void Link(Instruction* prev, Instruction* next) {
-  ASSERT(prev != next);
-  prev->set_next(next);
-  next->set_previous(prev);
-}
-
-
 // Helper to sort a list of blocks.
 static int LowestBlockIdFirst(BlockEntryInstr* const* a,
                               BlockEntryInstr* const* b) {
   return (*a)->block_id() - (*b)->block_id();
 }
 
 
 // Inline a flow graph at a call site.
 //
 // Assumes the callee graph was computed by BuildGraph with an inlining context
@@ skipping 38 matching lines @@
 
   // Insert the callee graph into the caller graph.
   if (callee_exits->is_empty()) {
     // TODO(zerny): Add support for non-local exits, such as throw.
     UNREACHABLE();
   } else if (callee_exits->length() == 1) {
     ReturnInstr* exit = (*callee_exits)[0];
     ASSERT(exit->previous() != NULL);
     // For just one exit, replace the uses and remove the call from the graph.
     call->ReplaceUsesWith(exit->value()->definition());
-    Link(call->previous(), callee_entry->next());
-    Link(exit->previous(), call->next());
+    call->previous()->LinkTo(callee_entry->next());
+    exit->previous()->LinkTo(call->next());
     // In case of control flow, locally update the dominator tree.
     if (callee_graph->preorder().length() > 2) {
       // The caller block is split and the new block id is that of the exit
       // block. If the caller block had outgoing edges, reorder the phis so they
       // are still ordered by block id.
       ReorderPhis(caller_entry);
       // The callee return is now the immediate dominator of blocks whose
       // immediate dominator was the caller entry.
       BlockEntryInstr* exit_block = exit->GetBlock();
       ASSERT(exit_block->dominated_blocks().is_empty());
@@ skipping 45 matching lines @@
         ASSERT(exit_instr != NULL);
         Value* use = exit_instr->value();
         phi->SetInputAt(i, use);
         use->set_instruction(phi);
         use->set_use_index(i);
       }
       // Replace uses of the call with the phi.
       call->ReplaceUsesWith(phi);
     }
     //  Remove the call from the graph.
-    Link(call->previous(), callee_entry->next());
-    Link(join, call->next());
+    call->previous()->LinkTo(callee_entry->next());
+    join->LinkTo(call->next());
     // The caller block is split and the new block id is that of the join
     // block. If the caller block had outgoing edges, reorder the phis so they
     // are still ordered by block id.
     ReorderPhis(caller_entry);
     // Adjust pre/post orders and update the dominator tree.
     DiscoverBlocks();
     // TODO(zerny): Compute the dominator frontier locally.
     GrowableArray<BitVector*> dominance_frontier;
     ComputeDominators(&dominance_frontier);
   }
 }
 
 
 intptr_t FlowGraph::InstructionCount() const {
   intptr_t size = 0;
   // Iterate each block, skipping the graph entry.
   for (intptr_t i = 1; i < preorder_.length(); ++i) {
     for (ForwardInstructionIterator it(preorder_[i]);
          !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
 
 }  // namespace dart