First step to SSA construction: Phi insertion.

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 73 matching lines @@
 intptr_t CreateArrayComp::InputCount() const {
   return ElementCount() + 1;
 }
 
 
 intptr_t BranchInstr::InputCount() const {
   return 1;
 }
 
 
+Value* BranchInstr::InputAt(intptr_t i) const {

[srdjan, 2012/06/12 17:34:37]

An alternative would be ASSERT(i == 0); return value();, but I am OK with this
as well

+  if (i == 0) return value();
+  UNREACHABLE();
+  return NULL;
+}
+
+
 intptr_t ReThrowInstr::InputCount() const {
   return 2;
 }
 
 
+Value* ReThrowInstr::InputAt(intptr_t i) const {
+  if (i == 0) return exception();
+  if (i == 1) return stack_trace();
+  UNREACHABLE();
+  return NULL;
+}
+
+
 intptr_t ThrowInstr::InputCount() const {
   return 1;
 }
 
 
+Value* ThrowInstr::InputAt(intptr_t i) const {
+  if (i == 0) return exception();
+  UNREACHABLE();
+  return NULL;
+}
+
+
 intptr_t ReturnInstr::InputCount() const {
   return 1;
 }
 
 
+Value* ReturnInstr::InputAt(intptr_t i) const {
+  if (i == 0) return value();
+  UNREACHABLE();
+  return NULL;
+}
+
+
 intptr_t BindInstr::InputCount() const {
   return computation()->InputCount();
 }
 
 
+Value* BindInstr::InputAt(intptr_t i) const {
+  return computation()->InputAt(i);
+}
+
+
+intptr_t PhiInstr::InputCount() const {
+  return inputs_.length();
+}
+
+
+Value* PhiInstr::InputAt(intptr_t i) const {
+  return inputs_[i];
+}
+
+
 intptr_t DoInstr::InputCount() const {
   return computation()->InputCount();
 }
 
 
+Value* DoInstr::InputAt(intptr_t i) const {
+  return computation()->InputAt(i);
+}
+
+
 intptr_t GraphEntryInstr::InputCount() const {
   return 0;
 }
 
 
+Value* GraphEntryInstr::InputAt(intptr_t i) const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
 intptr_t TargetEntryInstr::InputCount() const {
   return 0;
 }
 
 
+Value* TargetEntryInstr::InputAt(intptr_t i) const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
 intptr_t JoinEntryInstr::InputCount() const {
   return 0;
 }
 
 
+Value* JoinEntryInstr::InputAt(intptr_t i) const {
+  UNREACHABLE();
+  return NULL;
+}
+
+
 // ==== Recording assigned variables.
 void Computation::RecordAssignedVars(BitVector* assigned_vars) {
   // Nothing to do for the base class.
 }
 
 
 void StoreLocalComp::RecordAssignedVars(BitVector* assigned_vars) {
   if (!local().is_captured()) {
-    assigned_vars->Add(local().BitIndexIn(assigned_vars));
+    assigned_vars->Add(local().BitIndexIn(assigned_vars->length()));
   }
 }
 
 
 void Instruction::RecordAssignedVars(BitVector* assigned_vars) {
   // Nothing to do for the base class.
 }
 
 
 void DoInstr::RecordAssignedVars(BitVector* assigned_vars) {
@@ skipping 123 matching lines @@
   // nonoptimizing compiler.
   ASSERT(true_successor_ != NULL);
   ASSERT(false_successor_ != NULL);
   false_successor_->DiscoverBlocks(current_block, preorder, postorder,
                                    parent, assigned_vars, variable_count);
   true_successor_->DiscoverBlocks(current_block, preorder, postorder,
                                   parent, assigned_vars, variable_count);
 }
 
 
+void JoinEntryInstr::InsertPhi(intptr_t var_index, intptr_t var_count) {
+  // Lazily initialize the array of phis.
+  // Currently, phis are stored in a sparse array that holds the phi
+  // for variable with index i at position i.
+  // TODO(fschneider): Store phis in a more compact way.
+  if (phis_ == NULL) {
+    phis_ = new ZoneGrowableArray<PhiInstr*>(var_count);
+    for (intptr_t i = 0; i < var_count; i++) {
+      phis_->Add(NULL);
+    }
+  }
+  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;
 }
 
 
 BlockEntryInstr* Instruction::SuccessorAt(intptr_t index) const {
@@ skipping 698 matching lines @@
       StubCode::GetAllocationStubForClosure(closure_function));
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_index(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 #undef __
 
 }  // namespace dart