Fix bad mangling of environment parameters.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
@@ skipping 1084 matching lines @@
   }
 
   void emitAssignment(String destination, String source) {
     assignVariable(destination, new js.VariableUse(source));
   }
 
   /**
    * Sequentialize a list of conceptually parallel copies. Parallel
    * copies may contain cycles, that this method breaks.
    */
-  void sequentializeCopies(List<Copy> copies) {
+  void sequentializeCopies(List<Copy> copies,
+                           String tempName,

[ngeoffray, 2012/10/25 11:27:45]

Why parameterizing tempName? It's swapTemp for both calls.

[floitsch, 2012/10/31 14:49:19]

I don't want sequentializeCopies to deal with the variableNames object. It's
taking String->String mappings and returns String->String mappings.

+                           void doAssignment(String target, String source)) {
     // Map to keep track of the current location (ie the variable that
     // holds the initial value) of a variable.
     Map<String, String> currentLocation = new Map<String, String>();
 
     // Map to keep track of the initial value of a variable.
     Map<String, String> initialValue = new Map<String, String>();
 
     // List of variables to assign a value.
     List<String> worklist = <String>[];
 
     // List of variables that we can assign a value to (ie are not
     // being used anymore).
     List<String> ready = <String>[];
 
     // Prune [copies] by removing self-copies.
     List<Copy> prunedCopies = <Copy>[];
     for (Copy copy in copies) {
-      String sourceName = variableNames.getName(copy.source);
-      String destinationName = variableNames.getName(copy.destination);
-      if (sourceName != destinationName) {
-        prunedCopies.add(new Copy(sourceName, destinationName));
+      if (copy.source != copy.destination) {
+        prunedCopies.add(copy);
       }
     }
     copies = prunedCopies;
 
 
     // For each copy, set the current location of the source to
     // itself, and the initial value of the destination to the source.
     // Add the destination to the list of copies to make.
     for (Copy copy in copies) {
       currentLocation[copy.source] = copy.source;
       initialValue[copy.destination] = copy.source;
       worklist.add(copy.destination);
     }
 
     // For each copy, if the destination does not have a current
     // location, then we can safely assign to it.
     for (Copy copy in copies) {
       if (currentLocation[copy.destination] == null) {
         ready.add(copy.destination);
       }
     }
 
     while (!worklist.isEmpty()) {
       while (!ready.isEmpty()) {
         String destination = ready.removeLast();
         String source = initialValue[destination];
         // Since [source] might have been updated, use the current
         // location of [source]
         String copy = currentLocation[source];
-        emitAssignment(destination, copy);
+        doAssignment(destination, copy);
         // Now [destination] is the current location of [source].
         currentLocation[source] = destination;
         // If [source] hasn't been updated and needs to have a value,
         // add it to the list of variables that can be updated. Copies
         // of [source] will now use [destination].
         if (source == copy && initialValue[source] != null) {
           ready.add(source);
         }
       }
 
       // Check if we have a cycle.
       String current = worklist.removeLast();
       // If [current] is used as a source, and the assignment has been
       // done, we are done with this variable. Otherwise there is a
       // cycle that we break by using a temporary name.
       if (currentLocation[current] != null
           && current != currentLocation[initialValue[current]]) {
-        String tempName = variableNames.swapTemp;
-        emitAssignment(tempName, current);
+        doAssignment(tempName, current);
         currentLocation[current] = tempName;
         // [current] can now be safely updated. Copies of [current]
         // will now use [tempName].
         ready.add(current);
       }
     }
   }
 
   void assignPhisOfSuccessors(HBasicBlock node) {
     CopyHandler handler = variableNames.getCopyHandler(node);
     if (handler == null) return;
 
-    sequentializeCopies(handler.copies);
+    // Map the instructions to strings.
+    List<Copy> copies = handler.copies.map((Copy copy) {
+      return new Copy(variableNames.getName(copy.source),
+                      variableNames.getName(copy.destination));
+    });
+
+    sequentializeCopies(copies, variableNames.swapTemp, emitAssignment);
 
     for (Copy copy in handler.assignments) {
       String name = variableNames.getName(copy.destination);
       use(copy.source);
       assignVariable(name, pop());
     }
   }
 
   void iterateBasicBlock(HBasicBlock node) {
     HInstruction instruction = node.first;
@@ skipping 1588 matching lines @@
     if (!propagator.hasComplexBailoutTargets) return;
 
     js.Block nextBlock = new js.Block.empty();
     js.Case clause = new js.Case(new js.LiteralNumber('${node.state}'),
                                  nextBlock);
     currentBailoutSwitch.cases.add(clause);
     currentContainer = nextBlock;
     pushExpressionAsStatement(new js.Assignment(generateStateUse(),
                                                 new js.LiteralNumber('0')));
     js.Block setupBlock = new js.Block.empty();
-    int i = 0;
-    for (HInstruction input in node.inputs) {
+    List<Copy> copies = <Copy>[];
+    for (int i = 0; i < node.inputs.length; i++) {
+      HInstruction input = node.inputs[i];
       input = unwrap(input);
       String name = variableNames.getName(input);
-      if (!isVariableDeclared(name)) {
-        declaredVariables.add(name);
+      String source = "env$i";
+      copies.add(new Copy(source, name));
+    }
+    sequentializeCopies(copies,
+                        variableNames.swapTemp,
+                        (String target, String source) {
+      if (!isVariableDeclared(target)) {
+        declaredVariables.add(target);
         js.VariableInitialization init =
-            new js.VariableInitialization(new js.VariableDeclaration(name),
-                                          new js.VariableUse('env$i'));
+            new js.VariableInitialization(new js.VariableDeclaration(target),
+                                          new js.VariableUse(source));
         js.Expression varList =
             new js.VariableDeclarationList(<js.VariableInitialization>[init]);
         setupBlock.statements.add(new js.ExpressionStatement(varList));
       } else {
-        js.Expression target = new js.VariableUse(name);
-        js.Expression source = new js.VariableUse('env$i');
-        js.Expression assignment = new js.Assignment(target, source);
+        js.Expression jsTarget = new js.VariableUse(target);
+        js.Expression jsSource = new js.VariableUse(source);
+        js.Expression assignment = new js.Assignment(jsTarget, jsSource);
         setupBlock.statements.add(new js.ExpressionStatement(assignment));
       }
-      i++;
-    }
+    });
     setupBlock.statements.add(new js.Break(null));
     js.Case setupClause =
         new js.Case(new js.LiteralNumber('${node.state}'), setupBlock);
     (setup as js.Switch).cases.add(setupClause);
   }
 
   void startBailoutCase(List<HBailoutTarget> bailouts1,
                         [List<HBailoutTarget> bailouts2 = const []]) {
     if (!defaultClauseUsedInBailoutStack.last() &&
         bailouts1.length + bailouts2.length >= 2) {
@@ skipping 163 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }