Do not use hack around aborting loop body for a do/while.

sdk/lib/_internal/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.
 
 part of ssa;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 753 matching lines @@
 abstract class JumpHandler {
   factory JumpHandler(SsaBuilder builder, TargetElement target) {
     return new TargetJumpHandler(builder, target);
   }
   void generateBreak([LabelElement label]);
   void generateContinue([LabelElement label]);
   void forEachBreak(void action(HBreak instruction, LocalsHandler locals));
   void forEachContinue(void action(HContinue instruction,
                                    LocalsHandler locals));
   bool hasAnyContinue();
+  bool hasAnyBreak();
   void close();
   final TargetElement target;
   List<LabelElement> labels();
 }
 
 // Insert break handler used to avoid null checks when a target isn't
 // used as the target of a break, and therefore doesn't need a break
 // handler associated with it.
 class NullJumpHandler implements JumpHandler {
   final Compiler compiler;
 
   NullJumpHandler(this.compiler);
 
   void generateBreak([LabelElement label]) {
     compiler.internalError('generateBreak should not be called');
   }
 
   void generateContinue([LabelElement label]) {
     compiler.internalError('generateContinue should not be called');
   }
 
   void forEachBreak(Function ignored) { }
   void forEachContinue(Function ignored) { }
   void close() { }
   bool hasAnyContinue() => false;
+  bool hasAnyBreak() => false;
 
   List<LabelElement> labels() => const <LabelElement>[];
   TargetElement get target => null;
 }
 
 // Records breaks until a target block is available.
 // Breaks are always forward jumps.
 // Continues in loops are implemented as breaks of the body.
 // Continues in switches is currently not handled.
 class TargetJumpHandler implements JumpHandler {
@@ skipping 44 matching lines @@
     }
   }
 
   bool hasAnyContinue() {
     for (JumpHandlerEntry entry in jumps) {
       if (entry.isContinue()) return true;
     }
     return false;
   }
 
+  bool hasAnyBreak() {
+    for (JumpHandlerEntry entry in jumps) {
+      if (entry.isBreak()) return true;
+    }
+    return false;
+  }
+
   void close() {
     // The mapping from TargetElement to JumpHandler is no longer needed.
     builder.jumpTargets.remove(target);
   }
 
   List<LabelElement> labels() {
     List<LabelElement> result = null;
     for (LabelElement element in target.labels) {
       if (result == null) result = <LabelElement>[];
       result.add(element);
@@ skipping 848 matching lines @@
   /**
    * Ends the loop:
    * - creates a new block and adds it as successor to the [branchBlock].
    * - opens the new block (setting as [current]).
    * - notifies the locals handler that we're exiting a loop.
    */
   void endLoop(HBasicBlock loopEntry,
                HBasicBlock branchBlock,
                JumpHandler jumpHandler,
                LocalsHandler savedLocals) {
+    if (branchBlock == null && !jumpHandler.hasAnyBreak()) return;
+
     HBasicBlock loopExitBlock = addNewBlock();
-    assert(branchBlock.successors.length == 1);
+    assert(branchBlock == null || branchBlock.successors.length == 1);
     List<LocalsHandler> breakLocals = <LocalsHandler>[];
     jumpHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(loopExitBlock);
       breakLocals.add(locals);
     });
-    branchBlock.addSuccessor(loopExitBlock);
+    if (branchBlock != null) {
+      branchBlock.addSuccessor(loopExitBlock);
+    }
     open(loopExitBlock);
     localsHandler.endLoop(loopEntry);
     if (!breakLocals.isEmpty) {
       breakLocals.add(savedLocals);
       localsHandler = savedLocals.mergeMultiple(breakLocals, loopExitBlock);
     } else {
       localsHandler = savedLocals;
     }
   }
 
@@ skipping 197 matching lines @@
       // Add extra block to hang labels on.
       // It doesn't currently work if they are on the same block as the
       // HLoopInfo. The handling of HLabeledBlockInformation will visit a
       // SubGraph that starts at the same block again, so the HLoopInfo is
       // either handled twice, or it's handled after the labeled block info,
       // both of which generate the wrong code.
       // Using a separate block is just a simple workaround.
       bodyEntryBlock = openNewBlock();
     }
     localsHandler.enterLoopBody(node);
-    hackAroundPossiblyAbortingBody(node, () { visit(node.body); });
+    visit(node.body);
 
     // If there are no continues we could avoid the creation of the condition
     // block. This could also lead to a block having multiple entries and exits.
-    HBasicBlock bodyExitBlock = close(new HGoto());
-    HBasicBlock conditionBlock = addNewBlock();
+    HBasicBlock bodyExitBlock;
+    bool isAbortingBody = false;
+    if (current != null) {
+      bodyExitBlock = close(new HGoto());
+    } else {
+      isAbortingBody = true;
+      bodyExitBlock = lastOpenedBlock;
+    }
 
-    List<LocalsHandler> continueLocals = <LocalsHandler>[];
-    jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
-      instruction.block.addSuccessor(conditionBlock);
-      continueLocals.add(locals);
-    });
-    bodyExitBlock.addSuccessor(conditionBlock);
-    if (!continueLocals.isEmpty) {
-      continueLocals.add(localsHandler);
-      localsHandler = savedLocals.mergeMultiple(continueLocals, conditionBlock);
-      SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
-      List<LabelElement> labels = jumpHandler.labels();
-      HSubGraphBlockInformation bodyInfo =
-          new HSubGraphBlockInformation(bodyGraph);
-      HLabeledBlockInformation info;
-      if (!labels.isEmpty) {
-        info = new HLabeledBlockInformation(bodyInfo, labels, isContinue: true);
-      } else {
-        info = new HLabeledBlockInformation.implicit(bodyInfo, target,
-                                                     isContinue: true);
+    SubExpression conditionExpression;
+    HBasicBlock conditionEndBlock;
+    if (!isAbortingBody || hasContinues) {
+      HBasicBlock conditionBlock = addNewBlock();
+
+      List<LocalsHandler> continueLocals = <LocalsHandler>[];
+      jumpHandler.forEachContinue((HContinue instruction,
+                                   LocalsHandler locals) {
+        instruction.block.addSuccessor(conditionBlock);
+        continueLocals.add(locals);
+      });
+
+      if (!isAbortingBody) {
+        bodyExitBlock.addSuccessor(conditionBlock);
       }
-      bodyEntryBlock.setBlockFlow(info, conditionBlock);
+
+      if (!continueLocals.isEmpty) {
+        if (!isAbortingBody) continueLocals.add(localsHandler);
+        localsHandler =
+            savedLocals.mergeMultiple(continueLocals, conditionBlock);
+        SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
+        List<LabelElement> labels = jumpHandler.labels();
+        HSubGraphBlockInformation bodyInfo =
+            new HSubGraphBlockInformation(bodyGraph);
+        HLabeledBlockInformation info;
+        if (!labels.isEmpty) {
+          info = new HLabeledBlockInformation(bodyInfo, labels,
+                                              isContinue: true);
+        } else {
+          info = new HLabeledBlockInformation.implicit(bodyInfo, target,
+                                                       isContinue: true);
+        }
+        bodyEntryBlock.setBlockFlow(info, conditionBlock);
+      }
+      open(conditionBlock);
+
+      visit(node.condition);
+      assert(!isAborted());
+      HInstruction conditionInstruction = popBoolified();
+      conditionEndBlock = close(
+          new HLoopBranch(conditionInstruction, HLoopBranch.DO_WHILE_LOOP));
+
+      conditionEndBlock.addSuccessor(loopEntryBlock);  // The back-edge.
+      conditionExpression =
+          new SubExpression(conditionBlock, conditionEndBlock);
     }
-    open(conditionBlock);
 
-    visit(node.condition);
-    assert(!isAborted());
-    HInstruction conditionInstruction = popBoolified();
-    HBasicBlock conditionEndBlock =
-        close(new HLoopBranch(conditionInstruction, HLoopBranch.DO_WHILE_LOOP));
-
-    conditionEndBlock.addSuccessor(loopEntryBlock);  // The back-edge.
     loopEntryBlock.postProcessLoopHeader();
 
     endLoop(loopEntryBlock, conditionEndBlock, jumpHandler, localsHandler);
     jumpHandler.close();
 
-    SubExpression conditionExpression =
-        new SubExpression(conditionBlock, conditionEndBlock);
     SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
 
     HLoopBlockInformation loopBlockInfo =
         new HLoopBlockInformation(
             HLoopBlockInformation.DO_WHILE_LOOP,
             null,
             wrapExpressionGraph(conditionExpression),
             wrapStatementGraph(bodyGraph),
             null,
             loopEntryBlock.loopInformation.target,
@@ skipping 2731 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;
   }
 }