Fix break implementation.

frog/leg/ssa/builder.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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 520 matching lines @@
           joinedLocals[element] = instruction;
         } else {
           HInstruction phi = new HPhi.manyInputs(element, [instruction, mine]);
           joinBlock.addPhi(phi);
           joinedLocals[element] = phi;
         }
       }
     });
     directLocals = joinedLocals;
   }
+
+  /**
+   * The current localsHandler is not used for its values, only for its
+   * declared variables. This is a way exclude local values from the

[ngeoffray, 2012/02/29 10:02:54]

way *to*

[Lasse Reichstein Nielsen, 2012/02/29 10:42:02]

Done.

+   * result when they are no longer in scope.
+   * Returns the new LocalsHandler to use (may not be [this]).
+   */
+  void mergeMultiple(List<LocalsHandler> locals, HBasicBlock joinBlock) {

[ngeoffray, 2012/02/29 10:02:54]

void -> LocalsHandler

[Lasse Reichstein Nielsen, 2012/02/29 10:42:02]

Done.

+    assert(locals.length > 0);
+    if (locals.length == 1) return locals[0];
+    Map<Element, HInstruction> joinedLocals = new Map<Element,HInstruction>();
+    HInstruction thisValue = null;
+    directLocals.forEach((Element element, HInstruction instruction) {
+      if (element !== closureData.thisElement) {
+        HPhi phi = new HPhi(element);
+        joinedLocals[element] = phi;
+        joinBlock.addPhi(phi);
+      } else {
+        // We know that "this" never changes, if it's there.
+        // Save it for later. While merging, there is no phi for "this",
+        // so we don't have to special case it in the merge loop.
+        thisValue = instruction;
+      }
+    });
+    for (LocalsHandler local in locals) {
+      local.directLocals.forEach((Element element, HInstruction instruction) {
+        HPhi phi = joinedLocals[element];
+        if (phi !== null) {
+          phi.addInput(instruction);
+        }
+      });
+    }
+    if (thisValue !== null) {
+      // If there was a "this" for the scope, add it to the new locals.
+      joinedLocals[closureData.thisElement] = thisValue;
+    }
+    directLocals = joinedLocals;
+    return this;
+  }
 }
 
 
 // Represents a single break instruction.
 class BreakHandlerEntry {
   final HBreak breakInstruction;
   final LocalsHandler locals;
   BreakHandlerEntry(this.breakInstruction, this.locals);
 }
 
@@ skipping 411 matching lines @@
    * Ends the loop:
    * - creates a new block and adds it as successor to the [branchBlock].
    * - opens the new block (setting as [current]).
    * - notifies the locals handler that we're exiting a loop.
    */
   void endLoop(HBasicBlock loopEntry,
                HBasicBlock branchBlock,
                BreakHandler breakHandler) {
     HBasicBlock loopExitBlock = addNewBlock();
     assert(branchBlock.successors.length == 1);
+    List<LocalsHandler> breakLocals = <LocalsHandler>[];
+    breakHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
+      breakInstruction.block.addSuccessor(loopExitBlock);
+      breakLocals.add(locals);
+    });
     branchBlock.addSuccessor(loopExitBlock);
     open(loopExitBlock);
     localsHandler.endLoop(loopEntry);
-    breakHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
-      HBasicBlock joinBlock = addNewBlock();
-      breakInstruction.block.addSuccessor(joinBlock);
-      goto(current, joinBlock);
-      open(joinBlock);
-      localsHandler.mergeWith(locals, joinBlock);
-    });
+    if (!breakLocals.isEmpty()) {
+      breakLocals.add(localsHandler);
+      localsHandler = localsHandler.mergeMultiple(breakLocals, loopExitBlock);
+    }
   }
 
   // For while loops, initializer and update are null.
   visitLoop(Node loop, Node initializer, Expression condition, NodeList updates,
             Node body) {
     // Generate:
     //  <initializer>
     //  loop-entry:
     //    if (!<condition>) goto loop-exit;
     //    <body>
@@ skipping 89 matching lines @@
     }
 
     // If there are no continues we could avoid the creation of the condition
     // block. This could also lead to a block having multiple entries and exits.
     HBasicBlock bodyExitBlock = close(new HGoto());
     HBasicBlock conditionBlock = addNewBlock();
     bodyExitBlock.addSuccessor(conditionBlock);
     open(conditionBlock);
     visit(node.condition);
     assert(!isAborted());
-    conditionBlock = close(new HLoopBranch(popBoolified()));
+    conditionBlock = close(new HLoopBranch(popBoolified(),
+                                           HLoopBranch.DO_WHILE_LOOP));
 
     conditionBlock.addSuccessor(loopEntryBlock);  // The back-edge.
     loopEntryBlock.postProcessLoopHeader();
 
     endLoop(loopEntryBlock, conditionBlock, breakHandler);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     ClosureData nestedClosureData = closureDataCache[node];
     assert(nestedClosureData !== null);
@@ skipping 1045 matching lines @@
     if (handler === null) {
       // The labels are not break targets.
       visit(currentNode);
     } else if (currentNode is Loop || currentNode is SwitchStatement) {
       // The labels apply to that statement, and will be handled there.
       loopBreakHandler = handler;
       visit(currentNode);
       assert(loopBreakHandler === null);
     } else {
       // Introduce a new basic block.
+      LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler);
       HBasicBlock entryBlock = graph.addNewBlock();
       goto(current, entryBlock);
       open(entryBlock);
       visit(currentNode);
       if (isAborted()) {
         compiler.unimplemented(
             "SsaBuilder for labeled statement with aborting body", node: node);
       }
-      HBasicBlock exitBlock = current;
+      HBasicBlock joinBlock = graph.addNewBlock();
+      List<LocalsHandler> breakLocals = <LocalsHandler>[];
       handler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
-        HBasicBlock joinBlock = graph.addNewBlock();
         breakInstruction.block.addSuccessor(joinBlock);
-        if (!isAborted()) {
-          goto(current, joinBlock);
-          open(joinBlock);
-          localsHandler.mergeWith(locals, joinBlock);
-        } else {
-          open(joinBlock);
-          localsHandler = locals;
-        }
+        breakLocals.add(locals);
       });
-      if (current !== exitBlock) {
+      bool hasBreak = breakLocals.length > 0;
+      if (!isAborted()) {
+        goto(current, joinBlock);
+        breakLocals.add(localsHandler);
+      }
+      localsHandler = beforeLocals.mergeMultiple(breakLocals, joinBlock);
+
+      if (hasBreak) {
         // There was at least one reachable break, so the label is needed.
         HLabeledBlockInformation blockInfo =
             new HLabeledBlockInformation(entryBlock, current,
                                          handler.labels());
         handler.close();
-        entryBlock.labeledBlockInformation = blockInfo;
         // Mark both entry and exit with the information. You can
         // tell which one is which by comparing with blockInfo.start/end.
         // It doesn't matter which merge block we use, they won't be generating
         // any code, so put the end-marker on the last join block.
+        entryBlock.labeledBlockInformation = blockInfo;
         current.labeledBlockInformation = blockInfo;
       }
     }
   }
 
   visitLiteralMap(LiteralMap node) {
     compiler.unimplemented('SsaBuilder.visitLiteralMap', node: node);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
@@ skipping 109 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 }