dart2dart: Preserve variable names throughout the IR.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree.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.
 
 library dart_tree;
 
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart'
     show Element, FunctionElement, FunctionSignature, ParameterElement,
          ClassElement;
@@ skipping 65 matching lines @@
   int breakCount = 0;
 
   /// The [LabeledStatement] binding this label.
   LabeledStatement binding;
 }
 
 /**
  * Variables are [Expression]s.
  */
 class Variable extends Expression {
-  // A counter used to generate names.  The counter is reset to 0 for each
-  // function emitted.
-  static int counter = 0;
-  static String _newName() => 'v${counter++}';
+  Element element;
+  int index;

[sigurdm, 2014/06/04 07:51:56]

Maybe have a comment explaining what the index indicates.

[asgerf, 2014/06/04 09:40:51]

It was an akward field to have in the first place, especially since it is not
enough to prevent name clashes.

I deleted the index field and introduced proper name synthesis in dart_codegen.

 
-  Element element;
-  String cachedName;
+  int readCount = 0;
+  int writeCount = 0;
 
-  String get name {
-    if (cachedName != null) return cachedName;
-    return cachedName = ((element == null) ? _newName() : element.name);
-  }
-
-  Variable(this.element);
+  Variable(this.element, this.index);
 
   accept(Visitor visitor) => visitor.visitVariable(this);
 }
 
 /**
  * Common interface for invocations with arguments.
  */
 abstract class Invoke {
   List<Expression> get arguments;
   Selector get selector;
@@ skipping 141 matching lines @@
 /**
  * An assignments of an [Expression] to a [Variable].
  *
  * In contrast to the CPS-based IR, non-primitive expressions can be assigned
  * to variables.
  */
 class Assign extends Statement {
   Statement next;
   final Variable variable;
   Expression definition;
-  final bool hasExactlyOneUse;
 
-  Assign(this.variable, this.definition, this.next, this.hasExactlyOneUse);
+  Assign(this.variable, this.definition, this.next) {
+    ++variable.writeCount;
+  }
+
+  bool get hasExactlyOneUse => variable.readCount == 1;
 
   accept(Visitor visitor) => visitor.visitAssign(this);
 }
 
 /**
  * A return exit from the function.
  *
  * In contrast to the CPS-based IR, the return value is an arbitrary
  * expression.
  */
 class Return extends Statement {
   /// Should not be null. Use [Constant] with [NullConstant] for void returns.
   Expression value;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Return(this.value);
 
   accept(Visitor visitor) => visitor.visitReturn(this);
 }
 
 /**
  * A break from an enclosing [LabeledStatement].  The break targets the
  * labeled statement's successor statement.
  */
 class Break extends Statement {
-  Label _target;
-
-  Label get target => _target;
-  void set target(Label newTarget) {
-    ++newTarget.breakCount;
-    --_target.breakCount;
-    _target = newTarget;
-  }
+  Label target;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
-  Break(this._target) {
+  Break(this.target) {
     ++target.breakCount;
   }
 
   accept(Visitor visitor) => visitor.visitBreak(this);
 }
 
 /**
  * A continue to an enclosing [While] loop.  The continue targets the
  * loop's body.
  */
@@ skipping 109 matching lines @@
  * translation out of SSA.  Jumps are eliminated during the Tree-to-Tree
  * control-flow recognition.
  *
  * Otherwise, the output of Builder looks very much like the input.  In
  * particular, intermediate values and blocks used for local control flow are
  * still all named.
  */
 class Builder extends ir.Visitor<Node> {
   final dart2js.Compiler compiler;
 
-  // Uses of IR primitives are replaced with Tree variables.  This is the
-  // mapping from primitives to variables.
-  final Map<ir.Primitive, Variable> variables = <ir.Primitive, Variable>{};
+  /// Maps variable/parameter elements to the Tree variables that represent it.
+  final Map<Element, List<Variable>> element2variables = <Element,List>{};

[sigurdm, 2014/06/04 07:51:56]

Is there a reason not to use <Element, List<Variable>>{} ?

[asgerf, 2014/06/04 09:40:51]

No, fixed it.

 
   // Continuations with more than one use are replaced with Tree labels.  This
   // is the mapping from continuations to labels.
   final Map<ir.Continuation, Label> labels = <ir.Continuation, Label>{};
 
   FunctionDefinition function;
   ir.Continuation returnContinuation;
 
   Builder(this.compiler);
 
+  /// Obtains the variable representing the given primitive. Returns null for
+  /// primitives that have no reference and do not need a variable.
+  Variable getVariable(ir.Primitive primitive) {
+    if (primitive.registerIndex == null) {
+      return null; // variable is unused
+    }
+    List<Variable> variables = element2variables[primitive.element];
+    if (variables == null) {
+      variables = <Variable>[];
+      element2variables[primitive.element] = variables;
+    }
+    while (variables.length <= primitive.registerIndex) {
+      variables.add(new Variable(primitive.element, variables.length));
+    }
+    return variables[primitive.registerIndex];
+  }
+
+  /// Obtains a reference to the tree Variable corresponding to the IR primitive
+  /// referred to by [reference].
+  /// This increments the reference count for the given variable, so the
+  /// returned expression must be used in the tree.
+  Expression getVariableReference(ir.Reference reference) {
+    Variable variable = getVariable(reference.definition);
+    if (variable == null) {
+      compiler.internalError(
+          compiler.currentElement,
+          "Reference to ${reference.definition} has no register");
+    }
+    ++variable.readCount;
+    return variable;
+  }
+
   FunctionDefinition build(ir.FunctionDefinition node) {
+    new ir.RegisterAllocator().visit(node);
     visit(node);
     return function;
   }
 
   List<Expression> translateArguments(List<ir.Reference> args) {
     return new List<Expression>.generate(args.length,
-         (int index) => variables[args[index].definition]);
+         (int index) => getVariableReference(args[index]));
   }
 
   Statement buildParameterAssignments(
       List<ir.Parameter> parameters,
       List<Expression> arguments,
       Statement buildRest()) {
     assert(parameters.length == arguments.length);
     Statement first, current;
     for (int i = 0; i < parameters.length; ++i) {
+      Expression argument = arguments[i];
       ir.Parameter parameter = parameters[i];
       Statement assignment;
-      if (parameter.hasAtLeastOneUse) {
-        assignment = new Assign(variables[parameter], arguments[i], null,
-            parameter.hasExactlyOneUse);
+      Variable variable = getVariable(parameter);
+      if (variable == null || variable == arguments[i]) {
+        if (argument is Variable) {
+          assignment = null; // ignore pure expression
+          --argument.readCount; // kill unused argument
+        } else {
+          assignment = new ExpressionStatement(argument, null);
+        }
       } else {
-        assignment = new ExpressionStatement(arguments[i], null);
+        assignment = new Assign(variable, argument, null);
       }
 
-      if (first == null) {
-        current = first = assignment;
-      } else {
-        current = current.next = assignment;
+      if (assignment != null) {
+        if (first == null) {
+          current = first = assignment;
+        } else {
+          current = current.next = assignment;
+        }
       }
     }
 
     if (first == null) {
       first = buildRest();
     } else {
       current.next = buildRest();
     }
     return first;
   }
 
   Expression visitFunctionDefinition(ir.FunctionDefinition node) {
     returnContinuation = node.returnContinuation;
     List<Variable> parameters = <Variable>[];
     for (ir.Parameter p in node.parameters) {
-      Variable parameter = new Variable(p.element);
+      Variable parameter = getVariable(p);
+      assert(parameter != null);
       parameters.add(parameter);
-      variables[p] = parameter;
     }
     function = new FunctionDefinition(parameters, visit(node.body));
     return null;
   }
 
   Statement visitLetPrim(ir.LetPrim node) {
-    // LetPrim is translated to LetVal.
+    // LetPrim is translated to Assign.
     Expression definition = visit(node.primitive);
-    if (node.primitive.hasAtLeastOneUse) {
-      Variable variable = new Variable(null);
-      variables[node.primitive] = variable;
-      return new Assign(variable, definition, visit(node.body),
-          node.primitive.hasExactlyOneUse);
+    Variable variable = getVariable(node.primitive);
+    if (variable != null) { // variable is null if primitive is unused
+      return new Assign(variable, definition, node.body.accept(this));
     } else if (node.primitive is ir.Constant) {
       // TODO(kmillikin): Implement more systematic treatment of pure CPS
       // values (e.g., as part of a shrinking reductions pass).
       return visit(node.body);
     } else {
       return new ExpressionStatement(definition, visit(node.body));
     }
   }
 
   Statement visitLetCont(ir.LetCont node) {
     Label label;
     if (node.continuation.hasMultipleUses) {
       label = new Label();
       labels[node.continuation] = label;
     }
-    node.continuation.parameters.forEach((p) {
-        if (p.hasAtLeastOneUse) variables[p] = new Variable(null);
-    });
     Statement body = visit(node.body);
     // The continuation's body is not always translated directly here because
     // it may have been already translated:
     //   * For singly-used continuations, the continuation's body is
     //     translated at the site of the continuation invocation.
     //   * For recursive continuations, there is a single non-recursive
     //     invocation.  The continuation's body is translated at the site
     //     of the non-recursive continuation invocation.
     // See visitInvokeContinuation for the implementation.
     if (label == null || node.continuation.isRecursive) return body;
     return new LabeledStatement(label, body, visit(node.continuation.body));
   }
 
   Statement visitInvokeStatic(ir.InvokeStatic node) {
     // Calls are translated to direct style.
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeStatic(node.target, node.selector, arguments);
     ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       return new Return(invoke);
     } else {
       assert(cont.hasExactlyOneUse);
       assert(cont.parameters.length == 1);
       return buildParameterAssignments(cont.parameters, [invoke],
           () => visit(cont.body));
     }
   }
 
   Statement visitInvokeMethod(ir.InvokeMethod node) {
-    Variable receiver = variables[node.receiver.definition];
+    Expression receiver = getVariableReference(node.receiver);
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeMethod(receiver, node.selector, arguments);
     ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       return new Return(invoke);
     } else {
       assert(cont.hasExactlyOneUse);
       assert(cont.parameters.length == 1);
       return buildParameterAssignments(cont.parameters, [invoke],
           () => visit(cont.body));
@@ skipping 31 matching lines @@
 
   Statement visitInvokeContinuation(ir.InvokeContinuation node) {
     // Invocations of the return continuation are translated to returns.
     // Other continuation invocations are replaced with assignments of the
     // arguments to formal parameter variables, followed by the body if
     // the continuation is singly reference or a break if it is multiply
     // referenced.
     ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       assert(node.arguments.length == 1);
-      return new Return(variables[node.arguments[0].definition]);
+      return new Return(getVariableReference(node.arguments[0]));
     } else {
       List<Expression> arguments = translateArguments(node.arguments);
       return buildParameterAssignments(cont.parameters, arguments,
           () {
             // Translate invocations of recursive and non-recursive
             // continuations differently.
             //   * Non-recursive continuations
             //     - If there is one use, translate the continuation body
             //       inline at the invocation site.
             //     - If there are multiple uses, translate to Break.
@@ skipping 51 matching lines @@
   }
 
   Expression visitContinuation(ir.Continuation node) {
     // Until continuations with multiple uses are supported, they are not
     // visited.
     compiler.internalError(compiler.currentElement, 'Unexpected IR node.');
     return null;
   }
 
   Expression visitIsTrue(ir.IsTrue node) {
-    return variables[node.value.definition];
+    return getVariableReference(node.value);
   }
 }
 
 /**
  * Performs the following transformations on the tree:
  * - Assignment propagation
  * - If-to-conditional conversion
  * - Flatten nested ifs
  * - Break inlining
  * - Redirect breaks
@@ skipping 218 matching lines @@
 
   Statement visitLabeledStatement(LabeledStatement node) {
     if (node.next is Break) {
       // Eliminate label if next is just a break statement
       // Breaks to this label are redirected to the outer label.
       // Note that breakCount for the two labels is updated proactively here
       // so breaks can reliably tell if they should inline their target.
       Break next = node.next;
       Label newTarget = redirect(next.target);
       labelRedirects[node.label] = newTarget;
-      newTarget.breakCount += node.label.breakCount;
+      newTarget.breakCount += node.label.breakCount - 1;
       node.label.breakCount = 0;
       Statement result = visitStatement(node.body);
       labelRedirects.remove(node.label); // Save some space.
       return result;
     }
 
     node.body = visitStatement(node.body);
 
     if (node.label.breakCount == 0) {
       // Eliminate the label if next was inlined at a break
@@ skipping 104 matching lines @@
   static Statement combineStatementsWithSubexpressions(
       Statement s,
       Statement t,
       Expression combine(Expression s, Expression t)) {
     if (s is Return && t is Return) {
       return new Return(combine(s.value, t.value));
     }
     if (s is Assign && t is Assign && s.variable == t.variable) {
       Statement next = combineStatements(s.next, t.next);
       if (next != null) {
+        --t.variable.writeCount; // Two assignments become one
         return new Assign(s.variable,
                           combine(s.definition, t.definition),
-                          next,
-                          s.hasExactlyOneUse);
+                          next);
       }
     }
     if (s is ExpressionStatement && t is ExpressionStatement) {
       Statement next = combineStatements(s.next, t.next);
       if (next != null) {
         return new ExpressionStatement(combine(s.expression, t.expression),
                                        next);
       }
     }
     return null;
   }
 
   /// Returns a statement equivalent to both [s] and [t], or null if [s] and
   /// [t] are incompatible.
   /// If non-null is returned, the caller MUST discard [s] and [t] and use
   /// the returned statement instead.
   /// If two breaks are combined, the label's break counter will be decremented.
   static Statement combineStatements(Statement s, Statement t) {
     if (s is Break && t is Break && s.target == t.target) {
       --t.target.breakCount; // Two breaks become one.
       return s;
     }
-    if (s is Return && t is Return && equivalentExpressions(s.value, t.value)) {
-      return s;
+    if (s is Return && t is Return) {
+      Expression e = combineExpressions(s.value, t.value);
+      if (e != null) {
+        return new Return(e);
+      }
     }
     return null;
   }
 
-  /// True if the two expressions both syntactically and semantically
-  /// equivalent.
-  static bool equivalentExpressions(Expression e1, Expression e2) {
-    if (e1 == e2) { // Detect same variable reference
-      // TODO(asgerf): This might turn the variable into a single-use,
-      // but we currently don't discover this.
-      return true;
+  /// Returns an expression equivalent to both [e1] and [e2].
+  /// If non-null is returned, the caller must discard [e1] and [e2] and use
+  /// the resulting expression in the tree.
+  static Expression combineExpressions(Expression e1, Expression e2) {
+    if (e1 is Variable && e1 == e2) {
+      --e1.readCount; // Two references become one.
+      return e1;
     }
-    if (e1 is Constant && e2 is Constant) {
-      return e1.value == e2.value;
+    if (e1 is Constant && e2 is Constant && e1.value == e2.value) {
+      return e1;
     }
-    return false;
+    return null;
   }
 
   /// Try to collapse nested ifs using && and || expressions.
   /// For example:
   ///
   ///   if (E1) { if (E2) S else break L } else break L
   ///     ==>
   ///   if (E1 && E2) S else break L
   ///
   /// [branch1] and [branch2] control the position of the S statement.
@@ skipping 475 matching lines @@
     }
   }
 
   /// Destructively updates each entry of [l] with the result of visiting it.
   void _rewriteList(List<Expression> l) {
     for (int i = 0; i < l.length; i++) {
       l[i] = visitExpression(l[i]);
     }
   }
 }