Reapply "Change the SSA construction pass to also construct def-use chains."

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 4053 matching lines @@
   GrowableArray<PhiInstr*> redundant_phis(10);
 
   // We will recompute dominators, block ordering, block ids, block last
   // instructions, previous pointers, predecessors, etc. after eliminating
   // unreachable code.  We do not maintain those properties during the
   // transformation.
   for (BlockIterator b = graph_->reverse_postorder_iterator();
        !b.Done();
        b.Advance()) {
     BlockEntryInstr* block = b.Current();
+    JoinEntryInstr* join = block->AsJoinEntry();
     if (!reachable_->Contains(block->preorder_number())) {
       if (FLAG_trace_constant_propagation) {
         OS::Print("Unreachable B%"Pd"\n", block->block_id());
       }
+      // Remove all uses in unreachable blocks.
+      if (join != NULL) {
+        for (PhiIterator it(join); !it.Done(); it.Advance()) {
+          it.Current()->UnuseAllInputs();
+        }
+      }
+      for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
+        it.Current()->UnuseAllInputs();
+      }
       continue;
     }
 
-    JoinEntryInstr* join = block->AsJoinEntry();
     if (join != NULL) {
       // Remove phi inputs corresponding to unreachable predecessor blocks.
       // Predecessors will be recomputed (in block id order) after removing
       // unreachable code so we merely have to keep the phi inputs in order.
       ZoneGrowableArray<PhiInstr*>* phis = join->phis();
       if (phis != NULL) {
         intptr_t pred_count = join->PredecessorCount();
         intptr_t live_count = 0;
         for (intptr_t pred_idx = 0; pred_idx < pred_count; ++pred_idx) {
           if (reachable_->Contains(
                   join->PredecessorAt(pred_idx)->preorder_number())) {
             if (live_count < pred_idx) {
               for (intptr_t phi_idx = 0; phi_idx < phis->length(); ++phi_idx) {
                 PhiInstr* phi = (*phis)[phi_idx];
                 if (phi == NULL) continue;
-                phi->inputs_[live_count] = phi->inputs_[pred_idx];
+                Value* input = phi->inputs_[pred_idx];
+                input->set_use_index(live_count);
+                phi->inputs_[live_count] = input;
               }
             }
             ++live_count;
+          } else {
+            for (intptr_t phi_idx = 0; phi_idx < phis->length(); ++phi_idx) {
+              PhiInstr* phi = (*phis)[phi_idx];
+              if (phi == NULL) continue;
+              phi->inputs_[pred_idx]->RemoveFromUseList();
+            }
           }
         }
         if (live_count < pred_count) {
           for (intptr_t phi_idx = 0; phi_idx < phis->length(); ++phi_idx) {
             PhiInstr* phi = (*phis)[phi_idx];
             if (phi == NULL) continue;
-            phi->inputs_.TruncateTo(live_count);
-            if (live_count == 1) redundant_phis.Add(phi);
+            if (FLAG_remove_redundant_phis && (live_count == 1)) {
+              Value* input = phi->InputAt(0);
+              phi->ReplaceUsesWith(input->definition());
+              input->RemoveFromUseList();
+              (*phis)[phi_idx] = NULL;
+            } else {
+              phi->inputs_.TruncateTo(live_count);
+            }
           }
         }
       }
     }
 
     for (ForwardInstructionIterator i(block); !i.Done(); i.Advance()) {
       Definition* defn = i.Current()->AsDefinition();
       // Replace constant-valued instructions without observable side
       // effects.  Do this for smis only to avoid having to copy other
       // objects into the heap's old generation.
@@ skipping 41 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);
+        branch->UnuseAllInputs();
       }
     }
   }
 
   graph_->DiscoverBlocks();
   GrowableArray<BitVector*> dominance_frontier;
   graph_->ComputeDominators(&dominance_frontier);
-  graph_->ComputeUseLists();
-
-  if (FLAG_remove_redundant_phis) {
-    for (intptr_t i = 0; i < redundant_phis.length(); i++) {
-      PhiInstr* phi = redundant_phis[i];
-      phi->ReplaceUsesWith(phi->InputAt(0)->definition());
-      phi->mark_dead();
-    }
-  }
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart