Continue for simple loops (while/for).

frog/leg/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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
   String generate(WorkItem work, HGraph graph) {
     return measure(() {
@@ skipping 229 matching lines @@
   visit(HInstruction node, int expectedPrecedence) {
     int oldPrecedence = this.expectedPrecedence;
     this.expectedPrecedence = expectedPrecedence;
     node.accept(this);
     this.expectedPrecedence = oldPrecedence;
   }
 
   void handleLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     addIndentation();
     for (LabelElement label in labeledBlockInfo.labels) {
-      addLabel(label);
+      if (labeledBlockInfo.isContinue) {
+        addContinueLabel(label);
+      } else {
+        addBreakLabel(label);
+      }
       buffer.add(':');
     }
     TargetElement target = labeledBlockInfo.target;
     if (target.isSwitch) {
-      addImplicitLabel(target);
+      addImplicitBreakLabel(target);
       buffer.add(@':');
     }
+    if (labeledBlockInfo.isContinue) {
+      addImplicitContinueLabel(target);
+      buffer.add(':');
+    }
     buffer.add('{\n');
     indent++;
 
     visitSubGraph(labeledBlockInfo.body);
 
     indent--;
     addIndentation();
     buffer.add('}\n');
 
     if (labeledBlockInfo.joinBlock !== null) {
@@ skipping 158 matching lines @@
     if (dominated.isEmpty()) return;
     if (dominated.length > 2) unreachable();
     if (dominated.length == 2 && currentBlock !== currentGraph.entry) {
       unreachable();
     }
     assert(dominated[0] == currentBlock.successors[0]);
     visitBasicBlock(dominated[0]);
   }
 
   // Used to write the name of labels.
-  // The default implementation uses the unmodified Dart label name.
-  // Specializations might change this.
-  void addLabel(LabelElement label) {
+  void addBreakLabel(LabelElement label) {
     buffer.add(@'$');
     buffer.add(label.labelName);
   }
 
-  void addImplicitLabel(TargetElement target) {
-    buffer.add('\$${target.nestingLevel}');
+  void addContinueLabel(LabelElement label) {
+    buffer.add(@'c$');
+    buffer.add(label.labelName);
+  }
+
+  void addImplicitBreakLabel(TargetElement target) {
+    buffer.add(@'$');
+    buffer.add('${target.nestingLevel}');
+  }
+
+  void addImplicitContinueLabel(TargetElement target) {
+    buffer.add(@'c$');
+    buffer.add('${target.nestingLevel}');
   }
 
   visitBreak(HBreak node) {
     assert(currentBlock.successors.length == 1);
     addIndentation();
     buffer.add("break");
     if (node.label !== null) {
       buffer.add(" ");
-      addLabel(node.label);
+      addBreakLabel(node.label);
     } else {
       TargetElement target = node.target;
       if (target.isSwitch) {
+        // We are wrapping switches in a labeled block so that we can
+        // break from them even when they are implemented as if/else chains.
+        // For that reason, we need to use a labeled break targeting the
+        // "implicit" label we gave to the block.
         buffer.add(@' ');
-        addImplicitLabel(target);
+        addImplicitBreakLabel(target);
       }
     }
     buffer.add(";\n");
-    // We never follow the break to its target, even if it dominates the
-    // break target block. That block is always handled by the structure
-    // that introduced the break.
+  }
+
+  visitContinue(HContinue node) {
+    assert(currentBlock.successors.length == 1);
+    addIndentation();
+    // We currently implement "continue" in a loop as a break of a block
+    // containing the loop body. If we ever implement for-loops as such,
+    // we should use a real continue.
+    buffer.add("break ");
+    if (node.label !== null) {
+      addContinueLabel(node.label);
+    } else {
+      addImplicitContinueLabel(node.target);
+    }
+    buffer.add(";\n");
   }
 
   visitTry(HTry node) {
     addIndentation();
     buffer.add('try {\n');
     indent++;
     List<HBasicBlock> successors = node.block.successors;
     visitBasicBlock(successors[0]);
     indent--;
 
@@ skipping 697 matching lines @@
       buffer.add(')) ');
       bailout(node, 'Not a string or array');
     } else {
       unreachable();
     }
   }
 
   void beginLoop(HBasicBlock block) {
     addIndentation();
     for (LabelElement label in block.loopInformation.labels) {
-      addLabel(label);
+      addBreakLabel(label);
       buffer.add(":");
     }
     buffer.add('while (true) {\n');
     indent++;
   }
 
   void endLoop(HBasicBlock block) {
     indent--;
     addIndentation();
     buffer.add('}\n');  // Close 'while' loop.
@@ skipping 143 matching lines @@
     indent++;
   }
 
   void endBailoutSwitch() {
     indent--; // Close 'case'.
     indent--;
     addIndentation();
     buffer.add('}\n');  // Close 'switch'.
   }
 
-  // Adds a "$" in front of names of labels from the original source.
-  // This avoids conflicts with labels introduced by bailouts, which
-  // starts with a non-"$" character.
-  void addLabel(LabelElement label) {
-    buffer.add("\$${label.labelName}");
-  }
 
   void beginLoop(HBasicBlock block) {
     // TODO(ngeoffray): Don't put labels on loops that don't bailout.
     String newLabel = pushLabel();
     if (block.hasBailouts()) {
       startBailoutCase(block.bailouts, const <HBailoutTarget>[]);
     }
 
     addIndentation();
-    for (LabelElement label in block.loopInformation.labels) {
-      addLabel(label);
+    for (SourceString label in block.loopInformation.labels) {
+      addBreakLabel(label);
       buffer.add(":");
     }
     buffer.add('$newLabel: while (true) {\n');
     indent++;
 
     if (block.hasBailouts()) {
       startBailoutSwitch();
     }
   }
 
@@ skipping 71 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endElse(HIf node) {
     if (node.elseBlock.hasBailouts()) {
       endBailoutSwitch();
     }
   }
 }