Better bitwise and binary arithmetic when the left operand is known to be a number.

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 visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 922 matching lines @@
 
   bool isConstant() => false;
   bool isConstantBoolean() => false;
   bool isConstantNull() => false;
   bool isConstantNumber() => false;
   bool isConstantString() => false;
   bool isConstantList() => false;
   bool isConstantMap() => false;
   bool isConstantFalse() => false;
   bool isConstantTrue() => false;
+  bool isConstantInteger() => false;

[floitsch, 2012/06/19 11:15:58]

move next to isConstantNumber

[kasperl, 2012/06/19 11:22:06]

Done.

 
   bool isValid() {
     HValidator validator = new HValidator();
     validator.currentBlock = block;
     validator.visitInstruction(this);
     return validator.isValid;
   }
 
   /**
    * The code for computing a bailout environment, and the code
@@ skipping 440 matching lines @@
 
   // TODO(1603): The class should be marked as abstract.
   abstract BinaryOperation get operation();
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
-  HType computeTypeFromInputTypes() {
-    if (left.isInteger() && right.isInteger()) return left.propagatedType;
-    if (left.isNumber()) {
-      if (left.isDouble() || right.isDouble()) return HType.DOUBLE;
-      return HType.NUMBER;
-    }
-    return HType.UNKNOWN;
-  }
-
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
-    // If the desired output type is an integer we want two integers as input.
-    if (propagatedType.isInteger()) {
-      return HType.INTEGER;
-    }
-    // If the desired output is a number or any of the inputs is a number
-    // ask for a number. Note that we might return the input's (say 'left')
-    // type depending on its (the 'left's) type. But that shouldn't matter.
-    if (propagatedType.isNumber() || left.isNumber() || right.isNumber()) {
-      return HType.NUMBER;
-    }
-    return HType.UNKNOWN;
-  }
-
-  HType get likelyType() {
-    if (left.isTypeUnknown() || left.isNumber()) return HType.NUMBER;
-    return HType.UNKNOWN;
-  }
-
   AddOperation get operation() => const AddOperation();
-
   int typeCode() => 5;
   bool typeEquals(other) => other is HAdd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HDivide extends HBinaryArithmetic {
   HDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitDivide(this);
 
-  bool get builtin() => left.isNumber() && right.isNumber();
-
   HType computeTypeFromInputTypes() {
     if (left.isNumber()) return HType.DOUBLE;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // A division can never return an integer. So don't ask for integer inputs.
     if (propagatedType.isInteger()) return HType.UNKNOWN;
     return super.computeDesiredTypeForNonTargetInput(input);
   }
@@ skipping 102 matching lines @@
 
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 class HShiftLeft extends HBinaryBitOp {
   HShiftLeft(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftLeft(this);
 
+  // Shift left cannot be mapped to the native operator unless the
+  // shift count is guaranteed to be an integer in the [0,31] range.
+  bool get builtin() {
+    if (!left.isInteger() || !right.isConstantInteger()) return false;
+    HConstant rightConstant = right;
+    int count = rightConstant.constant.value;
+    return count >= 0 && count <= 31;
+  }
+
   ShiftLeftOperation get operation() => const ShiftLeftOperation();
   int typeCode() => 11;
   bool typeEquals(other) => other is HShiftLeft;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HShiftRight extends HBinaryBitOp {
   HShiftRight(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftRight(this);
 
+  // Shift right cannot be mapped to the native operator easily.
+  bool get builtin() => false;
+
   ShiftRightOperation get operation() => const ShiftRightOperation();
   int typeCode() => 12;
   bool typeEquals(other) => other is HShiftRight;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitOr extends HBinaryBitOp {
   HBitOr(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitOr(this);
@@ skipping 639 matching lines @@
 
   HType get guaranteedType() => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitIs(this);
 
   toString() => "$expression is $typeExpression";
 }
 
 class HTypeConversion extends HCheck {
   HType type;
-  final bool checked;
+  final int kind;
 
-  HTypeConversion(HType this.type,
-                  HInstruction input,
-                  [bool this.checked = false])
-    : super(<HInstruction>[input]) {
-      sourceElement = input.sourceElement;
+  static final int NO_CHECK = 0;
+  static final int CHECKED_MODE_CHECK = 1;
+  static final int ARGUMENT_TYPE_CHECK = 2;
+
+  HTypeConversion(HType type, HInstruction input)
+      : this.internal(type, input, NO_CHECK);
+  HTypeConversion.checkedModeCheck(HType type, HInstruction input)

[floitsch, 2012/06/19 11:15:58]

Alternatively we could have 3 subclasses of a HTypeConversion node.
Almost all of our visitors are using the base-visitor which would deal
gracefully with new sub-classes. And the ones that don't probably want to do
something different depending on the class anyways.

+      : this.internal(type, input, CHECKED_MODE_CHECK);
+  HTypeConversion.argumentTypeCheck(HType type, HInstruction input)
+      : this.internal(type, input, ARGUMENT_TYPE_CHECK);
+
+  HTypeConversion.internal(this.type, HInstruction input, this.kind)
+      : super(<HInstruction>[input]) {
+    sourceElement = input.sourceElement;
   }
 
+  bool isChecked() => kind != NO_CHECK;
+  bool isCheckedModeCheck() => kind == CHECKED_MODE_CHECK;
+  bool isArgumentTypeCheck() => kind == ARGUMENT_TYPE_CHECK;
+
   HType get guaranteedType() => type;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
-  bool hasSideEffects() => checked;
+  bool hasSideEffects() => kind != NO_CHECK;
+  bool isStatement() => kind == ARGUMENT_TYPE_CHECK;
+  bool isControlFlow() => kind == ARGUMENT_TYPE_CHECK;
 }
 
 class HStringConcat extends HInstruction {
   final Node node;
   HStringConcat(HInstruction left, HInstruction right, this.node)
       : super(<HInstruction>[left, right]);
   HType get guaranteedType() => HType.STRING;
 
   HInstruction get left() => inputs[0];
   HInstruction get right() => inputs[1];
@@ skipping 323 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);
 }