Move handleLogicalAndOr to the SsaBranchBuilder.

lib/compiler/implementation/ssa/builder.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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1555 matching lines @@
              node.elsePart != null ? () => visit(node.elsePart) : null);
   }
 
   void handleIf(Node diagnosticNode,
                 void visitCondition(), void visitThen(), void visitElse()) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, diagnosticNode);
     branchBuilder.handleIf(visitCondition, visitThen, visitElse);
   }
 
   void visitLogicalAndOr(Send node, Operator op) {
-    handleLogicalAndOr(node,
-                       () { visit(node.receiver); },
-                       () { visit(node.argumentsNode); },
-                       isAnd: (const SourceString("&&") == op.source));
+    SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
+    branchBuilder.handleLogicalAndOr(
+        () { visit(node.receiver); },
+        () { visit(node.argumentsNode); },
+        isAnd: (const SourceString("&&") == op.source));
   }
 
 
-  void handleLogicalAndOr(Node diagnosticNode,
-                          void left(), void right(), [bool isAnd = true]) {
-    // x && y is transformed into:
-    //   t0 = boolify(x);
-    //   if (t0) {
-    //     t1 = boolify(y);
-    //   } else {
-    //     t2 = t0;
-    //   }
-    //   result = phi(t1, false);
-    //
-    // x || y is transformed into:
-    //   t0 = boolify(x);
-    //   if (not(t0)) {
-    //     t1 = boolify(y);
-    //   } else {
-    //     t2 = t0;
-    //   }
-    //   result = phi(t1, true);
-    HInstruction boolifiedLeft;
-    HInstruction boolifiedRight;
-
-    void visitCondition() {
-      left();
-      boolifiedLeft = popBoolified();
-      HInstruction condition;
-      if (isAnd) {
-        condition = boolifiedLeft;
-      } else {
-        condition = new HNot(boolifiedLeft);
-        add(condition);
-      }
-      stack.add(condition);
-    }
-
-    void visitThen() {
-      right();
-      boolifiedRight = popBoolified();
-    }
-
-    handleIf(diagnosticNode, visitCondition, visitThen, null);
-    HPhi result = new HPhi.manyInputs(null,
-        <HInstruction>[boolifiedRight, graph.addConstantBool(!isAnd)]);
-    current.addPhi(result);
-    stack.add(result);
-  }
-
   void visitLogicalNot(Send node) {
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
     HNot not = new HNot(popBoolified());
     push(not);
   }
 
   void visitUnary(Send node, Operator op) {
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
@@ skipping 1494 matching lines @@
       // If this is the last expression, just return it.
       Link<Node> tail = skipLabels(remainingCases.tail);
       if (tail.isEmpty()) {
         left();
         return;
       }
 
       void right() {
         buildTests(tail);
       }
-      handleLogicalAndOr(remainingCases.head, left, right, isAnd: false);
+      SsaBranchBuilder branchBuilder =
+          new SsaBranchBuilder(this, remainingCases.head);
+      branchBuilder.handleLogicalAndOr(left, right, isAnd: false);
     }
 
     if (node.isDefaultCase) {
       // Default case must be last.
       assert(cases.tail.isEmpty());
       // Perform the tests until one of them match, but then always execute the
       // statements.
       // TODO(lrn): Stop performing tests when all expressions are compile-time
       // constant strings or integers.
       handleIf(node, () { buildTests(labelsAndCases); }, (){}, null);
@@ skipping 338 matching lines @@
     }
 
     _handleDiamondBranch(visitCondition, visitThen, visitElse, false);
   }
 
   handleConditional(void visitCondition(), void visitThen(), void visitElse()) {
     assert(visitElse != null);
     _handleDiamondBranch(visitCondition, visitThen, visitElse, true);
   }
 
+  void handleLogicalAndOr(void left(), void right(), [bool isAnd = true]) {
+    // x && y is transformed into:
+    //   t0 = boolify(x);
+    //   if (t0) {
+    //     t1 = boolify(y);
+    //   } else {
+    //     t2 = t0;
+    //   }
+    //   result = phi(t1, false);
+    //
+    // x || y is transformed into:
+    //   t0 = boolify(x);
+    //   if (not(t0)) {
+    //     t1 = boolify(y);
+    //   } else {
+    //     t2 = t0;
+    //   }
+    //   result = phi(t1, true);
+    HInstruction boolifiedLeft;
+    HInstruction boolifiedRight;
+
+    void visitCondition() {
+      left();
+      boolifiedLeft = builder.popBoolified();
+      HInstruction condition;
+      if (isAnd) {
+        condition = boolifiedLeft;
+      } else {
+        condition = new HNot(boolifiedLeft);
+        builder.add(condition);
+      }

[Lasse Reichstein Nielsen, 2012/07/12 07:18:26]

Could be shorter by using the stack more:
void visitCondition() {
 left();
 boolifiedLeft = builder.popBoolified();
 builder.stack.add(boolifiedLeft);
 if (isAnd) {
   builder.push(new HNot(builder.pop());
 }
}
 

[floitsch, 2012/07/12 09:23:30]

Agreed, but in this CL I'm not going to change any code (unless necessary for it
to work in the new location).

+      builder.stack.add(condition);
+    }
+
+    void visitThen() {
+      right();
+      boolifiedRight = builder.popBoolified();
+    }
+
+    handleIf(visitCondition, visitThen, null);
+    HPhi result = new HPhi.manyInputs(null,
+        <HInstruction>[boolifiedRight, builder.graph.addConstantBool(!isAnd)]);
+    builder.current.addPhi(result);
+    builder.stack.add(result);
+  }
+
   void _handleDiamondBranch(void visitCondition(),
                             void visitThen(),
                             void visitElse(),
                             bool isExpression) {
     SsaBranch conditionBranch = new SsaBranch(this);
     SsaBranch thenBranch = new SsaBranch(this);
     SsaBranch elseBranch = new SsaBranch(this);
     SsaBranch joinBranch = new SsaBranch(this);
 
     conditionBranch.startLocals = builder.localsHandler;
@@ skipping 29 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }