Added VariableUse expression to tree IR.

pkg/compiler/lib/src/tree_ir/optimization/copy_propagator.dart

 // Copyright (c) 2014, 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 tree_ir.optimization;
 
 /// Eliminates moving assignments, such as w := v, by assigning directly to w
 /// at the definition of v.
 ///
 /// This compensates for suboptimal register allocation, and merges closure
 /// variables with local temporaries that were left behind when translating
 /// out of CPS (where closure variables live in a separate space).
 class CopyPropagator extends RecursiveVisitor with PassMixin {
 
   /// After visitStatement returns, [move] maps a variable v to an
   /// assignment A of form w := v, under the following conditions:
-  /// - there are no uses of w before A
+  /// - there are no reads or writes of w before A
   /// - A is the only use of v
   Map<Variable, Assign> move = <Variable, Assign>{};
 
   /// Like [move], except w is the key instead of v.
   Map<Variable, Assign> inverseMove = <Variable, Assign>{};
 
   ExecutableElement currentElement;
 
   void rewriteExecutableDefinition(ExecutableDefinition root) {
     currentElement = root.element;
@@ skipping 16 matching lines @@
     // }
 
     // Variables must not occur more than once in the parameter list, so
     // invalidate all moving assignments that would propagate a parameter
     // into another parameter. For example:
     // foo(x,y) {
     //   y = x;
     //   BODY
     // }
     // Cannot declare function as foo(x,x)!
-    node.parameters.forEach(visitVariable);
+    node.parameters.forEach(invalidateMovingAssignment);
 
     // Now do the propagation.
     for (int i = 0; i < node.parameters.length; i++) {
       Variable param = node.parameters[i];
       Variable replacement = copyPropagateVariable(param);
       replacement.element = param.element; // Preserve parameter name.
       node.parameters[i] = replacement;
     }
   }
 
@@ skipping 15 matching lines @@
     // }
 
     // Variables must not occur more than once in the parameter list, so
     // invalidate all moving assignments that would propagate a parameter
     // into another parameter. For example:
     // foo(x,y) {
     //   y = x;
     //   BODY
     // }
     // Cannot declare function as foo(x,x)!
-    node.parameters.forEach(visitVariable);
+    node.parameters.forEach(invalidateMovingAssignment);
 
     // Now do the propagation.
     for (int i = 0; i < node.parameters.length; i++) {
       Variable param = node.parameters[i];
       Variable replacement = copyPropagateVariable(param);
       replacement.element = param.element; // Preserve parameter name.
       node.parameters[i] = replacement;
     }
 
   }
 
 
   Statement visitBasicBlock(Statement node) {
     node = visitStatement(node);
     move.clear();
     inverseMove.clear();
     return node;
   }
 
-  void visitVariable(Variable variable) {
-    // We have found a use of w.
-    // Remove assignments of form w := v from the move maps.
-    Assign movingAssignment = inverseMove.remove(variable);
+  /// Remove an assignment of form [w] := v from the move maps.
+  void invalidateMovingAssignment(Variable w) {
+    Assign movingAssignment = inverseMove.remove(w);
     if (movingAssignment != null) {
-      move.remove(movingAssignment.definition);
+      VariableUse def = movingAssignment.definition;
+      move.remove(def.variable);
     }
   }
 
+  visitVariableUse(VariableUse node) {
+    // We found a use of w; we can't propagate assignments across this use.
+    invalidateMovingAssignment(node.variable);
+  }
+
   /**
    * Called when a definition of [v] is encountered.
    * Attempts to propagate the assignment through a moving assignment.
    * Returns the variable to be assigned into, defaulting to [v] itself if
    * no optimization could be performed.
    */
   Variable copyPropagateVariable(Variable v) {
     Assign movingAssign = move[v];
     if (movingAssign != null) {
       // We found the pattern:
       //   v := EXPR
       //   BLOCK   (does not use w)
       //   w := v  (only use of v)
       //
       // Rewrite to:
       //   w := EXPR
       //   BLOCK
       //   w := w  (to be removed later)
       Variable w = movingAssign.variable;
 
       // Make w := w.
       // We can't remove the statement from here because we don't have
       // parent pointers. So just make it a no-op so it can be removed later.
-      movingAssign.definition = w;
+      movingAssign.definition = new VariableUse(w);
 
       // The intermediate variable 'v' should now be orphaned, so don't bother
       // updating its read/write counters.
-      // Due to the nop trick, the variable 'w' now has one additional read
-      // and write.
-      ++w.writeCount;
-      ++w.readCount;
 
       // Make w := EXPR
+      ++w.writeCount;
       return w;
     }
     return v;
   }
 
   Statement visitAssign(Assign node) {
     node.next = visitStatement(node.next);
     node.variable = copyPropagateVariable(node.variable);
+
+    // If a moving assignment w := v exists later, and we assign to w here,
+    // the moving assignment is no longer a candidate for copy propagation.
+    invalidateMovingAssignment(node.variable);
+
     visitExpression(node.definition);
-    visitVariable(node.variable);
 
     // If this is a moving assignment w := v, with this being the only use of v,
     // try to propagate it backwards.  Do not propagate assignments where w
     // is from an outer function scope.
-    if (node.definition is Variable) {
-      Variable def = node.definition;
-      if (def.readCount == 1 &&
+    if (node.definition is VariableUse) {
+      VariableUse definition = node.definition;
+      if (definition.variable.readCount == 1 &&
           node.variable.host == currentElement) {
-        move[node.definition] = node;
+        move[definition.variable] = node;
         inverseMove[node.variable] = node;
       }
     }
 
     return node;
   }
 
   Statement visitLabeledStatement(LabeledStatement node) {
     node.next = visitBasicBlock(node.next);
     node.body = visitStatement(node.body);
@@ skipping 58 matching lines @@
 
   void visitFunctionExpression(FunctionExpression node) {
     new CopyPropagator().rewrite(node.definition);
   }
 
   void visitFieldInitializer(FieldInitializer node) {
     visitStatement(node.body);
   }
 
 }