Change labeled statement to use visitSubGraph for its body instead of marking its "exit block" spec…

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 83 matching lines @@
   final Map<Element, String> parameterNames;
   final Map<int, String> names;
   final Map<String, int> prefixes;
 
   Element equalsNullElement;
   int indent = 0;
   int expectedPrecedence = JSPrecedence.STATEMENT_PRECEDENCE;
   HGraph currentGraph;
   HBasicBlock currentBlock;
 
+  // Records a block-information that is being handled specially.
+  // Used to break bad recursion.

[ngeoffray, 2012/03/06 11:17:37]

What's a bad recursion?

[Lasse Reichstein Nielsen, 2012/03/08 09:02:02]

Infinite recursion, recursing on the same input again. Will reword.

+  HLabeledBlockInformation currentBlockInformation;
+  // The subgraph is used to delimit traversal for some constructions, e.g.,
+  // if branches.
   SubGraph subGraph;
 
   SsaCodeGenerator(this.compiler,
                    this.work,
                    this.buffer,
                    this.parameters,
                    this.parameterNames)
     : names = new Map<int, String>(),
       prefixes = new Map<String, int>() {
     for (final name in parameterNames.getValues()) {
@@ skipping 112 matching lines @@
     }
   }
 
   visit(HInstruction node, int expectedPrecedence) {
     int oldPrecedence = this.expectedPrecedence;
     this.expectedPrecedence = expectedPrecedence;
     node.accept(this);
     this.expectedPrecedence = oldPrecedence;
   }
 
-  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");
+  void handleLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
+    addIndentation();
+    for (SourceString label in labeledBlockInfo.labels) {
+      addLabel(label);
+      buffer.add(":");
     }
+    buffer.add("{\n");
+    indent++;
+
+    visitSubGraph(labeledBlockInfo.body);
+
+    indent--;
+    addIndentation();
+    buffer.add("}\n");
+
+    visitBasicBlock(labeledBlockInfo.joinBlock);
   }
 
 
   visitBasicBlock(HBasicBlock node) {
+    // Abort traversal if we are leaving the currently active sub-graph.
     if (!subGraph.contains(node)) return;
 
+    // If this node has special behavior attached, handle it.
+    // If we reach here again while handling the attached information,
+    // e.g., because we call visitSubGraph on a subgraph starting here,
+    // don't handle it again.

[ngeoffray, 2012/03/06 11:17:37]

How can you end up doing this? Should we re-design the subgraph to make sure we
never encounter this case?

[Lasse Reichstein Nielsen, 2012/03/08 09:02:02]

For a labeled expression, the "HLabeledBlockInformation" is put on the first
block of the body, which is also the first block of the subgraph.
Any suggestions for redesign are appreciated.

VisitBasicBlock is called by visitSubGraph, and the label/loop tests are
necessary for that (they can be branches of an if, which also uses
visitSubGraph).

+    if (node.hasLabeledBlockInformation() &&
+        node.labeledBlockInformation !== currentBlockInformation) {
+      HLabeledBlockInformation oldBlockInformation = currentBlockInformation;
+      currentBlockInformation = node.labeledBlockInformation;
+      handleLabeledBlock(currentBlockInformation);
+      currentBlockInformation = oldBlockInformation;
+      return;
+    }
+
     currentBlock = node;
-
-    if (node.hasLabeledBlockInformation()) {
-      handleLabeledBlock(node);
-    } else if (currentBlock.isLoopHeader()) {
+    if (node.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, JSPrecedence.STATEMENT_PRECEDENCE);
         return;
       } else if (!instruction.generateAtUseSite()) {
         if (instruction is !HIf && instruction is !HBailoutTarget) {
           addIndentation();
         }
         if (instruction.usedBy.isEmpty() || instruction is HLocal) {
@@ skipping 1108 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endElse(HIf node) {
     if (node.elseBlock.hasBailouts()) {
       endBailoutSwitch();
     }
   }
 }