Split TypeGuard and BailoutTarget.

lib/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.
 
 interface 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);
@@ skipping 232 matching lines @@
   visitInvokeBinary(HInvokeBinary node) => visitInvokeStatic(node);
   visitInvokeDynamic(HInvokeDynamic node) => visitInvoke(node);
   visitInvokeDynamicField(HInvokeDynamicField node) => visitInvokeDynamic(node);
   visitInvokeUnary(HInvokeUnary node) => visitInvokeStatic(node);
   visitConditionalBranch(HConditionalBranch node) => visitControlFlow(node);
   visitControlFlow(HControlFlow node) => visitInstruction(node);
   visitFieldAccess(HFieldAccess node) => visitInstruction(node);
   visitRelational(HRelational node) => visitInvokeBinary(node);
 
   visitAdd(HAdd node) => visitBinaryArithmetic(node);
+  visitBailoutTarget(HBailoutTarget node) => visitInstruction(node);
   visitBitAnd(HBitAnd node) => visitBinaryBitOp(node);
   visitBitNot(HBitNot node) => visitInvokeUnary(node);
   visitBitOr(HBitOr node) => visitBinaryBitOp(node);
   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);
@@ skipping 163 matching lines @@
   static final int STATUS_NEW = 0;
   static final int STATUS_OPEN = 1;
   static final int STATUS_CLOSED = 2;
   int status = STATUS_NEW;
 
   HInstructionList phis;
 
   HLoopInformation loopInformation = null;
   HBlockFlow blockFlow = null;
   HBasicBlock parentLoopHeader = null;
-  List<HTypeGuard> guards;
+  List<HBailoutTarget> bailoutTargets;
 
   final List<HBasicBlock> predecessors;
   List<HBasicBlock> successors;
 
   HBasicBlock dominator = null;
   final List<HBasicBlock> dominatedBlocks;
 
   HBasicBlock() : this.withId(null);
   HBasicBlock.withId(this.id)
       : phis = new HInstructionList(),
         predecessors = <HBasicBlock>[],
         successors = const <HBasicBlock>[],
         dominatedBlocks = <HBasicBlock>[],
-        guards = <HTypeGuard>[];
+        bailoutTargets = <HBailoutTarget>[];
 
   int hashCode() => id;
 
   bool isNew() => status == STATUS_NEW;
   bool isOpen() => status == STATUS_OPEN;
   bool isClosed() => status == STATUS_CLOSED;
 
   bool isLoopHeader() {
     return loopInformation !== null;
   }
 
   void setBlockFlow(HBlockInformation blockInfo, HBasicBlock continuation) {
     blockFlow = new HBlockFlow(blockInfo, continuation);
   }
 
   bool isLabeledBlock() =>
     blockFlow !== null &&
     blockFlow.body is HLabeledBlockInformation;
 
   HBasicBlock get enclosingLoopHeader() {
     if (isLoopHeader()) return this;
     return parentLoopHeader;
   }
 
-  bool hasGuards() => !guards.isEmpty();
+  bool hasBailoutTargets() => !bailoutTargets.isEmpty();
 
   void open() {
     assert(isNew());
     status = STATUS_OPEN;
   }
 
   void close(HControlFlow end) {
     assert(isOpen());
     addAfter(last, end);
     status = STATUS_CLOSED;
@@ skipping 538 matching lines @@
 abstract class HCheck extends HInstruction {
   HCheck(inputs) : super(inputs);
   HInstruction get checkedInput() => inputs[0];
   bool get isStatement() => true;
   void prepareGvn() {
     assert(!hasSideEffects());
     setUseGvn();
   }
 }
 
+class HBailoutTarget extends HInstruction {
+  final int state;
+  bool isEnabled = false;
+  HBailoutTarget(this.state) : super(<HInstruction>[]);
+  void prepareGvn() {
+    assert(!hasSideEffects());
+    setUseGvn();
+  }
+
+  bool isControlFlow() => true;
+  bool get isStatement() => isEnabled;
+
+  accept(HVisitor visitor) => visitor.visitBailoutTarget(this);
+  int typeCode() => 29;
+  bool typeEquals(other) => other is HBailoutTarget;
+  bool dataEquals(HBailoutTarget other) => other.state == state;
+}
+
 class HTypeGuard extends HCheck {
-  final int state;
   final HType guardedType;
   bool isEnabled = false;
-  int checkedInputIndex = 0;
 
-  HTypeGuard(this.guardedType, this.state, List<HInstruction> env) : super(env);
+  HTypeGuard(this.guardedType, HInstruction guarded, HInstruction bailoutTarget)
+      : super(<HInstruction>[guarded, bailoutTarget]);
 
-  HInstruction get guarded() => inputs[checkedInputIndex];
+  HInstruction get guarded() => inputs[0];
   HInstruction get checkedInput() => guarded;
+  HBailoutTarget get bailoutTarget() => inputs[1];
+  int get state() => bailoutTarget.state;
 
   HType computeTypeFromInputTypes() {
     return isEnabled ? guardedType : guarded.propagatedType;
   }
 
   HType get guaranteedType() => isEnabled ? guardedType : HType.UNKNOWN;
 
   bool isControlFlow() => true;
 
   bool get isStatement() => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitTypeGuard(this);
   int typeCode() => 1;
   bool typeEquals(other) => other is HTypeGuard;
-  bool dataEquals(HTypeGuard other) {
-    return guarded == other.guarded && guardedType == other.guardedType;
-  }
+  bool dataEquals(HTypeGuard other) => guardedType == other.guardedType;
 }
 
 class HBoundsCheck extends HCheck {
   static final int ALWAYS_FALSE = 0;
   static final int FULL_CHECK = 1;
   static final int ALWAYS_ABOVE_ZERO = 2;
   static final int ALWAYS_TRUE = 3;
   /**
    * Details which tests have been done statically during compilation.
    * Default is that all checks must be performed dynamically.
@@ skipping 1587 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);
 }