Remove hack around aborting loop body in the case of for loops and while loops.

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 647 matching lines @@
     // In all other cases a new box will be created when entering the body of
     // the next iteration.
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     if (scopeData.hasBoxedLoopVariables()) {
       updateCaptureBox(scopeData.boxElement, scopeData.boxedLoopVariables);
     }
   }
 
   void endLoop(HBasicBlock loopEntry) {
+    // If the loop has an aborting body, we don't update the loop
+    // phis.
+    if (loopEntry.predecessors.length == 1) return;
     loopEntry.forEachPhi((HPhi phi) {
       Element element = phi.sourceElement;
       HInstruction postLoopDefinition = directLocals[element];
       phi.addInput(postLoopDefinition);
     });
   }
 
   /**
    * Merge [otherLocals] into this locals handler, creating phi-nodes when
    * there is a conflict.
@@ skipping 82 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();
   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;
 
   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 37 matching lines @@
       if (entry.isBreak()) action(entry.jumpInstruction, entry.locals);
     }
   }
 
   void forEachContinue(Function action) {
     for (JumpHandlerEntry entry in jumps) {
       if (entry.isContinue()) action(entry.jumpInstruction, entry.locals);
     }
   }
 
+  bool hasAnyContinue() {
+    for (JumpHandlerEntry entry in jumps) {
+      if (entry.isContinue()) 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 925 matching lines @@
         new SubExpression(conditionBlock, conditionExitBlock);
 
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
 
     // The body.
     HBasicBlock beginBodyBlock = addNewBlock();
     conditionExitBlock.addSuccessor(beginBodyBlock);
     open(beginBodyBlock);
 
     localsHandler.enterLoopBody(loop);
-    hackAroundPossiblyAbortingBody(loop, body);
+    body();
 
-    SubGraph bodyGraph = new SubGraph(beginBodyBlock, current);
-    HBasicBlock bodyBlock = close(new HGoto());
+    SubGraph bodyGraph = new SubGraph(beginBodyBlock, lastOpenedBlock);
+    HBasicBlock bodyBlock = current;
+    if (current != null) close(new HGoto());
 
-    // Update.
-    // We create an update block, even when we are in a while loop. There the
-    // update block is the jump-target for continue statements. We could avoid
-    // the creation if there is no continue, but for now we always create it.
-    HBasicBlock updateBlock = addNewBlock();
+    SubExpression updateGraph;
 
-    List<LocalsHandler> continueLocals = <LocalsHandler>[];
-    jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
-      instruction.block.addSuccessor(updateBlock);
-      continueLocals.add(locals);
-    });
-    bodyBlock.addSuccessor(updateBlock);
-    continueLocals.add(localsHandler);
+    // Check that the loop has at least one back-edge.
+    if (jumpHandler.hasAnyContinue() || bodyBlock != null) {
+      // Update.
+      // We create an update block, even when we are in a while loop. There the
+      // update block is the jump-target for continue statements. We could avoid

[floitsch, 2012/11/05 17:36:09]

It seems trivial to avoid the creation of the block if there are no continues.
But fine with doing that in a separate CL.

[ngeoffray, 2012/11/06 08:55:27]

Will do in another CL.

+      // the creation if there is no continue, but for now we always create it.
+      HBasicBlock updateBlock = addNewBlock();
 
-    open(updateBlock);
+      List<LocalsHandler> continueLocals = <LocalsHandler>[];
+      jumpHandler.forEachContinue((HContinue instruction,
+                                   LocalsHandler locals) {
+        instruction.block.addSuccessor(updateBlock);
+        continueLocals.add(locals);
+      });
 
-    localsHandler = localsHandler.mergeMultiple(continueLocals, updateBlock);
 
-    HLabeledBlockInformation labelInfo;
-    List<LabelElement> labels = jumpHandler.labels();
-    TargetElement target = elements[loop];
-    if (!labels.isEmpty) {
-      beginBodyBlock.setBlockFlow(
-          new HLabeledBlockInformation(
-              new HSubGraphBlockInformation(bodyGraph),
-              jumpHandler.labels(),
-              isContinue: true),
-          updateBlock);
-    } else if (target != null && target.isContinueTarget) {
-      beginBodyBlock.setBlockFlow(
-          new HLabeledBlockInformation.implicit(
-              new HSubGraphBlockInformation(bodyGraph),
-              target,
-              isContinue: true),
-          updateBlock);
+      if (bodyBlock != null) {
+        continueLocals.add(localsHandler);
+        bodyBlock.addSuccessor(updateBlock);
+      }
+
+      open(updateBlock);
+      localsHandler =
+          continueLocals[0].mergeMultiple(continueLocals, updateBlock);
+
+      HLabeledBlockInformation labelInfo;
+      List<LabelElement> labels = jumpHandler.labels();
+      TargetElement target = elements[loop];
+      if (!labels.isEmpty) {
+        beginBodyBlock.setBlockFlow(
+            new HLabeledBlockInformation(
+                new HSubGraphBlockInformation(bodyGraph),
+                jumpHandler.labels(),
+                isContinue: true),
+            updateBlock);
+      } else if (target != null && target.isContinueTarget) {
+        beginBodyBlock.setBlockFlow(
+            new HLabeledBlockInformation.implicit(
+                new HSubGraphBlockInformation(bodyGraph),
+                target,
+                isContinue: true),
+            updateBlock);
+      }
+
+      localsHandler.enterLoopUpdates(loop);
+
+      update();
+
+      HBasicBlock updateEndBlock = close(new HGoto());
+      // The back-edge completing the cycle.
+      updateEndBlock.addSuccessor(conditionBlock);
+      updateGraph = new SubExpression(updateBlock, updateEndBlock);
     }
 
-    localsHandler.enterLoopUpdates(loop);
-
-    update();
-
-    HBasicBlock updateEndBlock = close(new HGoto());
-    // The back-edge completing the cycle.
-    updateEndBlock.addSuccessor(conditionBlock);
     conditionBlock.postProcessLoopHeader();
-    SubExpression updateGraph = new SubExpression(updateBlock, updateEndBlock);
 
     endLoop(conditionBlock, conditionExitBlock, jumpHandler, savedLocals);
     HLoopBlockInformation info =
         new HLoopBlockInformation(
             HLoopBlockInformation.loopType(loop),
             wrapExpressionGraph(initializerGraph),
             wrapExpressionGraph(conditionExpression),
             wrapStatementGraph(bodyGraph),
             wrapExpressionGraph(updateGraph),
             conditionBlock.loopInformation.target,
@@ skipping 2822 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;
   }
 }