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

vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 48 matching lines @@
 }
 
 FOR_EACH_COMPUTATION(DEFINE_ACCEPT)
 
 #undef DEFINE_ACCEPT
 
 
 #define DEFINE_ACCEPT(ShortName)                                               \
 Instruction* ShortName##Instr::Accept(FlowGraphVisitor* visitor) {             \
   visitor->Visit##ShortName(this);                                             \
-  return StraightLineSuccessor();                                              \
+  return successor();                                                          \
 }
 
 FOR_EACH_INSTRUCTION(DEFINE_ACCEPT)
 
 #undef DEFINE_ACCEPT
 
 
 // True iff. the v2 is above v1 on stack, or one of them is constant.
 static bool VerifyValues(Value* v1, Value* v2) {
   ASSERT(v1->IsUse() && v2->IsUse());
@@ skipping 372 matching lines @@
   BitVector* vars =
       (variable_count == 0) ? NULL : new BitVector(variable_count);
   assigned_vars->Add(vars);
   // The preorder, parent, and assigned_vars arrays are all indexed by
   // preorder block number, so they should stay in lockstep.
   ASSERT(preorder->length() == parent->length());
   ASSERT(preorder->length() == assigned_vars->length());
 
   // 5. Iterate straight-line successors until a branch instruction or
   // another basic block entry instruction, and visit that instruction.
-  ASSERT(StraightLineSuccessor() != NULL);
-  Instruction* next = StraightLineSuccessor();
+  ASSERT(successor() != NULL);
+  Instruction* next = successor();
   if (next->IsBlockEntry()) {
     set_last_instruction(this);
   } else {
     while ((next != NULL) && !next->IsBlockEntry() && !next->IsBranch()) {
       if (vars != NULL) next->RecordAssignedVars(vars);
       set_last_instruction(next);
-      next = next->StraightLineSuccessor();
+      next = next->successor();
     }
   }
   if (next != NULL) {
     next->DiscoverBlocks(this, preorder, postorder,
                          parent, assigned_vars, variable_count);
   }
 
   // 6. Assign postorder number and add the block entry to the list.
   set_postorder_number(postorder->length());
   postorder->Add(this);
@@ skipping 33 matching lines @@
   }
   ASSERT((*phis_)[var_index] == NULL);
   (*phis_)[var_index] = new PhiInstr(PredecessorCount());
   phi_count_++;
 }
 
 
 intptr_t Instruction::SuccessorCount() const {
   ASSERT(!IsBranch());
   ASSERT(!IsGraphEntry());
-  ASSERT(StraightLineSuccessor() == NULL ||
-         StraightLineSuccessor()->IsBlockEntry());
-  return StraightLineSuccessor() != NULL ? 1 : 0;
+  ASSERT(successor() == NULL ||
+         successor()->IsBlockEntry());
+  return successor() != NULL ? 1 : 0;
 }
 
 
 BlockEntryInstr* Instruction::SuccessorAt(intptr_t index) const {
-  return StraightLineSuccessor()->AsBlockEntry();
+  return successor()->AsBlockEntry();
+}
+
+
+void Instruction::RemoveFromGraph() {
+  ASSERT(!IsBlockEntry());
+  ASSERT(previous() != NULL);
+  Instruction* next = successor();
+  previous()->set_successor(next);
+  if (next != NULL) {
+    if (!next->IsBlockEntry()) {
+      next->set_previous(previous());
+    } else {
+      // Removing the last instruction of a block.
+      ASSERT(!IsBranch());
+      ASSERT(!IsThrow());
+      ASSERT(!IsReturn());
+      ASSERT(!IsReThrow());
+      // Update last_instruction of the current basic block.
+      Instruction* current = this;
+      while (!current->IsBlockEntry()) {
+        current = current->previous();
+      }
+      ASSERT(current->AsBlockEntry()->last_instruction() == this);
+      current->AsBlockEntry()->set_last_instruction(previous());
+    }
+  }
+  // Reset successor and previous instruction to indicate
+  // that the instruction is removed from the graph.
+  set_successor(NULL);
+  set_previous(NULL);
+}
+
+
+bool Instruction::is_linked() const {
+  ASSERT(!IsBlockEntry() || ((successor() != NULL) && (previous() == NULL)));
+  ASSERT(IsBlockEntry() || previous() != NULL);
+  return (previous() != NULL) || (successor() != NULL);
 }
 
 
 intptr_t GraphEntryInstr::SuccessorCount() const {
   return 1 + catch_entries_.length();
 }
 
 
 BlockEntryInstr* GraphEntryInstr::SuccessorAt(intptr_t index) const {
   if (index == 0) return normal_entry_;
@@ skipping 766 matching lines @@
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 
 #undef __
 
 }  // namespace dart