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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
@@ skipping 513 matching lines @@
          StraightLineSuccessor()->IsBlockEntry());
   return StraightLineSuccessor() != NULL ? 1 : 0;
 }
 
 
 BlockEntryInstr* Instruction::SuccessorAt(intptr_t index) const {
   return StraightLineSuccessor()->AsBlockEntry();
 }
 
 
+void Instruction::SetSuccessor(Instruction* instr) {

[srdjan, 2012/06/25 15:57:16]

The two methods are (at least now) very simple setter and could be renamed to
set_successor, set_previous and moved into  header file. Or are there plans to
make them more complex?

[Florian Schneider, 2012/07/02 09:20:42]

Done.

+  ASSERT(!IsGraphEntry());
+  ASSERT(!IsReturn());
+  ASSERT(!IsBranch());
+  ASSERT(!IsPhi());
+  // TODO(fschneider): Also add Throw and ReThrow to the list of instructions
+  // that do not have a successor. Currently, the graph builder will continue
+  // to append instruction in case of a Throw inside an expression. This
+  // condition should be handled in the graph builder
+  successor_ = instr;
+}
+
+
+void Instruction::SetPrevious(Instruction* instr) {
+  ASSERT(!IsBlockEntry());
+  previous_ = instr;
+}
+
+
+void Instruction::RemoveFromGraph() {
+  ASSERT(!IsBlockEntry());
+  ASSERT(Previous() != NULL);
+  Instruction* next = StraightLineSuccessor();
+  Previous()->SetSuccessor(next);
+  if (next != NULL && !next->IsBlockEntry()) {

[srdjan, 2012/06/25 15:57:16]

Add parenthesis. Quick question: when is it possible to remove the last
instruction (next == NULL)? I.e., should (next != NULL) be an assert or is it
possible?

[Florian Schneider, 2012/07/02 09:20:42]

It can happen. But this just made me realize that we need to do more here:

The last instruction currently acts as an implicit Goto-instruction. So we need
to update the last_instruction of the block_entry if we want to remove it.

This would mean I need to find the entry corresponding to the current block from
every instruction. Maybe it would be nicer to have an explicit Goto-instruction
instead?

+    next->SetPrevious(Previous());
+  }

[srdjan, 2012/06/25 15:57:16]

Set successor and previous of this instruction to NULL

[Florian Schneider, 2012/07/02 09:20:42]

Done.

+}
+
+
 intptr_t GraphEntryInstr::SuccessorCount() const {
   return 1 + catch_entries_.length();
 }
 
 
 BlockEntryInstr* GraphEntryInstr::SuccessorAt(intptr_t index) const {
   if (index == 0) return normal_entry_;
   return catch_entries_[index - 1];
 }
 
@@ skipping 763 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