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.
+  HLabeledBlockInformation currentBlockInformation;
+  // Restriction on the block traversal.

[floitsch, 2012/03/06 10:12:13]

That comment doesn't work for me. Maybe (if that's what it does): The [subGraph]
variable is used to delimit the traversal for some instructions, like Ifs.

[Lasse Reichstein Nielsen, 2012/03/06 10:20:44]

Reworded.

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