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;

[ricow1, 2012/07/23 12:52:26]

why remove this?

[floitsch, 2012/07/23 13:27:48]

It looked like an unnecessary complexity to me.
Before this CL the input was the environment that was used for the bailout call,
and therefore the order mattered. Now that's not true anymore. We have the
bailout-target which defines how we should send the environment variables to the
bailout-function.

 
-  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 1581 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);
 }