Initial work on computing SSA.

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 2261 matching lines @@
   intptr_t next_index = (*parent)[current_index];
   if (next_index > start_index) {
     CompressPath(start_index, next_index, parent, label);
     (*label)[current_index] =
         Utils::Minimum((*label)[current_index], (*label)[next_index]);
     (*parent)[current_index] = (*parent)[next_index];
   }
 }
 
 
+void FlowGraphBuilder::InsertPhis(GrowableArray<BlockEntryInstr*>* preorder,
+                                  GrowableArray<BitVector*>* assigned_vars,
+                                  intptr_t var_count,
+                                  GrowableArray<BitVector*>* dom_frontier) {
+  int block_count = preorder->length();
+  // Map preorder block number to the highest variable index that has a phi
+  // in that block.  Use it to avoid inserting multiple phis for the same
+  // variable.
+  int* has_already = new int[block_count];
+  // Map preorder block number to the highest variable index for which the
+  // block went on the worklist.  Use it to avoid adding the same block to
+  // the worklist more than once for the same variable.
+  int* work = new int[block_count];
+
+  // Initialize has_already and work.
+  for (intptr_t block_index = 0; block_index < block_count; ++block_index) {
+    has_already[block_index] = -1;
+    work[block_index] = -1;
+  }
+
+  // Insert phis for each variable in turn.
+  GrowableArray<BlockEntryInstr*> worklist;
+  for (intptr_t var_index = 0; var_index < var_count; ++var_index) {
+    // Add to the worklist each block containing an assignment.
+    for (intptr_t block_index = 0; block_index < block_count; ++block_index) {
+      if ((*assigned_vars)[block_index]->Contains(var_index)) {
+        work[block_index] = var_index;
+        worklist.Add((*preorder)[block_index]);
+      }
+    }
+
+    while (!worklist.is_empty()) {
+      BlockEntryInstr* current = worklist.Last();
+      worklist.RemoveLast();
+      // Ensure a phi for each block in the dominance frontier of current.
+      BitVector::Iterator it((*dom_frontier)[current->preorder_number()]);
+      while (!it.Done()) {
+        int index = it.Current();
+        if (has_already[index] < var_index) {
+          BlockEntryInstr* block = (*preorder)[index];
+          ASSERT(block->IsJoinEntry());
+          block->AsJoinEntry()->InsertPhi(var_index);
+          has_already[index] = var_index;
+          if (work[index] < var_index) {
+            work[index] = var_index;
+            worklist.Add(block);
+          }
+        }
+      }
+    }
+  }
+
+  delete[] work;
+  delete[] has_already;
+}
+
+
+void FlowGraphBuilder::RenameLocals(intptr_t var_count) {
+  // Renaming environment is an array of values or NULL.
+
+  // Top-down recursive traversal of the dominator tree.  Pass a copy of the
+  // renaming environment to all children but the last one.
+
+  // Visit each instruction in the block.
+
+  // For each StoreLocal at current context level that is not captured,
+  // remove it from the graph and add it's rhs to the renaming environment.
+
+  // For each LoadLocal at current context level that is not captured,
+  // remove it from the graph.
+
+  // For each use of a load local or store local, replace it with the value
+  // in the environment.
+
+  // If the node does not dominate anything, process any phis in the
+  // successor.
+}
+
+
 void FlowGraphBuilder::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphBuilder Bailout: %s %s";
   const char* function_name = parsed_function_.function().ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart