Transitively mark inputs as live when they are generateAtUseSite.

lib/compiler/implementation/ssa/variable_allocator.dart

 // 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.
 
 /**
  * The [LiveRange] class covers a range where an instruction is live.
  */
 class LiveRange {
   final int start;
   // [end] is not final because it can be updated due to loops.
@@ skipping 163 matching lines @@
     assert(!loopMarkers.containsKey(header));
     loopMarkers[header] = id;
   }
 
   void removeLoopMarker(HBasicBlock header) {
     assert(loopMarkers.containsKey(header));
     loopMarkers.remove(header);
   }
 
   bool isEmpty() => liveInstructions.isEmpty() && loopMarkers.isEmpty();
-  bool contains(HInstruction instruction) => liveInstructions.containsKey(instruction);
+  bool contains(HInstruction instruction) =>
+      liveInstructions.containsKey(instruction);
   String toString() => liveInstructions.toString();
 }
 
 /**
  * Builds the live intervals of each instruction. The algorithm visits
  * the graph post-dominator tree to find the last uses of an
  * instruction, and computes the liveIns of each basic block.
  */
 class SsaLiveIntervalBuilder extends HBaseVisitor {
   final Compiler compiler;
+  final Set<HInstruction> generateAtUseSite;
 
   /**
    * A counter to assign start and end ids to live ranges. The initial
    * value is not relevant. Note that instructionId goes downward to ease
    * reasoning about live ranges (the first instruction of a graph has
    * the lowest id).
    */
   int instructionId = 0;
 
   /**
    * The liveIns of basic blocks.
    */
   final Map<HBasicBlock, LiveEnvironment> liveInstructions;
 
   /**
    * The live intervals of instructions.
    */
   final Map<HInstruction, LiveInterval> liveIntervals;
 
-  SsaLiveIntervalBuilder(this.compiler)
+  SsaLiveIntervalBuilder(this.compiler, this.generateAtUseSite)
     : liveInstructions = new Map<HBasicBlock, LiveEnvironment>(),
       liveIntervals = new Map<HInstruction, LiveInterval>();
 
   void visitGraph(HGraph graph) {
     visitPostDominatorTree(graph);
     if (!liveInstructions[graph.entry].isEmpty()) {
       compiler.internalError('LiveIntervalBuilder',
           node: compiler.currentElement.parseNode(compiler));
     }
   }
 
+  void markInputsAsLiveInEnvironment(HInstruction instruction,
+                                     LiveEnvironment environment) {
+    for (int i = 0, len = instruction.inputs.length; i < len; i++) {
+      markAsLiveInEnvironment(instruction.inputs[i], environment);
+    }
+  }
+
+  void markAsLiveInEnvironment(HInstruction instruction,
+                               LiveEnvironment environment) {
+    if (environment.contains(instruction)) return;
+    environment.add(instruction, instructionId);
+    // HPhis are treated specially.

[ngeoffray, 2012/08/17 13:04:53]

Do you remember if removing the HPhi check triggered an error?

[floitsch, 2012/10/03 09:22:39]

Sorry. Don't remember.

+    if (generateAtUseSite.contains(instruction) && instruction is !HPhi) {
+      markInputsAsLiveInEnvironment(instruction, environment);
+    }
+  }
+
   void visitBasicBlock(HBasicBlock block) {
-    LiveEnvironment environment = new LiveEnvironment(liveIntervals, instructionId);
+    LiveEnvironment environment =
+        new LiveEnvironment(liveIntervals, instructionId);
 
     // Add to the environment the liveIn of its successor, as well as
     // the inputs of the phis of the successor that flow from this block.
     for (int i = 0; i < block.successors.length; i++) {
       HBasicBlock successor = block.successors[i];
       LiveEnvironment successorEnv = liveInstructions[successor];
       if (successorEnv !== null) {
         environment.mergeWith(successorEnv);
       } else {
         environment.addLoopMarker(successor, instructionId);
       }
 
       int index = successor.predecessors.indexOf(block);
       for (HPhi phi = successor.phis.first; phi != null; phi = phi.next) {
-        environment.add(phi.inputs[index], instructionId);
+        markAsLiveInEnvironment(phi.inputs[index], environment);
       }
     }
 
     // Iterate over all instructions to remove an instruction from the
     // environment and add its inputs.
     HInstruction instruction = block.last;
     while (instruction != null) {
       environment.remove(instruction, instructionId);
-      for (int i = 0, len = instruction.inputs.length; i < len; i++) {
-        environment.add(instruction.inputs[i], instructionId);
-      }
+      markInputsAsLiveInEnvironment(instruction, environment);
       instruction = instruction.previous;
       instructionId--;
     }
 
     // We just remove the phis from the environment. The inputs of the
     // phis will be put in the environment of the predecessors.
     for (HPhi phi = block.phis.first; phi != null; phi = phi.next) {
       environment.remove(phi, instructionId);
     }
 
@@ skipping 358 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }