Make IL instructions a doubly-linked list within basic blocks.

vm/flow_graph_optimizer.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_optimizer.h"
 
 #include "vm/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 
@@ skipping 514 matching lines @@
   switch (class_id) {
     case kArray:
     case kGrowableObjectArray:
       comp->set_receiver_type(static_cast<ObjectKind>(class_id));
   }
 }
 
 
 static void TryFuseComparisonWithBranch(ComparisonComp* comp) {
   Instruction* instr = comp->instr();
-  Instruction* next_instr = instr->StraightLineSuccessor();
+  Instruction* next_instr = instr->successor();
   if ((next_instr != NULL) && next_instr->IsBranch()) {
     BranchInstr* branch = next_instr->AsBranch();
     UseVal* use = branch->value()->AsUse();
     if (instr == use->definition()) {
       comp->MarkFusedWithBranch(branch);
       branch->MarkFusedWithComparison();
       return;
     }
   }
   if ((next_instr != NULL) && next_instr->IsBind()) {
     Computation* next_comp = next_instr->AsBind()->computation();
     if (next_comp->IsBooleanNegate()) {
-      Instruction* next_next_instr = next_instr->StraightLineSuccessor();
+      Instruction* next_next_instr = next_instr->successor();
       if ((next_next_instr != NULL) && next_next_instr->IsBranch()) {
         BooleanNegateComp* negate = next_comp->AsBooleanNegate();
         BranchInstr* branch = next_next_instr->AsBranch();
         if ((branch->value()->AsUse()->definition() == negate->instr()) &&
             (negate->value()->AsUse()->definition() == instr)) {
           comp->MarkFusedWithBranch(branch);
           branch->MarkFusedWithComparison();
           branch->set_is_negated(true);
-          instr->SetSuccessor(next_next_instr);
+          instr->set_successor(next_next_instr);
           return;
         }
       }
     }
   }
 }
 
 
 void FlowGraphOptimizer::VisitRelationalOp(RelationalOpComp* comp) {
   if (!comp->HasICData()) return;
@@ skipping 49 matching lines @@
 
 FlowGraphAnalyzer::FlowGraphAnalyzer(
     const GrowableArray<BlockEntryInstr*>& blocks)
         :blocks_(blocks), is_leaf_(false) {}
 
 
 void FlowGraphAnalyzer::Analyze() {
   is_leaf_ = true;
   for (intptr_t i = 0; i < blocks_.length(); ++i) {
     BlockEntryInstr* block_entry = blocks_[i];
-    Instruction* instr = block_entry->StraightLineSuccessor();
+    Instruction* instr = block_entry->successor();
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       LocationSummary* locs = instr->locs();
       if (locs != NULL) {
         if (locs->is_call()) {
           is_leaf_ = false;
           return;
         }
       }
-      instr = instr->StraightLineSuccessor();
+      instr = instr->successor();
     }
   }
 }
 
 }  // namespace dart