Merge libv1.

sdk/lib/_internal/compiler/implementation/ssa/nodes.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;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
   R visitBoolify(HBoolify node);
   R visitBoundsCheck(HBoundsCheck node);
   R visitBreak(HBreak node);
   R visitConstant(HConstant node);
   R visitContinue(HContinue node);
   R visitDivide(HDivide node);
   R visitEquals(HEquals node);
   R visitExit(HExit node);
+  R visitExitTry(HExitTry node);
   R visitFieldGet(HFieldGet node);
   R visitFieldSet(HFieldSet node);
   R visitForeign(HForeign node);
   R visitForeignNew(HForeignNew node);
   R visitGoto(HGoto node);
   R visitGreater(HGreater node);
   R visitGreaterEqual(HGreaterEqual node);
   R visitIdentity(HIdentity node);
   R visitIf(HIf node);
   R visitIndex(HIndex node);
@@ skipping 181 matching lines @@
   }
 
   void assignDominators() {
     // Run through the blocks in order of increasing ids so we are
     // guaranteed that we have computed dominators for all blocks
     // higher up in the dominator tree.
     for (int i = 0, length = blocks.length; i < length; i++) {
       HBasicBlock block = blocks[i];
       List<HBasicBlock> predecessors = block.predecessors;
       if (block.isLoopHeader()) {
-        assert(predecessors.length >= 2);
         block.assignCommonDominator(predecessors[0]);
       } else {
         for (int j = predecessors.length - 1; j >= 0; j--) {
           block.assignCommonDominator(predecessors[j]);
         }
       }
     }
   }
 
   bool isValid() {
@@ skipping 38 matching lines @@
   visitBitXor(HBitXor node) => visitBinaryBitOp(node);
   visitBoolify(HBoolify node) => visitInstruction(node);
   visitBoundsCheck(HBoundsCheck node) => visitCheck(node);
   visitBreak(HBreak node) => visitJump(node);
   visitContinue(HContinue node) => visitJump(node);
   visitCheck(HCheck node) => visitInstruction(node);
   visitConstant(HConstant node) => visitInstruction(node);
   visitDivide(HDivide node) => visitBinaryArithmetic(node);
   visitEquals(HEquals node) => visitRelational(node);
   visitExit(HExit node) => visitControlFlow(node);
+  visitExitTry(HExitTry node) => visitControlFlow(node);
   visitFieldGet(HFieldGet node) => visitFieldAccess(node);
   visitFieldSet(HFieldSet node) => visitFieldAccess(node);
   visitForeign(HForeign node) => visitInstruction(node);
   visitForeignNew(HForeignNew node) => visitForeign(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
   visitIdentity(HIdentity node) => visitRelational(node);
   visitIf(HIf node) => visitConditionalBranch(node);
   visitIndex(HIndex node) => visitInvokeStatic(node);
@@ skipping 1734 matching lines @@
 class HTry extends HControlFlow {
   HParameterValue exception;
   HBasicBlock catchBlock;
   HBasicBlock finallyBlock;
   HTry() : super(const <HInstruction>[]);
   toString() => 'try';
   accept(HVisitor visitor) => visitor.visitTry(this);
   HBasicBlock get joinBlock => this.block.successors.last;
 }
 
+// An [HExitTry] control flow node is used when the body of a try or
+// the body of a catch contains a return, break or continue. To build
+// the control flow graph, we explicitely mark the body that
+// leads to one of this instruction a predecessor of catch and
+// finally.
+class HExitTry extends HControlFlow {
+  HExitTry() : super(const <HInstruction>[]);
+  toString() => 'exit try';
+  accept(HVisitor visitor) => visitor.visitExitTry(this);
+  HBasicBlock get bodyTrySuccessor => block.successors[0];
+}
+
 class HIf extends HConditionalBranch {
   HBlockFlow blockInformation = null;
   HIf(HInstruction condition) : super(<HInstruction>[condition]);
   toString() => 'if';
   accept(HVisitor visitor) => visitor.visitIf(this);
 
   HBasicBlock get thenBlock {
     assert(identical(block.dominatedBlocks[0], block.successors[0]));
     return block.successors[0];
   }
@@ skipping 861 matching lines @@
     }
     return condition.start;
   }
 
   HBasicBlock get loopHeader {
     return kind == DO_WHILE_LOOP ? body.start : condition.start;
   }
 
   HBasicBlock get end {
     if (updates != null) return updates.end;
-    if (kind == DO_WHILE_LOOP) {
+    if (kind == DO_WHILE_LOOP && condition != null) {
       return condition.end;
     }
     return body.end;
   }
 
   static int loopType(Node node) {
     return node.accept(const LoopTypeVisitor());
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
@@ skipping 74 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }