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(':');
     }

[ngeoffray, 2012/03/19 11:42:06]

Shouldn't you do: if !(labeledBlockInfo.labels.isEmpty()) ?

[Lasse Reichstein Nielsen, 2012/03/19 12:13:58]

It's never empty, so no.

     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) {

[ngeoffray, 2012/03/19 11:42:06]

Please add a comment that since we're generating switch as a loop, we must break
from that loop.

[Lasse Reichstein Nielsen, 2012/03/19 12:13:58]

Done.

         buffer.add(@' ');
-        addImplicitLabel(target);
+        addImplicitBreakLabel(target);
       }
     }
     buffer.add(";\n");
+  }
+
+  visitContinue(HContinue node) {
+    assert(currentBlock.successors.length == 1);
+    // No block finishing with a 'break' can have more than

[ngeoffray, 2012/03/19 11:42:06]

break -> continue

+    // one dominated block (since it has only one successor).

[ngeoffray, 2012/03/19 11:42:06]

more than one -> a ? You're checking that dominatedBlock.isEmpty.

+    // If the successor is dominated by another block, then the other block
+    // is responsible for visiting the successor.
+    assert(currentBlock.dominatedBlocks.isEmpty());
+    // Otherwise we would have bailed out in the builder.

[ngeoffray, 2012/03/19 11:42:06]

Should that comment be one line above?

[Lasse Reichstein Nielsen, 2012/03/19 12:13:58]

These comments should all go away, just as they did for break in the "switch"
CL.

+    addIndentation();
+    buffer.add("break ");

[ngeoffray, 2012/03/19 11:42:06]

Please add a comment on why this isn't 'continue'.

[Lasse Reichstein Nielsen, 2012/03/19 12:13:58]

Done.

+    if (node.label !== null) {
+      addContinueLabel(node.label);
+    } else {
+      addImplicitContinueLabel(node.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.
   }
 
   visitTry(HTry node) {
     addIndentation();
     buffer.add('try {\n');
     indent++;
     List<HBasicBlock> successors = node.block.successors;
@@ skipping 700 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);

[ngeoffray, 2012/03/19 11:42:06]

What about continue labels here?

[Lasse Reichstein Nielsen, 2012/03/19 12:13:58]

Continue labels are put as labels on a block surrounding the body, so that we
can break the body to reach the update block.

       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();
     }
   }
 }