Throw and a small fix to If.

frog/leg/ssa/nodes.dart

 // Copyright (c) 2011, 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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBasicBlock(HBasicBlock node);
   R visitDivide(HDivide node);
   R visitExit(HExit node);
   R visitGoto(HGoto node);
   R visitIf(HIf node);
   R visitInvoke(HInvoke node);
   R visitInvokeForeign(HInvokeForeign node);
   R visitLiteral(HLiteral node);
   R visitParameter(HParameter node);
   R visitPhi(HPhi node);
   R visitSubtract(HSubtract node);
   R visitMultiply(HMultiply node);
   R visitReturn(HReturn node);
+  R visitThrow(HThrow node);
   R visitTruncatingDivide(HTruncatingDivide node);
 }
 
 class HGraphVisitor {
   visitDominatorTree(HGraph graph) {
     void visitBasicBlockAndSuccessors(HBasicBlock block) {
       visitBasicBlock(block);
       List dominated = block.dominatedBlocks;
       for (int i = 0; i < dominated.length; i++) {
         visitBasicBlockAndSuccessors(dominated[i]);
@@ skipping 118 matching lines @@
     HInstruction instruction = node.first;
     while (instruction !== null) {
       instruction.accept(this);
       instruction = instruction.next;
     }
   }
 
   visitInstruction(HInstruction) {}
 
   visitArithmetic(HArithmetic node) => visitInvoke(node);
+  visitControlFlow(HControlFlow node) => visitInstruction(node);
 
   visitAdd(HAdd node) => visitArithmetic(node);
   visitDivide(HDivide node) => visitArithmetic(node);
-  visitExit(HExit node) => visitInstruction(node);
-  visitGoto(HGoto node) => visitInstruction(node);
-  visitIf(HIf node) => visitInstruction(node);
+  visitExit(HExit node) => visitControlFlow(node);
+  visitGoto(HGoto node) => visitControlFlow(node);
+  visitIf(HIf node) => visitControlFlow(node);
   visitInvoke(HInvoke node) => visitInstruction(node);
   visitInvokeForeign(HInvokeForeign node) => visitInvoke(node);
   visitLiteral(HLiteral node) => visitInstruction(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitArithmetic(node);
   visitParameter(HParameter node) => visitInstruction(node);
-  visitReturn(HReturn node) => visitInstruction(node);
+  visitReturn(HReturn node) => visitControlFlow(node);
   visitSubtract(HSubtract node) => visitArithmetic(node);
+  visitThrow(HThrow node) => visitControlFlow(node);
   visitTruncatingDivide(HTruncatingDivide node) => visitArithmetic(node);
 }
 
 class HBasicBlock {
   // [id] must be such that any successor's id is greater than this [id]. The
   // exception are back-edges.
   int id;
   HInstruction first = null;
   HInstruction last = null;
   final List<HBasicBlock> predecessors;
@@ skipping 285 matching lines @@
   bool isLiteralNumber() => false;
   bool isLiteralString() => false;
 
   bool isValid() {
     HValidator validator = new HValidator();
     validator.visitInstruction(this);
     return validator.isValid;
   }
 }
 
+class HControlFlow extends HInstruction {
+  HControlFlow(inputs) : super(inputs);
+  abstract toString();
+}
+
 class HInvoke extends HInstruction {
   final SourceString selector;
   HInvoke(this.selector, inputs) : super(inputs);
   toString() => 'invoke: $selector';
   accept(HVisitor visitor) => visitor.visitInvoke(this);
 }
 
 class HInvokeForeign extends HInvoke {
   HInvokeForeign(code, inputs) : super(code, inputs);
   accept(HVisitor visitor) => visitor.visitInvokeForeign(this);
@@ skipping 52 matching lines @@
 }
 
 class HTruncatingDivide extends HArithmetic {
   HTruncatingDivide(inputs) : super(const SourceString('~/'), inputs);
   accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
   num evaluate(num a, num b) => a ~/ b;
   bool typeEquals(other) => other is HTruncatingDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
-class HExit extends HInstruction {
+class HExit extends HControlFlow {
   HExit() : super(const <HInstruction>[]);
   toString() => 'exit';
   accept(HVisitor visitor) => visitor.visitExit(this);
 }
 
-class HGoto extends HInstruction {
+class HGoto extends HControlFlow {
   HGoto() : super(const <HInstruction>[]);
   toString() => 'goto';
   accept(HVisitor visitor) => visitor.visitGoto(this);
 }
 
-class HIf extends HInstruction {
+class HIf extends HControlFlow {
   bool hasElse;
   HIf(HInstruction condition, this.hasElse) : super(<HInstruction>[condition]);
   toString() => 'if';
   accept(HVisitor visitor) => visitor.visitIf(this);
 }
 
 class HLiteral extends HInstruction {
   final value;
   HLiteral(this.value) : super([]);
   void prepareGvn() {
@@ skipping 18 matching lines @@
   accept(HVisitor visitor) => visitor.visitParameter(this);
 }
 
 class HPhi extends HInstruction {
   HPhi(HInstruction input1, HInstruction input2)
       : super(<HInstruction>[input1, input2]);
   toString() => 'phi';
   accept(HVisitor visitor) => visitor.visitPhi(this);
 }
 
-class HReturn extends HInstruction {
+class HReturn extends HControlFlow {
   HReturn(value) : super([value]);
   toString() => 'return';
   accept(HVisitor visitor) => visitor.visitReturn(this);
 }
+
+class HThrow extends HControlFlow {
+  HThrow(value) : super([value]);

[ngeoffray, 2011/11/10 13:22:37]

does it still hold if value is null?

+  toString() => 'throw';
+  accept(HVisitor visitor) => visitor.visitThrow(this);
+}