Support break and labeled statements.

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 193 matching lines @@
       visit(argument);
     } else {
       buffer.add(temporary(argument));
     }
   }
 
   visit(HInstruction node) {
     return node.accept(this);
   }
 
+  void handleLabeledBlock(HBasicBlock node) {
+    HLabeledBlockInformation labeledBlockInfo = node.labeledBlockInformation;
+    if (labeledBlockInfo.start === node) {
+      addIndentation();
+      for (SourceString label in labeledBlockInfo.labels) {
+        addLabel(label);
+        buffer.add(":");
+      }
+      buffer.add("{\n");
+      indent++;
+    } else {
+      assert(labeledBlockInfo.end === node);
+      assert((){
+        // Check that this block is (transitively) dominated by the start block.
+        HBasicBlock block = node;
+        while (block.dominator !== null) {
+          block = block.dominator;
+          if (block === labeledBlockInfo.start) return true;
+        }
+        return false;
+      });
+      indent--;
+      addIndentation();
+      buffer.add("}\n");
+    }
+  }
+
   visitBasicBlock(HBasicBlock node) {
     currentBlock = node;
 
-    // While loop will be closed by the conditional loop-branch.
-    // TODO(floitsch): HACK HACK HACK.
-    if (currentBlock.isLoopHeader()) beginLoop(node);
+    if (node.hasLabeledBlockInformation()) {
+      handleLabeledBlock(node);
+    } else if (currentBlock.isLoopHeader()) {
+      // While loop will be closed by the conditional loop-branch.
+      // TODO(floitsch): HACK HACK HACK.
+      beginLoop(node);
+    }
 
     HInstruction instruction = node.first;
     while (instruction != null) {
       if (instruction is HGoto || instruction is HExit || instruction is HTry) {
         visit(instruction);
         return;
       } else if (!instruction.generateAtUseSite()) {
         if (instruction is !HIf && instruction is !HBailoutTarget) {
           addIndentation();
         }
@@ skipping 113 matching lines @@
     // is responsible for visiting the successor.
     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]);
   }
 
+  void addLabel(SourceString label) {

[floitsch, 2012/02/20 19:01:54]

to many addLabels and similar: sometimes with prefixed '$' sometimes with
label.toString, or with stringValue...
If they should be different make this clearer, if not share the code.

[Lasse Reichstein Nielsen, 2012/02/21 13:53:56]

There are two addLabels, one for optimized code (and being the default, it is in
SsaCodeGenerator), and one overriding it in SsaUnoptimizedCodeGenerator. I'll
add comments describing the difference.

+    buffer.add(label.toString());
+  }
+
+  visitBreak(HBreak node) {
+    assert(currentBlock.successors.length == 1);
+    addIndentation();
+    buffer.add("break");
+    if (node.label !== null) {
+      buffer.add(" ");
+      addLabel(node.label);
+    }
+    buffer.add(";\n");
+    List<HBasicBlock> dominated = currentBlock.dominatedBlocks;
+    // No block finishing with a 'throw' can have more than

[floitsch, 2012/02/20 19:01:54]

s/throw/break.

[Lasse Reichstein Nielsen, 2012/02/21 13:53:56]

Done.

+    // one dominated block (since it has only one successor).
+    // If the successor is dominated by another block, then the other block
+    // is responsible for visiting the successor.
+    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]);
+  }
+
   visitTry(HTry node) {
     addIndentation();
     buffer.add('try {\n');
     indent++;
     List<HBasicBlock> successors = node.block.successors;
     visitBasicBlock(successors[0]);
     indent--;
 
     if (node.finallyBlock != successors[1]) {
       // Printing the catch part.
@@ skipping 57 matching lines @@
     } else if (!node.hasElse && dominatedCount == 2) {
       // Normal case. Even if the then-branch terminated there is still
       // a join-block.
       assert(!dominated.last().isExitBlock());
       visitBasicBlock(dominated[1]);
     } else {
       // The then-branch terminates, and the code following the if terminates
       // too. The if happens to dominate the exit-block.
       assert(!node.hasElse);
       assert(dominatedCount == 3);
-      assert(dominated.last().isExitBlock());
       visitBasicBlock(dominated[1]);

[floitsch, 2012/02/20 19:01:54]

This doesn't look right. It seems that the if can dominate an arbitrary number
of blocks now (one for each break). And it's the if's job to visit them.

[Lasse Reichstein Nielsen, 2012/02/21 13:53:56]

You are right. All this complication has been reduced to a much simpler, more
generic version (but with fewer asserts, since we don't really know much).

       visitBasicBlock(dominated[2]);
     }
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
     buffer.add('.');
     // Avoid adding the generative constructor name to the list of
     // seen selectors.
     if (node.inputs[0] is HForeignNew) {
@@ skipping 130 matching lines @@
   visitLoopBranch(HLoopBranch node) {
     HBasicBlock branchBlock = currentBlock;
     handleLoopCondition(node);
     List<HBasicBlock> dominated = currentBlock.dominatedBlocks;
     // For a do while loop, the body has already been visited.
     if (!node.isDoWhile()) {
       visitBasicBlock(dominated[0]);
     }
     endLoop(node.block);
     visitBasicBlock(branchBlock.successors[1]);
-    // TODO(floitsch): with labeled breaks we can have more dominated blocks.
-    assert(dominated.length <= 3);
-    if (dominated.length == 3) {
-      // This happens when the body contains a 'return', and the exit-block is
-      // not dominated by a dominator of the while loop.
-      assert(dominated[2].isExitBlock());
-      visitBasicBlock(dominated[2]);
+    // With labeled breaks we can have more dominated blocks.
+    if (dominated.length >= 3) {
+      for (int i = 2; i < dominated.length; i++) {
+        visitBasicBlock(dominated[i]);
+      }
     }
   }
 
   visitNot(HNot node) {
     assert(node.inputs.length == 1);
     buffer.add('(!');
     use(node.inputs[0]);
     buffer.add(')');
   }
 
@@ skipping 290 matching lines @@
       checkArray(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not a string or array');
     } else {
       unreachable();
     }
   }
 
   void beginLoop(HBasicBlock block) {
     addIndentation();
+    for (SourceString label in block.loopInformation.labels) {
+      buffer.add("${label.stringValue}:");
+    }
     buffer.add('while (true) {\n');
     indent++;
   }
 
   void endLoop(HBasicBlock block) {
     indent--;
     addIndentation();
     buffer.add('}\n');  // Close 'while' loop.
   }
 
@@ skipping 141 matching lines @@
     indent++;
   }
 
   void endBailoutSwitch() {
     indent--; // Close 'case'.
     indent--;
     addIndentation();
     buffer.add('}\n');  // Close 'switch'.
   }
 
+  void addLabel(SourceString label) {
+    buffer.add("\$$label");
+  }
+
   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 (SourceString label in block.loopInformation.labels) {
+      addLabel(label);
+      buffer.add(":");
+    }
     buffer.add('$newLabel: while (true) {\n');
     indent++;
 
     if (block.hasBailouts()) {
       startBailoutSwitch();
     }
   }
 
   void endLoop(HBasicBlock block) {
     popLabel();
@@ skipping 67 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endElse(HIf node) {
     if (node.elseBlock.hasBailouts()) {
       endBailoutSwitch();
     }
   }
 }