Fix control flow graph in the presence of aborting instructions in a try/catch/finally.

sdk/lib/_internal/compiler/implementation/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.
 
 part of ssa;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 908 matching lines @@
       rti = builder.compiler.codegenWorld.rti,
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this);
   }
 
   static const MAX_INLINING_DEPTH = 3;
   static const MAX_INLINING_SOURCE_SIZE = 128;
   List<InliningState> inliningStack;
   Element returnElement;
   DartType returnType;
+  bool inTryStatement = false;
 
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
     methodInterceptionEnabled = false;
   }
 
   void enableMethodInterception() {
     assert(!methodInterceptionEnabled);
     methodInterceptionEnabled = true;
   }
@@ skipping 2498 matching lines @@
     visit(node.expression);
     // Remove the result and reveal the duplicated receiver on the stack.
     pop();
   }
 
   visitCascadeReceiver(CascadeReceiver node) {
     visit(node.expression);
     dup();
   }
 
+  void handleInTryStatement() {
+    if (!inTryStatement) return;
+    HBasicBlock block = close(new HExitTry());
+    HBasicBlock newBlock = graph.addNewBlock();
+    block.addSuccessor(newBlock);
+    open(newBlock);
+  }
+
   visitReturn(Return node) {
     if (identical(node.getBeginToken().stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     if (node.isRedirectingFactoryBody) {
       compiler.internalError("Unimplemented: Redirecting factory constructor",
                              node: node);
     }
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(constantSystem);
     } else {
       visit(node.expression);
       value = pop();
       value = potentiallyCheckType(value, returnType);
     }
+
+    handleInTryStatement();
+
     if (!inliningStack.isEmpty) {
       localsHandler.updateLocal(returnElement, value);
     } else {
       close(attachPosition(new HReturn(value), node)).addSuccessor(graph.exit);
     }
   }
 
   visitThrow(Throw node) {
     if (node.expression == null) {
       HInstruction exception = rethrowableException;
@@ skipping 70 matching lines @@
   visitEmptyStatement(EmptyStatement node) {
     // Do nothing, empty statement.
   }
 
   visitModifiers(Modifiers node) {
     compiler.unimplemented('SsaBuilder.visitModifiers', node: node);
   }
 
   visitBreakStatement(BreakStatement node) {
     assert(!isAborted());
+    handleInTryStatement();
     TargetElement target = elements[node];
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     if (node.target == null) {
       handler.generateBreak();
     } else {
       LabelElement label = elements[node.target];
       handler.generateBreak(label);
     }
   }
 
   visitContinueStatement(ContinueStatement node) {
+    handleInTryStatement();
     TargetElement target = elements[node];
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     if (node.target == null) {
       handler.generateContinue();
     } else {
       LabelElement label = elements[node.target];
       assert(label != null);
       handler.generateContinue(label);
@@ skipping 519 matching lines @@
     // Save the current locals. The catch block and the finally block
     // must not reuse the existing locals handler. None of the variables
     // that have been defined in the body-block will be used, but for
     // loops we will add (unnecessary) phis that will reference the body
     // variables. This makes it look as if the variables were used
     // in a non-dominated block.
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     HBasicBlock enterBlock = openNewBlock();
     HTry tryInstruction = new HTry();
     close(tryInstruction);
+    bool oldInTryStatement = inTryStatement;
+    inTryStatement = true;
 
     HBasicBlock startTryBlock;
     HBasicBlock endTryBlock;
     HBasicBlock startCatchBlock;
     HBasicBlock endCatchBlock;
     HBasicBlock startFinallyBlock;
     HBasicBlock endFinallyBlock;
 
     startTryBlock = graph.addNewBlock();
     open(startTryBlock);
@@ skipping 94 matching lines @@
       open(startFinallyBlock);
       visit(node.finallyBlock);
       if (!isAborted()) endFinallyBlock = close(new HGoto());
       tryInstruction.finallyBlock = startFinallyBlock;
       finallyGraph = new SubGraph(startFinallyBlock, lastOpenedBlock);
     }
 
     HBasicBlock exitBlock = graph.addNewBlock();
 
     addOptionalSuccessor(b1, b2) { if (b2 != null) b1.addSuccessor(b2); }
+    addExitTrySuccessor(successor) {
+      if (successor == null) return;
+      // Iterate over all blocks created inside this try/catch, and
+      // attach successor information to blocks that end with
+      // [HExitTry].
+      for (int i = startTryBlock.id; i < successor.id; i++) {
+        HBasicBlock block = graph.blocks[i];
+        var last = block.last;
+        if (last is HExitTry) {
+          block.addSuccessor(successor);
+        } else if (last is HTry) {
+          // Skip all blocks inside this nested try/catch.
+          i = last.joinBlock.id;
+        }
+      }
+    }
 
     // Setup all successors. The entry block that contains the [HTry]
     // has 1) the body, 2) the catch, 3) the finally, and 4) the exit
     // blocks as successors.
     enterBlock.addSuccessor(startTryBlock);
     addOptionalSuccessor(enterBlock, startCatchBlock);
     addOptionalSuccessor(enterBlock, startFinallyBlock);
     enterBlock.addSuccessor(exitBlock);
 
     // The body has either the catch or the finally block as successor.
     if (endTryBlock != null) {
       assert(startCatchBlock != null || startFinallyBlock != null);
       endTryBlock.addSuccessor(
           startCatchBlock != null ? startCatchBlock : startFinallyBlock);
     }
 
     // The catch block has either the finally or the exit block as
     // successor.
     if (endCatchBlock != null) {
       endCatchBlock.addSuccessor(
           startFinallyBlock != null ? startFinallyBlock : exitBlock);
     }
 
     // The finally block has the exit block as successor.
     if (endFinallyBlock != null) {
       endFinallyBlock.addSuccessor(exitBlock);
     }
+    
+    // If a block inside try/catch aborts (eg with a return statement),
+    // we explicitely mark this block a predecessor of the catch
+    // block and the finally block.
+    addExitTrySuccessor(startCatchBlock);
+    addExitTrySuccessor(startFinallyBlock);
 
     // Use the locals handler not altered by the catch and finally
     // blocks.
     localsHandler = savedLocals;
     open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
           wrapStatementGraph(bodyGraph),
           exception,
           wrapStatementGraph(catchGraph),
           wrapStatementGraph(finallyGraph)),
         exitBlock);
+    inTryStatement = oldInTryStatement;
   }
 
   visitScriptTag(ScriptTag node) {
     compiler.unimplemented('SsaBuilder.visitScriptTag', node: node);
   }
 
   visitCatchBlock(CatchBlock node) {
     visit(node.block);
   }
 
@@ skipping 406 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }