Avoid some unnecessary variables for phis.

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 {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
 
   String generateMethod(WorkItem work, HGraph graph) {
@@ skipping 67 matching lines @@
   final StringBuffer buffer;
   final String parameters;
 
   final Map<Element, String> parameterNames;
   final Map<int, String> names;
   final Map<String, int> prefixes;
   final Set<HInstruction> generateAtUseSite;
   final Map<HPhi, String> logicalOperations;
   final Map<Element, ElementAction> breakAction;
   final Map<Element, ElementAction> continueAction;
+  final Equivalence<HPhi> phiEquivalence;
 
   Element equalsNullElement;
   int indent = 0;
   int expectedPrecedence = JSPrecedence.STATEMENT_PRECEDENCE;
   HGraph currentGraph;
   /**
    * Whether the code-generation should try to generate an expression
    * instead of a sequence of statements.
    */
   int generationState = STATE_STATEMENT;
@@ skipping 20 matching lines @@
   SsaCodeGenerator(this.compiler,
                    this.work,
                    this.parameters,
                    this.parameterNames)
     : names = new Map<int, String>(),
       prefixes = new Map<String, int>(),
       buffer = new StringBuffer(),
       generateAtUseSite = new Set<HInstruction>(),
       logicalOperations = new Map<HPhi, String>(),
       breakAction = new Map<Element, ElementAction>(),
-      continueAction = new Map<Element, ElementAction>() {
+      continueAction = new Map<Element, ElementAction>(),
+      phiEquivalence = new Equivalence<HPhi>() {
 
     for (final name in parameterNames.getValues()) {
       prefixes[name] = 0;
     }
 
     equalsNullElement =
         compiler.builder.interceptors.getEqualsNullInterceptor();
   }
 
   abstract visitTypeGuard(HTypeGuard node);
@@ skipping 21 matching lines @@
   void endExpression(int precedence) {
     if (precedence < expectedPrecedence) {
       buffer.add(')');
     }
   }
 
   void preGenerateMethod(HGraph graph) {
     new SsaInstructionMerger(generateAtUseSite).visitGraph(graph);
     new SsaConditionMerger(generateAtUseSite,
                            logicalOperations).visitGraph(graph);
+    new PhiEquivalator(phiEquivalence, logicalOperations).analyzeGraph(graph);
   }
 
   visitGraph(HGraph graph) {
     preGenerateMethod(graph);
     currentGraph = graph;
     indent++;  // We are already inside a function.
     subGraph = new SubGraph(graph.entry, graph.exit);
     beginGraph(graph);
     visitBasicBlock(graph.entry);
     if (!delayedVarDecl.isEmpty()) {
@@ skipping 383 matching lines @@
 
             HBlockInformation oldInfo = currentBlockInformation;
             currentBlockInformation = info.body.start.labeledBlockInformation;
             visitSubGraph(info.body);
             currentBlockInformation = oldInfo;
 
             indent--;
             addIndentation();
             buffer.add("}\n");
           } else {
+            addIndentation();
             buffer.add(") {\n");
             indent++;
             wrapLoopBodyForContinue(info);
             visitSubGraph(info.updates);
             indent--;
             buffer.add("}\n");
           }
           success = true;
           break;
         }
@@ skipping 43 matching lines @@
     HInstruction instruction = node.first;
     while (instruction != null) {
       if (instruction === node.last) {
         for (HBasicBlock successor in node.successors) {
           int index = successor.predecessors.indexOf(node);
           successor.forEachPhi((HPhi phi) {
             bool isLogicalOperation = logicalOperations.containsKey(phi);
             // In case the phi is being generated by another
             // instruction.
             if (isLogicalOperation && isGenerateAtUseSite(phi)) return;
+            HPhi canonicalPhi = phiEquivalence.getRepresentative(phi);
+            HInstruction input = phi.inputs[index];
+            if (input is HPhi) {
+              HPhi inputPhi = input;
+              HPhi canonicalInput = phiEquivalence.getRepresentative(inputPhi);
+              // If we use the same variable, we don't need to create an
+              // assingment.

[floitsch, 2012/04/11 11:44:39]

assignment

[Lasse Reichstein Nielsen, 2012/04/11 11:55:26]

Done.

+              if (canonicalInput == canonicalPhi) {
+                assert(!isLogicalOperation);
+                return;
+              }
+            }
             if (isGeneratingExpression()) {
               addExpressionSeparator();
             } else {
               addIndentation();
             }
-            if (!temporaryExists(phi)) {
-              declareVariable(temporary(phi));
+            if (!temporaryExists(canonicalPhi)) {
+              declareVariable(temporary(canonicalPhi));
             } else {
-              buffer.add(temporary(phi));
+              buffer.add(temporary(canonicalPhi));
             }
             buffer.add(" = ");
             if (isLogicalOperation) {
               emitLogicalOperation(phi, logicalOperations[phi]);
             } else {
               use(phi.inputs[index], JSPrecedence.ASSIGNMENT_PRECEDENCE);
             }
             if (!isGeneratingExpression()) {
               buffer.add(';\n');
             }
@@ skipping 517 matching lines @@
   visitParameterValue(HParameterValue node) {
     assert(isGenerateAtUseSite(node));
     buffer.add(parameterNames[node.element]);
   }
 
   visitPhi(HPhi node) {
     String operation = logicalOperations[node];
     if (operation !== null) {
       emitLogicalOperation(node, operation);
     } else {
-      buffer.add('${temporary(node)}');
+      HPhi canonicalPhi = phiEquivalence.getRepresentative(node);
+      buffer.add('${temporary(canonicalPhi)}');
     }
   }
 
   visitReturn(HReturn node) {
     assert(node.inputs.length == 1);
     HInstruction input = node.inputs[0];
     if (input.isConstantNull()) {
       buffer.add('return;\n');
     } else {
       buffer.add('return ');
@@ skipping 668 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endElse(HIf node) {
     if (node.elseBlock.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }