Revert "Compute local variable liveness before translation to SSA."

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, 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_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 440 matching lines @@
 
 
 intptr_t JoinEntryInstr::IndexOfPredecessor(BlockEntryInstr* pred) const {
   for (intptr_t i = 0; i < predecessors_.length(); ++i) {
     if (predecessors_[i] == pred) return i;
   }
   return -1;
 }
 
 
+// ==== Recording assigned variables.
+void Definition::RecordAssignedVars(BitVector* assigned_vars,
+                                    intptr_t fixed_parameter_count) {
+  // Nothing to do for the base class.
+}
+
+
+void StoreLocalInstr::RecordAssignedVars(BitVector* assigned_vars,
+                                         intptr_t fixed_parameter_count) {
+  if (!local().is_captured()) {
+    assigned_vars->Add(local().BitIndexIn(fixed_parameter_count));
+  }
+}
+
+
+void Instruction::RecordAssignedVars(BitVector* assigned_vars,
+                                     intptr_t fixed_parameter_count) {
+  // Nothing to do for the base class.
+}
+
+
 void Value::AddToList(Value* value, Value** list) {
   Value* next = *list;
   *list = value;
   value->set_next_use(next);
   value->set_previous_use(NULL);
   if (next != NULL) next->set_previous_use(value);
 }
 
 
 void Value::RemoveFromUseList() {
@@ skipping 159 matching lines @@
   return (i >= 0) && (i < preorder->length()) && ((*preorder)[i] == block);
 }
 
 
 // Base class implementation used for JoinEntry and TargetEntry.
 void BlockEntryInstr::DiscoverBlocks(
     BlockEntryInstr* predecessor,
     GrowableArray<BlockEntryInstr*>* preorder,
     GrowableArray<BlockEntryInstr*>* postorder,
     GrowableArray<intptr_t>* parent,
+    GrowableArray<BitVector*>* assigned_vars,
     intptr_t variable_count,
     intptr_t fixed_parameter_count) {
   // If this block has a predecessor (i.e., is not the graph entry) we can
   // assume the preorder array is non-empty.
   ASSERT((predecessor == NULL) || !preorder->is_empty());
   // Blocks with a single predecessor cannot have been reached before.
   ASSERT(IsJoinEntry() || !IsMarked(this, preorder));
 
   // 1. If the block has already been reached, add current_block as a
   // basic-block predecessor and we are done.
   if (IsMarked(this, preorder)) {
     ASSERT(predecessor != NULL);
     AddPredecessor(predecessor);
     return;
   }
 
   // 2. Otherwise, clear the predecessors which might have been computed on
   // some earlier call to DiscoverBlocks and record this predecessor.
   ClearPredecessors();
   if (predecessor != NULL) AddPredecessor(predecessor);
 
   // 3. The predecessor is the spanning-tree parent.  The graph entry has no
   // parent, indicated by -1.
   intptr_t parent_number =
       (predecessor == NULL) ? -1 : predecessor->preorder_number();
   parent->Add(parent_number);
 
   // 4. Assign the preorder number and add the block entry to the list.
+  // Allocate an empty set of assigned variables for the block.
   set_preorder_number(preorder->length());
   preorder->Add(this);
-
-  // The preorder and parent arrays are indexed by
+  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 to record assigned variables and
   // find the last instruction in the block.  The graph entry block consists
   // of only the entry instruction, so that is the last instruction in the
   // block.
   Instruction* last = this;
   for (ForwardInstructionIterator it(this); !it.Done(); it.Advance()) {
     last = it.Current();
+    if (vars != NULL) {
+      last->RecordAssignedVars(vars, fixed_parameter_count);
+    }
   }
   set_last_instruction(last);
 
   // Visit the block's successors in reverse so that they appear forwards
   // the reverse postorder block ordering.
   for (intptr_t i = last->SuccessorCount() - 1; i >= 0; --i) {
-    last->SuccessorAt(i)->DiscoverBlocks(this,
-                                         preorder,
-                                         postorder,
-                                         parent,
-                                         variable_count,
-                                         fixed_parameter_count);
+    last->SuccessorAt(i)->DiscoverBlocks(this, preorder, postorder,
+                                         parent, assigned_vars,
+                                         variable_count, fixed_parameter_count);
   }
 
   // 6. Assign postorder number and add the block entry to the list.
   set_postorder_number(postorder->length());
   postorder->Add(this);
 }
 
 
 bool BlockEntryInstr::Dominates(BlockEntryInstr* other) const {
   // TODO(fschneider): Make this faster by e.g. storing dominators for each
@@ skipping 1608 matching lines @@
     default:
       UNREACHABLE();
   }
   return kPowRuntimeEntry;
 }
 
 
 #undef __
 
 }  // namespace dart