Avoid critical edge on do/while, and do not make handleLoopInfo return conditionnaly false: block b…

sdk/lib/_internal/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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 925 matching lines @@
             generateStatements(info.updates);
           } else {
             visitBodyIgnoreLabels(info);
           }
           currentContainer = oldContainer;
           body = unwrapStatement(body);
           loop = new js.While(jsCondition, body);
         }
         break;
       case HLoopBlockInformation.DO_WHILE_LOOP:
-        // If there are phi copies after the condition, we cannot emit
-        // a pretty do/while loop, se we fallback to the generic
-        // emission of a loop.
-        CopyHandler handler = variableNames.getCopyHandler(info.end);
-        if (handler != null && !handler.isEmpty) return false;
         if (info.initializer != null) {
           generateStatements(info.initializer);
         }
         js.Block oldContainer = currentContainer;
         js.Statement body = new js.Block.empty();
+        // If there are phi copies in the block that jumps to the
+        // loop entry, we must emit the condition like this:
+        // do {
+        //   body;
+        //   if (condition) {
+        //     phi updates;
+        //     continue;
+        //   } else {
+        //     break;
+        //   }
+        // } while (true);
+        HBasicBlock avoidEdge = info.end.successors[0];
+        js.Statement updateBody = new js.Block.empty();
+        currentContainer = updateBody;
+        assignPhisOfSuccessors(avoidEdge);
+        bool hasPhiUpdates = !updateBody.statements.isEmpty;
         currentContainer = body;
-        if (!isConditionExpression || info.updates != null) {
+        if (hasPhiUpdates || !isConditionExpression || info.updates != null) {
           wrapLoopBodyForContinue(info);
         } else {
           visitBodyIgnoreLabels(info);
         }
         if (info.updates != null) {
           generateStatements(info.updates);
         }
         if (condition == null) {
           push(newLiteralBool(false));
         } else if (isConditionExpression) {
           push(generateExpression(condition));
         } else {
           generateStatements(condition);
           use(condition.conditionExpression);
         }
         js.Expression jsCondition = pop();
+        if (hasPhiUpdates) {
+          updateBody.statements.add(new js.Continue(null));
+          body.statements.add(
+              new js.If(jsCondition, updateBody, new js.Break(null)));
+        }
+        loop = new js.Do(unwrapStatement(body), jsCondition);
         currentContainer = oldContainer;
-        body = unwrapStatement(body);
-        loop = new js.Do(body, jsCondition);
         break;
       default:
         compiler.internalError(
           'Unexpected loop kind: ${info.kind}',
           instruction: condition.conditionExpression);
     }
     attachLocationRange(loop, info.sourcePosition, info.endSourcePosition);
     pushStatement(wrapIntoLabels(loop, info.labels));
     return true;
   }
@@ skipping 250 matching lines @@
   void iterateBasicBlock(HBasicBlock node) {
     HInstruction instruction = node.first;
     while (!identical(instruction, node.last)) {
       if (instruction is HTypeGuard || instruction is HBailoutTarget) {
         visit(instruction);
       } else if (!isGenerateAtUseSite(instruction)) {
         define(instruction);
       }
       instruction = instruction.next;
     }
-    if (instruction is HLoopBranch) {
-      HLoopBranch branch = instruction;
-      // If the loop is a do/while loop, the phi updates must happen
-      // after the evaluation of the condition.
-      if (!branch.isDoWhile()) {
-        assignPhisOfSuccessors(node);
-      }
-    } else {
-      assignPhisOfSuccessors(node);
-    }
+    assignPhisOfSuccessors(node);
     visit(instruction);
   }
 
   visitInvokeBinary(HInvokeBinary node, String op) {
     if (node.isBuiltin(types)) {
       use(node.left);
       js.Expression jsLeft = pop();
       use(node.right);
       push(new js.Binary(op, jsLeft, pop()), node);
     } else {
@@ skipping 596 matching lines @@
       // Otherwise, we don't generate the expression, and leave that
       // to the code that called [visitSubGraph].
       if (isGeneratingExpression) {
         use(node.inputs[0]);
       }
       return;
     }
     HBasicBlock branchBlock = currentBlock;
     handleLoopCondition(node);
     List<HBasicBlock> dominated = currentBlock.dominatedBlocks;
-    if (node.isDoWhile()) {
-      // Now that the condition has been evaluated, we can update the
-      // phis of a do/while loop.
-      assignPhisOfSuccessors(node.block);
-    } else {
+    if (!node.isDoWhile()) {
       // For a do while loop, the body has already been visited.
       visitBasicBlock(dominated[0]);
     }
     endLoop(node.block);
 
     // If the branch does not dominate the code after the loop, the
     // dominator will visit it.
     if (!identical(branchBlock.successors[1].dominator, branchBlock)) return;
 
     visitBasicBlock(branchBlock.successors[1]);
@@ skipping 1215 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }