Compute local variable liveness before translation to SSA.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 3234 matching lines @@
         } else {
           // TODO(vegorov): this can be optimized for the case of a single
           // predecessor.
           // TODO(vegorov): this can be reordered to reduce amount of operations
           // temp->CopyFrom(first_predecessor)
           temp->SetAll();
           ASSERT(block->PredecessorCount() > 0);
           for (intptr_t i = 0; i < block->PredecessorCount(); i++) {
             BlockEntryInstr* pred = block->PredecessorAt(i);
             BitVector* pred_out = out_[pred->preorder_number()];
-            temp->Intersect(*pred_out);
+            temp->Intersect(pred_out);
           }
         }
 
         if (!temp->Equals(*block_in)) {
           // If IN set has changed propagate the change to OUT set.
           block_in->CopyFrom(temp);
           if (block_out->KillAndAdd(block_kill, block_in)) {
             // If OUT set has changed then we have new values available out of
             // the block. Compute these values creating phi where necessary.
             for (BitVector::Iterator it(block_out);
@@ skipping 1162 matching lines @@
         // Drop the comparison, which does not have side effects as long
         // as it is a strict compare (the only one we can determine is
         // constant with the current analysis).
         GotoInstr* jump = new GotoInstr(join);
         Instruction* previous = branch->previous();
         branch->set_previous(NULL);
         previous->LinkTo(jump);
         // Replace the false target entry with the new join entry. We will
         // recompute the dominators after this pass.
         join->LinkTo(next);
+        jump->SetEnvironment(branch->env());

[Vyacheslav Egorov (Google), 2013/03/21 22:48:27]

This change revealed serious flaw in the way we restructure graph that slipped
past reviews before. 

We when we insert goto's into the graph we forget to attach the environment to
them... But we *must* do that goto can become a deoptimization target.

It is very fragile part of the system. Fix in this place extinguished immediate
fire but we need to review all places where we generate gotos and branches and
ensure that they get proper environment. 

[Kevin Millikin (Google), 2013/03/22 11:57:52]

I wouldn't say it's a flaw in the way we restructure the graph, but a flaw in
the way we record deoptimization environments.

Off the top of my head, there are two more occurrences in this file just below
for branch propagation, and occurrences also for inlining exits.

As we try to do more complicated things with changing the graph structure, this
will get harder and harder.

+        branch->SetEnvironment(NULL);
         branch->UnuseAllInputs();
       }
     }
   }
 
   graph_->DiscoverBlocks();
   GrowableArray<BitVector*> dominance_frontier;
   graph_->ComputeDominators(&dominance_frontier);
 
   if (FLAG_trace_constant_propagation) {
@@ skipping 179 matching lines @@
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
 
 }  // namespace dart