Fix a bug in the variable allocator: a pure instruction between an inlined if and its inlined expre…

sdk/lib/_internal/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.
 
 part of ssa;
 
 /**
  * The [LiveRange] class covers a range where an instruction is live.
  */
 class LiveRange {
@@ skipping 166 matching lines @@
 }
 
 /**
  * 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;
+  final Set<HInstruction> controlFlowOperators;
 
   /**
    * 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, this.generateAtUseSite)
+  SsaLiveIntervalBuilder(
+      this.compiler, this.generateAtUseSite, this.controlFlowOperators)
     : 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));
     }
   }
@@ skipping 39 matching lines @@
         liveIntervals[instruction] =
             new LiveInterval.forCheck(instructionId, liveIntervals[checked]);
       }
     }
   }
 
   void visitBasicBlock(HBasicBlock block) {
     LiveEnvironment environment =
         new LiveEnvironment(liveIntervals, instructionId);
 
+    // If the control flow instruction in this block will actually be
+    // inlined in the codegen in the join block, we need to make
+    // whatever is used by that control flow instruction as live in
+    // the join block.
+    if (controlFlowOperators.contains(block.last)) {
+      HIf ifInstruction = block.last;
+      HBasicBlock joinBlock = ifInstruction.joinBlock;
+      if (generateAtUseSite.contains(joinBlock.phis.first)) {
+        markInputsAsLiveInEnvironment(
+            ifInstruction, liveInstructions[joinBlock]);
+      }
+    }
+
     // 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);
       }
@@ skipping 404 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }