Eliminate phis that do not reach any non-environment uses.

runtime/vm/flow_graph_allocator.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_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/intermediate_language.h"
 #include "vm/il_printer.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 62 matching lines @@
 
   blocked_cpu_regs_[CTX] = true;
   if (TMP != kNoRegister) {
     blocked_cpu_regs_[TMP] = true;
   }
   blocked_cpu_regs_[SPREG] = true;
   blocked_cpu_regs_[FPREG] = true;
 }
 
 
+// Remove environments from the instructions which can't deoptimize.
+// Replace dead phis uses with null values in environments.
 void FlowGraphAllocator::EliminateEnvironmentUses() {
+  ConstantVal* null_value = new ConstantVal(Object::ZoneHandle());
+
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* block = block_order_[i];
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
-      if (!current->CanDeoptimize()) current->set_env(NULL);
+      if (current->CanDeoptimize()) {
+        ASSERT(current->env() != NULL);
+        GrowableArray<Value*>* values = current->env()->values_ptr();
+
+        for (intptr_t i = 0; i < values->length(); i++) {
+          UseVal* use = (*values)[i]->AsUse();
+          if (use == NULL) continue;
+
+          PhiInstr* phi = use->definition()->AsPhi();
+          if (phi == NULL) continue;
+
+          if (!phi->is_alive()) (*values)[i] = null_value;
+        }
+      } else {
+        current->set_env(NULL);
+      }
     }
   }
 }
 
 
 void FlowGraphAllocator::ComputeInitialSets() {
   const intptr_t block_count = postorder_.length();
   for (intptr_t i = 0; i < block_count; i++) {
     BlockEntryInstr* block = postorder_[i];
 
@@ skipping 32 matching lines @@
         }
       }
     }
 
     // Handle phis.
     if (block->IsJoinEntry()) {
       JoinEntryInstr* join = block->AsJoinEntry();
       if (join->phis() != NULL) {
         for (intptr_t j = 0; j < join->phis()->length(); j++) {
           PhiInstr* phi = (*join->phis())[j];
-          if (phi == NULL) continue;
+          if ((phi == NULL) || !phi->is_alive()) continue;

[Kevin Millikin (Google), 2012/08/08 11:07:43]

It doesn't work to set (*join->phis())[j] = NULL when !phi->is_alive()?  That
seems better than leaving them in and skipping them everywhere.

+
           kill->Add(phi->ssa_temp_index());
           live_in->Remove(phi->ssa_temp_index());
 
           // If phi-operand is not defined by a predecessor it must be marked
           // live-in for a predecessor.
           for (intptr_t k = 0; k < phi->InputCount(); k++) {
             Value* val = phi->InputAt(k);
             if (val->IsUse()) {
               BlockEntryInstr* pred = block->PredecessorAt(k);
               const intptr_t use = val->AsUse()->definition()->ssa_temp_index();
@@ skipping 397 matching lines @@
   // the join.
   const intptr_t pred_idx = join->IndexOfPredecessor(block);
 
   // Record the corresponding phi input use for each phi.
   ZoneGrowableArray<PhiInstr*>* phis = join->phis();
   intptr_t move_idx = 0;
   for (intptr_t phi_idx = 0; phi_idx < phis->length(); phi_idx++) {
     PhiInstr* phi = (*phis)[phi_idx];
     if (phi == NULL) continue;
 
+    if (!phi->is_alive()) {
+      move_idx++;
+      continue;
+    }
+
     Value* val = phi->InputAt(pred_idx);
     MoveOperands* move = parallel_move->MoveOperandsAt(move_idx);
     if (val->IsUse()) {
       // Expected shape of live ranges:
       //
       //                 g  g'
       //      value    --*
       //
 
       LiveRange* range = GetLiveRange(
@@ skipping 26 matching lines @@
   // All uses are recorded at the start position in the block.
   const intptr_t pos = join->start_pos();
 
   ZoneGrowableArray<PhiInstr*>* phis = join->phis();
   if (phis != NULL) {
     intptr_t move_idx = 0;
     for (intptr_t phi_idx = 0; phi_idx < phis->length(); phi_idx++) {
       PhiInstr* phi = (*phis)[phi_idx];
       if (phi == NULL) continue;
 
+      if (!phi->is_alive()) {
+        move_idx++;
+        continue;
+      }
+
       const intptr_t vreg = phi->ssa_temp_index();
       ASSERT(vreg != -1);
 
       // Expected shape of live range:
       //
       //                 B
       //      phi        [--------
       //
       LiveRange* range = GetLiveRange(vreg);
       range->DefineAt(pos);  // Shorten live range.
@@ skipping 1273 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(Function::Handle(), block_order_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart